New Directions in the Introductory Computer Science Curriculum

New Directions in the Introductory Computer Science Curriculum Allen B. Tucker, Bowdoin College Peter Wegner, Brown University

Our goals are to review the evolution of curriculum developmen~ examine alternative curricular approaches, and explore new trends in the design of introductory computer science courses. We review the historical evolution of introductory computer science curricula, including Curriculum 68 and 78, the Liberrd Arts Model Curriculum of 1986, the Deming committee’s comprehensive (broad) approach in 1989, and the implementation of this approach in the recent report Computing Curricula 1991. Alternative approaches to introductory curriculum development are presented in terms of dichotomies such as depth versus breadth, single vemus multiple paradigm, conceptual versus pmctical, and active versus passive learning. The role of programming, mathematics, laboratories, and visualization in the curriculum is examined, We then focus more specifically on the goals and scope of specitlc approaches to the introductory courses, examining the role of introductory computer science within the technical and social context of the discipline as a whole.

to introduce a disciplined approach to problem solving, to introduce procedural and data abstraction, to teach good prog ramming style, to teach a block-structured language, and

to provide familiarity with the evolution of computer hardware and software. CS2 had the following objectives; to continue developing a disciplined approach to progmmrning, to teach data abstraction and data structures, to introduce different implementation strategies for data structures, and to introduce searching and sorting algorithms and their analysis. The Liberal Arta Model Curriculum [ 12 ] presented, in 1986, an alternative approach to the discipline, emphasizing that computer science has a coherent body of scientitlc principles. It defines computer science as the systematic study of formal properties, implementation, and application of algorithms and data structures. It differs fhrn Curriculum 78 in its idea that theory ought to be required~of all majors, so that they appreciate its impact on the discipline to the same extent that they appreciate the impact of design and programming. This model’s proposal for CS1 follows Curriculum ’78, while its proposal for CS2 places greater emphasis on conceptual and formal tools. This version of CS2 has the following goals: to consolidate the knowledge of algorithm design and programming emphastimg the design and implementation of large programs, to begin a detailed study of data structures and data abstraction as exemplitled by packages or modules, to introduce mathematical tools such as complexity (O-notation) and program verifkation, and to provide an overview of the rest of computer science, including computability, architecture, etc. Denning Report [ 10] The 1989 report of the Core Curriculum Tmk Force of the ACM reexamined the scope of computer science, proposed a new teaching paradigm, and presented an example of an introductory course sequence,It defines the discipline of computing as “the systematic study of algorithmic processes that describe and transform information: their theory, analysis, design, et%ciency, implementation, and application. It divides the discipline into nine subareas: algorithms and data structures, programming languages, architecture, numerical and symbolic computation, operating systems, software methodology and engineering, database and information retrieval, artificial intelligence and robotics, human-computer communication The report proposes a three-semester introductory sequence to cover all these areas, supported by intensive laboratory exercises. The introductory sequence is less oriented to programming than earlier approaches, and aims to provide a broad rather than deep overview of the discipline at the introductory level. Curriculum 91 The ACM/IEEE report Computing Curricula 1991 [ 3 ] draws the definition of the computing discipline directly into focus in the undergraduate curriculum. It is a curriculum design documen~ rather than a preIn this sense, Curriculum !?1 designed curriculum. intentionally encourages curriculum innovation-especially at the introductory level.

EVOLUTION OF THE CURRICULUM Curriculum

68 [ 1 ]

Computer

science emerged as a dis-

tinct discipline in the 1960s. Curriculum 68 is one of the earliest attempts to define the scope of the discipline, and includes not only a comprehensive curriculum but also a definition of the major subtields of computer science. It groups computer science into three subfields: information structures and processes,information processing systems, and methodologies. It proposes a core curriculum of four basic courses (algorithms and programming, computer and system structure, discrete structures, numerical calculus) followed by four intermediate courses (data structures, programming languages, computer organization, system programming). These courses emphasize numerical analysis and hardware more than the current core curriculum and omit software engineering but are otherwise similar to current core courses. Curriculum 78 [ 2 ] suggests that emphasis should be placed on algorithms, programming, &ta structures, and hardware, includes a list of topics and fundamental knowledge that every computer science major should know, and suggests that every major should possess the following six skills: to write programs, measure the efilciency of programs, know what problems are amenable to computer solution, understand individual and team problem solving, understand computer architectures, and be prepared to pursue in-depth trainhg or graduate study in computer science. Introductory courses CS1 and CS2 of Curriculum 78 were revised in 1984 [ 13, 14]. CS 1’s objectives becanw Permission to copy without fee ell or part of this meteriel ie granted provided that the copiee ore not made or distributed for direct commercial advantege, the ACM copyright notice and tha tiub af the pubfi.at;on and ks dote oppeor, and notice is given thet copying is by perrnkeion of the Amocistion for Computing Machinery. To copy otherwise, or to republish, requires a fee and~or epecific permission. SIGSCE 94-W, Phoank Ar&ona#SA @

1994 ACM 0-89791 —646W94/ooo3..$3.5o

11

SUBJECT COVERAGE Depth

Multiple vs single paradigms Multiple vs single topics

{

1 Practice

Breadth

Theory

Active / /

Passive

LEARNING STYLE

{ FIGURE 1

Programming vs analysis Science vs mathematics Writing vs reading Presenting vs listening Doing vs listening

Dimensions that reveal choices for curriculum

LEVEL OF ABSTRACTION

Modeling vs reasoning Infonnrd vs formal Engineering vs mathematics Large vs small scale Relevance vs concepts Interfaces vs algorithms

design in computing.

Curriculum 91 makes emphatic statements about each of the following curriculum design issues: the need for breadth of discipline coverag% the role of programming; the nahue and role of laboratories; interaction among the processesof theory, abstraction, and design; and the need to addtvss social and professional issues facing the discipline, These ideas are illustrated in 12 sample implementations that illustrate their feasibility in a wide range of institutional settings. Breadth of discipline covemge is ensured in the Curriculum 91 recommendations in the form of “knowledge units.” These are a collection of topics that span the nine major areas of the discipline (as laid out in the Denning Report), and are presented in the form of lectures and associated laboratory work. Collectively, the knowledge units would require 7 full semester courses to cover all of their lecture material and laboratory requirements. One of the issues that confront cumiculum planners is, therefore, what subject matter should be covered in the introductory curriculum (the fwst three or four courses) and which should be deferred. Different curriculum design projects have addressedthis question in quite different ways.

activities like reasoning, fonnrd methods, attention to concepts, and exploration of algorithms. Many courses, uo doubt, contain a mix of theory and practice, but that mix can vary greatly from one implementation of the same course to another. For example, a CS1 course can be fully consumed by programming or it can be dominated by more abstract concepts, such as logic and problem solving. The second dimension in curriculum design reflects the option to cover a single topic in a course vs the option to choose two or more major topics. For instance, rather than covering only programming in CS 1, an instructor may cover programming, logic, and digital design, using logic as a unifying theme across the other two topics. The third dmension, similarly, provides a continuum of learning style, from completely active at one extreme to completely passive at the other. Active learning is characterized by things like programming (synthesis), writing, and presenting, while passive learning is characterized by analysis, reading, and listening. A tradhional lecture course, for instance, is dominated by passive learning experiences, while an exercise in “cooperative learning” is an example of active learning. The learning style dimension of curriculum design has been explored by Denning et al [ 9 ]. Scientific scholarship has traditionally emphasized theory, depth, and passive learning. Computer science is not only a scientific discipline, it is also an engineering dkcipline that lends itself to both active learning and practical applications. Thus, computer science has more degrees of freedom than traditional disciplines in selecting educational strategies and therefore invites educational innovation of a kind that would not be possible in disciplines like mathematics of physics, Until recently, attempts to present alternatives in curriculum development have concentrated primarily on theory versus practice. The categories singled out in the Denning repom theory, abstmction, and design, are entirely in the theory versus practice dimension. Curriculum reform discussions are endlessly concerned with the theory versus pmctice dimension, devoting far less time to breadth versus depth and to passive versus active learning.

CHOICES IN CURRICULUM DEVELOPMENT Curriculum designers make choices when they define course content, teaching methodology, and other elements that contribute to a complete curriculum. We propose that these different choices in curriculum development can be classified along three dimensions, which we shall call “level of abstraction,” “ subject coverage,” and “learning style” (see Figure 1). The fust dimension reflects the fact that curriculum designers consciously choosesa level of abstraction that can be anywhere in a continuum that has “practice” at one end and “theory” at the other. Evidence of practice in a course is provided by activities like modeling, informal methods, attention to relevant examples, and the exploration of user interfaces. Evidence of theory on the other hand includes

12

Curricuktt ’91 and Tucker et al. [ 17] are exceptions, exploring depth versus breadth as a central question of curriculum development. The gord of Tucker et al. is to design a four-course introductory curriculum that covers in some measure each of the nine areas of the Denning mpom algorithms and data structures, architecture, artificial intelligence and robotics, database and information retrieval, human-computer communication, numericat and symbolic computation, operating systems, programming languages, and softwrue methodology and engineering. In addition, this curriculum seeksto integrate certain fundamental topics from discrete mathematics and the social context of the discipline at appropriate points in each coursq i.e., it moves along the level of abstraction axis in Figure 1, away from the practice ex~me and in the direction of the theory extreme. It aims, therefore, to show students not only the breadth of the discipline, but also the mathematical foundations and social concerns that interact with different subject areas. DIMENSIONS

IN THE INTRODUCTORY

sample curricula presented in Curriculum 91 take a traditional view of mathematics course sequencing and integration within an undergraduate’s course of study. On the other hand, concerns persist that becausecomputing is a mathematical discipline, a more careful intermingling of mathematics topics within the computing curriculum should be done in a satisfactory way [ 3 10 ]. Currently, most CS1 texts are quite nonmathematical in their style, leaving students with the clear impression that computing and mathematics are totatly separate disciplines. The discrete math course, unfortunately, does little to break this stereotype; it is often taught by mathematics faculty as a service course for several disciplines besides computing, such as economics and psychology. To help encourage better integration of mathematics into the introductory curriculum, the breadth-f~st model [17 18] intentionally includes a unit on propositional and predicate logic in the first course. Logic then participates in the process of &veloping a specification-based methodology for algorithmic problem solving. Logic atso provides a foundation for introducing elements of computer architecture near the end of the course. Thus, logic is seen as a unifying thread in the first course, rather than as an unrelated mathematical formatism. A similar role is played by the mathematical topics of function growth and computational complexity in the second course, for both the breadth-fwst model [ 19] and more conventional models [ 12]. There, these mathematical topics are used to assist the discussion of complexity of a.tgorithms for sorting, searching, and manipulating basic data structures. Visualization and interaction Visualization and interaction are two themes that have evolved recently in the introductory curriculum, but have received little formal attention from curriculum planners. In fact, Curriculum 91 allots only a minimal number of lecture hours to the subject area “Human-Computer Communication” in the entire core curriculum, far too little in the view of many. Nevertheless, progress has been made toward integrating an interactive and visual component into the f~st course. Pioneering in this effort are Niguidula and van Dam [ 16]. This a textbook that emphasizes visualization and graphics in programming. Further development of visualization and interaction as an interwoven theme in CS 1 should be greatly assisted by the evolution of CS 1 toward object-oriented (C)Q) programming: 00 languages are much better at sup-g vlsd and interactive programming than are traditional procedural languages, which provides an additioml argument for introducing an 00 paradigm immediately in Csl. The role of laboratories The development of integrated, disciplined laboratory experiences is an activity that Curriculum 91 has helped to accelerate during the last two years, The report recommends specific laboratory components to be developed and integrated with lecture material, for all knowledge units whose subjects have a natural Iabo-. ratory component. It is clear from recent SIGCSE literature that this recommendation has spurred extensive laboratory material development during the last two years, and much more needs to be done. Some introductory texts are now being published with accompanying laboratory manuals [refl, which convey a new discipline for students doing laboratory work. That is students need not only to do some programming, but more often than not they need to develop and hand in an accompanying written work that exposes their mastery of the exer-

COURSES

Because of the broad framework discussed in the foregoing section, many issues persist when designing the introductory

courses in computing. Four principle issues are the role of programming (language and paradigm choices); the role of mathematics; the role of visualization and interaction; and the role of labs. The role of programming Curriculum 91 makes the clear statement that programming is pervasive, and that students should receive training in problem solving and programming early and often in their undergraduate coursework. However, Curriculum 91 goes no further in answering questions like, “What languages?” “What programming paradigms’?” and “What programming?’ Conventionally, the CS1 course has been viewed as “the programming course.” Thus, it has emphasized practice over theory, depth over breadth, and active over passive learning (cf Figure 1). The predominant programming language taught in this course has been Pascal, although recent years have seen a clear treud away from Pascat in this course. The predominant programming pamdigm has been procedural, although that choice is not entirely universal either. Applicative programming and more recently, objectoriented programming (using C++, object-oriented extensions to Pascal, Smalltalk, and even Eiffel) are making strong inroads [ 18]. There is also some emerging sentiment tha~ by the time students complete two or three courses in the curriculum, they should be introduced to more than one (preferably two) paradigm [ 15 ], One way to do this is to introduce a fairly standard procedural paradigm in the fust course (using Pascal or C) and then follow with an object-oriented paradigm in the second course (using Object Pascal or C++, respectively) in the second course. Proponents of this particular choice would agree that the same base language should be used in both courses; otherwise, a good deal of time at the beginning of the second course is wasted relearning simple syntactic concepts in another language. Curriculum 91 The role of mathematics and theory

prescribes a clear mathematics component for the undergraduate major. That component includes five mathematics courses, including 2 semesters of calculus, discrete mathematics, and two others [ 3 ]. However, the exact placement and integration of mathematics topics with computer science courses is left to the individual institution to sort out. The

13

to programming. The goal of this alternative is to address the concern that students learn something more about the

cise. This work requires the analysis of program behavior, the recording and synthesis of results from running a simulation, and so forth. Thus, the scientitlchnalytic dimensions of the discipline are beiig supported with real laboratory ex-

major paradigms and subjects of the discipline beyond prof?ramming. The analogy here is with the natural sciences, where the introductory courses, beginning with the fmg treat the discipline more broadly and an accompanying weekly laboratory introduces students to the paradigm of “doing science.” For example, in [ 18 ], students spend 2–3 weeks of the course with an introduction to logic (thus becoming familii with some aspect of the underlying theory) and 2-3 weeks with computer organization (thus engaging some aspects of computer organization), in addition to 7 weeks of problem solving and programming methodology. Concurrently, a weekly laboratory for this course includes a sequenceof programming exercises along with experiments with logic problems, a simulated machine, and an assembler. This breadth-fret frost course also serves the interests of nomnajors as well as majors. Some fundamental tradeoffs between these strategies for CS1 course design can be summarized as follows. The single-paradigm model emphasizes programming and sacrifices breadth of discipline coverage. The breadth-fwst model adds some discipline coverage, but gives up some of the emphasis on programming in the exchange. Curriculum 91, in its sample implementations, pments introductory courses in both these varieties.

periences that are reminiscent of the analytic experiments that take place in introductory chemistry and physics labs. While laboratory exercises often have analytical components, they still focus in the first course on the general discipline of problem solving and programming. The methodology and tools vary widely, depending on the language choice as well as the hardware and software envimnmen~ The notion of a “closed lab” [ 3 ] is rdso an important contribution of Curriculum 91, and recent experience with this concept has proven to be quite positive [ 11 17]. Another distinctive role of laboratories is that of adding breadth. At Clemson, for example, the ftist course CS1 has a rather traMonal collection of lecture topics, but some of the labs are designed to give students exposure to an entirely different subject area of the discipline, such as computer graphics or artificial intelligence. This strategy helps the department add breadth to the fnst course without disrupting the lecturing preferences of the diffenmt faculty who teach the course.

CS1 AUDIENCE, GOALS, AND DESIGN The fmt course in computing (widely known as CS1) is a particularly complex course to design. Unlike the interme& ate or advanced courses, the fwst course does not have a uniform set of goals or audience. By its nature, thk course can vary radically in its content from one institution to another, and even from one instructor to another. What audiences does the fwst course typically serve? In the simplest scenario, only majors or prospective majors take the fwst course, the curriculum has a single goal (e.g., educating software practitioners or preparing students for graduate work in computing), and all students enter the frost course with similar backgrounds in computing (e.g., none). The first part of this scenario cart actually be realized in larger institutions where the service requirement is covered by a separate course. The second part is also attaimble, though many major programs have two or more gords (i.e., preparing students for gradnate school vs. preparing students for entering the profession vs. preparing students for “lifelong learning”). The third part of this scenario is ahnost never attainable; the presence of a mixed-background audience in CS1 is an important consideration no matter what other design decisions are made for the course.

CS2 AUDIENCE, GOALS, AND DESIGN Beyond the fmt course, the issues surrounding audience, goals, and course design become much more clear. That is, only majors and minors usually venture beyond the frost course, and then the goals of the intermediate and advanced parts of the curriculum tend to govern the design of courses CS2 and CS3. ~ically, students can take either one of two courses after they complete the first course, and both of these courses are required (core) courses for the major. In many instances, the CS2 course has evolved into a “programming in the large” course, often including art introduction to data stmctures and various implementation strategies. The other second course, CS3, introduces computer architecture. It has evolved out of the traditional “assembly language” course into one that covers architecture issues more circumspectly. Software Design course In CS2, a great deal of time is given to the problem of developing a large, complex software project. The laboratory work develops student skills in managing run-time storage and complex collections of processes, There, the notion of abstract data type (ADT) is minimally required as an organizational tool for exploring the characteristics of basic data strictures-liits, stacks, queues, and trees. In many instances, the ADT is giving way to the class as a basic building block, and 00P is finding a strong footing in this mum? [ 11 ]. Texts and lab manuals are now becoming available that cover these topics in an object~ented language, using object-oriented extensions to Turbo and THINK Pascal, as well as C++ [ 19] . Baby Algorithms course Some programs are taking a different view of CS2. At Brown, this course has become a %aby algorithms” course which introduces students more intensively to complexity theory and graph algorithms, as well as basic data structures, than the CS2 course described above. ‘fMs variation is enabled in part by Brown’s commitment in their CS 1 course to an unusually vigorous programming component-one in which students write and

In practice, the conventional design of the f~st course has been to train students in rdgorithmic problem solving and programming. This rationale follows from the argument that depth of mastery in one central aspect of the discipline should be achieved fm~ before students begin exploring other dimensions of the discipline, such as architedure, &tabases, or artitlcial intelligence. An analogy can be &awn with mathematics, where depth of study in calculus precedes broad exposure to subjects liie number theory, topology, algebra, and so forth. Other scientific and engineering disciplines that require CS 1 for their majors also assume that it will be a programming course. The frost course, when designed in this way, can thus fultlll a service requirement for

the depamnent and provide an introduction to the major. Another design for the ffist course is embodied in the “breadth-fust” approach [ 17 ]. There, one or hvo fundamental subjects in the d~cipline are introduced, in addkion

14

debug several thousand lines of code (rather than several hundred) over the period of a semester. That fmt course also incorporates the 00 paradigm. Systems and Architecture course Some of the mom recent [ 17] CS3 courses now incorporate an intensive laboratory introduction to logic design in their frost four weeks. This enables students to see the progression from the gate level of architecture to the basic fetch/execute cycle, thus closing the concepturd hierarchy at the lowest level of architecture. In the middle six weeks, traditional topics of machine organization and assembly language are still covered. In the last three weeks, Brown’s CS3 course ends with an investigation of current issues, such as RISC, parallel architectures, and operating systems. Bowdoin’s CS3 course [17], in the breadth-fwst spirit, ends with an investigation of Lisp machine architectmes. This choice allows students to explore the functional programming paradigm and begin to explore its utility in an entirely different subject area of the discipline-artificial intelligence. Other Alternatives Another design for the CS2 course has emerged at Harvard [ 15 ], where students examine abstract paradigms in computer science rdongside their concrete implementations. Students are exposed to Lisp, C, assembly language, compilation, and interpretation. Projects include propositional calculus resolution theorem proving, grep simulation of a nondeterministic finite automaton, fast sorting algorithms encoded in assembly language and timed, and a Lisp 1.0 interpreter written in C. Other versions of the second course have also been designed to meet special needs. One such need is that of students who have learned too much programming to profit from a traditional CS1 come, might like to major in computer science, but are not yet ready to enter the CS2 course. At Williams College [ 7 ], this need is addressedby a course that includes an accelerated review of standard CS 1 material and an introduction to a fictional language (Miranda) and highly parallel (datatlow and reduction) architectures.

Program in Computer Science, Communications of the ACM 22,3 (March 1979), 147-166. [ 3 ] ACM/IEEE-CS Joint Cunicuhun Task Force, Computing Curricula 1991, ACM Press and IEEE-CS Press, New York (1991), 154 pages. Portions reprinted in Communications of the ACM and IEEE Computer. [4] Abelson, H. and G. Sussman, Structure and Interpretation of Computer Programs, MIT Press,New York (1985). [ 5 ] Baldwin, D. and J. Koomen, “Using Scientific Experiments in Early Computer Science Laboratories,” ACM SIG(XE Bulletin 24,1 (March 1992), 102-106. [6] Biermann, A., Great Zdeas in Computer Science, MIT Press (1990). [ 7 ] Bruce, K., Presentation at the NECUSE Meeting on Introductory Curriculum, Harvard University (January 1993). [ 8 ] Cowley, B., G. Scragg, and D. Baldwin, “Gateway Laboratories: Integrated, Interactive Learning Modules,” ACM SIG(.XE Bulletin 25,1 (March 1993), 180-183. [ 9 ] Denning, l?, “Educating a New Engineerv Communkations of the ACM 35,12 (1992), 83–97. [10 ] Denning, P.,D. Comer, D. Gries, M. Mulder, A. Tucker, A. Turner, and P. Young, Report of the ACM Tmk Farce on the Core of Computer Science, ACM Press, New York (1988). Portions reprinted in Communications of the ACM 32, 1 (1989) and IEEE Computer (1989). [11 ] Epstein, R. and A. Tbcker, “Introducing Object=Orientednessinto a Breadth-First Curricuhnn,” Proceedings of 00PSLA 92, Vancouver, BC (October 1992). [12 ] Gibbs, N. and A. Tucker, A Model Curriculum for a Liberal Arts Degree in Computer Science, Communications of the ACM 29,3 (1986), 202–210.

CONCLUSIONS

[13 ] Koffman, E., Miller, P., and Wardle, C., “Recclmmended Cumiculmrt for CS 1: 1984,” Communications of the ACM 27,10 (1984), 998-1001.

This paper traces the evolution of the undergraduate cnrricu-

hun in computer science and engineering, wi@ special emphasis on the introductory courses. We propose that a framework for curriculum design should have three dhnensions: subject coverage, level of abstraction, and learning style. Recent curriculum recommendations have focussed on the levels of abstraction dimension, contrasting theory, abstraction, and design as operative patdgms in the dkcipline. Single paradigm (@ogratnming) has been a dominant theme in the fwst course until recently, when other models, including the %readth-fwst” model, have been introduced. Considerations for introducing more active learning styles have also emerged only recently, but promise to play htcreasing roles in future versions of the introductory courses.

[14 ] Koftinan, E., Stemple, D,, and Wade, C., “Recommended Curriculum for CS2: 1984,” Communications of the ACM 28,8 (1985), 815-818. [15 ] NECUSE Meeting on the Introductory Curriculum, Harvard University (January 1993); survey of twelve New England colleges and universities’ introductory curricuki. [16 ] Niguidul~ D. and A. van Dam, Pascal on the Macintosh, Addison-Wesley (1987). [17 ] Tucker, A. and D. Garnick, “A Breadth-First Introductory Curriculum in Computing,” Computer Science Education 3 (1991), 271-295.

REFERENCES

[18 ] Tucker, A., J. Bradley, A. Bema~ R. Cupper, and G. Scragg, Fundamentals of Computing I: Logic, Probl,em Solving, Programs, and Computers (2nd edition), McGrawHill (1994), 500 page~ and C++ edition (1994).

[ 1 ] ACM Curriculum Committee on Computer Science, Curriculum 68—Recommendations for the Undermaduate Program in Computer Science, Communications of ;h ACM 11,3 (March 1968), 151-197. [ 2 ] ACM Curriculum

Curriculum Committee 78—Recommendations

[19 ] Tucker, A., J, Bradley, R, Cupper, R. Epstein, and C. Kelemen, Fun&mentals of Computing 11:Abstraction, Data Structures, and Large Software Systems, McGraw-Hill (1993), 538 pages; and C++ edition (1994).

on Computer Science, for the Undergraduate

15