Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.1 6/24/83; site umcp-cs.UUCP
Path: utzoo!watmath!clyde!bonnie!akgua!sdcsvax!sdcrdcf!hplabs!hao!seismo!umcp-cs!chris
From: chris@umcp-cs.UUCP (Chris Torek)
Newsgroups: net.college,net.cse
Subject: Re: Should Computer Science be taught at the High School level?
Message-ID: <2092@umcp-cs.UUCP>
Date: Sun, 23-Dec-84 20:10:02 EST
Article-I.D.: umcp-cs.2092
Posted: Sun Dec 23 20:10:02 1984
Date-Received: Thu, 27-Dec-84 02:38:15 EST
References: <241@mss.UUCP> <705@ames.UUCP> <598@utcsrgv.UUCP> <685@clyde.UUCP>
Organization: U of Maryland, Computer Science Dept., College Park, MD
Lines: 91

What with all this ranting and raving about what should and should not
be taught, and how BASIC causes brain-damage, I feel compelled to
relate my own personal life's tale :-).  [This :-) is intended to set
the tone for the rest of this article, except for a serious note at the
very end, if you don't feel like wading through the next N zillion words.]

The first computer program I ever saw was written in a Radio Shack on a
TRS-80 Model I in what was called ``Level I BASIC''.  I promptly fell
in love with computing, and soon (a year or two later) I had scraped up
about $500 and bought my very own computer (with Level II, natch).  So
my first computer language was indeed BASIC.

I set out to learn as much as I could about my new toy.  As it was a
Z80-based machine, my second language (if you can call it that) was
assembly.  I used assembly code anytime something in BASIC wouldn't do
the job, which became annoyingly frequent as I acquired more hardware
and software.  I had bought the Editor/Assembler package; however, this
worked exclusively from tape, and when I got my disk drive running, I
naturally wanted to be able to store my files on disk.  This was the
driving force behind my first ``large scale project'' in BASIC:  to
write an assembler.  I did, and it even worked, at the stupendous rate
of 15 lines per minute---per pass.  (Well, can't have everything.)

Along about this time, I managed to wangle an account on an IBM 370
machine supporting the high school system in the county.  It ran IBM's
VSPC (Virtual Storage Personal Computing) and had two(!) languages
available, namely, BASIC and FORTRAN-IV.  Naturally I had to learn to
program in FORTRAN.  I found it to be a great improvement over BASIC.
Imagine:  local variables!  *Functions*!  Ah, if I had only had such
powerful tools when writing my assembler....  Anyway, FORTRAN was my
third language.

Many were my FORTRAN hacks, not the least of which were a few programs
that read various system tables and could show who was logged on, what
they were doing, and so forth.  The heart of this code was actually
stolen from Montgomery College (MC), a local community college which
rented time on the IBM machine (the 370 was owned by the Mongomery
County Board of Education).  The code depended on various features of
the FORTRAN compiler, and worked by changing an array reference into a
subroutine call, allowing one to run arbitrary 370 machine code.  The
community college also had an assembler (written in FORTRAN), which we
also managed to copy.  So I learned some 370 assembly, and had fun
dumping system tables.  (We---two cohorts and myself---also managed to
frighten the Board of Ed quite a bit by finding various publicly-
readable passwords, and doing some stuff they thought couldn't be
done.  But we didn't destroy anything; all we wanted was enough space
to run the ``PITS'' adventure game... but that's another story
entirely.)

Sometime during (I think) my senior year in high school, in parallel
with the 370 system hacking, I found a new concept in programming:
Structured FORTRAN, or STRUCFOR.  The folks at MC had a preprocessor
that converted WHILE/ENDWHILE, REPEAT/UNTIL, and IF/ENDIF statements
into the equivalent FORTRAN code.  I never did get a copy of theirs,
but wrote my own for my TRS-80 (I had the Microsoft FORTRAN compiler by
then).  This, I think, gave me the idea of designing my own language (a
project I never did complete).  Soon after this, though, one of my
cohorts mentioned above discovered Pascal.  I had thought I was amazed
at FORTRAN, but here in the Jensen & Wirth report was a language
positively miles ahead of even STRUCFOR.

Fortunate or not, I didn't have any chance to actually experiment with
Pascal before I came to the University of Maryland, and when I came
here (fall '81), the K&R C book had just appeared in the bookstores, so
I used C before Pascal.  I know now that, in reality, Pascal has some
serious problems.  (Yes, most implementations have workarounds for most
of the problems.  The problems still exist.)  But it does have that
important concept of structured programming.

[Begin serious conclusion]

In conclusion, I think that having started with BASIC hasn't been a
problem for me at all, because I used it enough that I felt the need
for something more.  Structured programming provided that ``more''.
Anyone who's written a large BASIC program probably wound up doing what
I did:  keeping a (paper) list of the entry points of each subroutine,
along with the variables it used for input and output, and grouping
related code by line number.  Not very clean, but effective.
Structured programming is obviously better, and having used both, I
know which I prefer.  More importantly, I know WHY I prefer it.

I don't think that what I did is for everyone.  Three years of
experience with the wrong approach to programming is not a viable way
to teach a college student that it is indeed the wrong approach.  But
boy, oh boy, it sure is effective!
-- 
(This line accidently left nonblank.)

In-Real-Life: Chris Torek, Univ of MD Comp Sci Dept (301) 454-7690
UUCP:	{seismo,allegra,brl-bmd}!umcp-cs!chris
CSNet:	chris@umcp-cs		ARPA:	chris@maryland