A first course in computer science that loosely follows the. Computing Curricula 2001 report is described. This course blends theory and practice, highlights ...
Implementing CC2001: A Breadth-First Introductory Course for a Just-in-Time Curriculum Design Andrew T. Phillips, Daniel E. Stevenson, Michael R. Wick Computer Science Department University of Wisconsin-Eau Claire Eau Claire, WI 54701 {phillipa, stevende, wickmr}@uwec.edu Abstract A first course in computer science that loosely follows the Computing Curricula 2001 report is described. This course blends theory and practice, highlights algorithm design, introduces a modest amount of imperative programming, and uses an Internet algorithmics theme to tie the topics together and keep the course both challenging and interesting to those with and without previous computing experience. 1 Introduction Within the community of computer science educators, little initiates more intense discussion than the issue of the structure and purpose of the introductory computer science course sequence. In the language of the Computing Curricula 2001 report [3], there are provisions for imperative-first, objects-first, functional-first, breadth-first, algorithms-first, and hardware-first approaches. Among these choices, the breadth-first approach has received at the same time the greatest verbal support and possibly the least “in practice” support since it was first formally endorsed in the 1989 Computing as a Discipline report [5] and the subsequent Computing Curricula 1991 report [4]. The newly released CC2001 report also notes that “Developing a successful breadth-first implementation … has proven to be difficult.” There are many possible reasons for this, but primary among them is that typical breadth-first approaches add at least one course to the beginning of the computer science program and therefore delay the “introduction to programming” that is the foundation for much of the remaining computer science curriculum. Hence, any of the potential advantages of the breadth approach likely would be outweighed by this significant disadvantage.
In this paper we present a breadth-first approach for a single first course in computer science that loosely models the CS100B course outlined in the CC2001 report. However, our approach does not add to the size of the computer science program, nor does it simply serve as a one-course breadth-first lead-in to a normal programming sequence. Rather, the first course is an essential first element of an overall approach that we call the “Just-inTime” (JIT) curriculum design in which a variety of intermediate and advanced knowledge units are introduced just in time for use in interesting applications even in the very first course. These same knowledge units are then further developed later throughout the undergraduate curriculum, but at increasing levels of sophistication and depth. This model has worked well for us, probably because we’ve invested so much time and effort in making it work. Nevertheless, we offer here some ideas that we think other computer science educators will find interesting and useful, should our model fit their basic needs, too. We also believe that by introducing the JIT curriculum design, we can foster increased conversation in the computer science education community for a curriculum model that, while consistent with the ideals of the CC2001, is different in its holistic view of the undergraduate experience. 2 General Goals CC2001 points to many technical advances in computer science that have dramatically increased the amount of information that students must learn during their four-year education. Of particular importance are technical advances like the World Wide Web, networking, graphics, relational databases, object-oriented programming, and humancomputer interaction ([3], p.10). In light of these new and exciting technologies, CC2001 designers have specifically reduced the number of “core” units of knowledge to leave room for the introduction of these new areas. In our case, we have chosen to focus on a first course that not only covers many of the core knowledge units as dictated by CC2001, but also covers many of the new technologies described above. We believe that by exposing students early to these new and exciting technologies, we can motivate underlying fundamentals concepts, lay the foundation for a detailed study of these same technologies within subsequent courses, and provide a first course
experience that is exciting, challenging, and fun for beginning students. Furthermore, at our institution, we are confronted with the difficult task of offering a first course that is equally challenging to all students regardless of their prior computing experience, that is exciting and fun for new computer science students, and that covers material in sufficient depth that later courses may leverage the solid foundation built by selection of topics covered. For this purpose we have selected a breadth-first course with a mandate of three specific goals that we believe are beneficial for any first course in computer science. We call these goals level playing field, get them hooked, and no wasted time. First, our breadth-first course attempts to level the playing field for all students. Almost no one comes to our first course already knowing any significant portion of the material, so we have only a few bad habits to break and only a small amount of “attitude” to overcome. And almost no one enters our first course with prior experience in anything other than HTML or JavaScript. So our inclusion of selected topics in computer architecture including MIPS assembly language, operating system process scheduling algorithms, database system queries and normalization, and JavaServer Pages is sure to be new and challenging to all students regardless of their prior experiences. In particular, this will benefit women computer science students because of a reduction in male “posturing”, something that often discourages women from continuing in the discipline [2]. Second, our breadth-first course uses the Internet algorithmics theme to quickly capture student interest and get them hooked. Typically, students come to computer science expecting to immediately build eye-popping applications that run across multiple platforms and that can be accessed via any web browser with ease. Many dislike having to wait through weeks of imperative programming constructs and / or weeks of object-oriented concepts, only to barely touch on the graphics and visualization APIs that they had been anticipating. Others are bored at the typical glossy broad overview of topics that are presented without any opportunity to actually create something meaningful or of interest. The need to produce a visual “product” is serious, and without such a product students may be turned off from the field before we really get them started. Third, even though the course is a breadth-first introduction to computer science, no time can be wasted. The first course should be an “advertisement” for the discipline, but more importantly it also must present substantive material and techniques on which many later courses will depend. As an example, our follow-on course is an object-oriented programming course. However, it is not a typical CS1 course. We assume that incoming students have experience with number system representations, elementary data types, and imperative programming. This allows us to immediately start the course with class design and OO principles, freeing up time later for building more
interesting applications. In particular, we use the reclaimed time for teaching web-based programming combining HTML, JavaServer Pages, Servlets, and JavaBeans into a unified framework. Not only does this provide an exciting application for students to work on, but the Model-ViewController style web framework builds on the Internet algorithmics theme and the foundation of HTML, JSP, and SQL knowledge gained in the breadth-first course. Thus, by the end of their first year, students have used or expanded on many of the knowledge units they learned in the first course. 3 A Comparison to CC2001 The advantages and disadvantages of a breadth-first introductory course are well documented in CC2001 ([3], pp. 22-26, 31-32) and will not be argued here. Rather, we focus on the suggested models put forth in CC2001 for implementing a breadth-first introductory course, and discuss how those models compare to, and also differ from, our breadth-first approach. CC2001 describes two basic approaches to implementing a breadth-first curriculum. The first, which they indicate is the most widely used approach, is to have a one-semester course (CS100B) that acts a breadth-first introduction to the discipline of computer science that is then followed by a traditional programming sequence. In this case, this first non-programming breadth-first course is designed for both computer science majors and non-majors alike. The second approach to a breadth-first curriculum described in CC2001 is a three-course sequence (CS101B/102B/103B) that covers all the mandatory introductory units of knowledge put forth in the report. The rationale here is that by spreading the introductory material over three semesters, rather than the traditional one or two, the breadth-first approach may stand a better chance of success. We follow neither of these approaches at our institution, because we do not feel that these models can satisfy our three goals. Instead, we have developed an entire curriculum, not just an introductory sequence, which calls for the introduction of intermediate and advanced knowledge units just prior to when they are needed, even in the first course. Our JIT approach includes in the very first course many of the knowledge units common to a traditional CS1 and CS2 sequence [1], plus many of the topics that CC2001 calls elective units of knowledge normally covered only in the intermediate or advanced courses. The following sections will explain the details of our approach, and how our approach maps to CC2001 while meeting our goals. 4 The JIT Curriculum Design CC2001 continues the tradition of designing a layered approach to an undergraduate computer science curriculum. In particular, CC2001 uses a three-layer system that divides the curriculum into introductory, intermediate, and
advanced courses. Further, within each layer CC2001 provides several alternative implementation strategies that could be used for designing the particular courses that make up each level. For example, they present imperativefirst, objects-first, functional-first, breadth-first, algorithmsfirst, and hardware-first alternatives for the introductory layer. Finally, CC2001 presents specific course outlines (with considerable built-in flexibility) for implementing each alternative strategy within each layer. The entire layered approach is founded on a large list of core and optional units that represent the “computer science body of knowledge.” Each layer is assigned core units that must be covered in their entirety within the specific layer as well as core units that may be partially covered within the specific layer. We believe that a different model, our JIT model, offers a more holistic picture of the undergraduate curriculum while still living within the intent of the CC2001 report. Our JIT model offers increased flexibility as to when and where core units should be covered and at what depth. A reoccurring theme in CC2001 and its predecessor CC1991 is the focus on integration throughout the undergraduate curriculum. In the JIT model, we take this focus on integration to an extreme. The JIT model calls for the introduction of units of knowledge just prior to when they are needed in support of discussions of both fundamental principles and new technologies, and even then only at the level necessary to handle those topics. For example, we introduce database queries using SQL in our first course just in time for the students to build a series of HTML forms and JavaServer Pages to provide a limited form of search capability to a small sample database. Of course, these same database concepts are then further reinforced in various follow-on courses as many of those courses also require a modest amount of database access as part of other more sophisticated programming topics. In this regard, no time is wasted in later courses by reintroducing previously covered material. The end result of our approach is a curriculum model that looks more like the popular Tetris game than the traditional layered approach. Units that are labeled as “introductory” by CC2001 appear throughout the curriculum, rather than being isolated to the first and second year, while other units that are labeled as “intermediate” appear almost immediately in the first and second courses. We believe the JIT curriculum offers several potential advantages over the traditional layer approach. First, since topics covered in early courses are directly expanded (with little or no review) in more advanced courses, students are forced to develop better retention skills. Second, since students are presented with material from the same core units of knowledge multiple times over the entire curriculum, each time with increasing levels of sophistication and depth, students are better prepared to understand the topics when covered in detail, and to systematically reflect on those topics as their overall
knowledge of the discipline grows. Third, students are directly motivated to study the theory of core units as that theory is immediately applied at the level learned to other topics within the computer science curriculum. For example, the OS concurrency knowledge unit (labeled OS3 in CC2001) is a core unit of the computer science body of knowledge that is delegated to the intermediate layer; it is not covered in any of the three breadth-first introductory sequences endorsed in CC2001. We believe, however, that concurrency can and should be introduced in the introductory sequence as it relates to asynchronous threads within a graphical user interface, another core unit (HC2) within the Human-Computer Interaction (HC) topic area. With the introduction of GUI buttons on screen in an early programming course, concurrent threads must be discussed and illustrated, because if not, the interface will exhibit strange and unrealistic behavior (i.e. refusing to allow a button to be clicked until some other process has finished running). Our JIT curriculum design is tailored to handle just this sort of situation, and at the same time provide the exciting and fun “get them hooked” kinds of projects that are needed in the first year sequence. While at odds with some details of CC2001, we believe our JIT curriculum model remains within the intended spirit of CC2001. In particular, the CC2001 report provides skeletal course outlines intentionally leaving room for additional material that fits the needs of individual institutions. While these distinctions [layers] are easy to understand in their own right, it is important to recognize that there is no necessary relationship between the level of a course and the notions of core and elective, which apply only to the units in the body of knowledge. Although introductory and intermediate courses will certainly concentrate on core material, it is perfectly reasonable to include some elective material even in the earliest courses. Similarly, advanced courses will sometimes include some core material… ([3], p. 18). Rather than designing a curriculum around courses that are introductory, intermediate, or advanced, we have designed our curriculum around a “Tetris” of units that are covered at all three levels of sophistication (introductory, intermediate, and advanced) throughout several courses in the curriculum. We still require coverage of all core units of knowledge (and a sufficient set of elective units) presented in CC2001, but we do so in the context of the entire undergraduate curriculum. In many cases, we use this flexibility to introduce units of knowledge that the CC2001 report leaves for later courses. Likewise, in later courses we use some of the flexibility to cover introductory units that CC2001 delegated as mandatory to the introductory sequence. Our main difference with CC2001 is that we view the undergraduate curriculum as a whole, not requiring any particular units to be covered at any particular level in any particular layer.
In the following section, we present the details of the first course in our overall JIT curriculum. 5 An Internet Algorithmics Breadth-First Course Our first course is a breadth-first course tied together, as CC2001 recommends, using a central theme that allows students to understand the material as a natural succession of related, and hopefully exciting, topics. In particular, our breadth-first course uses an Internet algorithmics theme [6] in which students are taken on a journey through the various technologies that support the World Wide Web. We stress fundamental algorithms and algorithm design throughout the course, and continuously weave the fundamental computing concepts into web centric applications that involve HTML and forms processing, JavaScript, and JavaServer Page technologies. Hence, we blend a mixture of traditional breadth style computer science topics with elementary programming concepts by using algorithms and the web as a unifying theme. Figure 1 illustrates the path for this journey.
Algorithms & Pseudo-code
Computer Architecture
Operating Systems
Web Design & Client-Side Computing
perspective. And it has the distinct advantage of providing visual products, since experience tells us that students want to accomplish something right away, or they lose interest. That something must be something they can proudly show to others, such as through a web browser. For example, our introduction to database systems includes an extensive coverage of SQL from both the data definition and data manipulation perspectives. On the theoretical side, entity-relationship modeling and database normalization through third normal form are covered at a level usually delayed until a junior/senior level course on the subject. Students typically develop an E-R model for a small sample database, normalize their model, implement that design using Oracle, and then build a series of HTML and JavaServer Pages (using Web Sphere Studio) to provide a limited form of search capability to their database. The web interface they build consists of an HTML form that connects to a JSP that in turn initiates the SQL query and returns the results in a dynamically created HTML table. In this way the students practice both database design and query techniques while polishing their skills on web design and elementary programming by way of the JSP. Table 1, taken in large part from CC2001 ([3], p28), shows how our first course fits within the CC2001 prescribed “minimal set of goals for an introductory curriculum” ([3], p. 26). Note that our approach satisfies approximately 40% of the “must cover” and “partially cover” lists of knowledge units (KU). The topics in which we indicate no coverage at all are in fact handled in later courses, mainly in our follow-on object-oriented programming class (five additional KUs from the lists covered) and a traditional Discrete Mathematics course (four additional KUs from the lists covered). More importantly though is the reason why we delay this coverage in favor of other knowledge units. Table 2 lists the additional, and in many cases more advanced, topics that we cover in place of some of the “required core” in our first course. KU
Must be covered
Covered?
DS1
Functions, relations, sets
No
DS2
Basic logic
Yes
DS4
Basics of counting
No
Figure 1: Breadth-First Topics Sequence
DS6
Discrete probability
No
The sequence of topics shown in Figure 1 also follows the traditional low-level hardware / systems to high-level software / applications breadth approach to computer science that is commonplace in many other breadth style computer science curricula. Like those models, we begin with number systems and work “outward” to hardware, to systems, and then to applications. This “increasing level of abstraction” idea of course also serves as a unifying theme, but we suspect that theme is more apparent to the instructors teaching the course than to the students taking it. The Internet algorithmics framework makes a more convincing and exciting theme from the student
PF1
Fundamental programming constructs
Yes
PF4
Recursion
No
PL1
Overview of programming languages
No
PL2
Virtual machines
Some
PL4
Declarations and types
Yes
PL5
Abstraction mechanisms
Yes
SP1
History of computing
No
Database Systems & Server-Side Computing
Must be at least partially covered DS3
Proof techniques
No
PF2
Algorithms and problem solving
Yes
6
PF3
Fundamental data structures
No
AL1
Basic algorithm analysis
Yes
AL3
Fundamental computing algorithms
Yes
AR1
Digital logic and digital systems
Yes
PL6
Object-oriented programming
No
SE1
Software design; OOA&D
No
SE2
Using APIs
No
SE3
Software tools and environments
Yes
SE5
Software requirements and specs
No
SE6
Software validation
No
Our implementation of the breadth-first model is also important in that it illustrates the power of an alternative way of looking at the undergraduate education. The JIT curriculum design that we have advocated frees the computer science education community from the more restrictive models proposed in CC2001 and opens the door to many exciting curricular possibilities. The JIT design allows a tight integration of theory and practice by allowing units of knowledge to be introduced only when needed and only at a level that is necessary to support the topic at hand. Over the course of the entire undergraduate curriculum, each successive exposure to a knowledge unit is at a deeper and more sophisticated level that builds on the students’ prior exposure and also takes advantage of other knowledge units that have been covered since the early introduction. And most importantly, our breadth-first approach is designed to attract and retain students from a wide variety of backgrounds by keeping them challenged and excited. Our hope in sharing our JIT curriculum vision in general, and the details of our breadth-first course in particular, is that we might be able to encourage other institutions to adopt similar designs. To facilitate this process, a complete set of Power Point lecture slides for our introductory course is available from the authors.
Table 1: Mapping of CC2001 “minimal set” to our JIT design It is the topics in Table 2 that allow us to build applications that students find exciting and for us to weave the webcentric thread that holds together the concepts from the “core” knowledge units. KU
Topic
PF5
Event-driven programming
AR2
Machine level representation of data
AR3
Assembly level machine organization
AR4
Memory system organization and architecture
OS1
Overview of operating systems
OS2
Operating system principles
OS4
Scheduling and dispatch
OS8
File systems
NC1
Introduction to net-centric computing
NC4
The web as an example of client-server computing
NC5
Building web applications
HC2
Building a simple graphical user interface
IM2
Database systems
IM3
Data modeling
IM4
Relational databases
IM5
Database query languages
IM6
Relational database design
Conclusion
References [1] ACM Curriculum Committee on Computer Science. Curriculum’78: Recommendations for the undergraduate program in computer science. [2] Barker, L., Garvin-Doxas, K., and Jackson, M. Defensive Climate in the Computer Science Classroom. SIGCSE2002, 43-47. [3] Computing Curricula 2001: Computer Science, Final Report, December 2001. The Joint Task Force on Computing Curricula, IEEE Computer Society, Association for Computing Machinery (2002). [4] Computing Curricula 1991: Report of the ACM/IEEECS Joint Curriculum Task Force. Association for Computing Machinery (1991). [5] Denning, P., Comer, D., Gries, D., Mulder. M., Tucker, A., Turner, A., and Young, P. Computing as a Discipline. Communications of the ACM 32(1) (January 1989), 9-23. [6] Goodrich, M., and Tamassia, R. Teaching Internet Algorithmics. Proceedings of the 32rd SIGCSE Technical Symposium on Computer Science Education, Ed. ACM. New York: ACM Press (February 2001), 129-133.
