Home MembershipSpecial Interest GroupsSIGCT (Computing Teachers)JCSE Online - Journal of Computer Science EducationPast Issues2003-2004 January 2004

Landamatics in Teaching Computer Programming

Laurence L. Leff, Ph.D.
Western Illinois University

Abstract

Landamatics is a technique where the teacher precisely defines and teaches the steps to do a problem. The students are trained to execute steps that are as precise as those that would define a computer algorithm. It has been used with success in such fields as mathematics instruction and training insurance company personnel to process claims. This paper shows its use in teaching programming. It draws on examples from the author's teaching in CS1and CS2. This method is analogous to the templates in the famous Programmer's Apprentice project (Rich & Waters, 1988). Landamatics has increased the number of assignments completed in my classes. This was shown in a data structures class at the p=0.01 level.

1 Introduction

Those of you in teaching programming have seen the following scenario. A student knows the syntax of a programming language. The student knows what each statement does. Yet, the student cannot put the statements together into a program. The teacher is tempted to say, "the student just can't think" and throw one's hands up in despair.

Lev Landa (1975) said, "It is common knowledge that pupils very often possess knowledge that is necessary in a certain subject, but they cannot solve problems. Psychologists and teachers often explain this by saying that their pupils do not know how to think properly, they are unable to apply their knowledge, the processes of analysis and synthesis had not been formed in their minds, . . .". Dr. Landa reports on an interview with a teacher of mathematics. Here, a teacher referred to one of her students who had just received a D in a geometry test. She said, "He doesn't know how to think. He didn't figure out that the chord should be considered as the side of an inscribed angle." Lev Landa asked, "why couldn't he figure it out?" The teacher responded, "He couldn't figure it out because he couldn't figure it out, that's why." Landa points out, "the problem ended where it really should have begun." (1976) This paper tells you how to begin when you have students in your class who appear not to be able to think when you ask them to write a program.

Lev Landa has developed an instructional technology termed Landamatics that addresses this problem. My paper shows how to address these students and their problems. As I show, these techniques enable the students to produce more programs and more complicated ones than they would have otherwise.

Dramatic results have been achieved by Landamatics. In one set of experiments, Dr. Landa developed a technique for breaking down the thinking processes for geometrical processes. He isolated the operations necessary to construct proofs in a high school geometry class. This is in comparison to the standard method where students are simply taught the concepts and theories of geometry and then shown examples of proofs. The teachers selected students who knew the necessary facts in geometry. This was shown by a test and reinforced by review of the material. However, the teachers felt that these individual students could not solve problems and "were not skilled in the general procedures of thinking." Prior to the instruction based on Landamatics, the students were only able to solve an average of 25% of the problems–the best students of the group could only get 40% of the problems right. After the Landamatics instruction, in the second test, the students solved 87% of the problems!

Lev Landa (1975) did a similar experiment in a class teaching Russian grammar. Here Landamatics reduced the number of mistakes seven fold. Using these techniques, Dr. Landa reduced a four-year course to three years instruction with much better student performance.

Business Week had an article on Landamatics (Port, 1992). Many businesses have been using Landamatics in industrial training. One business achieved a $35,000,000 savings. Allstate's claim processing operation improved productivity 75% and quality 90%. When novices were trained in a business procedure using Landamatics techniques, their performance after the training is compared to those who have not benefited from such training. Also, the trainees are compared to experts. The trainees reached the performance of experts. Ford's Starnet subsidiary saved a million dollars. DuPont saved one million dollars in a quality check operation. After a demonstration project involving those processing claims, Allstate Insurance was so impressed that they trained a group of 23 "in-house Landamatics consultants," which was termed a Landamatics University. (Landamatics, 1993)

In my work, I prepare templates for the students for each type of program they are to do. These templates contain a general version of the program. It would have words or lines in italics that act as a placeholder, showing the students where to fill things in. There would be hints or areas that provide the students choices for the code to be filled in. Once the students filled in the necessary parts, they would have a program that would solve the specific homework problem posed to them.

Such a template follows in spirit the template used in the "Programmer's Apprentice." (Rich & Waters, 1988) The author observed that expert programmers have many patterns that they would use in programming. A programmer does not develop each new program from scratch. Instead, he would observe that the problem matched a pattern they already had seen or developed. They could quickly enter the code. Waters (1985) developed computer technology that helps a programmer apply these patterns–filling them in and creating programs.

Landa (1985) observed a correspondence between his work in teaching geometry theorem proving techniques and that of Newell and Simon’s General Problem Solver (Barr 1981). Landa developed a method of extracting problem solving techniques for use in teaching and for individuals to execute manually. Dr. Landa developed his techniques of interviewing experts and setting up curricula on the subject based upon the rules the experts used to solve problems. This was done in the fifties, before expert systems and knowledge engineering. The difference is that Dr. Landa transformed these into manual expert systems and rules in printed form to be executed by human beings. Then, these novices were able to perform at an expert level. Feigenbaum and others of the expert system movement transformed knowledge elicited by experts into computer systems that were shown to perform at an expert level (Landamatics, 1993).

The Programmer's Apprentice Project at MIT in the 1980's developed techniques to help a programmer generate certain parts of their program (Waters, 1985; Rich & Waters, 1988). A knowledge engineer would create templates that correspond to frequently recurring code patterns. These templates are called "cliches" with the formal representation called the "Plan Calculus" by those authors. There are "{...}" annotations that show where certain things are to be replaced. For example, one such template would be "CREATE simple REPORT" Lines in that cliche (written for ADA) read as in figure 1.

A program called KBEmacs helps the user employ these cliches and fill in the annotations. The template provides five options for filling in the enumeration function. These allow the system to fill in such annotations as {element_accessor of the enumerator} and {the step of the enumerator}. The user of the KBEmacs system would choose one based upon whether the data was in a file, in a linked list, in an array, etc. The system also allowed the programmer to define new cliches. Waters (1985) reported on the implementation on a Symbolics Lisp machine. At the time, the software was slow, but they anticipated that with re-implementation and expected improvements in hardware speed, the ideas would be practical.

In similar work, Soloway and Erlich (1984) developed an experimental procedure to determine whether advanced programmers used plans. They developed pairs of programs that did the same thing. Each pair of programs followed a plan of attack like a "data-guard if" or "maximum search loop plan." The second program of each pair violated the expected assumptions of such a plan. They had both novice programmers and advanced programmers take tests of comprehension on these plans. Of course, the advanced programmers did better than the novice programmers. Both sets of programmers showed better on the "plan-like" program than the "unplan-like" programs. However, the advanced programmers had more of a difference in performance between the "plan-like" programs and the "unplan-like" programs than the novices did.

This showed that advanced programmers were more likely to use plans in thinking about programming than the novice programmers.

This idea is now being promulgated in the software engineering community under the name "design patterns." Truett (2001) and Grand (1998) provide catalogs of such design patterns in Java. However, most of these concern ways of organizing the relationship of classes. These include object-oriented ideas such as delegation, the use of interface, small special-purpose languages, and optimizing an application that uses a large number of similar objects. However, one pattern listed, "iterator," concerns logic in the program. It is similar to the first template I describe below.

This paper reports on teaching programming students to generate programs by manually filling in templates that I provide. This is analogous to the relationship between Landa's work and that of the pioneers in artificial intelligence. Figure 2 shows a precise form for the analogy.

2 Two Case Studies

I have used this template method, applying the methods of Landamatics to the construction of programs, in several courses. These include our Computer Science Principles I, Computer Science Principles II, Assembly Language Programming, UNIX, LISP, and a Graphical User Interfaces (GUI) course.

Each Landamatics template handout consists of the following five components:

1. a description of the class of problems that the template can solve.
2. a template to use to solve those problems.
3. a discussion, often line by line, describing how to use that template.
4. a specific program generated using the template. This is often a program that was an example taught earlier in the course. At that time, the example was introduced and discussed in the conventional manner.
5. an explanation showing how the sample program (d) was developed using the template (b). This often includes a line-by-line matching.

2.1 A Template Handout for Two-Dimensional Array Programming Assignments

I will introduce the method by showing the important part of a template handout used in teaching the second computer science course in the main sequence at our University (i.e., Computer Science I and II).

Figure 1 shows the use of a template handout for the generation of a doubly-nested loop. It solves a class of problems that involve what I term a big property and a small property. This template helps students solve problems involving two-dimensional arrays. For example, it would include finding the column with the most even numbers, determining which row has the smallest maxima, finding which row of a two-dimensional array had the largest sum, or counting the number of rows with more than three sevens.

Figure 3 tells the student the precise form of the problem question (component a, above). This is the class of problems that the template will solve.

The next part of the handout is the template itself (see figure 4). The student has to choose two variable names. Placeholders in the template are big-property-value and small-property-value. These are in italics so the student realizes that a substitution is needed–this corresponds to the annotations in ellipsis reported by Rich (1988). (The template handout includes a similar template for processing a two-dimensional array, column by column. e.g., it would be used when writing a program to find the column with the largest sum. The template handout also includes an explanation of how to read in the data by row or by column.)

Some readers may wish to see this or other template handouts as the students would see them. A list of many web links is provided in Section 2.3, each pointing to a different classroom-tested template handout.

Line-by-line instructions in the template handout tell the student how to fill in each line of the template. (These are analogous and similar in spirit to the line-by-line instructions that accompany Internal Revenue Service tax forms.) For example, in this template handout, the instructions for line 1 tell the student to initialize big-property-value to zero when it represents a sum or a count. It also says to initialize to a very large number when it represents a minimum and a very small number when it represents a maximum.

I include here the description for the most interesting line, the one with which students have the most trouble. That is line 7 in figure 4, updating the big-property-value from the small-property-value.

Figure 6 shows a program produced with this template–one to compute the row with the largest sum.

Finally, in the handout, is a description of how the template that was seen in figure 4 relates to the sample program seen in figure 6. We show the text explaining the line 7 (of figure 4) in figure 7.

2.2 A Template Handout for File I/O

This template handout is from a one-credit course which was part of the CS1 course. See below. In 2001, I used three templates in a CS1 course. They covered programs that read and wrote multiple files, applet programs, and programs to sort and search arrays of objects. I discuss the file manipulation template.

In Java, free-form input from files is done via a library class StreamTokenizer. Free-form output is done via the library class PrintWriter. My template has the student create a table indicating the Java StreamTokenizer, and Java PrintWriter used for the processing of each input file and output file. Then the template guides the students in reading from the files the information specified by the problem. Finally, the template guides the students in computing the output and putting it into the output files that the problem specifies.

The template’s first five steps have the student read the problem and identify the names of the files. These are the file names that show up in the DOS or Unix operating system. They also choose internal names for their Java objects, which are the names used for the StreamTokenizerName and the PrintWriter objects. The student’s table looks like that shown in figure 8.

Later, the students identify the input variables, and the files from which they must be read (see figure 9). The template guides them in using the template to prepare the nextToken() and other statements to extract the values.

The template itself has a place holder where the students write the calculations. In the first programs assigned, they correspond to single assignments. (In later ones, these correspond to the other programming techniques such as loops and if statements. There are, of course, other templates for these. Thus, there is the opportunity for students to use two templates to solve a particular programming assignment.)

Then, the template handout has the students prepare a table to identify the output of variables and the files to which they go (as shown in figure 10). The template guides the students through writing the println and close commands for their output files.

Our template example reads in a value for the total from total.in. It reads a value from tip.in into the variable tips. It reads a value from win.in into winnings. The program outputs the sum of these values to total.out. (By the way, this corresponded to a one-line answer to one of the trainer puzzles (Webber, 2001) that the students also did, see below.) Then, the students created the tables specifying the internal and external file names as in figure 11.

From these two tables, and the description of the problem, the students create a table relating the StreamTokenizer to a variable which to input (see figure 12). Then writing lines 24, 26, and 28 of the program is mechanical when using the template.

The template as it would appear in the template handout is shown in figure 14.

2.3 List of Templates

Many of these templates are available on my web site. They are part of the class notes I write for the students:

1. The Template for processing each row of a two-dimensional row discussed earlier (http://www.wiu.edu/users/mflll/cs214/2DTEM.html). A version was also prepared for a course in programming for scientists and engineers using C++ (http://www.wiu.edu/users/mflll/225/TwoD.html).
2. The template for processing files in Java discussed above (http://www.wiu.edu/users/mflll/j/jone.html).
3. A template for creating applets with multiple edit boxes and buttons (http://www.wiu.edu/users/mflll/j/jtwo.html). This was also used in my CS1 course mentioned above.
4. In that same course, I also gave out a template for processing arrays of classes. The example applet program had the user enter information on pump names and capacities. Then, they could search for a pump whose capacity was in a specific range (http://www.wiu.edu/users/mflll/j/h16.html).
5. I also had a similar template for a program that manipulated an array of classes where the data was read from a file. The user enter their query from a character interface (http://www.wiu.edu/users/mflll/j/h18.html).
6. Arrays of linked lists. The example problem tracked the students in each course. The array contained the courses at the University. Each had a pointer to a linked list of the students registered for that course:
               Pascal: (http://www.wiu.edu/users/mflll/cs214/LINK3_2.html)
               C++: (http://www.wiu.edu/users/mflll/351/landa1.html)
7. Many-to-many relations in C++. The example program tracked both the students in the course and the course in the student (http://www.wiu.edu/users/mflll/351/landa1.html).
8. Polymorphism in C++. The example program maintained a linked list of various elements, all of which were derived from a generic trip class (http://www.wiu.edu/users/mflll/351/CCintro.html).
9. Units in C++ with operator overloading. The example program had classes for lengths in feet and inches and another class for lengths in meters. Operators were defined to correctly add these, multiply them by numbers, etc. (http://www.wiu.edu/users/mflll/351/Overload.html).
10. In IBM mainframe assembler programming, a template to move a bit field from one word to another. For example, the sample program moved bits twenty-eight to thirty from A to bits twenty-six and twenty-eight of B (http://www.wiu.edu/users/mflll/cs310/unit24.html).
11. Translation of if statements from a conventional higher level language to IBM mainframe assembler (http://www.wiu.edu/users/mflll/cs310/unit41.html).
12. Translation of programs in conventional higher level languages with nested for loops and two dimensional arrays into mainframe assembler (http://www.wiu.edu/users/mflll/cs310/unit610.html and http://www.wiu.edu/users/mflll/cs310/unit611.html).
13. For a Visual Basic Course for non-majors, I have a Template for problems with three database tables and a grid. The example program allowed the user to step through a course. As the user changed courses, a grid showed the students registered for that course. As the user clicked on a student in the grid, the program averaged the grades for the student from still a third table (http://www.wiu.edu/users/mflll/CS488/done/).

3 Some Usage Results and Conclusion

As mentioned earlier, I have used Landamatics successfully in several of my courses. Landamatics achieves efficiency gains in teaching, particularly in the problem solving component of the courses. This efficiency increase can be used in several ways (Landa, 1975):

1. to reduce the time it takes to teach the same material,
2. increase the percentage of students learning the material,
3. to raise the expertise level,
4. to decrease the student's error rate.

I chose to use Landamatics to increase the quantity and difficulty of the problems that the students accomplished. Yet, I maintained the same pass rate as the other faculty teaching other sections of the same class.

For example, in my CS1 class, all the sections had the students do an exercise involving sorting one dimensional arrays. In my classes, all students completed one or more sorting exercises where there were primary and secondary keys. This involved multiple one-dimensional arrays, each representing a column. This is one of the templates listed in Section 2.3. The other faculty teaching parallel sections of this course all had students simply sort a single one-dimensional array.

In Fall 2001, I used Landamatics to dramatically increase the number of assignments completed. However, I must set the background. Our Computer Science department changed its CS1 course to have two parts, treated as separate courses: CS211 and CS212. CS211 was a large lecture that met two hours per week. CS212 was a one-credit small course that met for one hour per week. I was assigned several sections of CS212. The first nine weeks focused on a Computer-Aided Instructional aid termed the Java trainer (Webber, 1995; Webber, 2001) The remaining weeks focused on using the Java SDK from Sun to implement "real" programs. I assigned a total of nineteen assignments with the average student completing 15.1 problems. (Students were offered various opportunities to be excused from problems as an incentive for finishing early. Also, some students "risked" not earning an A in the course by not handing in all homeworks assigned.) By contrast, all other instructors assigned no more than five homework problems.

The table below shows the percentage completing the CS212 course with a C, B, or A. The class with the Landamatics training but with three times as many homeworks completed had a slightly lower success rate. For comparison, in Spring 2002, I tried teaching the section the regular way: without Landamatics but with only five homeworks. The success ratio dropped. Thus, I conclude the lower completion ratio than my colleagues was not due to the teaching technique and the number of homeworks. The difference reflected the instructor or the fact that the instructor’s sections were in the afternoon while many of the other sections were early morning sections.

In a course on data structures, I started using Landamatics in the third semester that I taught the course. This increased the number of assignments completed from 7.6 to 12.8 (significant at the 0.01 level) (Sheskin, 1997).

The interested but skeptical reader might raise the following questions at this point:

• Wouldn't it be better if the students had the joy of discovering these techniques and templates on their own?
• Are the students simply writing the programs following the templates without even understanding them?
• What if a student encountered a problem that didn't fit one of the templates?

As (Waters, 1985), points out, "it is not practical to be creative all the time" and "it is never practical to reason about anything from first principles." In (Landamatics, 1993), Dr. Landa states, "Despite the educational superiority of teaching how to discover algorithms on one's own and actually discovering them, it is practically impossible to have students discover by themselves all the algorithms they have to learn and know. Their life might not be long enough to do this." Yet, our courses in programming often do not teach the common cliches. They simply leave our students to discover them on their own. Sometimes, this occurs in later classes. Worse, the job may be left until the student reaches employment.

Dr. Landa (1975) points out a process in which a student trained with Landamatics proceeds from the algorithmic stage to the post-algorithmic stage. In the first part, the student follows the algorithm, step by step. He checks each step and then applies that step to the particular problem. As the student continues to do problems using this technique, the mind will form unconscious associations between the items and the actions to be performed at each step. The step-by-step process is replaced by an involuntary and simultaneous post-algorithmic process. (Landa, 1995) shows how this relates to "learning to learn." At this point, the student will recognize similarities between the objects in the algorithm. This statement reminded the author of a neural network which recognizes objects similar to those on which it was trained. Then the student will see associations and become creative in the use of the material.

Landa himself (1975) recognized that it is important that the students must be taught "how to discover algorithms on their own." In each of my homework sets, I have three sets of problems. The first includes those that can be solved systematically with the Landamatics template with no creativity. The second set are those problems that are related to the template but require some twist or creative approach. The final set are "blue sky" problems that come from "left field" that have nothing to do with the template. This has important implications in the grading method (see Leff, 1998).

In conclusion, Landamatics is a viable technique in the computer science classroom. It is not a substitute for conventional instruction of knowledge and principles to help students understand the material. However, it does help students learn how to complete problems and write more complicated problems than they would without these techniques.

4 References

Barr, A., Feigenbaum, E. A. (1991), The Handbook of Artificial Intelligence, Volume 1, HeurisTech Press, Stanford, California.

Grand, M. (1998). Patterns in Java, Volume 1: A Catalog of Reusable Design Patterns Illustrated with UML, John Wiley and Sons, New York, Chichester, Weinheim, Brisbane, Singapore, Toronto.

Landa, L. (1975). Some Problems in Algorithmization and Heuristics in Instruction. Instructional Science. 4, 99-112.

Landa, L. (1976). Instructional Regulation and Control: Cybernetics, Algorithmization and Heuristics in Education, Educational Technology Publications, Englewood Cliffs, NJ.

Landa, L. (1985). "Why Schools Fail to Teach Thinking and the Ability to Effectively Learn and What to Do About It," Educational Research Service ED 419 831

Landamatics Ten Years Later: An Interview with Lev N. Landa (1993). Educational Technology. 33(6). 7-18.

Leff, L. (1998, December) Contract Grading in the Computer Science Courses. Journal of Computer Science Education. 2(3,4), 16-22.

Port, O. (1992, September 21). Lev Landa's Worker Miracles. Business Week, No. 3284. 72-73.

Rich, C. and Shrobe, H. E. (1978, November) Initial Report on a LISP Programmer’s Apprentice IEEE Transactions on Software Engineering, SE-4(6), 456-467.

Rich, C. and Waters, R. C. (1988, November) The Programmer’s Apprentice: A Research Overview. Computer. 21(1). 10.

Sheskin, D. J. (1997) Handbook of Parametric and Nonparametric Statistical Procedures. CRC Press, New York, NY.

Soloway, S. and Erlich, K. (1984, September). IEEE Transactions on Software Engineering, SE-10 (5). 595-609.

Truett, L. (2001) Design Patterns — Iterator (a.k.a. Cursor) A GoF Behaviral Pattern [Online document] Available: http://www.fluffycat.com/java/JavaNotes-GoFIterator.html

Waters, R. (1985, November) The Programmer's Apprentice. IEEE Transactions on Software Engineering, SE-11 (11). 1296-1320.

Webber, A. B. (March, 1996) The Pascal Trainer, SIGCSE Bulletin, Vol 28, No. 1, 261-265, (Proceedings of the Twenty-Seventh SIGCSE Technical

Symposium on Computer Science Education, Philadelphia, Pennsylvania, Feb 15-18,

Webber, A. B. et. al. (2001) The Trainer Project [Online document]. Macomb, IL: Western Illinois University. Available: trainer.wiu.edu