From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=ham autolearn_force=no version=3.4.4 X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: f8c65,30e368bdb3310fe5 X-Google-Attributes: gidf8c65,public X-Google-Thread: fac41,af40e09e753872c X-Google-Attributes: gidfac41,public X-Google-Thread: 109fba,f292779560fb8442 X-Google-Attributes: gid109fba,public X-Google-Thread: 103376,30e368bdb3310fe5 X-Google-Attributes: gid103376,public X-Google-Thread: 1008e3,30e368bdb3310fe5 X-Google-Attributes: gid1008e3,public X-Google-Thread: 10db24,30e368bdb3310fe5 X-Google-Attributes: gid10db24,public X-Google-Thread: 1014db,30e368bdb3310fe5 X-Google-Attributes: gid1014db,public From: tangent@cyberport.com (Warren Young) Subject: Re-designing CS (long) Date: 1996/06/21 Message-ID: <31ca2b3b.184418880@news.cyberport.com> X-Deja-AN: 161364216 references: <4o07o9$rfu@seagoon.newcastle.edu.au> <4o1vo3$p2a@news1.ni.net> <4oegks$ntn@goanna.cs.rmit.EDU.AU> <4p2jau$hkp@seagoon.newcastle.edu.au> <4p3dad$mia@charm.magnus.acs.ohio-state.edu> <39@wonk.demon.co.uk> <4pq56b$fdi@nerd.apk.net> organization: none newsgroups: comp.lang.ada,comp.lang.c++,comp.lang.c,comp.lang.modula3,comp.lang.modula2,comp.edu,comp.lang.eiffel Date: 1996-06-21T00:00:00+00:00 List-Id: 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