Session T3C FROM THEORY TO PRACTICE: IMPLEMENTING THE CC2001’S INTRODUCTORY PROGRAMMING SEQUENCE Jeff Matocha1 , Andrea Edwards2 , Marguerite S. Giguette3 , R. Raymond Lang4 Abstract - Xavier University of LA’s Computer Sciences and Computer Engineering (CSCE) Department recently assessed its computer science program using both its own assessment data and the Computing Curricula 2001 (CC2001) recommendations. This assessment resulted in changes to Xavier’s computer science curriculum. Specifically, the department examined its introductory programming sequence and developed a detailed schedule that addressed both the department’s needs and the curriculum recommendations. The previous ACM recommended curriculum suggested a two-course introductory programming sequence; however, since a large number of Xavier’s incoming students have no programming experience, the CSCE Department had been offering a threecourse introductory programming sequence. This threecourse sequence provided time for the faculty to discuss the recommended topics in the detail necessary for our students. The CC2001 recommendations realized that a three-course sequence is more appropriate for the topic coverage needed and provided a curriculum that contained this type of introduction. The Xavier CSCE faculty considered these recommendations and used its experience in working with a three-course introductory sequence to develop a new sequence that includes the topics suggested in the new curriculum recommendations while considering many of the realities of teaching such a sequence to undergraduates with no programming experience. This paper discusses the process used by the department in making the curriculum changes, particularly focusing on the introductory programming sequence. The paper provides the rationale used in developing the course sequence and the specific topics addressed in these courses. Index Terms – Computing Curricula 2001, Curriculum design, Introductory programming sequence.
INTRODUCTION Xavier University of Louisiana, the only historically, black Catholic university, has a strong tradition of providing a solid education in the sciences. Xavier ranks first in the nation in the number of: (1) African Americans placed into medical school, (2) undergraduate degrees earned annually
in both the life and the physical sciences, and (3) pharmacy degrees annually awarded to African Americans. “Xavier's student body is predominantly African American (84.9%), but the university is open to all: 3% European American (non-Hispanic), and 12.86% Asian/Asian American, Hispanic or other. Non-black students enroll primarily in the Graduate School or College of Pharmacy. … Admissions policy aims to provide opportunities for students with high school backgrounds that span the spectrum of preparation. The average ACT and SAT scores for entering freshman are 20.5 and 982, respectively, both just slightly below the national average. In maintaining its historic commitment to academic excellence, the University attracts many students with high achievement, while it also admits some under-prepared students and provides workable ways for them to succeed. Developmental courses and related support systems in the essential academic areas of mathematics, writing, and speech have helped an increasingly large proportion of freshmen to move into sophomore year, at an actual retention rate of 77.5% this past year.” [2] Xavier’s Computer Sciences and Computer Engineering (CSCE) Department has approximately 115 students and offers three majors, Computer Science (CS), Co mputer Information Systems (CIS), and Computer Engineering (CE). Students are required to complete 134 semester hours in CS, 138 hours in CIS, and 134 in CE. Since Xavier is a liberal arts institution, these hours include a sixty-six (66) hour core curriculum (forty-six hours for CE). Most freshmen majors have no previous programming experience, and some have only limited computer experience of any kind. In addition, most of these students are required to enroll in either developmental mathematics or Precalculus. Therefore, it is necessary that our curriculum accommodate both under-prepared students as well as Xavier’s large core requirements. This paper describes how the CSCE Department used the CC2001 recommendations to update our three-course introductory programming sequence. It discusses the sequence in use up to the current year, the need for change, the revised introductory sequence, and our initial observations following two semesters of implementation.
1
Jeff Matocha, Computer Sciences and Computer Engineering Department, Xavier University of Louisiana, New Orleans, LA 70125,
[email protected] Andrea Edwards, Computer Sciences and Computer Engineering Department, Xavier University of Louisiana, New Orleans, LA 70125,
[email protected] 3 Marguerite S. Giguette, Computer Sciences and Computer Engineering Department, Xavier University of Louisiana, New Orleans, LA 70125,
[email protected] 4 R. Raymond Lang, Computer Sciences and Computer Engineering Department, Xavier University of Louisiana, New Orleans, LA 70125,
[email protected] 2
0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-1
Session T3C Changes were made to the three-course sequence, but only two semesters have passed since these changes were made; therefore, no students taking this sequence have reached the third course yet. Furthermore, the complete impact of these changes will not be known until students matriculate through the redesigned curriculum.
PREVIOUS CURRICULUM The department’s faculty conducted a review of the existing curriculum at the end of the 2001-02 term. The curriculum in use at that time is described in this section. Xavier operates on a 14-week semester schedule. All three majors (CS, CIS, and CE) share a common opening three-course sequence: Computer Science I, Computer Science II, and Data Structures. CS I and CS II have zero credit drills (closed labs) as co-requisites. CS I required that students had completed all developmental mathematics courses. CS I and CS II are 3 credit hours, and Data Structures is 4 credit hours. Starting in the 1997-98 term, CS I and CS II used the Java language and Data Structures used C++ (migrating students from Java to C++ was one reason for the extra credit hour in Data Structures). Since the 2001-02 term, the C++ language has been used in CS I and CS II as well as in Data Structures. The change from Java to C++ was made to ease the transition to Data Structures; C++ was chosen over Java because of the faculty’s commitment to the coverage of explicit pointer operations. The department had previously developed a weekly schedule of topics for CS I and CS II; these are presented in Tables 1 and 2, respectively. Each schedule shows 13 weeks of topics with the remaining days used for testing. The topic schedules presented here are those that were adopted following the decision to use C++ exclusively in the introductory sequence. These two courses corresponded to the CS 1 course in the previous ACM curriculum recommendations. Since the 1997-98 term, both CS I and CS II have corequired two-hour drill sessions (closed labs) that meet once per week. In these sessions, students solve problem sets drawn from the current topic. The drills are a mix of “paperand-pencil” exercises, program design problems, and implementations. The Data Structures course covered pointers and dynamic memory, linear containers (stacks, queues, and lists, both statically and dynamically allocated), sorting, binary trees and introduced hash tables.
new curriculum guidelines. This section describes the motivations of the department in modifying its CS curriculum. Week 1
Topic(s) Computer organization, fundamentals of memory, SW development cycle, compile -edit-debug cycle. 2 Skeleton of a console application, primitive types, console I/O, basic syntax, computer arithmetic, precedence of operators. 3 Overview of control structures (sequence, selection, repetition), begin selection. 4 Multiple selection, nested selection, switch statement. 5 Introduction to repetition structures, definite repetition (counting loops) to produce tables. 6 Counting loops with non-unit increments, introduction to indefinite repetition. 7 Sentinel loops, bottom-tested loops. 8 Complete repetition, introduction to functions. 9 Functions and parameter passing. 10 Functional decomposition. 11 Introduction to 1-d arrays. 12 Arrays as parameters to methods, searching. 13 More on 1-d arrays, introduction to 2-d arrays. Table 1. CS I old weekly schedule of topics. Week Topic(s) 1 Review of CS I topics 2 2-d arrays 3 More on 2-d arrays 4 File processing 5 Sorting 6 String processing 7 Records 8 More on records 9 More on records 10 More on file processing 11 Complex data structures using arrays 12 Recursion 13 More on recursion Table 2. CS II old weekly schedule of topics.
As described earlier, many of the students that declare themselves computing majors have poor analytical skills. We analyzed student performance in the major based on their ACT and SAT math scores. It was found that a larger percentage of students that entered Xavier eligible to take THE N EED FOR CHANGE Calculus were successful in CS1 and CS2 than those that The spring of 2002 provided a unique opportunity for entered who were required to enroll in Precalculus or Xavier’s CSCE Department. The ACM Computing developmental math courses. The lack of analytical skills in Curricula 2001 had been approved and Xavier was in a these students was also seen as limiting the material that can catalog year allowing for changes to the university’s be covered in introductory CS courses. curricula. The CSCE Department held a series of meetings The coverage of topics in the introductory course examining its Computer Science major in the light of the sequence was another topic of discussion during the 0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-2
Session T3C curriculum planning meetings. We found that, often, students do not recall pivotal topics from their introductory courses when those topics re-emerge in the subsequent as well as the upper level courses. We expect that the changes to the curriculum, described in the next section, will ensure that students have a better and more persistent understanding of the material covered during the introductory courses. Of course, we noted that our curriculum did not provide the in-depth topic coverage recommended by the ACM Computing Curricula 2001. We spent a large amount of effort to ensure that our new curriculum was in agreement with these guidelines. This included changes to the previous CS1, CS2, and Data Structures sequence.
NEW CURRICULUM D ESIGN In the spring of 2002, Xavier’s CSCE Department made a variety of changes to its curricula, including stronger prerequisites, specifying a new weekly schedule for the introductory programming sequence, and modifying the previous Software Engineering course to include group projects and intermediate programming concepts included in the CC2001. This section describes many of the changes we made to Xavier’s Computer Science curriculum, specifically the introductory programming sequence. Since Xavier’s old curriculum was modeled after the imperative first model of the previous curriculum guidelines and had a three course introductory sequence, we chose to continue with the CS101i , CS102i , and CS103i model as presented by the CC2001. This is an imperative first model which teaches programming constructs in the first course, object-based programming in the second, and data structures, object oriented programming, and an introduction to algorithms in the third course. In order to address consistency between sections and even more so, between semesters, the department developed a weekly schedule for the three course introductory sequence. We expect the schedules to allow us to know the topic coverage independent of instructor or even the student body. It is often tempting to cover a reduced set of topics during a semester with a group of under-prepared students as compared to a class full of exceptional students. The schedule also acts as a standard by which instructors can be evaluated. Our CS101i schedule primarily consists of imperative programming topics as described in the CC2001 course description. This course focuses on problem solving as well as C++ control structures. CS101i begins with an overview of computer history, a basic description of computer architecture, and an introduction to the software development cycle. Throughout this schedule, the presentation of new C++ instructions is preceded by the use of each new control structure in structure charts; this progression allows students to distinguish between the design phase and the implementation phase of the development cycle. This arrangement also allows students
to be introduced to the semantics of a new control structure independent of its syntax. Types, I/O, arithmetic operators, and simple functions are introduced in the first two weeks and students are given a punch-and-run assignment as well as an assignment requiring I/O and arithmetic manipulations. The third week consists of the use of simple functions; examples are presented which include functions with no return type, functions with no parameters, and functions where the parameter types do not match the return type. Selection structures are presented with examples of an if without an else, compound conditions, and nested ifs. At this point, we discuss simple statements as opposed to compound statements and about branch coverage testing strategies. Following selection, repetition is covered, beginning with counting loops using the while statement, condition-based loops, and sentinel based loops. Counting loops using the for statement are introduced after the initialize, test, and update steps are able to be recognized in condition-based loops. Of course, nested loops are also covered as a part of repetition. At this point of the semester, functions are reexamined. Although students are expected to have been using functions since the third week, pass by reference is the main topic during this section. Arrays are covered next starting with one dimensional; we present linear search and sorting as motivating examples of an array’s use. Parallel arrays (and the issues with using them) and two dimensional arrays are also covered. The final topic in CS101i is the presentation of structures. Table 3 summarizes the weekly schedule for the CS101i course. Week 1
Topic Intro to computers; PL history; problem solving methodology; types; arithmetic operations; punch and run assignment 2 Hierarchy of operations; program skeleton; I/O; string class (assignment, I/O) 3 Functions – call by value only; trace some calls in a program 4 Selection Structure – conditional and relational operators; hierarchy of operations; compound statements; testing strategies 5 More on selection 6 Begin loops 7 More on loops; nested loops 8 More on loops Functions – pass by reference 9 1-d arrays; linear search; sort; files – I/O redirection 10 Parallel arrays 11 2-d arrays 12 More on 2-d arrays 13 Structs Table 3. CS101i weekly schedule of topics.
0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-3
Session T3C The CS102i course is an introduction to object-based programming and an introduction to basic static memory data structures. In the past, this course spent several weeks reviewing CS101i material, specifically arrays. The new schedule includes only two weeks of review, but focuses primarily on the use of two dimensional arrays. An overall theme, beginning these first weeks, is that of incremental development; the size of projects in this course requires a complete design with incremental implementation. These more complex problems expand the students’ understanding of the software development cycle Two major topics are covered next in this course. The first is classes, specifically their use for encapsulation purposes. Fundamental linear data structures (e.g., stacks, queues) are presented during this discussion as motivation for encapsulation. Of course, these data structures are array based static implementations since the students have not yet been exposed to dynamic memory allocation. Dynamic arrays are presented next in CS102i . The new instruction is only applied to creating arrays whose size is not determined at compile-time and for creating arrays that can be returned from a function. In continuation of the object-based focus of the course, operator overloading is covered, while avoiding the use of the friend modifier. Recursion is presented with a focus on mathematically defined functions (e.g., factorial, Fibonacci sequence) and fundamental algorithms (e.g., binary search, merge sort). We realize that the coverage of recursion in this course is incomplete, but is enough to prepare students for CS103i where recursion will be covered in more detail. Sorting, searching, and linear data structures are revisited with a recursive implementation. Week 1 2 3
Topic Review of 1710 More review of 1710 Introduction to Class –motivate encapsulation and information hiding 4 Interface – behavior vs. implementation; separate compilation; modularity 5 Dynamic arrays 6 Static data structures – stacks and queues 7 More on static data structures – stacks and queues 8 Operator overloading 9 Recursion (mathematical and merge sort) 10 Searching and sorting 11 IDE, API programming 12 Virtual machine; security issues 13 Inheritance Table 4. CS102i weekly schedule of topics.
data structures and algorithms are examined and compared to student-developed implementations. Data Structures starts with a review of CS102i . The second week introduces templates as a mechanism for reuse. Week three revisits linear containers as dynamic linked structures. All structures are presented as C++ class templates. Examples such as postfix evaluation, queuing simulations, and common list applications (e.g., address books, line editor) are presented. The course continues with an introduction to algorithmic complexity analysis that focuses on running time complexity of alternate implementations of common container operations. For example, the complexity of a size method that computes the size on each call is compared to a method that returns the value of a size member. A review of recursion precedes the discussion of trees. Binary trees, binary search trees, expression trees, heaps, general trees, and the applications of these are presented. Representation and traversals of graphs as well as path finding are covered. Fundamental object-oriented mechanisms such as inheritance and polymorphism are treated. Hash tables are motivated as a means of achieving constant time look-up and retrieval. Various sorting algorithms are compared for complexity. Some sorting methods were previously seen in CS101i and CS102i . Other sorts (e.g., heap, Shell) are seen for the first time in Data Structures. The course concludes with an introduction to the algorithm design classes divide and conquer, greedy, and backtracking. Table 5 summarizes the weekly schedule for the CS103i course. In addition to developing these weekly schedules, the department made several other changes to the introductory sequence. After examining the success rates of students in the old curriculum, we felt that it is unfair to allow students without a strong mathematics background to begin the Computer Science curriculum. Requiring Precalculus (or the test scores to enter Calculus I directly) as a prerequisite for CS101i will increase the percentage of students who are able to complete CS101i . Additionally, the analytical maturity of the students in the course will allow the instructors of the course to present a more appropriate set of topics and to assign a more rigorous set of assignments. We expect this change in the math prerequisite to positively affect the quality of the entire major.
CS103i is a traditional data structures course. It includes an introduction to algorithmic complexity analysis and algorithmic techniques (e.g., divide and conquer, greedy). Throughout this course, STL implementations of 0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-4
Session T3C Week 1 2 3
Topic
Review of 1720 Templates; programming paradigms Dynamic linked structures – stacks, queues, linked lists 4 More dynamic linked structures – stacks, queues, linked lists; big O, standard complexity classes 5 Trees – BST 6 Trees – expression trees, heaps (priority queues), general trees 7 Graphs – representation; traversals 8 Graphs – path finding; introduce virtual functions and polymorphism 9 Hash tables 10 Sorts – heap, quick, merge – basic algorithmic analysis; experimental analysis 11 Recursion 12 Divide and conquer 13 Backtracking Table 5. CS103i weekly schedule of topics. The final major topic of the CS102i course is that of inheritance. Students complete the course with a project that includes an inheritance hierarchy. Students are introduced to basic inheritance models (e.g., automobile, animal, simulation). Table 4 summarizes the weekly schedule for the CS102i course. Previously, instructors spent a considerable amount of class time reviewing material from prerequisite courses. In examining the CC2001 recommendations, it was clear that continuing this practice would not support the Department’s goal of covering the material outlined in the CC2001 documentation. Therefore, in the new curriculum, minimal class time is spent reviewing previously covered material. At Xavier, we augment the lecture courses of CS101i and CS102i with a drill section, a mandatory weekly problem solving section. These drill sections, although they have been in place for many years, were reexamined in light of the CC2001 recommendations. Additional content was identified to be covered in these drills. Typically, this material came from topics in the recommendations that were not being specifically covered in other courses (e.g., event driven programming, API programming, office applications). We also use the two hour drill section for testing. Lecture tests are given that include a written and a practical section. Testing in drill not only allows for an extended testing, but also frees three hours of lecture time. A conscious effort has been made to increase students’ programming skills. “Programming is an essential skill that must be mastered by anyone studying computer science.” [1] We have observed that students in the upper level courses have difficulty applying the material presented in earlier classes to more complex problems. Therefore, in order to
ensure that upper level students’ and graduates’ programming skills are sufficient, we are: • Assigning harder problems in CS101i , CS102i , and CS103i , • Increasing the number and scope of programs in upper level courses, and • Modifying the software engineering course to include a substantial amount of programming topics.
CONCLUSIONS The CC2001 recommends a three-course introductory programming sequence that is complementary with our curriculum goals. Prior to adopting these recommendations, our internal assessment committees recommended a more rigorous and comprehensive introductory programming curriculum for our majors. The CC2001 recommendations guided our transition to this new curriculum. To adopt these recommendations, we had to assess the curriculum and its effects on the mission of the university. With this beginning, most of our computer science freshmen are not prepared with the problem solving and analytical skills necessary for the introductory programming courses. Prior to adopting the CC2001 recommendations, our three-semester introductory programming courses were filled with the breadth of conventional computer science programs but with little time for the needed depth. Even with programming labs coincident with the first two programming courses, our majors were not being properly prepared for their subsequent computer science courses. The CC2001 recommendations guided our change to an introductory programming sequence that has the breadth and the depth of material that is needed by all computer science majors. To meet the recommendations of the three-course sequence, we adopted changes in both the mathematics and computer science requirements of our students. • Students entering our introductory programming sequence must be calculus ready. Students in CS101i show markedly better problem-solving skills since we adopted this requisite. Still, these same students do not show the analytical skills necessary for CS102i . Our observation is that our majors need significantly more mathematics proficiency, better problem solving skills, and more understanding of proofs than is taught in our calculus course. • We are proposing that discrete mathematics be required in the second semester instead of the fourth semester. As recommended in the CC2001 guidelines, our majors will schedule discrete mathematics earlier than in our old curriculum. We expect these students to show significant improvement in Data Structures (CC103i ). We are currently collaborating with the Mathematics Department to make this change. • A weekly topic schedule guarantees material coverage between semesters and amongst instructors. Instructors
0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-5
Session T3C
•
•
are free to cover the weekly topics and assign problems as they deem appropriate but the list of tasks for each particular week must be covered completely. Course and instructor assessments are less likely to vary by semester or to vary by the quality of the class of students. CS101i and CS102i each have an additional two contact hour closed laboratory section each week. During these laboratory hours we use active learning and group exercises to reinforce topics covered in lecture. These closed laboratories provide faculty an opportunity to accommodate students’ different learning styles. These laboratories were designed so that novice programmers would have a closed laboratory experience when developing their programming skills. Progressively increasing the rigor in each of the introductory programming courses has helped many of our under-prepared majors to become better computing sciences students. Since adopting the CC2001 recommendations, our CS101i and CS102i students are completing more difficult and comprehensive programming assignments. They are better at problemsolving and have increased independence of thought when introduced to new topics.
• • •
Creating a large set of small study problems for students’ use outside of class, Holding faculty office hours in the department’s tutoring center, and Attracting better prepared students to the program with a concerted recruiting effort.
Still, transforming majors from under-prepared students into adequately prepared beginning computing scientists is a significant improvement. Since adopting the CC2001 recommendations, our CS101i students now begin their major with significantly better analytical skills and our CS102i students are more ready for object-oriented programming methodologies. Students in both of these courses are better prepared and are able to apply more of the material from their previous courses.
REFERENCES [1]
ACM/IEEE Computing Committee on Computer Science, Computing Curricula 2001, December 15, 2001.
[2]
Xavier University of Louisiana, "Quick Facts Xavier University of Louisiana 2003", http://www.xula.edu/Quickfacts.html.
Since adopting the CC2001 recommendations, the students who complete our introductory programming courses are better prepared for subsequent computer science courses. These majors have improved problem-solving skills, have solved more complex programming assignments, and possess both greater breadth and depth of material coverage. Consequently, these students are better prepared for upper-level computer science courses. During the two semesters since we adopted the CC2001 recommendations, we have had a few surprises and many successes. Since we had instituted a more rigorous prerequisite for CS101i , we had expected a higher student success rate. However, we have not seen an improvement in the success rate over the two-course sequence – roughly the same percentage of students is completing this sequence. Even with more in-depth coverage and more complex examples and assignments in CS101i , students continue to have problems grasping the new object-based material covered in the CS102i course. These topics require higher level thinking skills such as generalization and abstraction. We continue to be concerned about the low percentage of students that are able to complete the introductory programming sequence (less than 20%). We plan to continue to seek strategies to increase the retention rate of these students while keeping the rigor at the level described in this paper. Some of these strategies include: • Introducing new teaching techniques appropriate for our audience, • Providing optional weekly study sessions, • Looking for ways to make material more engaging to motivate students to spend time studying the material, 0-7803-7961-6/03/$17.00 © 2003 IEEE November 5-8, 2003, Boulder, CO 33 rd ASEE/IEEE Frontiers in Education Conference T3C-6
