Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!think!harvard!seismo!umcp-cs!mangoe
From: mangoe@umcp-cs.UUCP (Charley Wingate)
Newsgroups: net.lang,net.cse
Subject: Re: introductory programming languages
Message-ID: <3362@umcp-cs.UUCP>
Date: Wed, 26-Feb-86 00:13:30 EST
Article-I.D.: umcp-cs.3362
Posted: Wed Feb 26 00:13:30 1986
Date-Received: Fri, 28-Feb-86 21:41:44 EST
References: <6796@boring.UUCP>
Distribution: net
Organization: U of Maryland, Computer Science Dept., College Park, MD
Lines: 76
Xref: watmath net.lang:2151 net.cse:627

A number of years ago we had a nice little language here at MAryland called
SIMPL-T, which was used in the second programming course.  The first course
was in Fortran because it was thought that people needed to know it and
nobody wanted to teach it in an upper-level course.  This first course was
very basic.  The second course, however, taught this SIMPL-T language.  Now
this language was much like Algol-60 except radically streamlined; there
were integer and string types, there were arrays, there was a single
character type (which was rarely used), there was recursion, and there were
simple files.  Parameters could be passed by value or reference, and there
was a Fortran interface when one needed.  THere were no semicolons, and no
"Begin-end" blocks (the conditionals and loops were like those in FTN-77);
there was also no goto construct.  The language was sufficiently advanced so
that one could write a working compiler in it.  This language sufficed to
teach structured programming and basic techniques (e.g., linked lists and
recursion).  Most of us who used the language basicaly enjoyed it.

The primary argument against its use was that nobody used it but Maryland.
I've never really been convinced by this argument, because it has always
seemed to me that language syntax shouldn't be that big a thing as far as
educational goals are concerned.  Eventually, Pascal was brought in.  This
had the effect of making programs more difficult to debug, because under the
old system, people were introduced to BNF and Algol-60 before they had to
deal with the likes of Pascal and PL/1.  It also encouraged much more
complicated programs, a situation which was exacerbated by the massive
increase in students within the department.

Eventually, Harlan Mills and the "Gang of seven" struck with a totally new
system.  This had the following features:

* Essentially no Fortran (actually, 2 weeks at the end of the second course)
* Use of CF-Pascal (to be described)
* Program verification through Mills's "Program Calculus"
* Spreading both the teaching of pascal and the verification over two courses
* splitting techniques off into a third course

The language CF-pascal is important to note.  It consists of Pascal stripped
of everything but characters, text files, and function calls.  Needless to
say, it is very difficult to do almost anything in this language.

Does this new system work?  Well, it's not really clear to me.  I was a
teaching assistant for these courses a few years back, and certainly all but
the very brightest students had a lot of trouble-- not that we didn't want
to weed people out very aggresively.  The course has changed quite a bit
since then though; in particular, the text has been revised massively.  I
would not want to attempt to give an opinion on it as it currently exists.

I do have some comments about the efficacy of Pascal as a teaching language
(which, we should all remember, was its orginal intent).  My experience is
that for people who haven't programmed, the syntax is too troublesome.
Without BNF it is difficult to account for where semicolons go.  The bug in
relational-boolean precedence is also a problem.  THe handling of text files
is problematic.

An ideal procedural teaching language would avoid:

* Begin-end blocks
* statement delimiters
* complicated output formatting

It would have:

* a string type
* recursion
* parameter passing by value and reference
* strong typing
* lots of run-time (and even development-time) support

SIMPL-T (and, judging from Mr. Pemberton's presentation, B) has these.  No
subset of any Algol-like language does.  Oddly enough, the next generation
Fortran will have most of these.

These of course are my own opinions, and do not represent the opinions of
the U. of Md. Computer Science Department or any of its personnel other than
myself.

C. Wingate