A Flowchart-based Programming Environment for Improving Problem Solving Skills of Cs minors in computer programming.pdf

Printed in the Philippines
ASIA LIFE SCIENCES 24(2): 629-646, 2015
The Asian International Journal of Life Sciences
Received 26 November 2014; Accepted 24 December 2014
©Rushing Water Publishers Ltd. 2015
A flowchart-based programming environment for
improving problem solving skills of Cs minors in
computer programming
DANIAL HOOSHYAR1*
, RODINA BINTI AHMAD1
,
SHAHABODDIN SHAMSHIRBAND1
, MOSLEM YOUSEFI2
and SHI-JINN HORNG3
Novice programmers have a misconception of what programming is in the early stages
of learning programming. A Flowchart-based Programming Environment (FPE) is developed
inthisresearchwiththeaimofintroducingtheearlystagesoflearningprogrammingtoclarify
matters. An attempt is made to introduce the basic programming algorithms prior to surface
structure using an automatic text-to-lowchart conversion approach in order to improve
students’ problem-solving skills. Thus, this system allows students to focus less on language
and syntax and more on solution designing in the form of lowchart development. The main
objective of this study is to support the problem-solving ability through designing activities.
How exactly FPE employs text-to-lowchart conversion as a visualization-based approach
to provide the students with their inal lowchart for subsequent stages of programming is
discussed in this paper. The proposed system is evaluated using 50 irst-year undergraduate
students taking their irst introductory courses in programming called “Programming 1” at
University of Malaya, who gave very positive feedback. A very awarding inding was that
an automatic text-to-lowchart conversion approach applied in FPE successfully motivated
almost all participants in problem-solving activities. Consequently, the results suggest
further development of a text-to-lowchart conversion approach in the form of a Multi-Agent
System (MAS) in future in order to make the early stages of learning programming more
encouraging for students.
Keywords: programming environments, novice programmers, visualizations, text-to-
lowchart conversion
1
Faculty of Computer Science and Information Technology, University of Malaya, 50603, Lembah
Pantai, Kuala Lumpur, Malaysia
2
Center for Systems and Machines Intelligence, College of Engineering, Universiti Tenaga Nasional,
4300, Kajang, Malaysia
3
Department of Computer Science and Information Engineering, National Taiwan University of
Science and Technology, Taiwan

630
Hooshyar et al. 2015
Asia Life Sciences 24(2) 2015
INTRODUCTION
Computer science and engineering students are required to be able to do
programming, as there are several programming courses in these fields that require
programming skills (McCracken et al. 2001). As indicated in literature, there are
high dropout and failure rates in initial programming courses. Carter and Jenkins
(1999) stated that many students avoid programming in their final year projects
on the grounds of either not being able to program or believing they cannot. Lack
of problem-solving skills, solution designing and use of programming languages
that are often artificial for many students is a reason why learning programming
is more difficult (Moser 1997, Pillay 2003, Pillay & Jugoo 2005). However, it
should be mentioned that students’ science background and motivation, class size
and programming language syntax are other, most often highlighted reasons.
Commonly, the majority of students understand the basic programming constructs
but are not able to apply them for creating programs to solve problems. Due to the
aforementioned reason, it is believed that to compose and coordinate instruction for
creating the components of a program is the major problem of countless students
(Mayer 1981, Spohrer & Soloway 1985). In our view, programming languages are
only a way of expressing solutions while more priority and attention should be
given to problem-solving abilities, because basically, learning to solve problems
algorithmically contributes to learning to program. Due to the fact that programming
skills cannot be absolutely transferred from instructors to students, novices should
also actively practice programming to gain knowledge (Boada et al. 2004, Ben-Ari
2001). Although, most students face various difficulties in the preliminary learning
stages and are unable to develop solutions for simple problems. This might make
them give up trying and lose interest, which leads to dropout and failure. Several
programming tools have been developed which instead of focusing on problem
solving skills, which are more essential for weaker students, those tools stress more
on programming language features. With the hope of solving this difficulty, we
developed our flowchart-based programming environment that benefits from an
automatic text-to-flowchart conversion approach to enable creating initial solutions
for simple problems and to improve problem-solving skills. Natural Language
Processing (NLP), Knowledge Base System, Knowledge Expansion, and a Web
Crawler (web monitoring service) are Artificial Intelligence (AI) techniques applied
in our proposed system so as to convert the statement of a given programming
problem, here in English, to a relevant flowchart. A Flowchart-based Programming
Environment (FPE) tool also contains an online chat and databases improvement
process, using web crawler, without human intervention as well as visualization-
based approach to support weaker students in creating basic algorithms. Three
databases are improvised in the system which the first one contains main
programming keywords, the second one used as a dictionary to find synonym and
substitution of extracted keyword, and the third one for storing unknown keyword
entered by users. An interesting approach has been also utilized in FPE which
enables it to even generate the flowchart for the programming problem having no
keywords in their statement. The rationale behind the development of FPE is to
help students understand the relation between the problem statement exercise, in

631
Flowchart-based programming environment
English text here, and its relevant flowchart in order to create an initial solution
that can subsequently be improved. Using FPE, the students are guided through
a dialogue system chat. This interaction urges students to construct solutions step
by step. Novice programmers who have no prior knowledge of programming are
the target audience of this research. The main contribution of this work is a novel
flowchart-based programming environment benefiting from an automatic text-
to-flowchart conversion approach for improving problem-solving skills of novice
programmers in a form of solution designing activities. The remaining parts of this
paper are dedicated to the following sections: mental model and visualization, the
proposed system architecture, evaluation and participants, results and discussion,
conclusions and future work.
RELATED WORKS
Inanattempttopresentprogramminganditsintroductorycoursestobeginners,
iconic based programming and flowchart based notation environments are highly
applicable. These environments assist in providing a precise and accurate mental
model in addition to providing a conceptual understanding of the vital subjects and
their execution, and in a way enhancing the problem-solving abilities of the novice
programmers (Moghaddam et al. 2013). However, the majority of flowchart-based
programming environments emphasized on flowcharts and the generated code but
none has concentrated on automatically converting a given problem, i.e. the English
text, to its corresponding flowchart without human intervention. This means that
by filling this gap, not only can the problem-solving skills of novice programmers
be improved, but also a complete software agent tool can be developed which can
replace the role of a programming tutor in the real world for novice programmers,
since the process from building a flowchart until coding, debugging, tracing, etc.
have already been developed (Hooshyar et al. 2013). This study tries to discover an
automatic approach of drawing a flowchart that has been described by those texts
(Hooshyar et al. 2014). Currently, very few studies have been done on this subject
matter, using keyword matching technique and they are not aimed at improving
problem-solving of novice programmers and they are commercial. Although, there
have been some attempts such as in LIM-G (Wong et al. 2007), ALBERT (Oberem
1987) and FREEBODY (Oberem et al. 1993) in addition to a few other studies
(Koedinger & Sueker 1996, Looi & Tan 1998, Steele & Steele 1999, Wheeler &
Regian 1999, Chang et al. 2005, Mukherjee & Garain 2005). LIM-G and ALBERT
applied strong NLP (Natural Language Processing) approaches and a restricted
knowledge base in order to understand the significant types of school-level
mensuration and the problems of physics corresponding to a textual demonstration
and offered solutions along with the illustrative diagrams. FREEBODY, although
is an adaptation of ALBERT, is a specific software that is able to understand a
free body diagram that has been drawn by a beginner and guides the learner to
making any corrections. Another system which was developed by Mukherjee,
Garain and Biswas (2013) named “Automatic Text-to-Diagram Conversion: a Novel
Teaching Aid for the Blind People”, along with the systems developed by ALBERT
and LIM-G, are somewhat similar to our proposed system. FPE is able to convert

632
text-to-flowchart automatically which simulates human technique of resolving a
programming problem as well as providing novices with an online system chat to
address their issues during solution designing. The system utilizes an accessible
knowledge base source, dialogue-based tutoring system, and innovative intelligent
demonstration schemes which are built from various fields such as knowledge
presentation, automated reasoning, natural language processing, query expansion,
and dialogue-based systems.
THE PROPOSED SYSTEM ARCHITECTURE
The FPE architecture is shown in Figure 1. The proposed system supports
teaching computer programming to novice programmers. The primary purposes of
this system are to support the problem-solving ability through designing activities
as well as to show the importance of highlighting the essential principles of various
algorithms on a higher level of abstraction.
Figure 1. The architecture of flowchart-based programming environment (FPE).
At this section we focus on the first component, automatic text-to-flowchart
conversion, which consists of five main sub-components namely text processing,
knowledge-based, query expansion, dialogue-based tutoring system, and a crawler.
Firstly, the semantic and syntactic analysis of entered programming problem in
English text is performed by Natural Language Processing (NLP) parser module in
order to extract keywords out of the textual description. Secondly, a knowledge base
is applied in the parser, named D1 containing general programming information

633
about all of possible programming problem inputs and programming meaning
of the keywords to summarize useful information extracted from the problem.
Thirdly, another knowledge base with the name of D2 is applied to expand the
query by synonyms words and substitutions’ verbs. Fourthly, a dialogue-based
tutoring system is applied to interact with novice programmers and make necessary
online guidance to trace the finalized flowchart with the aim of improving solution
designing and problem solving skills. Last but not the least, a web crawler is
tasked to automatically search the Internet for the new and unknown programming
keywords and problems stored in D3 and add the relevant extracted information
from the Internet to D1. It is also should be noted that during the engagement of the
system with novices using dialogue-based tutoring system, they will be provided
with appropriate online feedbacks once the flowchart is being completed. Besides,
several pre-defined questions will be asked from users, using online system chat,
before and after completing the flowchart. The main purpose of this module is to
improve problem-solving skills as well as to support solution designing and design
activities. Therefore, by using dialogue-based tutoring system, novice programmers
are asked to identify the solution of a given problem, in English text, in a shape of
text-to-flowchart conversion along with finding the best possible way to complete
and trace the flowchart. It is also should be noted that unlike many other systems,
this framework has two parsers in order to simulate the logical and knowledge-
based human approach. The first one is applied to analyze the text and to extract
useful words out of textual description in order to produce language-free technical
summary, while the second one employs the produced technical summaries for
further processing and acting on the intermediate representation of the given
programming problem maintained by D1 knowledge base. Graphical module
generates the needed diagrams by taking each line of the draw-able representation
as input. Finally, it invokes the line-draw, point-draw or circle-draw functions and
passes the relevant set of data (e.g. coordinate values) as arguments of the functions.
And then, by each function in one entity, the relevant result is called to generate
digital flowchart on the computer display. By the time that all the entities are drawn
consecutively, the whole flowchart takes shape.
DIFFERENT CATEGORIES OF A GIVEN PROBLEM
Typical problems having keywords. In this type of problem, namely the Factorial,
Fibonacci series, palindrome number, quadratic equation, and etc, the proposed
system will go through listed process in below:
Text processing including parsing the sentence, noise removal, and main
words separation.
Referring to domain-specific knowledge-base, D1, to extract keywords with
cross-checking of words with each other.
Extract the relevant information and equation, and to pass them to
representation module; and after generating flowchart or sub-flowchart on the
screen, the dialogue-based tutoring system start communicating with novices to
make sure they comprehend the solution of given problem with giving them some
options to trace the generated flowchart.

634
Example 1. “Write a program to generate the Fibonacci series”. In this example,
after the text processing stage the output will be: to/TO generate/VB the/DT
Fibonacci/NN series/NNS.
At the second stage, it goes through D1 knowledge base to find keyword.
So, “Fibonacci” and “Fibonacci series” are recognized as keywords and their
respective information and equations will be passed to representation module.
The corresponding flowchart or sub-flowchart will be generated digitally and then
dialogue-based tutoring system starts questioning the novices to assure they fully
understand all solution designing stages, or it starts tracing the final flowchart in
order to show novices different steps of solution designing so as to improve their
problem-solving skills. The screenshot of FPE for example 1 is shown in Figure 2.
Figure 2. Workspace provided by FPE along with generated lowchart and the full
lowchart from the Internet.
Typical problems having no keywords.In this type of problems, namely: “Write a
program to return largest element in a list”, “Write a program to enter your name
and convert to uppercase”, and etc. the developed system will follow the process
mentioned in below:
Text processing including parsing the sentence, noise removal and main words
separation.
Referring to domain-specific knowledge-base to extract keywords with cross-
checking of words with each other.
If no keyword is found, it would be passed to query expansion which affects
verbs.
After generating flowchart or sub-flowchart on the screen, the natural language
dialogue system starts communicating with novices to make sure they comprehend
the solution of given problem with asking them to trace the generated flowchart. It

635
also should be noted that the system should be able to extract more keywords while
chatting with novices via dialogue-based tutoring system, and refer them back to
domain-specific knowledge base and query expansion to find more hints.
Example 2.“Write a program to find the largest among three numbers”. In this
example, after the text processing and noise removal stage the output will be:Find/
VB largest/JJS among/IN three/CD numbers/NNS.
In this example, once the tagged output words are entered, D2 recognizes
‘largest’ and extracts its synonyms such as ‘biggest’, ’max’, and ’maximum’ and
passes these three to D1. This means that keyword searching is started again with
the new words, for example ‘biggest’, ’max’, ’maximum’ and etc. By doing so, these
three are extracted as keywords. Then they are passed to the second parser to be
searched through the D1 knowledge base to extract more information for drawing
a flowchart. Information extracted from the keywords is passed to representation
module in order to plot the flowchart or sub-flowchart for novices.
Figure 3. Workspace provided by FPE along with generated lowchart and the full
lowchart from the Internet.
The worst case scenario. In this type of problem, namely: “Write a program in c to
accept sentence from user”, the system will go through following process in below:
Text processing including parsing the sentence, noise removal, and main
words separation
Referring to domain-specific knowledge-base to extract keywords with cross-
checking of words with each other
If no keyword is found, it would be passed to query expansion which affects
verbs

636
If no verb is recognized to be substituted or replaced by its synonyms in order
to expand the query, the proper shapes would be assigned to the main verbs and
the rest of the nouns are entered into the shape in order to build a proper flowchart.
After generating flowchart or sub-flowchart on the screen, the natural
language dialogue system start communicating with novices to make sure they
comprehend the solution of given problem with asking them to complete the final
flowchart out of given guidance, sub-flowchart, as well as giving them some options
to trace the generated flowchart. It also should be noted that the system should
be able to extract more keywords while chatting with novices via dialogue-based
tutoring system, and refer them back to domain-specific knowledge base and query
expansion to find more hints. It is worth mentioning that an on-line chat with admin
is designed for this mode to assure novices realize the final process of conversion
and to assure their problem-solving and solution designing skills are improved as
already targeted.
Example 3.“Write a program that asks the user to type an integer and write _you
win_ if the value is between 56 and 78”.
In this example, after the text processing and noise removal stage the output
will be:
Asks/VBZ user/NN type/VB integer/NN write/VB _/VBG you/PRP win/VB _/
NNS if/IN value/NN is/VBZ between/IN 56/CD 78/CD
In this example, ‘asks’ is assigned to a rectangle automatically as it is a process,
‘write’ is assigned to a parallelogram as it is a output, and finally ‘if’ is assigned to a
diamond as it is a condition, the generated sub-flowchart by the system for example
3 is shown in Figure 4.
Figure 4. Workspace provided by FPE along with the generated sub-lowchart
Evaluation and participants.

637
Evaluation and Participants. The current study participants comprise 50 first-
year undergraduate students from the University of Malaya (UM), Malaysia. They
mostly had no prior experience and knowledge of programming. The study was
conducted over two consecutive weeks and the study duration for each day was two,
two-hour sessions. Our initial hypothesis was to use FPE to improve the problem
solving skills of participants while reducing the syntactical burden inherent in most
programming languages. In the first session, the participants were supposed to solve
three given programming problems after a presentation of traditional instruction. In
the second session, participants were introduced to FPE with a 30-minute lecture
and then were asked to solve three given exercises using FPE. The programming
problems selected for this study were simple and basic, and their complexity
increased from one to another. They were basically extracted from the repository of
final exam questions of the computer science and information technology faculty
at UM. The participants were asked to solve 2 simple programming problems in
order to be introduced to using FPE and a few programming concepts. Examples
of special cases were provided for clarification. Evaluations were conducted in an
informal setting by ten evaluators every two hours. The five approaches selected to
evaluate FPE were: (1) Test the participants’ problem solving improvement while
being exposed to FPE; 2) Observe the users’ engagement with FPE; (3) Observe the
participants’ attitude toward the usability and efficacy of FPE by providing them
with a questionnaire after being exposed to FPE; (4) Interview participants during
and after exposure to FPE regarding usability and efficacy, and (5) Monitor the
participants’ problem solving skills.
Instruments and data collection. In evaluating FPE two key factors were
considered. First, the usability of FPE was regarded as similar to any other
software applications. Jacob Nielsen (2003) indicated that the usability of
software applications is employed to assess how easy to use user interfaces are.
Regarding FPE usability, the feedback gained from evaluation was categorized in
five general areas, namely ease of use, error handling, enjoyment, reliability and
website-related questions. Secondly, in order to prove whether FPE is educationally
beneficial to novice programmers, system efficacy should be assessed which
is the most important factor. Four instruments were applied in conducting this
study to ensure more accurate results regarding FPE usability and efficacy were
obtained. Questionnaires, observation and interviews were applied to collect
feedback and assess the participants’ satisfaction with their learning experience
using FPE. Moreover, problem solving monitoring was used to assess participants’
improvement in problem solving abilities. The first three data gathering techniques
obtained mainly subjective data. However, the latter was used to gather objective
data, or quantitative data, regarding the effect of FPE on improving the problem
solving skills of novice programmers. Monitoring the task completion times and
number of solved problems in each session were two methods used to gather data
(Warnlulasooriya et al. 2007, Hearrington 2009).

638
RESULTS AND DISCUSSION
This research is aimed to generate feedback regarding FPE usability, efficacy
and problem-solving ability. Table 1 and Figure 8 present the questionnaire
data gathered from the study, mean, standard deviation, variance as well as the
description and frequency of responses. In order to combine the results of the
questionnaires using different scales, percentage terms are used to present the data.
The questionnaire is divided into two groups: usability and efficacy.
Table 1. Questionnaire Results.
No
Study
Aim
Evaluation Criteria Mean
Std.
Deviation
Variance
1 Usability This programming tool is enjoyable to use 3.9800 .55291 .306
2 Usability
This programming tool is easy to use and
understand (I can learn how to use the tool
within 5 minutes)
4.3600 .85141 .725
3 Usability
The tool performs its function in a correct
and eficient manner
4.3800 .63535 .404
4 Usability The tool is speedy and responsive 4.1000 .50508 .255
5 Usability
The use of color is beneicial (The design
of this tool is attractive)
4.1400 .72871 .531
6 Usability Launching the tool is easy 4.2800 .64015 .410
7 Usability
The user interface design is appropriate for
an inexperienced user
4.1200 .84853 .720
8 Usability
The animation helped me develop a
solution and understand how a program
works
4.3600 .74942 .562
9 Usability
I enjoyed solving the programming
problem using this tool
4.6400 .48487 .235
10 Usability
System chat and instant feedback are
helpful
4.4400 .70450 .496
11 Usability
The error messages are helpful to provide
guidance to correct my mistake
4.1400 .63920 .409
12 Usability
The programming problems given are at
the right dificulty level for me
4.0200 .86873 .755
13 Eficacy
The automatic text-to-lowchart approach
is helpful when I have no idea about the
solution
4.2600 .98582 .972
14 Eficacy
The lowchart visualization helped me
when developing a solution
4.5400 .50346 .253
15 Eficacy
I had few problems learning how to use
the tool to develop my solution
3.0200 .79514 .632

639
16 Eficacy
The lowchart is useful for designing
computer programs and sharing ideas
4.6000 .49487 .245
17 Eficacy
I understand the relationship between
the lowchart and programming problem
statement after using the tool
4.5400 .64555 .417
18 Eficacy
The tool made the programming concept
easier to understand
4.2600 .69429 .482
19 Eficacy
I would recommend the tool to others who
want to learn programming
4.5400 .50346 .253
20 Eficacy
The tool enabled me to see a design
solution
4.4400 .73290 .537
21 Eficacy
The lowchart enabled me to understand
the solution being developed
4.6000 .49487 .245
22 Eficacy
I feel I have learnt some skills by using the
tool and solving the problems
4.1600 .68094 .464
23 Eficacy
The tool has positively inluenced my
interest in programming
3.9800 .95810 .918
24 Eficacy
The tool helped me understand how to
design a solution in programming
4.3000 .61445 .378
25 Eficacy
The tool helped me develop and improve
my solution designing and problem-
solving skills
4.3000 .76265 .582
26 Eficacy
The tool increased my understanding of
computer programming
4.2800 .57286 .328
27 Eficacy
The tool as a whole and its features helped
me overcome conceptual dificulties in
programming
4.3600 .69282 .480
28 Eficacy
The tool enables me to focus and improve
my problem solving skills
4.4400 .64397 .415

640
Figure 8. Questionnaire data gathered from 50 participants.
Upon collecting the evaluation results, their reliability should be studied.
Many methods have been applied by various researchers to measure reliability
and we used Cronbach’s Alpha in this research. This method is normally used to
measure internal consistency and the range is between 0 and 1. It is said that as
long as α is close to 1, it is reliable (Cronbach 1951) but overall, this range should be
higher than 0.7 to prove reliability. The Cronbach’s alpha measure for the usability
and efficacy of questions shown in Table 2 are greater than 0.7, which indicates the
high reliability level of this research and implies sufficient internal consistencies
have been judged for a reliable measure.
Table 2. Reliability Statistics.
Factor Cronbach’s Alpha
Usability .947
Efficacy .972
Generally, the data collected indicates the positivity of the research. Figure
9 illustrates the main results for the samples as a whole and individually for each
factor, where bars show the average score assigned to each item.

641
Figure 9. Results of students’ opinion about FPE.
The above diagram shows that participants liked learning with FPE and
they thought that FPE helped them enjoy problem-solving and solution designing
activities with ease of use. Other factors, such as web and online problem solving
tasks, overall efficacy, flowchart, animation, and error handling were indicated
highly positive by users. Most students reported high satisfaction with FPE. Table
3 provides additional details, the mean and standard deviation concerning various
factors. Regarding the efficacy of FPE in improving problem-solving skills, which
is considered the main goal of this research, the results indicate that the overall
system efficacy in problem-solving and solution designing activities was 4.60. This
signifies how successful FPE was in attaining the main aim of the research.
Table 3 Mean (M) and standard deviation (SD) for items about students’ opinion of
FPE.
Items Usability Eficacy M SD
Enjoyment * 3.9800 0.782
Ease of use * 4.3600 0.765
Reliability * 4.6400 0.870
Website and Online Problem Solving Tasks * 4.0200 0.910
Overall eficacy * 4.6000 1.028
Flowchart * 4.6400 1.037
Animation * 3.7600 0.980
Error handling * 4.3000 1.030
Analysis of the problems solving. In this section, problem solving activities along
with their efficacy are assessed. As indicated in previous sections, in order to
monitor participants’ problem solving activities, the improvement in the completion
time of 10 participants (Table 4), and the number of problems solved in each session
by 32 participants (Figure 10) were monitored and assessed. Once the learning
difficulties were tackled, the completion time decreased even though problem

642
complexity increased. Regarding the number of problems solved per session, by
using the system the majority of participants were at least able to solve one or two of
the given programming problems. This shows the effectiveness of FPE in problem
solving activities. A few participants were unable to solve problems before using
FPE, but by using FPE their problem solving abilities enhanced and they solved at
least one problem per session. In general, the feedback and results collected from
problem solving monitoring indicate that the participants found FPE very effective
and enjoyable. It should also be mentioned that some participants responded with
a low positive. The time limitation made some of the participants spend less time
familiarizing with FPE. Other factors affecting the evaluation results were age and
gender, which should be investigated further.
In spite of the fact that the problems grew in complexity from one to the
next, the time completion rate results shown in Table 4 demonstrate a decline in
completion time with each successive problem. During problem solving monitoring,
there were four evaluators who were not able to complete problems a2 and a3.
However, by using FPE not only could they tackle this issue, but the time decrement
in completion time for problems b2 and b3 was a real surprise. This shows that FPE
and the problem solving activities had a very positive impact on the problem solving
skills of most evaluators.
Figure 10. Average number of problems completed per session.

643
Table 4. Time completion rates of 10 participants in two different sessions.
Participant
No
Problem
a1
Problem
a2
Problem
a3
Problem
b1
Problem
b2
Problem
b3
1 2:45 min 2:20 min 3:00 min 2:40 min 2:10 min 3:00 min
2 3:10 min 3:00 min 1:55 min 2:10 min 2:45 min
5 4:00 min 2:30 min 2:40 min 2:30 min
9 2:00 min 3:10 min 1:20 min 1:55 min 1:55 min
Max 4:00 min 3:10 min 3:00 min 2:40 min 2:50 min 3:00 min
Min 1:50 min 1:50 min 2:00 min 1:10 min 1:30 min 1:40 min
Avg. Time 2:27 min 2:32 min 2:38 min 1:55 min 2:07 min 2:18 min
No 10 9 7 10 10 10
CONCLUSION AND FUTURE WORK
At present, in an attempt to introduce novices to programming and also
for introductory programming developments, iconic based environments and
flowchart-based notation are largely used to enhance their logical and critical
thinking skills (Barzegar et al. 2010). More research in this field has revealed
that the lack of problem-solving skills is exacerbated by language syntax that the
novices employ. This might result in giving up trying and losing interest, which
can lead to dropping out and higher failure rates. Thus, our proposed novel text-to-
flowchart conversion approach intends to simulate human mechanism of solving a
programming problem, stated in English, prompting novices to focus on solution
rather than on programming syntax by engaging them in meaningful planning
activities and solution designing so as to improve their problem solving skills. Two
knowledge base systems are applied to draw the corresponding flowchart as well as
a dialogue-based tutoring system, which gets novices involved in a dialogue and ask
them to complete the corresponding flowchart or tracing the finalized flowchart
with the aim of improving solution designing and problem solving skills. A Web
crawler is designed to automatically search the Internet for the new and unknown
programming problems entered by users and add the relevant extracted information
from the Internet to D1 knowledge base. The proposed approach applied in FPE is an
advance and improvement over many existing visual programming environments.
An E-learning environment that visualizes the solution construction for a
programming problem by automatically converting the given problem statement to
its relevant flowchart while engaging users in flowchart development, will provide

644
novices with an accurate mental model of execution. Thus, the main aim of this
study is to support the problem-solving ability through designing activities. We
believe FPE was very successful because the criteria were designed carefully. The
system benefits from a mature repository of basic and fundamental programming
problems aimed at novice programmers along with a novel approach of automatic
text-to-flowchart conversion, which enables FPE to get novices involved in
flowchart development. There are not many developed visualization tools intended
for students with no prior knowledge of programming. Besides our system, a few
others have been developed, such as SICAS (Gomes & Mendes 2000) and RAPTOR
(Carlisle et al. 2005). They are similar to FPE in a sense that they provide students
with an environment for flowchart construction and visualization. However, the
novel approach applied in FPE distinguishes it from other related works. Novice
programmers who do not know anything about programming are sometimes unable
tousetheaforementionedtoolsastheyrequiresomesortofuserknowledgeregarding
the entered programming problems. FPE resolves this inconvenience using a web-
based environment to get users involved in flowchart development of the entered
programming problem. It is worth mentioning that even the worst case scenarios
are improvised in our proposed system in order to fully assist users, even in terms
of problems that are not stored in the main system repository. Additionally, FPE
automatically improves its repository using an extra database to store the unknown
entered programming problems along with web crawlers to enhance its main
database. FPE received very positive feedback from 50 first-year undergraduate
students taking their first introductory courses in programming, “Programming
1” at University of Malaya. Various evaluation methods showed that FPE could
improve the participants’ problem solving skills. The main contribution of this work
is a novel flowchart-based programming environment benefiting from an automatic
text-to-flowchart conversion approach for improving problem-solving skills of
novice programmers in a form of solution designing activities. FPE can be utilized
in many academic applications namely in problem solving, drawing diagrams, and
etc. as well as to make teaching programming subjects a more appealing option for
instructors. Consequently, the results suggested future, further development of a
text-to-flowchart conversion approach in the form of a Multi-Agent System (MAS)
in order to make the early stages of learning programming more encouraging for
students.
ACKNOWLEDGMENTS
This work is inancially supported by the Postgraduate Research Grant (PPP) of
University of Malaya under the Project PG072-2014 A.
LITERATURE CITED
Barzegar, S., M. Shojafar and M.R.Keyvanpour. 2010. Improvement user interface in virtual
learnin environment. International Journal of Digital Society 1(3): 21-29.
Ben-Ari, M. 2001.Constructivism in computer science education. Journal of Computers in
Mathematics and Science Teaching 20: 45-73.
Boada, I., J. Soler, F. Prados and J. Poch. 2004. A teaching/learning support tool for
introductory programming courses, pp. 604-609. In: Proceedings of the 5th
International

645
Conference on Information Technology Based Higher Education and Training, Spain,
31 May-2 June 2004.
Carlisle, M.C., T. Wilson, J. Humphries and S. Hadield. 2005. RAPTOR: A visual
programming environment for teaching algorithmic problem solving, pp. 176-180. In:
Proceedings. of the 36th SIGCSE Technical Symposium on Computer Science Education,
United States Air Force Academy, USAFA, CO, USA, 2005.
Carter, J. and T. Jenkins. 1999. Gender and programming: What’s going on? pp. 1-4. In:
Proceedings of the 4th
Annual Conference on Innovation and Technology in Computer
Science Education, Poland, 1999.
Chang, K.E., Y.T. So and H.F. Lin. 2005. Computer-assisted learning for mathematical
problem solving. Computers and Education 46 (2): 140-151.
Cronbach, L.J. 1951. Coeficient alpha and the internal structure of tests. Psychometrika
16: 297-334.
Gomes, A. and Mendes, A.J. 2000. Suporte à aprendizagem da programação com o ambiente
SICAS. In: Proceedings of the V Congresso Ibero-Americano de Informática Educativa,
Leiria, Portugal, 16-18 Novembro de 2000.
Hearrington, D. 2009.Learning eficiency and eficacy in a multi-user virtual environment,
International Society for Technology in Education, Journal of Digital Learning in Teacher
Education 27(2): 65-75.
Hooshyar, D., R.B. Ahmad, M.H. Nasir, Md. Nizam and W.C. Mun.2014. Flowchart-based
approach to aid novice programmers: A novel framework. International Conference on
Computer and Information Sciences (ICCOINS), Kuala Lumpur, Malaysia, 3-5 June 2014.
doi: 10.1109/ICCOINS.2014.6868826
Hooshyar, D., T. Maíen and M. Masih. 2013. Flowchart-based programming environments
aimed at novices. International Journal of Innovative Ideas 13(1): 52-62.
Koedinger, K.R. and E.L.F. Sueker. 1996. PAT goes to college: Evaluating a cogni-
tive tutor for Developmental Mathematics, pp.180-187. In: Proceedings of the Second
International Conference on the Learning Sciences, where exactly, when?
Looi, C.K. and B.T. Tan. 1998. A Cognitive-apprenticeship-based environment for
learning word problem solving. Journal for Research in Mathematical Education
17(4): 339-354.
Mayer, R.E. 1981.The psychology of how novices learn computer programming. Computer
Surveys 13: 121-141.
McCracken, M. V. Almstrum, D. Diaz, M. Guzdial, D. Hagan, Y.B. Kolikant,
C. Laxer, L. Thomas, I. Utting, and T. Wilusz. 2001. A multinational, multi-institutional
study of assessment of programming skills of irst-year CS students, pp. 125-180. In:
Proceedings of the 6th
Annual Conference on Innovation and Technology in Computer
Science Education, ACM, New York, NY, USA, c. 2001.
Moghadam, M.K., M. Shojafar, M.R. Nami and H. Rashidi. 2013. A new multi-agent
system for e-health functionalites. International Journal of Software Engineering and Its
Applications7(3): 23-34.
Moser, R. 1997. A fantasy adventure game as a learning environment: why learning to
program is so dificult and what can be done about it, ACM SIGCSE Bulletin 29: 114-116.
Mukherjee, A. and U. Garain. 2009. A review of methods for automatic understanding of
natural language mathematical problems. Artiicial Intelligence Review 29(2): 93-122.
Mukherjee, A. U. Garain and A. Biswas. 2013. Automatic Text-to-Diagram Conversion: A
novel teaching aid for the blind people. Journal on Educational Technology and Society
17(3): 40.
Nielsen, J. 2003. Usability 101: Introduction to Usability, Nielsen Norman Group, Freemont,
CA, USA. http://www.useit.com/alertbox/20030825.html. Accessed 06/05/2014.

646
Oberem, G.E. 1987. ALBERT: A Physics problem solving monitor and coach, pp.179-84.
In: Proceedings of the First International Conference on Computer Assisted Learning
(ICCAL’87), Calgary, Alberta, Canada, 25-30 June 1994.
Oberem, G.E., P.S. Shaffer and L.C. McDermott. 1993. Using a computer to investigate and
address student dificulties in drawing free-body diagrams. A paper presented at the Sum-
mer Meeting of the American Association of Physics Teachers, Boise, ID, USA,
Pillay, N. 2003. Developing intelligent programming tutors for novice programmers. ACM
SIGCSE Bulletin 35: 78-82.
Pillay, N. and V. Jugoo. 2005. An investigation into student characteristics affecting novice
programming performance. ACM SIGCSE Bulletin 37: 107-110.
Spohrer, J.C. and E. Soloway. 1985. Putting it all together is hard for novice programmers,
pp. 728-735. In: Proceedings of the IEEE International Conference on Systems, Man and
Cybernetics, Tucson, Arizona, USA.
Steele, M. and J. Steele. 1999. DISCOVER: An intelligent tutoring system for teaching
students with learning dificulties to solve word problems. Journal of Computers in
Mathematics and Science Teaching 18(4): 351-359.
Warnlulasooriya, R., D. Palazzo and D. Pritchard. 2007. Journal of Experimental
Analysis of Behaviour 88(1): 103-113.
Wheeler, J.L. and J.W. Regian. 1999. The use of a cognitive tutoring system in the
improvement of the abstract reasoning component of word problem solving. Computer in
Human Behavior 15: 243-254.
Wong, W.K., S.-C. Hsu, S.-H. Wu, C.-W. Lee and W.-L. Hsu. 2007. LIMG: Learner-
Initiating Instruction Model based on cognitive knowledge for geometry word problem
comprehension. Computers and Education 48(4): 582-601.
Beyond Excellence©
e-mails: asialifesciences@yahoo.com wsmgruezo@gmail.com
http://journals.uplb.edu.ph/index.php/ALS
©Rushing Water Publishers Ltd., Philippines 2015
Asia Life Sciences has an Impact Factor of 0.259.
Asia Life Sciences is a recipient of the Journal Accreditation
Award of the Commission on Higher Education (CHED),
Republic of the Philippines (2010-2015).
Printed on acid-free papers

A Flowchart-based Programming Environment for Improving Problem Solving Skills of Cs minors in computer programming.pdf

More Related Content

Similar to A Flowchart-based Programming Environment for Improving Problem Solving Skills of Cs minors in computer programming.pdf

More from Cynthia Velynne

Recently uploaded

A Flowchart-based Programming Environment for Improving Problem Solving Skills of Cs minors in computer programming.pdf