🚀 go-pugleaf

I have decided to step into the fray here.

(1) The object of an introductory course that includes programming is to
teach problem solving techniques using a computer.  Teaching a programming
language is a necessary vehicle for this (unless you wish only to use
canned programs, and even there you have some sort of language).

(2) There is the choice to teach only one programming language or to teach
multiple ones.  To me the major choices (of categories) are to teach a
primitive language (Fortran or Cobol), an Algol-based language (C, Pascal,
Modula-2, Ada), an interactive language (BASIC, APL), functional language
(LISP, Scheme), other (Smalltalk, Logo).  [Sorry if you don't like
my taxonomy.]  Traditionally, intro courses have switched from teaching
primitive languages to Algol-based languages, with an occasional intermediate
stage at PL/I (kind of Algol-like).  Recent experimentation has been done
in teaching Lisp or Lisp-dialects (Scheme).  Most of the Logo and Basic
teaching is done at earlier grade levels than college.  Other than the
college level, Pascal is mainly taught at the late High School level
(with part of the reason for its use being the AP exam in CS).

One argument is that teaching multiple language paradigms will give
students a better feeling for what Computer Science is all about.
A counterargument is that it may overwhelm the students, the students
may not yet be ready to make the distinctions necessary when several
languages are taught, and that little depth may be possible, especially
in a quarter course.

(3) Regardless of the choice of a single language or multiple
languages (preferably with different paradigms), one of them is likely
to be first.  Of all the Algol-based languages, Pascal is currently
the best introductory teaching language in my opinion.  C suffers from
lack of enforced discipline that is very useful for beginning
programmers.  Besides, C is advocated primarily by UNIX users, and the
error message "Segment fault, core dumped" is not my idea of a user
friendly error message that would help a novice programmer find the
error in the program.  I don't know anyone who seriously suggests
teaching Ada as a first language (they should be punished by having to
teach Ada to Cobol programmers).  Modula-2 is a good "contender for
the title" and may become the language of choice once (1) it is
standardized including support modules, (2) it is as widely available
as Pascal, and (3) there are enough Modula-2 based intro programming
textbooks so that you can choose one using a teaching approach you
agree with.  Also note that once you have learned Pascal, it is relatively
simple to learn another Algol-based language.

Many advocates of Lisp as a first language argue that it facilitates
teaching some more advanced topics, such as recursion, earlier than
Algol-based languages.  They also like the simplicity of the syntax
and that programs and data are uniform (built out of the same list
structures, if you will).  There are several popular varieties of Lisp,
somewhat mutually incompatible, and Lisp is not universally available,
and using Lisp requires use of an interactive system.  [While I believe
that every student learning intro CS should be given sufficient access
to an interactive computer system, the lack of available facilities at
some institutions preclude this.]  Perhaps Common Lisp will win out,
or maybe it will be just one more variant of Lisp.  There are also
fewer intro textbooks on Lisp than on Pascal, but that will make the
selection process that much easier (or perhaps that much more frustrating).

I think that the jury on Lisp vs. Algol-based language (really Pascal)
is still out.

(4) My opinions?  I'm glad you asked that question.  I believe in
teaching Pascal as a first programming language.  Other language
paradigms can be taught in a programming languages survey course.  Of
course, I have a vested interest; I am author of "A First Course in
Computer Programming Using Pascal" (McGraw-Hill, 1982; second edition
in progress).

Arthur

-- 
------------------------------------------------------------------------------
Arpanet: ARK@SALLY.UTEXAS.EDU
UUCP:    {gatech,harvard,ihnp4,pyramid,siesmo}!ut-sally!ark

In article <4253@ut-sally.UUCP> ark@sally.UUCP (Arthur M. Keller) writes:
>
>I have decided to step into the fray here.
>
>(1) The object of an introductory course that includes programming is to
>teach problem solving techniques using a computer.  Teaching a programming
>language is a necessary vehicle for this (unless you wish only to use
>canned programs, and even there you have some sort of language).

I am not sure that this is the actual goal of introductory programming courses.
I know introductory courses which teach ``what is a function'' and
``what is a loop'' and ``what is an if-then-else'' and ``what is
a linked list''.  For a great many people, especially those who have
only a passing interest in computer science but think that having ``a few
computer courses'' will help them be better economists (or whatever it
is that they *are* interested in) this is about all that they can handle.

I don't consider this ``problem solving'' -- just like learning how to
recognise and use a saw and hammer doesn't make you a carpenter.  I
also think that it is far more important to teach your course in a
language for which there is an excellent text book than to teach your
course in a ``better'' language.  
-- 
Laura Creighton		
ihnp4!hoptoad!laura  utzoo!hoptoad!laura  sun!hoptoad!laura
laura@lll-crg.arpa

>
> Personally, I hate Pascal and consider it the scourge of computer science,
> if I had to choose one language I would go with either C or Lisp. The
> former because it is a traditional, ALGOL-like language which higher-ups
> seem to like in an intro programming language (ie. just enough like Pascal
> to sell the idea) and it doesn't have all the Pascal brain-damage (for starters

pascal is a much better choice as a first language.  it would be cruel to
teach C to anyone who has not already passed two courses in heiroglyphics..

In article <557@hoptoad.uucp> laura@hoptoad.UUCP (Laura Creighton) writes:
>In article <4253@ut-sally.UUCP> ark@sally.UUCP (Arthur M. Keller) writes:
>>(1) The object of an introductory course that includes programming is to
>>teach problem solving techniques using a computer.  Teaching a programming
>>language is a necessary vehicle for this (unless you wish only to use
>>canned programs, and even there you have some sort of language).
>
>I am not sure that this is the actual goal of introductory programming courses.
>I know introductory courses which teach ``what is a function'' and
>``what is a loop'' and ``what is an if-then-else'' and ``what is
>a linked list''.  For a great many people, especially those who have
>only a passing interest in computer science but think that having ``a few
>computer courses'' will help them be better economists (or whatever it
>is that they *are* interested in) this is about all that they can handle.
>
>I don't consider this ``problem solving'' -- just like learning how to
>recognise and use a saw and hammer doesn't make you a carpenter.  I
>also think that it is far more important to teach your course in a
>language for which there is an excellent text book than to teach your
>course in a ``better'' language.  
>-- 
>Laura Creighton		
>ihnp4!hoptoad!laura  utzoo!hoptoad!laura  sun!hoptoad!laura
>laura@lll-crg.arpa

I did not mean to imply that every intro computing/programming course
teaches problem solving using a computer.  However, when I teach intro
CS, that is what I teach.  There are several parts to problem solving:
(1) analysis of the problem, (2) having sufficient knowledge of useful
and relevant tools, (3) choosing the relevant tools for the problem,
and (4) applying the relevant tools to solve the problem at hand.
Number (2) can be further divided into three parts: (2a) having a list of
tools, (2b) knowing what each tool does, (2c) and knowing how to use it.

Teaching "what a loop is" is essentially teaching (2b).  But you don't
really understand it unless you also know (2c).  The only wait to
learn (2c) is to practice doing (4).  I claim that this paradigm is
useful outside of computer science, but is well illustrated in CS; you
need to master it to master a CS course involving significant
programming.  Learning more about steps (1), (3), and (4) are very
useful to anyone, even if you never interact in any way with a
computer again.  Steps (2) are necessary to apply the other steps to
the discipline of computer science, and they are the ones that depend
significantly on the programming environment (not just the language)
that the students use.

Learning how to recognize and use a hammer and saw does not make you
any more a carpenter than taking an intro CS course involving
programming makes you a programmer.  But not any less either.
Learning how to use a hammer involves banging nails into things.  To
motivate it, maybe you build a doghouse or something.  How is that
different from writing toy programs to solve toy problems?  When I
teach intro CS, I tell my students that this one course will not make
them "programmers".  (On the other hand, how many people build things
at home on weekends just from the knowledge gained in one semester
shop class in high school?)

I agree with the importance of a good book.  (After all, I think I
wrote one.)  But don't underestimate the importance of a good
environment: programming language, debugging tools, operating system
environment, etc.  I believe that there will be a choice of Modula2
intro programming books wwithin a few years.

"When the only tool you have is a hammer, it is tempting to think of
everything else as a nail."

Arthur

-- 
------------------------------------------------------------------------------
Arpanet: ARK@SALLY.UTEXAS.EDU
UUCP:    {gatech,harvard,ihnp4,pyramid,siesmo}!ut-sally!ark

In article <4253@ut-sally.UUCP> ark@sally.UUCP (Arthur M. Keller) writes:
>I have decided to step into the fray here.

Same here.  Normally, I'd stay away from this sort of discussion as it
invariably becomes "religious", but the following comment made me feel
like doing a little evangelizing...

>I don't know anyone who seriously suggests
>teaching Ada as a first language (they should be punished by having to
>teach Ada to Cobol programmers).

Gag me (as I believe the idiom is) with a spoon!  I don't understand why,
if Pascal could be considered as an introductory language, Ada should be
regarded as worse.  I often hear the complaint "But Ada is so *huge* and
*complicated*!".  Maybe, if you look at the complete language.  However,
there is a subset of Ada which is remarkably Pascal-like: if one ignores
tasking, and the rest of the "further on in the book" stuff, there remains
a simple, elegant, Algol-like language which should be as comprehensible
to a beginning programmer as Pascal is, if not more so.  And it doesn't have
the quirks which make Pascal difficult to explain.
Have you ever tried to explain Pascal I/O to beginners?  I have, and I can't
say it sounds entirely convincing.

But then I *like* Ada.  So you can disregard the above as "religious" if you
want.
							Kay.
-- 
Virtue is its own punishment.
			... mcvax!ukc!warwick!kay

In article <433@snow.warwick.UUCP> kay@warwick.UUCP (Kay Dekker)
writes about my disparaging remarks on teaching Ada as a first
language.  The main issue appears to be that if you restrict yourself
to the features of Pascal when teaching Ada, what's wrong with using
Ada syntax and an Ada compiler?  Pascal can run on lots of
environments rather efficiently.  I am not convinced that the typical
Ada compiler will compile a Pascal-like program as quickly and running
as fast as a Pascal compiler for the same machine would do to the
Pascal program.  Pascal is a simple yet powerful language.  It has
most of the features you would want to use when teaching intro CS and
programming using the Algol-based language paradigm.  Most
corresponding things in Ada are more complex and have the potential
for confusing novices.  I cannot believe that learning Ada as a second
language after Pascal will disadvantage a programmer over learning Ada
as a first language; I think it would be an advantage.

>Have you ever tried to explain Pascal I/O to beginners?  I have, and I can't
>say it sounds entirely convincing.

I have done it reasonably successfully in class and in my book.  Have
you ever tried to explain Ada I/O to programmers new to Ada, let alone
novices to programming?

Arthur

-- 
------------------------------------------------------------------------------
Arpanet: ARK@SALLY.UTEXAS.EDU
UUCP:    {gatech,harvard,ihnp4,pyramid,seismo}!ut-sally!ark

In article <4360@ut-sally.UUCP> ark@sally.UUCP (Arthur M. Keller) writes:
>The main issue appears to be that if you restrict yourself
>to the features of Pascal when teaching Ada, what's wrong with using
>Ada syntax and an Ada compiler?  Pascal can run on lots of
>environments rather efficiently. Pascal is a simple yet powerful language.  

Several articles by Soloway, Bonar, Erlich & co. suggest that the ability
to break out of a loop makes learning to program much easier.  For example,
See CACM vol 26 (1983) pp853-860.  Standard PASCAL doesn't have this feature.
If you want efficient compilers & a simple language, I'd suggest Modula-2.
This also has the advantages of defined string-handling, modules & separate
compilation, instaed of the various ad-hoc hacks to PASCAL to make it a halfway
reasonable programming language.

I can't remember if Modula-2 has a break statement.  If not, I guess ADA should
be considered.

-- 
	Dave Berry. CS postgrad, Univ. of Edinburgh		
					...mcvax!ukc!cstvax!db

In article <4360@ut-sally.UUCP> ark@sally.UUCP (Arthur M. Keller) writes:
>Pascal is a simple yet powerful language.  It has
>most of the features you would want to use when teaching intro CS and
>programming using the Algol-based language paradigm.

I've been convinced by some people around here that imperative languages
don't make the best introductory languages for CS (although obviously they
must be taught eventually).  The reason is that 'declarative' languages
use variables in a way closely to their use in maths and logic.  Hence
students will get used to using them this way, and won't find the first
encroachments of CS theory into their curriculum so strange.

Certainly talking to students around here I get the impression they would
find it easier to learn ML first & then switch to PASCAL, rather than the
other way round as at present.  Our department is considering teaching
Scheme to first-years (if we can get the resources to do it, etc.)
-- 
	Dave Berry. CS postgrad, Univ. of Edinburgh		
					...mcvax!ukc!cstvax!db