The First Year, Beyond Language
SIGCSE 96 Panel Presentation
Michael B. Feldman
Department of Computer Science
School of Engineering and Applied Science
The George Washington University
Washington, DC 20052
(202) 994-5919 (voice)
mfeldman@seas.gwu.edu (Internet)
http:/www.seas.gwu.edu/faculty/mfeldman (WWW)
Underlying Themes
- Undergraduate Computer Science should be seen as a profession.
- CSAB criteria serve as a reasonable set of definitions of an
undergraduate professional program.
- The first year should lay the professional foundations for the
remaining three years.
- Classical CS1 and CS2 need to be updated, primarily with an
increased emphasis on object thinking.
- However, classical CS1 and CS2 are still a good basis, so lets
not throw out the baby with the bath water.
- Students see an undergraduate program as a path to a job; we
cannot pretend that it is not.
- However, we must be careful that our educational principles
are sound and that we do not just jump unquestioningly on industry
fads.
Speaker Background
- Has taught CS2 every year since 1975
- Taught CS1 1975-1982 and 1991-present
- Teaches File Structures (has CS1/CS2 as prerequisites)
- Currently developing/teaching a real-time software
course/laboratory using an HO scale model of the DC rapid transit
system (which really is automatically controlled)
University Background
- private, Washington, DC (near White House)
- 5,000 undergraduates, 300 in EECS
- ABET-accredited in EE, Computer Engrg
- CSAB-accredited in CS
- 10,000 grad students, 500 in EECS
- We are not:
- University of Washington, Seattle
- Washington Univ., St. Louis
- Washington College (Maryland)
- Washington & Lee (Virginia)
- Mary Washington College (Virginia)
- Georgetown Univ. (DC)
- George Mason Univ. (Virginia)
Computer Science: the Profession (CSAB 1994
Report, p. 6)
- "...[T]he discipline spans both advancing the fundamental
understanding of algorithms and information processes in general,
as well as the practical design of efficient reliable software and
hardware to meet given specifications...
-
- "A professional computer scientist ... should be able to apply
the fundamental concepts and techniques of computation,
algorithms, and computer design to a specific design problem. The
work includes detailing of specifications, analysis of the
problem, and provides a design that functions as desired, has
satisfactory performance, is reliable and maintainable, and meets
desired cost criteria."
The Undergraduate Course Sequence: Computer
Science as a Profession
- Students should aspire to design and implement the computer
systems that influence our lives:
- Telephone switches
- Airliners and air traffic control
- Automotive systems (ABS, speed-control, fuel systems)
- ATMs and other banking systems
- Supermarket scanners and databases
- Medical systems
- Word processors and video games pale in importance. We must
emphasize:
- Correctness and robustness first, then glitz
- Discipline first, then creativity
- Maintainability first, then flexibility
- Composition first, then inheritance
Classical CS1 (Koffman et al, 1984)
- Basic concepts of computer systems
- Problem-solving and algorithm development
- Control structures
- Data structures (scalar, composite)
- Procedural and data abstraction, information hiding
- Top-down and bottom-up design and implementation
- Generation of test data, stubs and drivers
- Optional advanced topics
- Dynamic data structures and pointers
- Algorithm analysis (big O)
- Verification and loop invariants
Classical CS2 (Koffman et al, 1985)
- Methodology: specification, design, coding, correctness
- Linear data structures: stacks, queues, linear lists
- Nonlinear data structures: trees, sets
- Files: sequential, random access
- Implementation of data structures
- Recursion
- Searching and sorting, including "big O" analysis
- Optional Advanced Topics
- B-trees, AVL trees, graphs
- Formal specification
An Objects Early Approach to Foundation
Courses
- An object has state and behavior.
- A type is a set of values and a set of operations.
- Students should learn from the start that variables are
objects: each object has a type, which means it has a value
(state) and behavior (operations).
- Types can be built up from others (composition/encapsulation)
or inherited from others (classification/inheritance).
- Students start out using encapsulated objects and grow into
writing their own. Students learn to encapsulate as early as
possible, which requires that the early capsules be small and
simple.
- Generic templates should get more attention than inheritance;
encapsulation is seen (in industry too!) as the heavier
contributor to reliable and maintainable software.
First Course
- The student leaves the course with a well-rounded set of
programming concepts to use in writing or reading programs later,
in whatever language
- Control, data, and encapsulation structures are introduced and
scaled up in parallel as much as possible
- Objects Early, but no magic: course-specific packages are
simple enough that students can understand the implementations
within a few weeks of using them
- Projects embody a reasonable mixture of numerical and
data-processing applications
- Projects emphasize
- good design and documentation
- robustness (bulletproof-ness) and testing strategies
- esthetically pleasing and readable code construction
- portability: no system-specific features (GUI, etc.) at
this level (the canonical course platform is Solaris, but
students can use our PCs of their own and re-compile on
Solaris)
Projects in First Course
- 8-10 projects, roughly 1 every week or so
- project requirements: a Case Study
- problem statement, analysis (English), data requirements
- main algorithm and refinements thereof
- test plan (a list of justified test cases)
- source listing (date-stamped by compiler)
- execution log of successful run (Unix or DOS script)
- size of documentation scales up with size of program, but all
elements required in each project
- grade weighting
- 30% analysis and design documents
- 20% test plan
- 30% code correctness
- 20% code quality (comments, indentation, variables, etc.)
Basic Principles in Second Course
- 4-5 projects
- key principles: teach classical data structures in the context
of generic ADTs, with some use of inheritance
- distinguish between developer and user (client program);
emphasize guaranteeability of operations, subject to preconditions
- show benefits of well-specified interface with several
implementations and several client programs
- project requirements:
- user guide: generally an expanded package spec
- test plan (a list of justified test cases)
- source listing
- listing of successful compilation; script of successful run
- grade weighting
- 30% user guide
- 20% test plan
- 30% code correctness
- 20% code quality (comments, indentation, variables, etc.)
Why Ada 95 as the Foundation Language?
- the disciplined control and data structures of Pascal
- system composition structures (private types, packages,
exceptions, generics, concurrency) derived from Simula, Clu, CSP
- classification structures in Ada 95 are an easily understood
extension of the existing type and package structures
- a standard that is taken seriously: provides portability, and
sets a good example of professionalism and maturity in the
software field
Ada as a Foundation Language: Number of
Institutions, by Year
