Path: utzoo!attcan!utgpu!jarvis.csri.toronto.edu!cs.utexas.edu!usc!zaphod.mps.ohio-state.edu!uakari.primate.wisc.edu!unmvax!ogicse!cvedc!nosun!qiclab!m2xenix!puddle!p101.f4.n494.z5.fidonet.org!Pat.Terry
From: Pat.Terry@p101.f4.n494.z5.fidonet.org (Pat Terry)
Newsgroups: comp.lang.modula2
Subject: Modula2 <-- Pacsal
Message-ID: <149.257CC7A5@puddle.fidonet.org>
Date: 6 Dec 89 05:03:34 GMT
Sender: ufgate@puddle.fidonet.org (newsout1.26)
Organization: FidoNet node 5:494/4.101 - Settler City Fido, Grahamstown RSA
Lines: 88


 > We are considering replacing Pascal with Modula2 as the language of
 > instruction in our introductory Computer Science courses and were
 > wondering (1) How many other schools have made this change? (2) How
 > has it worked out? Any response would be appreciated.

We changed from Pascal to Modula-2 three years ago in our junior years
after a few years of using it in the senior years.  We work on IBM-PC's
and use compilers like the shareware FST one (excellent value, and a
nice tight implementation for beginners) and JPI TopSpeed (real nice
environment that the kids all love when they are clever enough to handle
it and not panic after a few wrong function key presses).

It works well.  Very well.

Now I notice some of the folk in this thread are saying "well, it's easy
to change to M-2, and you can avoid the real M-2 stuff for a while" or
words to that effect.

I think this makes a rather bad mistake.  I'm convinced now that there
is no great point in delaying some of the object oriented paradigm where
it's useful - and we can give our kiddies much more fun importing
Turtles, Jukeboxes, etc at an early stage - as well as get them onto
modularised tree handlers, stack handlers, since we have to have some
traditional stuff too!  Sure, OOP is not everything, and M-2 isn't
really OOP, some will say, but it can support some of the basic ideas
rather well.

I rolled my own book.  Started life as a pascal clone, like so many do,
but after some excellent remarks from my reviewers, by the time it came
into print I had modified my view considerably, and I'm glad I did.

For the record it's "An introduction to programming with modula-2",
Addison Wesley, 1987, 0-201-17438-3.  You can get all the sources
(useful since I abandoned InOut for what I thought was a better, more self
consistent one) and sources for some other exercises as well, from me.

There are a few other books that try to be subtly different.  I thought
Messer and Marshall were on track in this respect, and the Stubbs and
Webre second level one is good too.  Doubtless there will be more good
ones soon, but it seems a difficult market to reach.

There are too many pascal clone books out there.  I tried in mine to get
the idea of "abstract" types across as early as possible.  The one that
student implement have to be rather simple at first (not the whole
opaque pointer picnic, though of course they can use Turtles and
Jukeboxes that have been done like that long before they can implement
them for themselves). Were I to rewrite the book now I'd be even more
radical, but at the time it seemed sensible to be fairly conventional in
the choice of first examples and so on.  The last two years I have moved
to trying to be more innovative in the use of modules and ADTs (simple
ones) from as early a stage as possible. It works very well.  Not only
does it challenge the students (many of whom have quite extensive
TurboWhatsit experience before they get here) but it has also given the
instructors a fresh breeze of insight and inspiration.  So too, the
distinction between the first "hacker" style course and the second "data
structures" course is getting blurred.  We try to emphasize design and
interface specifications as early as possible too.  Doesn't always work
out too well, as for beginner level programs the division of "expertise"
into different modules seems a bit contrived, especially to the better
hackers, who can knock up a monolithic solution faster than their slower
classmates can read the problem sheet.

To summarise: I think M-2 works very well, but don't confine yourself
to thinking of it as Pascal. Do it properly.  It's not harder!

I have to admit that the M-2 compilers on PC's haven't been as flashy
or as fast as TurboWhatsit (though if students haven't seen the latter,
they don't notice that M-2 is a bit slower, of course).  And I concede
that by now Turbo has most of the features of M-2 incorporated.  Sadly,
if students move to other Pascal systems they can't port their expertise
in all the ad-on areas directly - whereas they can to a great extent
with M-2.

Later courses by my colleagues teach the kiddies C.  Don't want to start
the languages war; just one sad comment.  Some of the students see the
approach in the C courses as so different from my M-2 one that they
think it is a whole new ball game.  Out goes the design, abstraction,
etc and in comes the "isn't it fun to get close to the machine and write
all this cryptic stuff".  I still have to find a way to teach
programming so they see it as that, and not just as coding.  There are
lots of challenges left in life!



--  
uucp: uunet!{oresoft,intelhf}!m2xenix!puddle!5!494!4.101!Pat.Terry
Internet: Pat.Terry@p101.f4.n494.z5.fidonet.org