[comp.edu] Texts on fundamentals of programmin

gillies@p.cs.uiuc.edu (04/02/89)

You need to say what you're interested in programming.  If you want to
do

Type of Programming		Type of book
-------------------------------------------------
Scientific Programming		Computer Numerical Analysis
Database Programming		Database book (Ullman)
Compiler Programming		Compiler book (Dragon book)
Optimization Programming	Zillions of math/theory books
PC applications (lotus)		Data Structures / Knuth
Soft. Eng. practice		"The Mythical Man Month"
Device Drivers			OS books / assembly texts
Graphics			Graphics textbook
Simulation			...
...				...

Here are some elementary texts that cover 1 or more areas:

"Data Structures in Pascal", Reingold & Hansen
    In a recent ACM Computing Surveys article, this book was rated best
    among 4 data structures books.

"How to solve it by Computer", R. G. Dromey
    Looks like a cookbook with many examples

"Algorithms, 2nd edition", R. Sedgewick
    Another cookbook, with 40 chapters, but it looks like it has more
    explanation, and covers some knuth, optimization, and, geometry.


Cookbook is a good analogy, since it takes tons of practice on "the
basics" in order to become a good algorithm designer.  You can read
the recipes in the second 2 books, or you can study the ingredients,
using the first book.

gillies@m.cs.uiuc.edu (04/03/89)

> The approach to problem sets in the class at MIT was great
> - they would give you lots of code and you would then have to figure
> it out and then modify or extend it. Much more of a real-world
> approach than writing everything from scratch. 
>
>				Peter Desnoyers


I have to disagree furiously.  I recently reviewed my course notes and
problem sets from 6.001, when it was taught in CLISP ('81).  More than
HALF THE PROBLEMS ARE AI TOY PROBLEMS!!!!  I also took intro to C.S.
for majors at Illinois, and the problems were much more realistic.

Face it, you're not going to be writing lisp interpreters,
reprogramming eliza's, simulating infinite lists of primes, or
reimplementing MacSyma out in the real world.  A LARGE fraction of our
problems in 6.001 could not easily be translated into other languages.
They were very heavily dependent on the intricacies of LISP!

The course is unrealistic.  It is fun, and it teaches recursion
beautifully, and it neglects documentation totally, and the problems
are unrealistic.

cs3b3aj@maccs.McMaster.CA (Stephen M. Dunn) (04/04/89)

In article <82400029@p.cs.uiuc.edu> gillies@p.cs.uiuc.edu writes:
>
>You need to say what you're interested in programming.  If you want to
>do
>
>Type of Programming		Type of book
>-------------------------------------------------
>Database Programming		Database book (Ullman)
   And, of course, there's the old standard, C. J. Date, for database 
programming.  I guess it must be a pretty decent book, because just about
everybody seems to use it for their database course.
-- 
======================================================================
! Stephen M. Dunn, cs3b3aj@maccs.McMaster.CA ! DISCLAIMER:           !
! I always wanted to be a lumberjack! - M.P. ! I'm only an undergrad !
======================================================================

gillies@p.cs.uiuc.edu (04/04/89)

> The approach to problem sets in the class at MIT was great
> - they would give you lots of code and you would then have to figure
> it out and then modify or extend it. Much more of a real-world
> approach than writing everything from scratch. 
>
>				Peter Desnoyers

I agree that one valid way to teach programming is to have students
modify code.

But I have to disagree furiously with the overall implication.  I
recently reviewed my course notes and problem sets from 6.001, when it
was taught in CLISP ('81).  More than HALF THE PROBLEMS ARE AI TOY
PROBLEMS!!!!  I also took intro to C.S.  for majors at Illinois, and
the problems were much more realistic.

Face it, you're not going to be write lisp interpreters, reprogram
eliza's, simulate infinite lists of primes, or reimplement MacSyma out
in the real world.  A LARGE fraction of our problems in 6.001 could
not easily be translated into other languages.  The course is heavily
dependent on the intricacies of LISP!

The course is very unrealistic.  It is fun, and it teaches recursion
beautifully, it neglects documentation totally, but it is VERY UNREALISTIC....


Don Gillies, Dept. of Computer Science, University of Illinois
1304 W. Springfield, Urbana, Ill 61801      
ARPA: gillies@cs.uiuc.edu   UUCP: {uunet,harvard}!uiucdcs!gillies

P.S.  When I took the course, to get an 'A' you had to understand how
to implement LISP closures on a LISP frame stack.  Yes, I got an 'A',
and this knowledge has proven to be about as useful as being able to
jump through a hoop.  In fact, I can't see the fundamental difference!

spencer@eecs.umich.edu (Spencer W. Thomas) (04/05/89)

In article <2323@maccs.McMaster.CA> cs3b3aj@maccs.McMaster.CA (Stephen M. Dunn) writes:

>      And, of course, there's the old standard, C. J. Date, for database 
>   programming.  I guess it must be a pretty decent book, because just about
>   everybody seems to use it for their database course.

Actually, I taught a database course from this book a couple of years
ago, and I was not that impressed with it.  The guy is too wordy and
too "IBM-centric".  Since I'm not a database expert (just a
well-rounded CS professor), I cannot recommend a better book.  I am
just sure that there must be some.  I know that Ullman's book was used
by others in my department for that course, but I don't know whether
it was better.

--
=Spencer (spencer@eecs.umich.edu)

reuven@athena.mit.edu (Reuven M. Lerner) (04/06/89)

I'm taking 6.001 now, and just wanted to respond to a previous
posting.  Granted, this is my first "real" encounter with Computer
Science, but I still think my comments have some validity.

In article <82400035@p.cs.uiuc.edu> gillies@p.cs.uiuc.edu writes:
>Face it, you're not going to be write lisp interpreters, reprogram
>eliza's, simulate infinite lists of primes, or reimplement MacSyma out
>in the real world.  A LARGE fraction of our problems in 6.001 could
>not easily be translated into other languages.  The course is heavily
>dependent on the intricacies of LISP!

True, they want us to learn Lisp.  And not just any Lisp, but "Scheme"
(a dialect developed, to no one's surprise, at MIT).  It's also true
that many of the things we're doing are somewhat difficult, if not
impossible, to translate into other languages.

But the point of the course is not to learn a "practical" programming
language.  Nor is it to learn to program "practical" program.  Or to
translate programs into other languages.

Instead, 6.001 is supposed to teach us (if I'm not mistaken) general
techniques for attacking problems, and writing algorithms using the
benefits a language gives us.  Granted, they stress recursion half of
the time, but they touch on topic (such as mutable data) that would be
difficult to teach in most other languages.

Another advantage of using Lisp is that very few students have
programmed in it before.  If they were to use Pascal or C, many
students would deserve A's before the class even began.

>The course is very unrealistic.  It is fun, and it teaches recursion
>beautifully, it neglects documentation totally, but it is VERY UNREALISTIC....

The course doesn't neglect documentation; it goes about it in a
roundabout way.  We've been learning about data abstraction, and how
important it is to maintain a "level of abstraction" in your programs.
Part of the purpose of abstraction is to make the code more-readable.

Other courses, such as 1.00 (C or Pascal), teach "real-world
programming" in "real-world languages."  6.001 teaches introductory
Computer Science, using a language somewhat popular in CS.

---
Reuven