Re-designing CS (long) (Was: Re: The Last Word on Comments)

[tangent@cyberport.com (Warren Young)]

sjsobol@nstc.com (Steve Sobol) wrote:

>>>Why don't schools design projects/labs that build upon themselves.  Every one 
>
>I think that in concept, this is an excellent, excellent idea (being a
>CompSci student myself). Problem is, if someone transfers into your CS
>department, are you going to make them take all the classes over
>again? or drop them in the middle?

Good point.  Making them start over is probably unreasonable.  Maybe
if they were to take some tests to prove their competence level to the
professor, the student would be provided with a "reference
implementation" for that level of the course, which they could then
build on.  I'll discuss this further below.

It's important to realize that this will all have to fit within the
school's current curriculum model -- you won't get them to change the
model for one department.  It will also require intra-department
cooperation, because several professors will have to basically be
working on a single project.  As it currently stands, each course is
basically autonomous.

I do think the vision has merit, but I don't think that the whole CS
program should be dominated by one big project.  So, I've worked a
shorter long-term project into this, my current vision of a "new CS":

*********************

First, what of the question of what language to start with?  I've not
thought it through too closely, but I think staying with the Pascal
family probably has its benefits.  

You would start the course two semesters of basic programming with
Pascal or Modula-2.  The students will also learn basic data
structures and algorithms, which will be built upon later.

At this point, we've taught the student the basics of programming, and
shaken out most of the posers that weren't suited for programming.
Now it's time for those who are left to decide on a more serious
language and tool set.  Unfortunately, my experience is that most
people at this point don't _really_ know what they want to do.  So,
there will be a few 200-level courses to help them decide.

These courses would be of two types.  The first type would teach them
one of a few more powerful languages, preferrably an OO one.  A school
could offer one in Ada 95 and one in C++, for example.  They would
also learn things like multi-module programming and how to use the new
tools to build large projects.

They would also learn how to read design diagrams appropriate to the
language -- for example, Unified Method for C++ and Ada 95, a
structured design methodology for (ewww!) COBOL, etc.  This lets the
professors supply the design (just like the real world: newbies get
the design handed to them from On High).  This makes sure that
everyone can talk about their programs and have people understand
them.

Currently, students do their own design.  Often, the professor will
essentially give it away in his lecture, but the students aren't
actually constrained to a given design.  I wonder if this is the right
way to go.  Isn't it better to teach the students programming first
and design second?  This lets a student focus on learning good
programming at first; as they program to the given design, they will
absorb the basic lessons of good design.  Eventually, they can be
turned loose to do their own design, and having a grounding in basic
design principles, they will less likely to make any of the basic
design mistakes, so they'll learn faster.

The second type of course would be a pure languages course, with a
course of the first type as a prerequisite.  Since the student knows
the basics of OO, the tools, the filesystem, and the notations, this
type of course can proceed much faster and farther than the first
type.

Basically, the idea is this: The student chooses the first "real
language" that they want to learn, and that course teaches them that,
plus the tools they'll need to go onward.  If they decide they don't
like that language (or just want to try another before going on), they
can take one of the pure language courses.  The student could also
take several of the first type of courses, becuase the design
methodology would probably be different for each.

Next comes "The Big Project".  There could be several similar courses
like this, each based on one of the languages taught in the "Intro to
OO" courses.  So, you could have one track building the Big Project in
Ada 95, one in COBOL, and one in C++, for example.  Again, the student
gets to choose the language they like most to do the project.

This course would be a two-semester deal.  I think that this is long
enough to learn about long-term programming, but short enough that the
system won't be tedious to build.  The project would teach them more
advanced data structures and algorithms, and give them a chance to
appreciate and use some good design.  It also gives them practice and
experience building a largish program, and they become comfortable
with the tools and such.

By the by, having the Project span multiple semesters is another good
reason to provide a mandatory design.  The program would probably be
built class-by-class, each according to the design.  After each one is
built, everyone should have compatible programs, with interchangeable
classes.  The professor could then issue a "reference implementation"
of each class after it's due.  The students could choose to substitute
it for their version, or to keep using their own.  This ensures that
the students and professors can talk intelligently about their
programs, becuase they're all using the same components.   Most
importantly, it will allow the student to take each half of the course
from a different professor.

The Big Project's relatively short length means that a transfer
student probably won't mind starting at the beginning.  It's likely
that they've either got the basics to start the project, or that
they've learned everything the project would teach them, so they can
skip it.  If they really must start in the middle, they can just be
given a reference implementation to build on, just like all the other
students.

The other semesters of a basic degree program would allow the student
to learn things like operating systems, assembly language, compilers,
and additional languages.  Most of these could actually be 200 or 300
level courses, becuase they only require a basic grounding in some
given language.

Here is a basic, sample curriculum:

Intro to Programming with Pascal
Intro to Data Structures (Pascal)
Intro to OO with C++
OO Programming in Ada 95
Large Project Programming in Ada 95, Part 1
Large Project Programming in Ada 95, Part 2
Compilers (C)
Operating Systems (C)

Here's a more ambitious one, for a more intellectually voracious
student:

Intro to Programming with Pascal
Intro to Data Structures (Pascal)
Intro to COBOL, concurrently with Intro to C++
OO Programming in Eiffel
Large Project Programming in C++, Part 1
Large Project Programming in C++, Part 1
Graphics (C++), concurrently with Assembly (summer semester)
Compilers (C)
Operating Systems (C)

**********************

I find it amusing that this thread was the Last Word on Comments.
Especially since I'm asking for comments now...  Heh, heh.

= Warren -- http://www.cyberport.com/~tangent