hgoldber@polyob.UUCP (A1 harry goldberg ) (02/17/86)
*** 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
jbs@mit-eddie.UUCP (Jeff Siegal) (02/21/86)
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
jxs7451@ritcv.UUCP (02/21/86)
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
crocker@ihwpt.UUCP (ron crocker) (02/21/86)
> *** 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.
manis@ubc-cs.UUCP (Vince Manis) (02/21/86)
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.mark@nyit.UUCP (Mark Smith) (02/22/86)
> 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
deb@gt-cmmsr.UUCP (Deborah Jackson) (02/22/86)
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 ^^^^^
bzs@bu-cs.UUCP (Barry Shein) (02/23/86)
>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 Obviously you were expecting this...This has been done, I believe Eliot Organick wrote a big CS textbook that was intended to be an intro course book and was used at University of Utah. According to a friend of mine who went there (quite a while ago! 10+ yrs) that is exactly what the course was, topics were taught in the language thought appropriate (I believe among the languages were fortran, basic, snobol and lisp.) I agree, an intro course should be a survey course. It should be shallow and a good intro into 'the great ideas' of the field just like any intro course in the sciences (bio, phys, chem etc). Some programming should be taught as in any good intro lab course (laboratory practices and methods, remember intro chem, bio...) I have always thought it unfortunate that the emphasis here has been (in the past anyhow, haven't kept up with the intro courses lately) Programming in Pascal 101 rather than Computer Science 101 (also known as "Shuffle the semi-colons till it stops complaining 101".) 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 there are lots of big systems written in C, can't barely say the same for Pascal, there's a reason for that, like strong typing for weak minds philosophy.) I would go for LISP because it's easy to get into, a reasonable interpreter works well with an editor, debugger and tracer. More of a lab environment, less of a core-dump environment, there's plenty of time for that later (tho on UNIX/4.2 dbx makes all this a bit better.) Lisp dialects could be considered tho not sure why exactly except that Sussman et al's book using Scheme has great potential to base a course on, and a good text is a great place to start designing a course. If only they would listen...oh well, I teach the C and UNIX/sys courses. -Barry Shein, Boston University
ark@ut-sally.UUCP (Arthur M. Keller) (02/23/86)
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!arkbzs@bu-cs.UUCP (02/24/86)
From: manis@ubc-cs.UUCP (Vince Manis) >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. This is the attitude I object to that leaves us nowhere in Computer Science Education. I believe one has to abandon the job training mentality and just teach their subject on the sole assumption that everyone in the room is there to build a foundation for computer science. If that necessitates opening a different course for 'programming', so be it. It has been an unfortunate fallacy that has been pushed on Computer Science Departments that one can simultaneously teach an introductory CS course and a terminal, one-shot programming course and do both well. The result, as can be predicted, is to end up with a bunch of bored to death non-CS people and a bunch of CS students who end up believing that CS is a process of getting the syntax errors out (shuffling the semi-colons as I like to call it.) I am sympathetic, here at BU there is constant discussion between CS and Engineering (the former is in the College of Liberal Arts, the latter is a school unto itself) as to whether or not the intro CS courses' curriculum is properly fulfilling general engineering requirements. Needless to say it causes strange things to happen in the curriculum for CS and, I believe, ultimate dissatisfaction for both parties. It is my firm belief that: a) College is not job-training in such a direct manner as emphasizing programming right from the start implies. b) Computer Science is not programming, nor is it not not programming (double negative intentional.) Programming is simply a critical lab skill that may take more than one intro course to develop properly and should be nurtured within the context of the big picture, not as an end unto itself. My opinions, I believe, make more sense when compared to other sciences. One does not teach an intro course in glassware and centrifuging in a chemistry department nor expect people after a year of intro chem to be able to get a job at General Foods or the Public Health service doing product testing. Intro physics is not confused with engineering, intro Math with accounting or actuarial skills. As absurd as these comparisons appear I am certain that these same attitudes are held in regards to computer science, that we teach programming because it is a fast road to a good job. Unfortunately that is not true, even if a year of programming were emphasized I believe a rational survey of the jobs it opens up would reveal that although the starting salaries and job openings may seem high, the advancement etc is comparable with that of many white collar jobs which do not require any specific college skills, unless the individual is unusually talented in which case all bets are off in either case. A $25K job to start may seem like heaven to a new graduate, but at 30 years old and having moved all the way to $35K they will start to realize that the success was short-lived and illusory, that they should have nurtured something in college beyond such a specific talent as programming (again, I am talking averages here which is much more likely to be a Cobol programmer in a big IBM shop than a Steve Wozniak or Bill Joy that every kid who learns a little programming thinks is their fate, it just aint so, and without a broad education in the issues it is much harder to advance.) -Barry Shein, Boston University
brad@looking.UUCP (Brad Templeton) (02/24/86)
I hate Pascal as much as anybody who's had to implement one, but I will second it as the choice for an introductory course. Your audience in an introductory course is quite broad. Some are going on to further education in CS. Others want something they can use. If you give them fortran or cobol, you won't give much in the way of CS concepts to those going on. If you give them something unusual like lisp, they will have trouble using their lisp skills in the real world. You need something that's widely accepted, fairly standardized (at some level) and that contains the basic concepts you want to deal with in a complete degree program. This leaves you with C and Pascal. Pascal was designed for teaching, and much of what is wrong with it is that people have forgotten this. (Although I will never forgive writeln myself) If you put Pascal in a nice interactive environment (like mine; plug, plug, plug) this is your only choice. This is not a statement to be proud of, necessarily. Nonetheless, what is being used in the real world does control what can be taught to some exent. -- Brad Templeton, Looking Glass Software Ltd. - Waterloo, Ontario 519/884-7473
schuh@geowhiz.UUCP (David Schuh) (02/24/86)
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.
lear@topaz.RUTGERS.EDU (eliot lear) (02/24/86)
Barry Shein @ Boston University writes: > I agree, an intro course should be a survey course. It should be shallow > and a good intro into 'the great ideas' of the field just like any intro > course in the sciences (bio, phys, chem etc). Some programming should be > taught as in any good intro lab course (laboratory practices and methods, > remember intro chem, bio...) At Rutgers, our intro class IS an Introduction to Computer Science. We do some minor programming in PASCAL but the emphasis is not placed on programming at all. If your intro course is a survey course for languages, you waste too much time teaching the languages instead of giving the students a good taste of Computer Science. In fact, since I've been at Rutgers, the intro course has always used a computer with software that would make it easiest to program in. For example, when I got here the course was on Teraks using the Cornell PL/CS Synthesizer, which uses templates. In 1984, the CS111 and CS112 moved to Mac Pascal. The idea was that the student should NOT play 'Shuffle the semi-colon' yet get the strong type checking needed for beginning programmers. > 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..... > ..... I would go for LISP because it's easy to get into, a reasonable > interpreter works well with an editor, debugger and tracer. The problem I have with LISP is that it involves recursion, a subject that most of the people here were not very comfortable with until after their intro course. C, however, would not be a bad idea - especially if you do not want to waste time in the future explaining the quirks of that language. It is a lower level language in many ways but it still supports the higher level operations. However, you lose with weak type checking. > I have decided to step into the fray here. ARK @ SALLY.UTEXAS.EDU adds: > (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 glad you did. This is exactly my point. At Rutgers we have two survey courses involving languages - one for non-majors that teaches BASIC, a text formatter, and a spread sheet; and the other is a 300 level course that discusses in depth the structure/uses/limitations of various languages. The idea behind the first is to give the person who doesn't use a computer a chance to discover its usefulness. The reason the second course is 300 level is that by this point, the student is expected to be able to grasp languages faster. In the past, this course has covered SNOBOL, LISP, SETL, and PROLOG in depth while glancing over other languages. My point is that the introductory course should NOT be a language survey course and it should use a language that has a strong enough back- bone that it will catch silly mistakes and leave student to worry about the logical errors. Later on (s)he can pick up as many languages as (s)he wants. That knocks C out of the water and since I don't consider recursion an introductory idea, that knocks out lisp too. As far as assembly language is concerned, I have a feeling I would have become a better programmer if I got an intense shot of assembly first but I doubt I would have gotten an introduction to the analysis of algorythms in the process. Also, one of the most important topics in our intro classes is that of data structures. eliot lear [lear@topaz.rutgers.edu] [{allegra,seismo}!topaz!lear]
laura@hoptoad.uucp (Laura Creighton) (02/26/86)
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
robt@molihp.UUCP (Robert L Thurlow) (02/26/86)
[] In article <497@looking.UUCP> brad@looking.UUCP (Brad Templeton) writes: >I hate Pascal as much as anybody who's had to implement one, but I will >second it as the choice for an introductory course. > I also cast my vote for Pascal, but think that more exposure is to other languages is necessary, especially to an assembly language. I learned Algol-W and FORTRAN first and got an idea about algorithms, and then engineering gave a feel for limited resources with assembly language on an 8080 (gack, barf, even worse than an 8088! :-) with almost no memory. Then I got into Pascal, 'C' and the other things, and I found I had a lot more respect and understanding for the machine and the problems you can get into. What highlighted this was the System/370 assembler they throw in at the end of the second-year computer science courses at UBC; a large portion of the class were fighting just to get the concepts of memory and registers straight while the engineers were basking in the luxury of the architecture compared to the 8080. (Hey, Al, this thing does floating point math! All by itself! :-) Most of the class was fuzzy about looking around for the resources you have and using them properly, anf this was only due to lack of exposure to what is REALLY going on under there. If your teaching Pascal can spit out assembly code, perhaps showing the students what it looks like would help. # UUCP : ...!ubc_vision!molihp!robt Robert Thurlow # <DISCLAIMER : my thoughts are my own, and are void where prohibited by law.> # "There was something fishy aboout the butler. I think he was a Pisces, # # probably working for scale." - Nick Danger #
bert@ucla-cs.UUCP (02/27/86)
> > 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..
ark@ut-sally.UUCP (Arthur M. Keller) (02/27/86)
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
jimb@tekcbi.UUCP (Jim Boland) (02/27/86)
In article <497@looking.UUCP>, brad@looking.UUCP (Brad Templeton) writes: > I hate Pascal as much as anybody who's had to implement one, but I will > second it as the choice for an introductory course. > > > Pascal was designed for teaching, and > much of what is wrong with it is that people have forgotten this. > (Although I will never forgive writeln myself) >From: latham@bsdpkh.UUCP (Ken Latham) >Ah yes.... PASCAL.... >Why PASCAL ....? > I think this is the real point ... The compiler has to be > so strict as to not let the student get too inventive ... > like C ... The objective is to learn Algoritmic Representation > not the language. > Even though the language keeps a tight reigh it also has a > sufficient array of types ( structures, pointers, sets, etc.) > and an expressive enough syntax and semantics to do just about > anything. > There I admit I am a C programmer (and Computer Scientist) > that actually LIKES PASCAL!!! I have had to learn and use various languages while in school (BASIC, FORTRAN) and later on jobs. I hve programmed in Basic, Basic+, Pascal, and C. Each language has it's good points and bad points. Each has merits. Basic is quite easy to learn and do things. However, I sure don't like to look at code I didn't write or haven't seen for a year and try to figure out what the heck is going on. With all the line numbers and goto's and gosub's, one can get lost real fast. Then along came Pascal. I sure didn't like it at first. However, after using it for a while, I started to see real merits in it, particularly in reviewing code at a later date or trying to see what someone else had done. I have no real problems with that. Then along came C. I like the way some things are done and I like what I can do with it. Yes, I currently am a C programmer, also. However, I must say that if I had my choices, I believe I would lean more towards Pascal. But then, I have been programming Pascal since 1975. If I had been programming C since then, and started Pascal recently, I would probably prefer C. Sorry, It doesn't work the same for Basic. I started that around 1970. And nope, I would never prefer it over C or Pascal. (Except for a few applications) If you are just passing through a course, will only program for 3 months and never do it again, Basic is probably sufficient.
kay@warwick.UUCP (Kay Dekker) (02/28/86)
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
sean@ukma.UUCP (Sean Casey) (02/28/86)
*** The following comments are my OPINION, I am allowed it...anyone ***
*** who would disagree with this please route all @#$%^&* to /dev/null. ***
Pascal as an introductory language? Yes, good choice.
What I hate to see is when BASIC is used as a first language. One learns
to use gotos and all the other slimy things that BASIC forces you to
use and then has to unlearn them to use languages like Pascal or C effect-
ively. Why bother to use BASIC in the first place? I remember my first
CS class, taught with BASIC...learned to use gotos and all those neat
little things. Then came the second class, taught with Pascal. At first
I was befuddled. "Variable types? There are more than two?" "Procedures?"
"Parameters?" It took me longer to unlearn BASIC than it did to learn Pascal.
Once I learned to use all that Pascal had to offer, I honestly thought that
my first semester had been wasted.
Many will argue for using C as a first language...it would be a good choice
too, but it may be a little cryptic for a BEGINNING student. Pascal uses
more english-like syntax than does C. Pascal has much more rigid type
checking than does C. Pascal's pointers might not be as powerful as C's,
but they are easier to learn. Besides, all the things that one might
learn using Pascal can be easily used in C. C offers even more for the
advanced student to take advantage of, but maybe too much for a novice.
There are cons for Pascal too. String handling isn't great (in most
dialects), declarations may be too lengthy for some...there are probably
more that I am unaware of, due to the fact that I don't have the experience
with other languages that I do with Pascal. All-in-all though
I think Pascal would make the better choice...CERTAINLY better than
BASIC, and only better than C in that it might be a little easier to learn,
but not better on a whole.
Keith Hatfull
(mailing from Sean's account)
--
-------------------------------------------------------------------------------
Sean Casey UUCP: sean@ukma.uucp CSNET: sean@uky.csnet
University of Kentucky ARPA: ukma!sean@anl-mcs.arpa
Lexington, Kentucky BITNET: sean@ukma.bitnet
"Who's `we', sucker?"ark@ut-sally.UUCP (Arthur M. Keller) (03/01/86)
In article <528@tekcbi.UUCP> jimb@tekcbi.UUCP (Jim Boland) writes: >If you are just passing through a course, will only program for 3 months and >never do it again, Basic is probably sufficient. I suppose that if you are just passing through foreign language literature course, will only read foreign literature for 3 months and never do it again, foreign language newspapers are probably sufficient. I don't buy that. If you are taking a 3 month course and will never directly apply the knowledge, then learning concepts is probably the most important because you will forget the details. It is easier to learn the concepts of programming (the basis for learning Computer Science, but not *all* of CS) using Pascal as many are simply not expressible in Basic. (Don't bug me about Turing equivalence, and I won't ask you to write a universal Turing machine in Basic.) On the other hand, if you are teaching a "computer literacy" course, that is, a primarily non-programming course, it may be worthwhile to use Basic because the start up costs are low, programming is a minor part of the course, and you are not attempting to teach programming concepts but rather have the students write a few trivial programs. Pascal is also a problem for students who have not yet mastered high school algebra and who may be able to manage some simple Basic programs. Probably better to teach them Logo or Karel the Robot. Arthur -- ------------------------------------------------------------------------------ Arpanet: ARK@SALLY.UTEXAS.EDU UUCP: {gatech,harvard,ihnp4,pyramid,seismo}!ut-sally!ark
gast@ucla-cs.UUCP (03/03/86)
>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.
ark@ut-sally.UUCP (Arthur M. Keller) (03/04/86)
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