IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
211
A Programming Learning System for Beginners— A Completion Strategy Approach Kuo-En Chang, Bea-Chu Chiao, Sei-Wang Chen, and Rong-Shue Hsiao
Abstract—The purpose of this research is to develop a programming learning system for beginners using the completion strategy. The completion strategy uses well-designed programs to let students engage in completing, modifying, and extending their programs. The completion strategy is a paradigm of learning by examples with learning enforcement. In this paper, learning theories of the completion strategy are investigated. A template technique is employed to realize the strategy. An educational experiment was made to show the learning impact of the proposed system. The experimental result shows that the completion strategy is benefit to the programming learning for beginners. Index Terms—Completion strategy, programming learning, template technique.
I. INTRODUCTION
S
YSTEMS for teaching programming have been studied for many years with the purpose of helping students to establish programming concepts and skills. Programming tutors such as Lisp Tutor [4], PROUST [8], Bridge [3], ELM-PE [15], [16], and CAPRA [9], are available. These systems assist students in acquiring programming skills through the development of specific programs. These systems display a problem on the screen, with an editor, which allows students to either design a program freely, or to utilize a function list to develop plans to organize a program. Later, syntax and semantics errors in the program are detected by the system. These systems tell students where and why the mistakes are made and initiate corrections. The approach of asking students to independently design and write a complete program has been referred to as the Program Generation Strategy. However, asking beginners to initiate a program out of the blue will easily cause frustration to them and further lower their learning motive. Furthermore, the program solutions to a problem are often not limited to one. For any problem, systems usually take much time to trace a program solution that may be different for each student. To compensate for this drawback, Gegg-Harrison [6], [7] presented an approach that let students fill in or complete blanks in the program assignment. Van Merrienboer [13], [14] has proposed a completion strategy as the basis of a programming tutor for beginners. The completion Manuscript received January 21, 1997; revised January 28, 2000. This work was supported in part by the National Science Council of the R.O.C. under Contract NSC-85-2511-S-003-043. K.-E. Chang, B.-C. Chiao, and S.-W. Chen are with the Department of Information and Computer Education, National Taiwan Normal University, Taipei, Taiwan, R.O.C. (e-mail:
[email protected]). R.-S. Hsiao is with the Department of Electronic Engineering, National Taipei University of Technology, Taipei, Taiwan, R.O.C. Publisher Item Identifier S 0018-9359(00)04191-1.
strategy uses a well-designed program (i.e., a program designed by an expert). With the well-designed program, students are allowed to complete, modify, and extend it. While students engage in the completion, modification, and extension, they will learn programming concepts and skills. The completion strategy is a paradigm of learning by examples with learning enforcement. The filling-in-blank proposed in Gegg-Harrison is one of learning enforcement. Except of filling-in-blank (or close), the completion strategy also proposed two learning enforcement, modification and extension. Van Merrienboer has proved that the completion strategy is effective on programming learning for beginners. The benefits of adopting this strategy are as follows. 1) The practice patterns can be multi-phased to stimulate learning motivation. 2) The correct answer can be limited to a small area to simplify the complex diagnosis process of tracing program. The purpose of this research is founded on the completion strategy to develop a programming learning system and further allow students to systematically establish basic programming concepts and skills. In the next section, the programming learning theories and the completion strategy are explored. Section III introduces the system structure and template technique. The template technique is used to realize the completion strategy. In Section IV, an experiment is used to evaluate the proposed system. Section V concludes the study. II. THEORIES OF LEARNING PROGRAMMING Deimel and Moffat [5] suggested that there should be four steps in an introduction course of programming. Step 1) Let students execute program in order to observe its execution and evaluate its benefits and limitations. Step 2) Have students study fine structured programs. Step 3) Have students engage in program’s modification and extension. Step 4) Let students independently design and write a new program. Anderson et al. [2] pointed out that students often use good examples as blue prints to solve new problems. In other words, students rewrite the original model program to adapt for the quests of new problems. Adelson [1] indicated that students should establish problem solving knowledge through program functions, pay attention to the similarity of well-known program functions, distinguish program sections, and apply the well-known program functions into the newly designed
0018–9359/00$10.00 © 2000 IEEE
212
IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
Fig. 1.
Programming tutor exercises (completion strategy application).
program. It is known that, for beginners, using examples to conduct the first three steps of programming training in [5] is a fine strategy. Due to the nature of beginners not being familiar with the programming approaches, van Merrienboer and Krammer [12] initiated the completion strategy. The completion strategy uses well-designed programs as basic programs to be completed, modified and extended. The completion strategy suggests that the learning contents or programming skills should exist in the well-designed programs. These model programs may be complete or incomplete, and it is students’ duty to modify or extend the original model program. Van Merrienboer [13], [14] has proved that the completion strategy would produce effective programming learning for beginners. In terms of completion strategy, the learning content is a combination of model programs and matching operation patterns, such as cloze (filling in blanks), modification, and extension. These patterns are named the learning operators which give birth to a variety of questions for beginners to learn. The three operators are: 1) Clozing operator: Several parts of the complete program are left out and students need to fill in the correct answers. The blanks represent the important concepts which the system wants students to learn, for example the first and second exercises shown in Fig. 1. The first exercise is to train students on how to find the accumulation, and the
second exercise is to train students on how to obtain the average. 2) Modifying operator: Rewrite the program to improve it, simplify it, or use another program to perform the same function. The third exercise in Fig. 1 is a typical example. The purpose of this modifying operator is to allow students to understand the meaning of the algorithm and the role that each statement plays in the program. 3) Extending operator: Add new criteria or new commands to the original questions, and have students rewrite the old program by adding or subtracting some steps. For instance, the fourth exercise in Fig. 1 adds new commands to the original question, and students have to rewrite the model program for satisfying the new requirements. The purpose of the extending operator is to stimulate students’ ability to establish problem-solving strategies. Fig.2 shows another example applying the completion strategy. The exercise 1 practices the clozing form. The exercises 2 and 3 are the practices to modify the model program. The extending problems are given in the exercises 4 and 5. Another benefit for using the completion strategy is to force students to study model programs carefully. The students may also use these model programs as the analogical foundations through analyzing and imitation. Based on the analogical foundations or learning by model programs, the programming knowledge will be established.
CHANG et al.: A PROGRAMMING LEARNING SYSTEM FOR BEGINNERS
Fig. 2.
213
Example of completion strategy application.
Oliver [10] initiated a hierarchical structure on programming knowledge based on his experiment. There are three basic types of programming knowledge: 1) Understanding of syntax or program structure. 2) The ability to apply statements (this means to combine statements and organize them into algorithm). 3) The problem solving ability. For the first type of knowledge, Oliver concluded that students have to be able to trace algorithms and understand any statement in programs, instead of understanding the content of operations. In regards to the second type of knowledge, Oliver believed that beginners have to know the meaning of operations. When facing a problem with solution being similar to a model program, students have to use the model program to solve this problem. For the third type of knowledge, Oliver considered the limited knowledge of beginners. Therefore, he did not emphasize students writing a program independently, but rather requested students to rewrite the model program to satisfy the augmented demands of the question. For proving the hierarchical structure of programming knowledge, Oliver has designed a test named Algorithmic Process Test (APT). The process in APT is divided into three steps to understand students’ three types of programming knowledge. In each step, there are some testing problems designed to meet the requirements for each type of programming knowledge.
On the basis of the above discussion, the completion strategy matches Oliver’s theory. Both believe beginners should start with cloze learning, then work on modifying and extending exercises to be able to independently write a complete program. To summarize, it was concluded that the completion strategy is the more appropriate learning method for beginners; hence, the completion strategy was used to develop our programming learning system. III. SYSTEM STRUCTURE The purpose of this research is to develop a completion strategy-based programming learning system to allow students to practice clozing, modifying, and extending exercises, and practice how to use the existing model programs. The proposed system is operated as follows. The system first offers students a problem description and a model program, and the students may engage in clozing, modifying, and extending the program. Then, the system makes evaluations on the students’ augmentations. According to the evaluations, the system records the students’ learning status. Then, the system chooses the next problem based on the students’ learning status. This procedure continuously repeats until the students have learned the programming skills. There are five units in the system, as shown in Fig. 3. The problem database is a collection of problems which may be used
214
Fig. 3.
IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
Structure of programming learning system.
Fig. 4. Main portions of problem description.
for students to practice. The problem generator can select appropriate problems from the database. Using the template library, the problems will be transformed into appropriate exercises according to the student’s learning status in the student model. These exercises will be displayed on the user interface for the student to practice. The evaluator will check the correctness of the student’s answers to make an evaluation on the patterns of his/her mistakes. The student model will be recorded through the conclusions from evaluator, and sum up the entire student’s learning data to decide the learning concepts that the student has to learn. Therefore, while the problem generator makes the next problem, the system is able to initiate appropriate exercises that cater to the student’s demands. A. Problem Database The problem database collects various problems of which the contents emphasize on certain portions of the programming con-
cepts, for instance, loop or conditional branch. In terms of this system, when an exercise is presented to students, an incomplete model program is displayed along with problem description. To comply with the problem generator to design exercises and to ensure the problems produced are meaningful, a simple language to describe the core problem has been designed. An example problem description in the problem database is shown in Fig. 4, in which the “text” portion is the problem description. The “solution” portion describes the model program. The model program is defined by some templates. In each “template ,” the name of the template directly follows the alphabets of “template,” then is a series of parameters. For example, of “template sum-initialize (sum, 0),” the template is named as sum_initialize, sum and 0 are parameters. Each template is defined as a representation of a basic programming concept. The basic programming concepts are those which the system wants the students to learn in the problem. The definition
CHANG et al.: A PROGRAMMING LEARNING SYSTEM FOR BEGINNERS
215
Fig. 5. Description of modification exercise.
Fig. 6. Description of extension exercise.
of template will be discussed in the next subsection. The “modification” and “extension,” indicate the exercises evolving from modification and extension learning operators, respectively. Fig. 4 shows that the problem no. 3 (such as no. 3) may evolve one “modification” exercise (modification 1) and one “extension” exercise (extension 1) ,which are defined in Figs. 5 and 6. In the example of Fig. 5 or Fig. 6, besides indicating the problem that the exercise belongs to (belong-to portion) and exercise description (text portion), it also defines the solution of exercise (solution portion). Evaluator will refer the solution that represented by templates in order to compare with the students’ answers. In the following sections, we will discuss how to obtain the program solution and evaluate students’ answers based on the template technique. B. Template Library A fine problem description should be ableto allow the evaluator to “understand” the program, know the modifications made by students, and further evaluate their solutions. If model programs are only described by source statements, then the only method by which the evaluator can judge the correctness of the students’ modifications is through program code comparison. The work of comparison is impractical and difficult because all possible “correct” program codes have to be pre-stored. For instance, there are so many alternates to express the statement of “
Fig. 7.
Definition of a template.
,” it is impossible to store each one of them. Therefore, the other representations have to be used for overcoming the difficulty in the work of code comparison. For example, the LISP tutor [4] used a rule-based representation for the definition of problem. The proposed system uses the template technique. The concept of template library was studied in [11]. A template is defined as a basic building unit to construct a program. Template library collects all templates of problem solutions. In general, all problem solutions have their implications concerning programming skills and concepts, especially to the program fragment in small problems. In other words, each template that defines the program fragment to solve a problem represents an important concept that students have to learn. Thus, when students learn a certain template, they learn the concepts that are contained within this template. In the example of Fig. 7, the
216
Fig. 8.
IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
Model program converted from problem defined in Fig. 4 based on template technique.
template represents the concept of “divisor may not be zero,” hence, learning this template may allow students to understand the content of “divisor may not be zero”. The semantics of the template language are explained next. In Fig. 7, the sign of “name” indicates the name of template; the “parameter” portion lists all parameters used in the template; the “code” portion is to solve problems with the BASIC Language. Referring to Fig. 4, in the use of “template average(sum, count, average), the template will, respectively, replace the ?sum, ?cnt, ?avg in the definition of “average” template, shown in Fig. 7, by sum, count, average. The Appendix also lists some template definitions related to the model programs defined in Figs. 4, 5, and 6. There are three reasons to use templates to define problems. First, students should learn the technique of using templates as basic units. Familiarity with solving small problems is prerequisites for students to solve larger problems. Secondly, the template representation is beneficial for the problem generator to effectively produce appropriate exercises and model programs. In addition, the benefit of using the template approach is that the “code” portion in the definition of the template may easily be changed when a different program language is to be taught, instead of rewriting the whole system. To use the template library and the problem database, the model program can be defined. In the example of Fig. 3, referring to the template definitions in the Appendix, the model program will be obtained by the expansion in Fig. 8. Each template in Fig. 4 is expanded to source codes by the approach, described in Fig. 8, similar to the macro expansion used in macro assembler.
C. Problem Generator Based on the completion strategy of van Merrienboer, three learning operators are proposed which include cloze, modification, and extension. Utilizing the recorded data of student model, in complying with these operators, the problem generator may produce exercises that cater to students’ weakness to reinforce or correct their concept learning. The existence of these operators brings another benefit that is the diverse exercise patterns. This may well stimulate student’s motivation to learn accordingly. Suppose a student is having a problem with addition or ignores the concept of “divisor may not be zero”. At this time, the problem generator will look for the template of “sum_value” in the problem library for the student to reinforce his/her addition concept; or to look for the problem in “average” template to correct his/her concept of division. After the exercise is completed, the problem generator will transfer the problem “solution” defined in the problem database into BASIC model programs through the use of templates in the template library, as the translation shown in Fig. 8. As the problem of Fig. 4 illustrates, both the “sum_value” template and the “average” template are ones which students should learn, so the problem generator will automatically reserve these two templates for students to fill in, these become the clozing exercises. As students are familiar with certain templates, the problem generator will elevate the complexity of the problems, and submit more difficult exercises, which means the modification or extension programs. “Modification” and “extension” are added to every problem in the problem database (referring to
CHANG et al.: A PROGRAMMING LEARNING SYSTEM FOR BEGINNERS
217
Fig. 9. Improved extension exercise (presented in clozing form).
Figs. 4–6). When engaging in modification or extension, the problem generator may reveal the exercise description and model program for students to rewrite. Considering the learning situation of the beginner, when facing “modification” and “extension” exercises, the proposed system adopts the “guide-based” learning approach that makes the extending or modifying portions of model program in clozing form to have students only fill them out but do not rewrite the whole program. To beginners, the cloze pattern will guide them to learn the content. At the same time, this clozing form may avoid large changes to model program and simplify the work of evaluator. Fig. 9 is an example of extension exercise presented in clozing form. The cloze pattern is designed to lure students to answer. D. Evaluator The system offers model programs for students to practice and fill. The students’ answers are to fill statements or tokens in the blanks of the model program. To evaluate the students’ answers, the evaluator has to know the correct solution that is easily derived from the problem generator. The evaluator then compares the derived solutions with students’ answers. In the event of mismatch, the mistaken statements or tokens can be
determined. Each statement or token has an associated template. The mismatch of the statement or token means the associated mistaken template is decided by the evaluator. At the same time, the evaluator will change the students’ learning records in the student model. Using Fig. 10 as an example, while comparing with the student’s solution and the system’s correct answer, it is obvious that the mismatch occurs on line 50. The statement of line 50 has the associated template “sum_value”. The evaluator will record the template “sum_value” into the student model. The student model is represented as the pattern of Fig. 11. The attribute records the names of mistaken templates. When a misunderstood template XXX is found, a [Student (attribute XXX)] will be recorded. If the evaluator has detected the correct answer achieved by the student and the corresponding template is in the record, the template is removed from the record. The problem generator produces exercises based on the student’s learning records in the student model. The problem generator first marks the templates in the solution portion of the problem definition in the problem database. To mark templates means that these marked templates have to be learned by the student. Student’s learning records state a series of misunderstood concepts or wrong doing templates. The generator marks the corresponding templates according to the student learning
218
Fig. 10.
IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
Error example of a student.
Fig. 11. Form of student model.
record. After this, the generator will translate the codes in templates into the source program. During the translating process, if marked templates have been found, the clozing portions are determined. IV. EXPERIMENT Van Merrienboer [14], [15] has investigated the effects on learning outcomes for the completion strategy and generation strategy. He divided subjects into a completion group and a generation group, and concluded the completion strategy has the following benefits on the programming learning: 1) The completion strategy is superior to the generation strategy for program construction. 2) Students in the completion group often had less difficulties in findings or coding a solution to their conventional programming problems. 3) Students in the completion group had high acquisition of templates and thus superior programming ability. 4) The better use of templates in the completion group resulted in a higher overall quality of the programs. Although the benefits of the completion strategy were proven by van Merrienboer, it was important to evaluate our proposed system on learning outcomes. The samples from high school freshman were used. The students had just begun to learn programming. In this experiment, the students were randomly divided into two different groups with 24 students in a control group and 21 students in an experiment group. The students in both groups attended classroom lectures. In addition to the normal class teaching, all students took 30 min to practice their programming after each class. In the practice time, the students in the control group studied the programming by themselves and the students in the experiment group completed the programming practices using our system. After the course, all students took a test. The test was designed to satisfy the principles in the Oliver’s APT testing [10]. The test includes the problems of choice, cloze, and program design. The choice problems are to evaluate the students’ memorization and basic comprehension. The design of choice problems meets the first step of the APT test. The cloze problem is to test students’ abilities to apply statements, satisfying the
conditions to the second step of the APT test. The program design problems tested the students’ problem solving ability which meets the third step of the APT test. Based on the results of the test, the learning outcomes of the students in the two groups are shown on Table I. The table shows that the completion strategy is superior to the conventional class teaching methods, especially on the knowledge of applying statements and the abilities of designing programs. To better understand the students’ perspective on the system, a questionnaire was given to students in the experiment group. From the questionnaires, most of the students affirmed the system: 76.2% of the students thought that this system gives rise to more motive in learning BASIC programming; and 71.4% of the students agreed this system is helpful in the learning process. V. CONCLUSION The traditional programming tutoring systems require students to write a complete program, which can be overwhelming to the students and may decrease their willingness to learn. This research adopts the completion strategy to guide students to learn programming. The completion strategy focuses on the utilization of well-designed cloze, modification, and extension learning program for beginners. Van Merrienboer has made a conclusion that the completion strategy might be used to teach effectively the elementary computer programming, and suggested that the use of the completion strategy might prove to be important to the design of intelligent tutoring system for the novice programming learning. Gegg-Herrison [6], [7] has designed a programming learning system with the fill-in-blank learning operator that is one of the learning operators in the completion strategy. To our knowledge, no learning systems based on the completion strategy with three learning operators have been reported. In this paper, the completion strategy is implemented and a learning system of programming for beginners by the use of template technique is proposed. The system consists of problem database, template library, student model, problem generator, and evaluator. This programming learning system was developed on MS-Windows. The language taught by the system is BASIC. The development tool CLIPS of expert system was adopted to design problem generator and evaluator. CLIPS were used to write inference rules and procedures to be responsible for producing exercises and evaluating the correctness of the student’s answer. The successful operation of the system lies in the user interface. Students not familiar with programming will not harmonize with the system, unless friendly a user interface
CHANG et al.: A PROGRAMMING LEARNING SYSTEM FOR BEGINNERS
219
TABLE I THE AVERAGE SCORES OF THE TEST ON THE THREE TYPES OF PROBLEMS
is used. Therefore, we used VISUAL BASIC to develop the user interface. In this system, the difficulty and the complexity of the problem design are limited for the beginners. The present problem library has eight subjects, and there are at least four exercises in every subject. This system puts emphases on the learning of programming skills, instead of language teaching; thus users must have the basic language knowledge. Although van Merrienboer has demonstrated the advantages of the completion strategy, our system was also evaluated on learning outcomes. Based on this experiment, the system was shown to be satisfactory, especially on the knowledge of applying statements and the abilities of designing programs.
6. (template name: sentinel_control_input parameter: ?new, ?cnt, ?sum, ?stop code: template input(?new) while ?stop do template counter_value(?cnt) template sum_value(?sum, ?new) template input(?new) wend ) 7. (template name: average parameter: ?sum, ?cnt, ?avg code: if ?cnt 0 then ?avg ?sum/?cnt template output(?avg)
APPENDIX SOME TEMPLATE DEFINITIONS
else print “no data” ) 8. (template name: sentinel_control_condition_input
1. (template name: sum_initialize
parameter: ?new, ?cnt, ?sum, ?stop
parmeter: ?tot, ?value
code: template condition_input(?new)
code: ?tot ?value
while ?stop do
)
template counter_value(?cnt)
2. (template name: sum_value
template sum_value(?sum, ?new)
paremeter: ?tot, ?no
template condition_input(?new)
code: ?tot ?tot ?no )
wend )
3. (template name: counter_initialize
9. (template name: condition_input
parameter: ?cnt
parameter: ?new, ?condition
code: ?cnt 0
code: template input(?new)
)
while ?condition do
4. (template name: counter_value
print “error input! please input again:”
parameter: ?tot
template input(?new)
code: ?tot ?tot 1 )
wend )
5. (template name: input
10. (template name: output
parameter: ?no
parameter: ?str
code: input “please input a number:”; ?no )
code: print ?str )
220
IEEE TRANSACTIONS ON EDUCATION, VOL. 43, NO. 2, MAY 2000
REFERENCES [1] B. Adelson, “Problem solving and the development of abstract categories in programming languages,” Memory and Cognition, vol. 9, no. 4, pp. 422–433, 1981. [2] J. R. Anderson, R. Farrell, and R. Sauers, “Learning to program in Lisp,” Cognitive Science, vol. 8, no. 2, pp. 87–129, 1984. [3] J. G. Bonar and R. Cummingham, “BRIDGE: Tutoring the programming process,” in Intelligent Tutoring Systems: Lessons Learned, J. Psatka, D. Massey, and S. A. Nutter, Eds. Hillsdale, NJ: LEA, 1988. [4] A. T. Corbett and J. R. Anderson, “LISP intelligent tutoring system: Research in skill acquisition,” in Computer-Assisted Instruction and Intelligent Tutoring System: Shared Goals and Complementary Approaches, J. H. Larkin and R. W. Chabay, Eds. Hillsdale, NJ: Lawrence Earlbaum, 1992. [5] L. E. Deimel and D. V. Moffat, “A more analytical approach to teaching the introductory programming course,” in Proc. NECC, J. Smith and M. Schuster, Eds., 1982. [6] T. S. Gegg-Harrison, “Learning Prolog in a schema-based environment,” Instruc. Sci., vol. 20, no. 2/3, pp. 173–192, 1991. , “ADAPT: Automated debugging in an adaptive Prolog tutor,” in [7] Proc. 2nd Int. Conf., ITS’92, 1992, pp. 343–350. [8] W. L. Johnson and E. Soloway, “PROUST: An automatic debugger for Pascal programs,” in Artificial Intelligence & Instruction: Applications and Methods, G. P. Kearsley, Ed. Menlo Park, CA, 1987. [9] U. Maite and V. M. Felisa, “A cooperative system for the interactive debugging of novice programming errors,” in Instructional Models in Computer-Based Learning Environments, S. Dijkstra, H. P. M. Krammer, and J. J. G. van Merrienboer, Eds. New York: Springer-Verlag, 1992. [10] R. Oliver, “Measuring hierarchical levels of programming knowledge,” J. Educational Computing Research, vol. 9, no. 3, pp. 299–312, 1993. [11] P. K. Schank, M. C. Linn, and M. J. Clancy, “Supporting PASCAL programming with an on-line template library and case studies,” Int. J. Man-Mach. Stud., vol. 38, no. 6, pp. 1031–1048, 1993. [12] J. J. G. van Merrienboer and H. P. Krammer, “Instructional strategies and tactics for the design,” Computers and Education, vol. 10, pp. 375–378, 1987. [13] J. J. G. van Merrienboer, “Strategies for programming instruction in high school: Program completion vs. program generation,” J. Educational Computing Research, vol. 6, no. 3, pp. 265–285, 1990. [14] J. J. G. van Merrienboer and M. B. M. De Croock, “Strategies for computer-based programming instruction: Program completion VS. program generation,” J. Educational Computing Research, vol. 8, no. 3, pp. 365–394, 1992. [15] G. Weber and A. Mollenberg, “ELM-PE: A knowledge-based programming environment for learning LISP,” in Proc. ED-MEDIA’94, 1994, pp. 557–562. [16] G. Weber, “Providing examples and individual remindings in an intelligent programming environment,” in Proc. AI-ED’95, 1995, pp. 477–484.
Kuo-En Chang received the B.S. degree in electronic engineering from National Taiwan University of Science and Technology, Taipei, Taiwan, R.O.C., in 1984, and the M.S. and Ph.D. degrees in electrical engineering from National Taiwan University, Taipei, in 1986 and 1989, respectively. He was the Director of Computer Center at National Taiwan Normal University, Taipei, from 1989 to 1992. He is currently a Professor of the Department of Information and Computer Education at National Taiwan Normal University. His research interests include fuzzy system, neural networks, and intelligent computer-aided instruction. His major research is the study of computer techniques with applications to education.
Bea-Chu Chiao received the B.S. and M.S. degrees in information and computer education from National Taiwan Normal University, Taipei, Taiwan, R.O.C., in 1993 and 1995, respectively. She is currently a Teacher in the Taipei Municipal Sihlin Commercial Senior High School, Taipei, Taiwan. Her major research is the study of computer techniques with applications to education.
Sei-Wang Chen received the B.Sc. degree in atmospheric and space physics and the M.Sc. degree in geophysics from National Central University, Chunli, Taiwan, in 1974 and 1976, respectively, and the M.Sc. and Ph.D. degrees in computer science from Michigan State University, East Lansing, in 1985 and 1989, respectively. From 1977 to 1983, he was a Research Assistant in the Computer Center of Central Weather Bureau, Taiwan. In 1990, he was a Researcher in the Advanced Technology Center of the Computer and Communication Laboratories at the Industrial Technology Research Institute. He is currently a Professor of the Department of Information and Computer Education at the National Taiwan Normal University, Taipei, Taiwan. His areas of research interest include fuzzy logic and control, artificial neural networks, intelligent tutoring systems, pattern recognition, image processing, and computer vision.
Rong-Shue Hsiao received the B.S. degree in inductrial education from National Taiwan Normal University, Taipei, Taiwan, R.O.C., in 1978, and the M.S. degree in computer science from Old Dominion University, Norfolk, VA, in 1985. He is currently pursuing the Ph.D. degree in engineering and inductrial applied mathematics at the California State University, Long Beach. He is currently an Instructor in the Department of Electronic Engineering, National Taipei University of Technology. His research interests include intelligent computer-aided instruction and inductrial applied mathematics.
