🚀 go-pugleaf

In article <109@polyob.UUCP> hgoldber@polyob.UUCP (A1 harry goldberg ) writes:
>*** REPLACE THIS LINE WITH YOUR MESSAGE ***
>am interested to hear pros and conss about using pascal as the 
>language in which to teach introductory programming

My opinion is that you shouldn't really be emphasizing the programming
language itself all that much anyway.  Students who want to get into
the details of a particular language can do so on their own.  

Instead, teach general techniques of good software development
(design, modularity, documentation, etc.).  

As for which programming language to use, it really depends on what
facilities you have available.  What coices to you have?  Many
courses which have chosen to teach Pascal have done so as an
alternative to BASIC, which sounds like a good idea to me.  There are
other (besides Pascal) reasonable choices though.

For a new (I think) idea in progressive teaching, how about using 3
or 4 languages, and allowing students to use whichever one they feel
most comfortable with (for projects and exam questions, etc.).

Jeff Siegal - MIT EECS

In article <109@polyob.UUCP> hgoldber@polyob.UUCP (A1 harry goldberg ) writes:
>am interested to hear pros and conss about using pascal as the 
>language in which to teach introductory programming

Here at RIT they use Pascal in the introductory computer courses for
both comp sci/related stuff, and the introductory stuff for everyone else
("everyone at RIT has computer experience").  The courses are obviously
much different, but Pascal is probably a good choice because of it's
typing, which introduces a little disipline.

Also for some unknown reason most of the freshman comp sci's start
with something called karel the robot, which is a Pascal like waste
of time.

As far as Pascal goes, it is alright, but can anyone suggest anything
better?

jeff "in sunny downtown Rochester"(or something like that)

UUCP:                        {allegra,seismo}!rochester!ritcv!jxs7451
CSNET:                       jxs7451%rit@csnet-relay.ARPA
BITNET:                      JMS7451@RITVAXC

> *** REPLACE THIS LINE WITH YOUR MESSAGE ***
> am interested to hear pros and conss about using pascal as the 
> language in which to teach introductory programming

I think PASCAL is a good choice for an introductory programming
language, but others are fine.  What PASCAL offers that some other
languages do not is:
1) recursion 
This is a nice thing for introductory classes.  I remember when I
took CS 121 at the U of I we used PL/I and used the recursive
features of the language to implement a recursive solution to the
Tower of Hanoi problem and implement a simple recursive descent
parser (although we didn't know that was what we were doing).
2) strong type checking
This will help keep these new programmers in line.  (Just imagine a
new programmer with C!)
3) data structures.  By having an introduction to simple data
structures early can help with more complicated structures later. 
PASCAL offers a fairly flexible method for implementing data
structures.

PASCAL has drawbacks (I/O for one) but is a better choice than
BASIC for an introductory course, in my opinion.

Ron Crocker
AT&T Bell Laboratories
Naperville-Wheaton Road
Naperville, IL  60566

Opinions expressed are mine alone and have nothing to do with my
employer or their agents.

Perhaps this discussion belongs in net.cse, but...

It may be reasonable to teach introductory MIT students four languages, but
our students have difficulty with one. At present, our first year sequence
(two terms) covers Pascal and Intel 8080 assembly language (three weeks or so,
for computer organisation concepts, rather than assembly language skill). Even
that is really pushing it. 

As far as I can see, introductory programming courses teach almost nothing
about program design, whether or not one spends the entire time teaching 
program design. The reality seems to be that students ignore all the stuff
you want them to learn, and learn syntax instead. It's only once they've
actually tried to write large programs by hacking, and failed, that they're
ready to listen to our remarks on software design.

If we teach four languages rather than one, all we end up doing is confusing
them on syntax. Until this year, our first year sequence included a unit on
Fortran, which had the effect of causing students to be unable to write
Pascal on the final exam. One might argue that Fortran's semantics are too
similar to those of Pascal, and that one should try a completely different
language, such as Lisp or Prolog. Maybe so, but shouldn't one try to teach
how to do something well before trying to teach completely different
technologies? (Perhaps Lisp is the right introductory language; my
objections are on aesthetic grounds, and therefore not terribly debatable.)

Back to Pascal: this year I switched my second year data structures/program
design course from Pascal to Modula-2. I've been very happy about the
results. But I still believe that at present Pascal is the right
introductory language, not primarily because of its merits (the only
advantage of Pascal over Modula-2--for rank beginners--is the simpler I/O in
Pascal), but because of its acceptance:

     * Pascal is the language used by the U.S. Advanced Placement program;
     * zillions of textbooks;
     * lots of very good implementations, including Turbo Pascal, IBM
       Pascal/VS, and DEC VAX Pascal.

The average introductory student has no longterm commitment to computer
science, so one ought to teach him/her a directly usable skill; that means
teaching a language s/he has heard of.

> am interested to hear pros and conss about using pascal as the 
> language in which to teach introductory programming

     The Pascal Language, I believe, was created as a teaching language.
     In that job, it has become remarkably widespread.

     But I have always disliked it as a first language for the computer
     science major.  For those students who are to go on to become
     `computer people' I have always favored assembly language as the first
     language.

     Why you ask?  Well, it was my first language that I learned.  When it
     came time to learn other languages `the jump' to a higher level was
     easier then `the jump' from a high level language to a low level.
     I attribute this to the fact that assembly language forces you to
     understand what is going on.

     I can't remember how many times, first time Pascal programmers, gave
     me the impression that they really did not know what memory was.

     For those students who are not destined to be computer science majors,
     and for those students who have already been introduced to programming,
     the Pascal language is great.

-- 

				Mark Smith

				NYIT Computer Graphics Laboratory
				Old Westbury, New York
				...{philabs,sbcs}!nyit!mark

In article <247@mit-eddie.UUCP> jbs@eddie.UUCP (Jeff Siegal) writes:
>In article <109@polyob.UUCP> hgoldber@polyob.UUCP (A1 harry goldberg ) writes:
>>*** REPLACE THIS LINE WITH YOUR MESSAGE ***
>>am interested to hear pros and conss about using pascal as the 
>>language in which to teach introductory programming
>
>Jeff Siegal - MIT EECS writes:

>Instead, teach general techniques of good software development
>(design, modularity, documentation, etc.).  

***** BRAVO!! ******
>
>For a new (I think) idea in progressive teaching, how about using 3
>or 4 languages, and allowing students to use whichever one they feel
>most comfortable with (for projects and exam questions, etc.).
>

The main problem with using multiple languages in an intro course is time.
By forcing too many languages at the students the general principals of
software development get lost because the students end up spending far
too much time trying to learn the syntax and semantics of each language.

The other problem is that throwing more than a couple languages at intro
students tends to confuse them...Not to mention the headaches the poor 
graders would have! 

-- 
_______
Deborah J. Jackson
Georgia Tech, School of Electrical Engineering, Atlanta, GA 30332
(404)894-3058
uucp:  ...!{akgua,allegra,hplabs,ihnp4,seismo,ulysses}!gatech!gt-eedsp!deb
                                                                 ^^^^^

In article <717@ihwpt.UUCP> crocker@ihwpt.UUCP (ron crocker) writes:
>> *** REPLACE THIS LINE WITH YOUR MESSAGE ***
>> am interested to hear pros and conss about using pascal as the 
>> language in which to teach introductory programming
>
>I think PASCAL is a good choice for an introductory programming
>language, but others are fine.  What PASCAL offers that some other
>languages do not is:
>1) recursion 
> ...
>2) strong type checking
> ...
>3) data structures.  By having an introduction to simple data
> ...
>PASCAL has drawbacks (I/O for one) but is a better choice than
>BASIC for an introductory course, in my opinion.
>
>Ron Crocker
>
	Folks interested in which language to use in introductory classes,
might recall that Pascal was disigned specifically as an instructional
language intended to promote the good programing practices we all know
and love.  I started out with BASIC and have given much thought to whether
that was the right choice as an intro class and language.  The answer I
reached is that it was not.  If I were teaching an intro class intended
for cs majors I would avoid like the plague BASIC or any language that has
things like self declarations, or lack of self defined data structures 
value/formal parameters, strong type checking or procedures/functions etc ... .

	Sure pascal has drawbacks, especially if your undertaking vlarge projects
(standard pascal at least) and its string manipulations are somewhat stilted.
It wasnt really intended as a systems language but its popularity became so
great that people used it anyway. Hence several versions with extensions to make
those things possable.  However these restrictions are probably a blessing for
for beginning programers.

   So my recomendation is pascal with a strong emphasis on good programing
practices.

-- dave schuh
!uwvax!schuh

PS. Well a language pascal like benifits would also be suitable (modula perhaps)
Just avoid Basic and fortran for sure.

(I am speaking as someone who has taught introductory programming with
several different languages, including Pascal, and who is now involved in a
project designing a new programming language for 'non-professional'
programmers (which includes students)).

In my view, an introductory programming course should teach as much as
possible about algorithms and programming, and as little as possible about
the nuts and bolts of programming languages. The programming language used
should therefore support this as much as possible by allowing algorithms to
be expressed as closely as possible to their formulation, without the
language imposing itself too much.

Furthermore, the language should help the student and teacher as much as
possible, by reducing the need for the student to ask about trivial matters
(a better syntax for Pascal or C for instance would reduce problems with
semi-colons). Strong typing for example is a boon to teachers (I believe)
because many problems are picked out far earlier and can be solved by the
student without reference to the teacher.

So, an introductory language should have several basic properties:
- It should be simple
  So that as little time as possible is spent teaching the language, and as
  much as possible on teaching programming.
- It should have a simple syntax
  For the same reasons. An editor that flags syntax errors as you type them
  in would be a great time saver and educational tool too.
- It should be high level
  To take the emphasis away from the machine, and put it on the algorithms
- It should be structured
  For expressing algorithms
- It should have strong typing
  and other static checks, to detect errors earlier, and speed up
  development time.

An interactive system is also far more helpful than a batch one.

A language that satisfies these requirements is B (the new one, NOT the
predecessor to C): it is simple (only 2 basic types, and 3 structured ones),
has a simple syntax (without  semicolons) with an editor that does a lot of the
syntax work for you (no missing brackets for instance), it is high level and
structured, has strong typing (without declarations: it checks that all uses
are consistent), and it is interactive.

As an example of what I mean, consider what would be necessary to teach in
Pascal or C in order to be able to teach about garbage collection, and how
long a program simulating it would be, and how long it would take a student
to write.

Here is a program in B to do it. B has numbers and texts (=strings) and
(sorted) lists. So {1; 4; 9; 16; 25} is a list of numbers, and
{"cow"; "goat"; "dog"} a list of texts. Tables are a generalisation of
arrays: the indexes and elements may be of *any* type, so:
	PUT {} IN graph
initialises the variable 'graph' with an empty table
	PUT {1; 45; 61} IN graph[2]
	PUT {8; 27; 96; 125} IN graph[61]
adds two elements to the table. Lists can be updated:
	INSERT 42 IN graph[2]
	REMOVE 61 FROM graph[2]
	WRITE graph[2]
	{1; 42; 45}
The keys (=indexes) of a table can be got as a list:
	WRITE keys graph
	{2; 61}

So here is the garbage collection program. The store is a graph, represented
by a table where each index represents the 'address' of a data-object, and
the element associate with that index is a list of addresses that that
data-object references. The program is a function that takes such a graph,
and a root node, and returns the graph with all nodes not reachable from the
root deleted. It works by first collecting the addresses of all nodes
reachable, and then deleting those not in that list.

YIELD graph accessible'from root:
   MARK
   SWEEP
   RETURN graph
MARK:
   PUT {root}, {root} IN accessible, to'do
   WHILE to'do > {}:
      SELECT'NODE
      TREAT'NODE
SELECT'NODE:
   PUT min to'do IN node
   REMOVE node FROM to'do
TREAT'NODE:
   FOR sub'node IN graph[node]
      IF sub'node not'in accessible:
         INSERT sub'node IN accessible
	 INSERT sub'node IN to'do
SWEEP:
   FOR node in keys graph:
      IF node not'in accessible:
         DELETE graph[node]



B is actually in use in a couple of schools in the Netherlands, with some
others planning it. The major problems are that the implementations are not
really fast enough for large groups of students on one machine (though the
Dutch schools are doing this; on personal computers it is fast enough for
education), and there are not (yet) any introductory text-books.

Steven Pemberton, CWI, Amsterdam; steven@mcvax

In article <6796@boring.UUCP> steven@mcvax.UUCP (Steven Pemberton) writes:
>In my view, an introductory programming course should teach as much as
>possible about algorithms and programming, and as little as possible about
>the nuts and bolts of programming languages. The programming language used
>should therefore support this as much as possible by allowing algorithms to
>be expressed as closely as possible to their formulation, without the
>language imposing itself too much.
>

I certainly agree.  A family member learning programming started out going
through chapter 1 of Kernighan and Ritchie, and learned a lot, but started
getting bogged down when algorithm design started to dominate the programming
task.  She started an intro to DP class, in which was assigned "Karel the
Robot" by (sorry, book not at hand).  It turned out to be a VERY effective
introduction to structured programming and algorithm design, with all the
messes of math, data types, etc.etc. stripped away.  The idea is, there's this
programmable robot which can move, pick up objects, iterate...  An emulator
for the robot is available, sort of as shareware i.e. not free (see the book
for address).  But it's quite practical to emulate the robot by hand.

-- 
James F. Carter            (213) 206-1306
UCLA-SEASnet; 2567 Boelter Hall; 405 Hilgard Ave.; Los Angeles, CA 90024
UUCP:...!{ihnp4,ucbvax,{hao!cepu}}!ucla-cs!jimc  ARPA:jimc@locus.UCLA.EDU

>In article <109@polyob.UUCP> hgoldber@polyob.UUCP (A1 harry goldberg ) writes:

>am interested to hear pros and conss about using pascal as the 
>language in which to teach introductory programming

What language should be used depends on who is taking the course.
If the course is programming for poets then Pascal or BASIC are
fine.  They are essentially teaching languages.  If the course
is for computer science majors then I would vote for Algol 68 or
Lisp or Prolog.  

Algol 68 is much better than Pascal because it is much more general.  It
doesn't restrict the programmer to write in a manner such that a one
pass compiler can be used.  It is orthogonal and general.  Structs
(records) can be returned by a function, for example.  (Pascal does not
allow this).  Mode (type) equivalence is not by name as it is in Pascal.
Thus, it is possible to write a generalized sort routine.  How do you
teach someone to write a sort routine in Pascal?  

Only a few ideas have to be learned, not a complex set of rules and 
regulations.  One example is the idea of the equivalence of expressions 
and statements.  Students can think about problem solving, not syntax.

In the upper division programming languages course at UCLA, the
language the students like best is Algol 68.  Is there any wonder
why?

Finally, HOW DO YOU EXPECT STUDENTS TO WRITE ORTHOGONAL AND GENERAL 
PROGRAMS IF THE LANGUAGE THEY ARE USING IS NON-ORTHOGONAL? 

David Gast
{ihnp4, ucbvax}!ucla-cs!gast
gast@ucla-locus.arpa

P.S.  The argument is that there are not enough textbooks or compilers
is not valid.  If 10,000 professors started clammoring for Algol 68
textbooks and complilers, they would appear.  Even Joe "I don't know
Anything" Technical writer would write a book on Algol 68.