1 Feb
2022
1 Feb
'22
6:19 p.m.
From: Clem Cole
So by the late 70s/early 80s, [except for MIT where
LISP/Scheme reigned]
Not quite. The picture is complicated, because outside the EECS department,
they all did their own thing - e.g. in the mid-70's I took a programming
intro couse in the Civil Engineering department which used Fortran. But in
EECS, in the mid-70's, their intro programming course used assembler
(PDP-11), Algol, and LISP - very roughly, a third of the time in each. Later
on, I think it used CLU (hey, that was MIT-grown :-). I think Scheme was used
later. In both of these cases, I have no idea if it was _only_ CLU/Scheme, or
if they did part of it in other languages.
Noel
1 Feb
1 Feb
6:47 p.m.
New subject: ratfor vibe
On Tue, Feb 1, 2022 at 1:19 PM Noel Chiappa <jnc(a)mercury.lcs.mit.edu> wrote:
Interesting .. I trust you, but I had thought ( famously) you folks had
required a LISP and/or Scheme in the required "intro to computers" course
using the Gerald Sussman and Hal Abelson "Structure of Computer Programs"
[Scheme IIRC] until it was finally replaced a few years ago with a
Python based one [I thought it was tjt that told me that, but I could
easily have been misled/misunderstood].
FWIW: Through the 60s, the early and into the later 70s, CMU used to call
its 15-104 "Intro to Computer Programming" and was based on batch (card)
computing using FTN4, later WATFIV. They used a number of books. The book
I had was from Waterloo and other than being blue and black in color, I
remember little from it - since I already knew how and the TA let me take
'self-taught' by turning in assignments/taking the tests without going to
class. Like Freshman Physics and Calc, all intro science and engineering
majors were required to take it however, since the engineering depts were
sure what you would see when you graduated was FTN based code [which was
probably true for the more pure Science types]. Much later (many years
after I left) the CS Dept finally convinced Mat Sci, Chem E and Mech E to
allow the course to be taught using Pascal. I think they use either Java
or Python now, but I haven't checked.
On the other hand, at UCB the intro course was called CS-40 "Introduction
to Computing" which was required of all Letters and Science Majors. When
I helped to teach it in the early 80s as a grad student, we could only
handle a thousand students and turned away over another thousand [for a
required undergrad course]. We used Clancy and Cooper's "Oh Pascal" as
the text and the UCB pi interpreter on the 11/70s running a flavor of V7 /
2BSD. Before I got there, they must have taught it on the CDC machine
using FTN, but I'm not sure.
From: Clem
Cole
So by the late 70s/early 80s, [except for MIT
where LISP/Scheme
reigned]
Not quite. The picture is complicated, because outside the EECS department,
they all did their own thing -
7:10 p.m.
New subject: ratfor vibe
On Tue, Feb 1, 2022 at 1:49 PM Clem Cole <clemc(a)ccc.com> wrote:
[snip]
FWIW: Through the 60s, the early and into the later 70s, CMU used to call
its 15-104 "Intro to Computer Programming" and was based on batch (card)
computing using FTN4, later WATFIV. They used a number of books. The book
I had was from Waterloo and other than being blue and black in color, I
remember little from it - since I already knew how and the TA let me take
'self-taught' by turning in assignments/taking the tests without going to
class. Like Freshman Physics and Calc, all intro science and engineering
majors were required to take it however, since the engineering depts were
sure what you would see when you graduated was FTN based code [which was
probably true for the more pure Science types]. Much later (many years
after I left) the CS Dept finally convinced Mat Sci, Chem E and Mech E to
allow the course to be taught using Pascal. I think they use either Java
or Python now, but I haven't checked.
There was a bit of a stir about 10 years ago when CMU switched from Java (I
think?) to Python and SML for introductory computer science education. I
remember reading a report at the time, which I _think_ is this:
http://reports-archive.adm.cs.cmu.edu/anon/2010/CMU-CS-10-140.pdf
Though perhaps not, because it _really_ bit into Java and the whole OOP
thing.
Robert Harper had a blog post that I found interesting about exposing
freshmen to functional programming:
https://existentialtype.wordpress.com/2011/03/15/teaching-fp-to-freshmen/
- Dan C.
7:39 p.m.
New subject: ratfor vibe
Dan - thanks.
Clem
On Tue, Feb 1, 2022 at 2:10 PM Dan Cross <crossd(a)gmail.com> wrote:
On Tue, Feb 1, 2022 at 1:49 PM Clem Cole
<clemc(a)ccc.com> wrote:
[snip]
FWIW: Through the 60s, the early and into the later 70s, CMU used to
call its 15-104 "Intro to Computer Programming" and was based on batch
(card) computing using FTN4, later WATFIV. They used a number of books.
The book I had was from Waterloo and other than being blue and black in
color, I remember little from it - since I already knew how and the TA let
me take 'self-taught' by turning in assignments/taking the tests without
going to class. Like Freshman Physics and Calc, all intro science
and engineering majors were required to take it however, since the
engineering depts were sure what you would see when you graduated was FTN
based code [which was probably true for the more pure Science types].
Much later (many years after I left) the CS Dept finally convinced Mat
Sci, Chem E and Mech E to allow the course to be taught using Pascal. I
think they use either Java or Python now, but I haven't checked.
There was a bit of a stir about 10 years ago when CMU switched from Java
(I think?) to Python and SML for introductory computer science education. I
remember reading a report at the time, which I _think_ is this:
http://reports-archive.adm.cs.cmu.edu/anon/2010/CMU-CS-10-140.pdf
Though perhaps not, because it _really_ bit into Java and the whole OOP
thing.
Robert Harper had a blog post that I found interesting about exposing
freshmen to functional programming:
https://existentialtype.wordpress.com/2011/03/15/teaching-fp-to-freshmen/
- Dan C.
9:21 p.m.
New subject: ratfor vibe
On Tue, Feb 1, 2022 at 2:40 PM Clem Cole <clemc(a)ccc.com> wrote:
Dan - thanks.
Sure thing.
By the way: the thing I was thinking about earlier that was so biting
towards OOP was an earlier version of Harper's post, in which he writes,
"Object-oriented programming is eliminated entirely from the introductory
curriculum, because it is both anti-modular and anti-parallel by its very
nature, and hence unsuitable for a modern CS curriculum."
https://web.archive.org/web/20110321004746/https://existentialtype.wordpres…
(How's _that_ for an academic glove-slap?)
It would appear that language was softened to read "unsuitable for our
purposes" sometime in 2013, and then that rather inflammatory clause was
removed entirely by early March, 2015. I had read the original and felt
some schadenfreude.
- Dan C.
On Tue, Feb 1, 2022 at 2:10 PM Dan Cross <crossd(a)gmail.com> wrote:
> On Tue, Feb 1, 2022 at 1:49 PM Clem Cole <clemc(a)ccc.com> wrote:
>
>> [snip]
>> FWIW: Through the 60s, the early and into the later 70s, CMU used to
>> call its 15-104 "Intro to Computer Programming" and was based on batch
>> (card) computing using FTN4, later WATFIV. They used a number of books.
>> The book I had was from Waterloo and other than being blue and black in
>> color, I remember little from it - since I already knew how and the TA let
>> me take 'self-taught' by turning in assignments/taking the tests
without
>> going to class. Like Freshman Physics and Calc, all intro science
>> and engineering majors were required to take it however, since the
>> engineering depts were sure what you would see when you graduated was FTN
>> based code [which was probably true for the more pure Science types].
>> Much later (many years after I left) the CS Dept finally convinced Mat
>> Sci, Chem E and Mech E to allow the course to be taught using Pascal. I
>> think they use either Java or Python now, but I haven't checked.
>>
>
> There was a bit of a stir about 10 years ago when CMU switched from Java
> (I think?) to Python and SML for introductory computer science education. I
> remember reading a report at the time, which I _think_ is this:
> http://reports-archive.adm.cs.cmu.edu/anon/2010/CMU-CS-10-140.pdf
>
> Though perhaps not, because it _really_ bit into Java and the whole OOP
> thing.
>
> Robert Harper had a blog post that I found interesting about exposing
> freshmen to functional programming:
> https://existentialtype.wordpress.com/2011/03/15/teaching-fp-to-freshmen/
>
> - Dan C.
>
>
9:33 p.m.
New subject: ratfor vibe
On Tue, Feb 1, 2022 at 4:22 PM Dan Cross <crossd(a)gmail.com> wrote:
On Tue, Feb 1, 2022 at 2:40 PM Clem Cole
<clemc(a)ccc.com> wrote:
Amen...
My disagreement with them using scripting (python) as step one is the lack
of teaching data typing early AND python's silly use space/tabs to set up
structure instead of real {} or B/E blocks. Automatic data conversion has
never been a good idea in my experience because like many things that
happen magically, it almost never works as I expect.
Funny we were discussing the roff family and that is why I like it over
things like Word -- way too much hidden behind the screen for my taste.
I'm a make it explicit kinda guy I guess. I hate surprises ...
Also, it remains to be seen if teaching FP early helps - which they are
clearly making play. Who am I to say, as one of the earliest languages I
learned APL, so FP thinking was drilled into me in my youth.
Clem
Dan - thanks.
Sure thing.
By the way: the thing I was thinking about earlier that was so biting
towards OOP was an earlier version of Harper's post, in which he writes,
"Object-oriented programming is eliminated entirely from the introductory
curriculum, because it is both anti-modular and anti-parallel by its very
nature, and hence unsuitable for a modern CS curriculum."
https://web.archive.org/web/20110321004746/https://existentialtype.wordpres…
(How's _that_ for an academic glove-slap?)
11:12 p.m.
New subject: ratfor vibe
On Tue, Feb 1, 2022 at 4:33 PM Clem Cole <clemc(a)ccc.com> wrote:
My disagreement with them using scripting (python) as
step one is the lack
of teaching data typing early
Teaching types is very important. But Python is strongly typed: a string
is not a number is not a hashtable. When it's important for performance
reasons or consistency across a large codebase, you can add static type
information to your Python code without overloading n00b brains with
mandatory type annotations.
AND python's silly use space/tabs to set up structure instead of real {}
or B/E blocks.
Nobody would accept code that was incorrectly indented (although some
languages have more than one indentation convention, like C) in an
assignment or pull request. And when looking at correct or mostly correct
code, we look at the indentation structure, not the braces. That being so,
having both braces and indentation is fundamentally a DRY violation.
Automatic data conversion has never been a good idea in my experience
because like many things that happen magically, it
almost never works as
I expect.
I think it was a customer revolt that persuaded IBM to add "mixed-mode"
expressions like "A + I" to Fortran IV; they had been disallowed in Fortran
II. I haven't heard anyone saying we ought to revert that change.
7:39 p.m.
New subject: ratfor vibe
Interesting .. I trust you, but I had thought (
famously) you folks had
required a LISP and/or Scheme in the required "intro to computers" course
using the Gerald Sussman and Hal Abelson "Structure of Computer
Programs" [Scheme IIRC] until it was finally replaced a few years ago
with a Python based one [I thought it was tjt that told me that, but I
could easily have been misled/misunderstood].
I think that wasn't until 1981. I took 6.912, which was an experimental
pre-cursor to the SICP class as a sophomore. We did LISP programming on
Multics. I might have the years off by one -- it was when "Fear of Music"
came out. :) The mainstream intro classes used Algol on a PDP-11 I think?
To emphasize Noel's point about the distributed nature, the intro to
programming class in the MechE department, 2.10, was Fortran first on punch
cards and then interactive when they got a big-ass DEC 20 running Digital
software. Amusingly MIT AI got one shortly after, and there was some
controversy about leaving TOPS-20 or converting it to ITS; ITS lost.
10:30 p.m.
New subject: ratfor vibe
With regard to programming languages at UCB in 1980 ...
I'd done something of a survey of colleges, and in my mind at the time, there were
two approaches to a CS degree: mostly or entirely theoretical (those CS departments that
had grown out of Mathematics tended to have this focus), or more practical
tools/techniques/operational theory (those CS departments that had grown out of
Engineering tended to be this way). UCB was definitely the latter, and that's what I
wanted.
I got to UCB in fall 1980, admitted to the College of Letters & Science. At the time,
there were two ways to get intro to programming:
CS1 - FORTRAN IV, taught on the CDC 6400 running CalidoSCOPE in batch mode with real punch
cards, punched up on IBM 029 keypunch machines.
CS3 - Pascal, as Clem described.
CS1 was for engineers & scientists, CS3 for students who wanted to get into the CS
degree program in L&S. You could take CS1 in lieu of CS3, but that was frowned upon.
Two paths to a computer science degree: A.B. CS from L&S, or B.S. EECS from the
College of Engineering (which you had to be explicitly admitted to before you got there).
There was a basic difference in emphasis between L&S and Engineering for CS: L&S
was "software with a smattering of hardware" (cf. CS-150, CS-152), and
Engineering's EECS (B.S.) degree was the inverse: "hardware with a smattering of
software."
L&S was the largest "college" at UCB: everyone got into that one
"undeclared", and for your freshman & sophmore years, you studied to
accumulate course credits towards declaring a major once you had "sophmore
standing" (however, if you were prudent, you accumulated credits towards a
"backup" major if the undergraduate degree program you wanted
wouldn't/couldn't let you in). If you couldn't declare major at sophmore
standing, you were bounced out of the university. Some of this setup was hangover from
anti-student radical policies from the 1960s: prevent "students" from hanging
around the university forever (and fomenting).
The "weeder" course for L&S CS was CS40: more Pascal than you'd ever
want to code in a lifetime. L&S CS needed that filter: just before I got there,
they'd let anyone into the program, but in 1980 or 1981, they limited the class size
to 200 undergrads because there was too much demand from students for that degree program
for the department to handle - didn't make the cut? I hope you have a backup major
...
They didn't formally teach C to undergrads until "upper division" (declared
major in CS, junior or senior standing), and IIRC, there wasn't a formal course in it
- you were expected to pick it up as part of the upper division course in operating
systems. After all, you already know Pascal and Assembly, right?
Of course, once you had an account on one of the PDP-11/70s running Unix, C and shell
programming was entirely available to you, so I went for what amounted to self-directed
learning (reading manuals & books) as fast as I could.
Erik
2 Feb
2 Feb
12:54 a.m.
New subject: ratfor vibe
Erik E. Fair says:
With regard to programming languages at UCB in 1980
...
I'd done something of a survey of colleges, and in my mind at the
time, there were two approaches to a CS degree: mostly or entirely
theoretical (those CS departments that had grown out of Mathematics
tended to have this focus), or more practical
tools/techniques/operational theory (those CS departments that had
grown out of Engineering tended to be this way).
Quoting my 2019 message to the cctech mailing list:
----
Adam Thornton <athornton(a)gmail.com> says:
The genealogy of Computer Science departments (and
their curricula)
(at least in the US) is also weird and historically-contingent.
Basically it seems to have been a tossup at any given school whether
it came out of the Electr[ical|onic] Engineering department, in
which case it was memories and logic gates and a bottom-up,
hardware-focused curriculum, or out of the Mathematics department,
in which case it was algorithms and complexity analysis and a
software-focused curriculum.
Yes, I've noticed the same thing. Example: Harvard's CS department is
originally from the math side, while MIT's is from EE (thus today's
EECS).
Berkeley = EE
Brown = Math
BYU = Math
Caltech = EE
Columbia = EE
Cornell = Operations research, math
Dartmouth = Math
Illinois = Math
NYU = Both (because Polytechnic developed its own CS program long
before NYU acquired it to regain an engineering school)
Penn = EE
UCLA = OR (probably because of the RAND heritage)
Caltech until very recently did not formally offer CS degrees;
students received degrees in Engineering and Applied Science, with a
focus on CS (or aeronautics, or civil, or ME).
Illinois is an example of a track we might call "other" or even
"defense". With government funding the university built its own
computers (including ILLIAC and PLATO), and the group that did so
became the CS department, but the undergraduate CS program began
within the math department. Harvard's and Penn's programs might also
qualify.
Undergraduate CS degrees are BA (Example: Harvard), BS (Example:
Penn), or both (Example: Columbia). At Penn one must be an engineering
student to major in CS. At Columbia one can major in CS in either the
liberal arts or engineering schools, but with different
curriculums. At Yale there is one undergraduate school, within which
one can receive a BA or BS in CS, with different curriculums. Cornell,
Northwestern, and Berkeley offer CS in their separate liberal arts and
engineering schools; undergraduates receive BA or BS degrees with
identical CS curriculums, with only other requirements differing.
I've read that medical schools are good at teaching either
pharmacology (drugs), or pathology (diseases); perhaps this is also
because of the expertise/specialty of their early faculty members.
----
Two paths to a computer science degree: A.B. CS from
L&S, or
B.S. EECS from the College of Engineering (which you had to be
explicitly admitted to before you got there).
Still true today. As I mention above, Berkeley's CS curriculum is identical
regardless of the degree (or was the last time I checked), something not always true at
other universities that offer multiple CS undergraduate degree options.
--
geo:37.783333,-122.416667
1 Feb
1 Feb
9:50 p.m.
New subject: ratfor vibe
On Feb 1, 2022, at 1:19 PM, Noel Chiappa
<jnc(a)mercury.lcs.mit.edu> wrote:
I took 6.001 (with Scheme) in the spring of 1983, which was using a course
handout version of what became Structure and Interpretation of Computer
Programs by Sussman and Abelson. My impression was that it had been
around for a year before that, but not much more, and it was part of
revamping the EECS core curriculum at the time.
In at least the early 80s, CLU was used in 6.170, Software Engineering
Laboratory, in which a big project was writing a compiler.
And Fortran was still being taught for the other engineering departments.
In 1982(ish), those departments had the Joint Computing Facility for a lot
of their computing, of which the star then was a new VAX 11/782.
- Win
From: Clem Cole
So by the late 70s/early 80s, [except for MIT
where LISP/Scheme reigned]
Not quite. The picture is complicated, because outside the EECS department,
they all did their own thing - e.g. in the mid-70's I took a programming
intro couse in the Civil Engineering department which used Fortran. But in
EECS, in the mid-70's, their intro programming course used assembler
(PDP-11), Algol, and LISP - very roughly, a third of the time in each. Later
on, I think it used CLU (hey, that was MIT-grown :-). I think Scheme was used
later. In both of these cases, I have no idea if it was _only_ CLU/Scheme, or
if they did part of it in other languages.
823
days inactive
824
days old
10 comments
8 participants
participants (8)
-
Clem Cole -
Dan Cross -
Erik E. Fair -
jnc＠mercury.lcs.mit.edu -
John Cowan -
Richard Salz -
Win Treese -
Yeechang Lee