WHY WE NEED TO DEVELOP SUCCESS IN INTRODUCTORY
Jim McKeown, Asst. Professor of Computer Education
Dakota State University
Madison, SD 57042
Tom Farrell, Asst. Professor of Information Systems
Dakota State University
Madison, SD 57042
Current employment trends indicate a shortfall in qualified computer programmers with this trend continuing for the foreseeable future. In order to increase the number of workers in this field it is necessary to increase the number of students graduating with degrees in computer and information sciences. Unfortunately, the educational methods used in introductory programming classes often discourage new students. Some of this problem stems from outdated teaching methods and courses that lack a basis in educational pedagogy. It is essential that the problems these students face be recognized and eliminated. Until this happens, we can expect a continued shortfall of workers in these fields.
Currently, there is a considerable shortfall of these workers and the projections are for continued shortages of workers for the foreseeable future. In a survey of nearly 1,500 companies, both within and outside of information technology industries, the Information Technology Association of America and Virginia Polytechnic Institute (Davis, 1998; Reuters, 1998; Savitz, 1998) found an estimated 350,000 unfilled information technology (IT) jobs in U.S. companies with more than 100 employees. This is an estimated ten percent shortfall in IT workers and represents an increase in estimated vacancies of forty-six percent in the last year.
Exacerbating the problem is a decrease in the number of computer science graduates in recent years (Savitz, 1998; Smith, et al., 1995). Figures indicate a drop in graduates from 42,195 to 24,200 from 1986 to 1994, a decrease of 43%. A similar decline of computer science and information systems graduates of 41% has been noted between 1986 and 1992. The worker shortages are not limited to traditionally "high-tech" firms, but include firms, such as banks, hospitals and retailers, which rely on programmers, analysts and engineers to design, operate and maintain their systems.
As reported by the Presidential Advisory Committee for the National Coordination Office for Computing, Information and Communications, part of the problem lies in two other areas as well, the shortage of information technology faculty (Joy & Kennedy, 1998), and the shortage of software capable of accomplishing mission-critical tasks (Joy & Kennedy, 1998; Guth, 1998). The shortage of qualified faculty can only be addressed in the long-term. Indeed, in the short-term, some faculty will migrate to higher-paying jobs in industry and most graduates in the field will shun academia for better pay in industry. Some will also move into industry because of the perception that work in industry is more "exciting" and "cutting edge" than work at a university. The rapid growth in demand for software applications far outpaces developers ability to produce it. As reported, this "software gap" strains physical infrastructures, creates performance problems, is costly, unreliable, difficult to maintain and hard to upgrade. The shortage of qualified workers has forced industry and government to rely on outdated and unsound software systems. Development of new systems is also hampered by the lack of qualified developers. These problems can only be addressed in the long-term.
THE DEVELOPMENT OF COMPUTER PROGRAMMERS
Essential to the development of capable programmers is an educational system geared to handle the educational needs of these students. Without a firm understanding of how computer students learn computing, and later programming, an effective educational program for them cannot exist. This is especially true for novice programmers who need good experiences with programming to build confidence and develop skills. Without these fundamental skills many will not continue their development. This area is one of concern for professionals developing preservice teachers (Galloway, 1990). In this study, preservice teachers were taught computing skills. Most harbored misconceptions about fundamental computing skills. These hampered the development of further skills including programming knowledge. Galloway concluded that most were able to grasp fundamental computing skills, although their understanding of these skills was incomplete, restricted and limited. Most had a limited conceptual base for computer fundamentals. The subjects' understanding of programming skills was even more limited as only a small percentage achieved any success with the programming portion of the course. While this was a small study, it indicates that while computing skills are attainable, they may be limited and inaccurate. It also indicates that programming skills can only be attained after considerable fundamental computing skills have been developed. Other studies (Palumbo, 1990) indicate that the acquisition of programming skills is difficult and lengthy.
A shortage of workers in these fields in general means that some, if not many, teachers and trainers are underqualified in their jobs. While they may possess the technical skills required for their occupation, they may lack teaching skills and/or a background in programming pedagogy. It is, therefore, important to provide them with training and the latest educational research in this area and to continue to promote and develop their skills.
From observation, it appears that the high dropout and failure rates among students in programming classes can be attributed to several factors. First, programming is challenging. It requires the use of high-level, abstract thinking skills. Many students have not taken courses that either required or have helped to develop these skills. Many do not enter a programming class with adequate conceptual skills for programming. Because it is far different than most other subjects, students have difficulty relating to the concepts taught in the class. They have difficulty transferring the skills acquired in a programming class into other subjects and activities and even more trouble adapting known skills for use in a programming class. This inability to associate new material with existing knowledge or to apply their new knowledge to existing problem sets becomes a source of fear and frustration for students.
Programming texts appear to pay little or no attention to instructional design principles. Texts merely present programming concepts in a conceptual order. Simple principles are first presented and later built upon as more abstract principles are introduced. There appears to be little attention paid to problem-solving principles or debugging issues, areas that have consistently proven to be major stumbling blocks for novice programmers. Programming texts almost exclusively concentrate on business problems and use these to explain concepts, provide examples and supply activities and projects for students. While business knowledge is important for many programming jobs, most students lack business skills at this stage of their learning. Therefore, they may have difficulty understanding the business task at hand, which compounds the problems they face when learning programming principles. It seems logical to assume that where possible problems and activities should be geared toward areas where students possess more than a rudimentary understanding. Ideally, students would be provided with multiple and varied examples and activities to increase their understanding.
It appears that student fear and frustration plays a significant role in their ultimate success or failure. Student fear and frustration when programming hampers their studies. They appear to spend less time than needed on classwork because of these difficulties. As a result, their inactivity causes more problems and frustration until this downward spiral makes success difficult if not impossible. While this may be true for many students, it certainly is not true for all students. Why do some adapt and become successful, others do not? This is an interesting question that appears to be tied to both student ability, activity and to teaching methods.
It appears that the methods for teaching programming have changed little. Many introductory programming classes appear to be a "weed out" class where only the highly successful will endure. This may be a contributing factor to the current shortage of programmers. Instead of developing new and more-effective teaching methods, these courses have remained a "make or break" course which discourages all but the best students. Given the current shortage or programmers, it seems necessary to revise and adapt the teaching methods to encourage more students to enter the field and to promote the retention of students where possible. This means that more students must be given success in programming by giving them the tools and skills to be successful. There is little research available in this area, although such research into the skills and pedagogical knowledge of programming teachers might prove interesting and revealing.
FOCUS OF PROGRAMMING RESEARCH
Much of the research into novice computer programmer pedagogy has focused on very specific programming constructs and the errors associated with them (Ben-Ari, 1998; Perkins, Schwartz & Simmons, 1988; Mayer, 1988; Weinberg, 1971) or on the educational value of teaching programming (Palumbo, 1990; Martin & Hearne, 1990). Programming syntax, the exact coding requirements of a language, is a source of confusion and frustration for students (Sleeman, Putnam, Baxter & Kuspa, 1988; van Merrienboer & Krammer, 1987). The semantics of a computer program, the structure commands, procedures and processes as well as their patterns and rules, are even more confusing for novice programmers (Pea & Kurland, 1983).
Students often have little understanding of the underlying operations of a computer and the compiler. Thus, they have difficulty conceptualizing how the computer, the language, and the compiler interact (Mayer & Fay, 1987; Sleeman, Putnam, Baxter & Kuspa, 1988). Students' incomplete or faulty mental models of a computer and programming syntax and semantics cause problems (van Merrienboer & Krammer, 1987).
Students tend to anthropomorphize the computer (Perkins, Schwartz & Simmons, 1988). Often they assume a computer will understand their incomplete or faulty commands and execute them as they understand them, not the way the computer is designed to execute them.
Conflicts between the everyday understanding of a command and the computer's understanding of a command's execution are a problem for students learning to program (Mayer & Fay, 1987). For example, students often write a compound If statement as If A > B and > C Then They mistakenly assume that the comparisons are being made between A and B and A and C. The computer makes no such assumptions and returns an error.
Sometimes a conflict between a student's commonsense understanding of previous learning interferes with the acquisition of programming knowledge (Sloane & Linn, 1988; Sleeman, Putnam, Baxter & Kuspa, 1988). In this instance students have been taught that the equal sign means that variables or constants on either side of an equals sign are equivalent. In some programming languages though, the equals sign is used as an assignment statement. Thus, a students could see Count = Count + 1 and have a conceptual problem with the language because no known number will equal itself when one is added to it.
There have been studies focusing on the problems students face when debugging a program. Error detection and correction is recognized as a central problem among novice programmers (Allwood & Bjorhag, 1990). Students often invoke one of several strategies when debugging a program. These strategies are hampered by a "fragile" knowledge of the language (Perkins, Schwartz & Simmons, 1988), a "trial and error" approach (Sloane & Linn, 1988) and poor problem-solving strategies (Sloane & Linn, 1988; Soloway, Spohrer & Littman, 1988).
Poor problem-solving techniques are often the result of unstructured approaches. Students are seldom taught problem-solving techniques (Sloane & Linn, 1988; Mayer, 1988; Soloway, Spohrer & Littman, 1988) and are often taught that there is a single "correct" solution to every programming problem rather than multiple possible solutions from which to choose. An example of this is looping strategies. Most languages offer several types of loops. For some problems, a solution can be created using almost any of these. Yet, students are taught only one method or are not shown the techniques for deciding which is best to use in a given situation.
Research has focused on how students fail to link solutions in a programming problem to the structures and commands needed to solve the problem (Ebrahimi, 1994; Perkins, Schwartz & Simmons, 1988). Students have difficulty finding the right command or set of commands for solving a problem, creating a structure for these commands, placing them in the correct order and then getting them to work properly. Student problems in this area often stem from the teaching methods used by programming instructors (Ebrahimi, 1994; Sloane & Linn, 1988, Mayer, 1988; Perkins, Schwartz & Simmons, 1988). Students are seldom taught specific design techniques. Novices possess an incomplete understanding of program design and are unable to analyze a problem, dissect it, and create a working program. Additionally, they often lack the ability to modify existing algorithms (Oliver & Malone, 1993). The mental model they are able to construct is incomplete because, as yet, they do not completely understand the similarities and differences between similar programming structures.
Novice programming students have not developed solution evaluation skills which stress how and when to use programming techniques and when to explore alternative techniques when solving problems (Soloway, Spohrer & Littman, 1988). Programming students are taught to seek a single solution to a problem instead of looking for multiple solutions and alternatives to a problem. This happens in nearly all subjects at nearly every grade level, not just computer programming. In general, there is little amiss with moving on once a correct or workable solution is found. Consequently, when students are programming, they seek only one solution rather than looking for other alternatives which could increase their understanding of the language. Unfortunately, programming skills developed in such a manner are difficult to transfer from classroom and textbook examples to programming assignments. It is even more difficult to transfer them to real-world problems that students must solve (van Merrienboer & Krammer, 1987).
Research indicates that students encounter difficulty when trying to juggle the syntax of a language along with the semantics needed to create a program (van Merrienboer & Krammer, 1987). These difficulties stem from the novice's inability to understand the problem and its solution as well as the methods needed to accomplish this. Experienced programmers are better able to cope with these problems because of a more-complete understanding of programming concepts, plans and structures. They understand larger chunks of code, blocks of code which perform a specific function (Pea and Kurland, 1983). This enables them to see program flow without becoming lost in the syntax of each line of code. They have a better understanding of syntax (Sloane & Linn, 1988), and a better understanding of program design considerations (Adelson, 1981). It is also difficult to teach novice and more experienced programming students in the same class (Shneiderman & Mayer, 1979).
For many, a programming class is vastly different from other classes in the curriculum. It appears the computer programming is a unique field of study, much different from nearly all the other classes students commonly take. This diversity makes it difficult to find workable examples and demonstrations and to relate learning to other areas. This difficulty only increases the perception among students that programming is not worthwhile and that it has very little practical application in the everyday world.
While much of the research in both of these areas has stopped, there is a continuing need for studies to help determine effective methods for teaching and learning programming. In particular, there continues to be a need to develop strategies to teach programming logic, debugging skills, program flow, problem-solving and deep understanding of programming structures.
LIMITS OF THE CURRENT RESEARCH
Recent research into the education of novice computer programming has been geared toward discovering how students think about specific programming problems and problem-solving strategies (Palumbo, 1990; McCoy, 1990), the transfer of programming skills (Martin & Hearne, 1990), the justifications for teaching computer programming (Lockard, Abrams & Many, 1987) and how to recognize problems and debug computer programs (Brouwer, 1993).
While much has been accomplished in these areas, not enough has been done to discover what students should know and understand at any level in the learning process. In addition, students have not been given an understanding of the various levels of understanding and development of programming skills, the time it takes to progress from one level to another or the skills needed to progress from one level to another. Little exists in the literature to show that teachers are aware of these barriers to student learning, that students are aware of their own understanding and limits, or that these problems have been studied. Furthermore, there is little to suggest that a general set of concepts exists that will help to determine the relative skills level of a student at any stage in their development.
It appears that programming students pass through several levels as they learn a language. The first level appears to be one that could be characterized by fear or anxiety. For some it is minimal, but for others there is great trepidation and anxiety. The degree to which they experience this fear and the duration of this level appears to be associated with the initial amount of success they have in a programming class. It appears that students can move past this level by successfully learning to use the programming editor and compiler and by writing short, working programs. Most students successful move past this level.
The second level appears to be one of frustration and confusion. Students know they should be able to write a program and have it successfully execute, but their limited understanding of programming syntax and semantics can prevent them from writing executable programs. Students appear to be confused by the variety of programming commands and the number of ways these commands can be combined to create programs. Many seem to be able to follow programming logic as explained, but they cannot duplicate the logic in their own programs or extend it to other designs. They seems to have great difficulty debugging their own programs or following the logic of others' programs. It appears that students can move past this level by successfully learning to write and debug programs. The exact methods needed to successfully complete this level are unclear. It appears that most students struggle with this level and only a minority of them moves past it.
The third level appears to be one of enjoyment, fun or fascination. Students seem to grasp new ideas and concepts. They are able to take programming techniques learned in previous lessons and combine and apply them to new situations. They appear to enjoy the problem-solving involved in writing and debugging programs. They can relate programming concepts to other areas translate problems from other areas into programming designs. At this stage, it appears that students are more self-motivated to learn and they seem to enjoy the "mental exercise" of a programming problem much the same way others might enjoy a crossword puzzle. It appears that only a small percentage of students reach this level. The challenge, of course, is to find teaching methods which will enable more students to reach this level, and to ultimately decrease the time it takes for students to get to this point.
Some of the instructional methods needed may have to include ways to make the programming experience more relevant to their existing knowledge base and to make the programming experience more enjoyable for them. Regardless, more time and effort must be spent with students at the introductory level. This means investing more money, effort and time at the entry level. This may mean that the best teachers will have to be placed in these classes instead of using graduate teaching assistants. It may require smaller classes and more attention for students. There are certainly other solutions as well, such as online help, student tutors, help desks and more. The implications are clear, without a greater emphasis at the introductory level, the shortages of qualified graduates will continue with perilous consequences for the world economy and our place in it.
Research indicates a steadily worsening shortage of qualified computer programmers. Because of this shortage greater emphasis must be placed on the development of programmers. One area where greater emphasis should be placed is introductory courses. Most successful students move through several levels of success and confidence. However, many students do not. Part of the problem seems to lie in the teaching methods and resources used. One way to ease the shortage is to place greater emphasis on providing success in introductory programming courses. This can be accomplished by developing teaching materials that have a sound basis in educational pedagogy, through the use of exceptional teachers, smaller class sizes, and by shifting the emphasis of these courses from "make or break" to one of student success and development.
Adelson, B. (1981). Problem-solving and the development of abstract categories in programming languages. Memory and Cognition, 9(4), 422-433.
Allwood, Carl Martin & Bjorhag, Carl-Gustav, (1990). Novices' debugging when programming in Pascal, International Journal of Man-Machine Studies, (33) 707-724.
Ben-Ari, Mordechai, (1998). Constructivism in Computer Science Education, SIGSCE 98 Atlanta, GA., 257-261.
Brouwer, Peter Scot, (1993). An Analysis of Student Debugging Strategies, Doctoral Dissertation, State University of New York at Buffalo.
Davis, Jillian J., (1998). A Drop in the Bucket: US Commits Funds to Fighting Skills Shortage, Inside Technology Training, March 1998, p. 8.
Ebrahimi, Alireza, (1994). Novice programmer errors: language constructs and plan composition, International Journal of Human-Computer Studies, 41, 457-480.
Fay, A. L. & Mayer, R. E. (1988). Learning LOGO: a cognitive analysis. In R. E. Mayer (Ed.), Teaching and learning computer programming (pp 55-74). Hillsdale, NJ: Lawrence Erlbaum Associates.
Galloway, Jerry P., (1990). Misconceptions of Computing Concepts Among Preservice Teachers, Journal of Research on Computing in Education, 413-429.
Guth, Rob, Feds Blast IT for Fragile Infrastructure, InfoWorld, July 20, 1998, p. 1.
Joy, Bill & Kennedy, Ken, (1998). Presidential Advisory Committee Report to President Clinton on Information Technology, June 3, 1998.
Lockard, James, Abrams, Peter D., & Many, Wesley A., Microcomputers For Educators, p. 220.
Martin, Bernadette & Hearne, J. Dixon, Transfer of Learning and Computer Programming, Educational Technology, 30(1), 41-44.
Mayer, R. E. (1988). Introduction to research on teaching and learning computer programming. In R. E. Mayer (Ed.), Teaching and learning computer programming (pp 1-12). Hillsdale, NJ: Lawrence Erlbaum Associates.
Mayer, R. E. & Fay, A. L., (1987). A chain of cognitive changes with learning to program in LOGO. Journal of Educational Psychology, 79, 269-279.
McCoy, Leah, P., Literature Relating Critical Skills for Problem Solving in Mathematics and Computer Programming, School Science and Mathematics, 90(1), 48-60.
Oliver, R. & Malone, J. (1993). The influence of instruction and activity on the development of semantic programming knowledge. Journal of Research on Computing in Education, 25(4), 521-533.
Palumbo, David B., (1990). Programming Language/Problem-Solving Research: A Review of Relevant Issues, Review of Educational Research, Spring 1990, 65-89.
Pea, R. D. & Kurland, D. M. (1983). On the cognitive effects of learning computer programming. New Ideas in Psychology, 2(2), 137-168.
Perkins, D. N., Schwartz, S. & Simmons, R. (1988). Instructional strategies for the problems of novice programmers. In R. E. Mayer (Ed.), Teaching and learning computer programming (pp 153-178). Hillsdale, NJ: Lawrence Erlbaum Associates.
Putnam, R., Sleeman, D., Baxter, J. A. & Kuspa, L. K. (1989). A Summary of Misconceptions of High School BASIC Programmers. In Soloway, Elliot & Spohrer, James, C. (Ed.), Studying the Novice Programmer (pp 301-314). Hillsdale, NJ: Lawrence Erlbaum Associates.
Reuters News Service, (1998). Fed Responds to IT Shortage, Washington Post, January 12, 1998.
Savitz, Eric J. (1998). The Business of Training Workers, Dow Jones Saturday, February 28, 1998.
Shneiderman, B. (1977). Measuring computer program quality and comprehension. International Journal of Man-Machine Studies, 9, 465-478.
Shneiderman, B. & Mayer, R. E. (1979). Syntactic/semantic interactions in programmer behavior: A model and experimental results. International Journal of Computer and Information Sciences, 8, 219-238.
Sleeman, D., Putman, R. T., Baxter, J. & Kuspa, L. (1988). An introductory Pascal class: A case study of students' errors. In R. E. Mayer (Ed.) Teaching and learning computer programming (pp 207-235). Hillsdale, NJ: Lawrence Erlbaum Associates.
Sloane, K. D. & Linn, M. C. (1988). Instructional conditions in Pascal programming classes. In R. E. Mayer (Ed.) Teaching and learning computer programming (pp 137-152). Hillsdale, NJ: Lawrence Erlbaum Associates.
Smith, Thomas M., Perie, Marianne, Alsalam, Nabeel, Mahoney, Rebecca Pratt, Young, Beth Aronstamm, et al., "The Condition of Education 1995", U.S. Department of Education, Office of Educational Research and Improvement, National Center for Education Statistics, NCES 95-273.
Soloway, E., Spohrer, J. & Littman, D. (1988). e unum pluribus: Generating alternative designs. In R. E. Mayer (Ed.) Teaching and learning computer programming (pp 137-152). Hillsdale, NJ: Lawrence Erlbaum Associates.
Spohrer, J. C. & Soloway, E. (1989). Novice Mistakes: Are the Folk Wisdoms Correct?. In Soloway, Elliot & Spohrer, James, C. (Ed.), Studying the Novice Programmer (pp 401-416). Hillsdale, NJ: Lawrence Erlbaum Associates.
van Merrienboer, J. J. G. & Krammer, H. P. M. (1987). Instructional strategies and tactics for the design of introductory computer programming courses in high school. Instructional Science, 16, 251-285.
Vessey, I. (1985). Expertise in debugging computer programs: a process analysis. International Journal of Man-Machine Studies. 23, 459-494.
Weinberg, G. (1971). The Psychology of Computer Programming. New York, NY: Van Nostrand Reinhold.