I know it’s off-topic, but this guy is awesome, and this news is
terrible.
Pray for him, send him good vibes, whatever your belief system
accomodates. A great innovator, we want him to pull through.
---------- Forwarded message ----------
From Andy Carvin:
Hi everyone,
I’ve just received the terrible news that education
technology pioneer Seymour Papert has been gravely
injured in an accident in Hanoi. He was attending a
conference there and was hit by a motorbike,
sustaining significant head trauma.
Seymour is one of the developers of constructionist
learning theory. He helped found MIT’s artificial
intelligence lab, developed the LOGO programming
language and inspired both the Maine laptop initiative
and the $100 laptop.
Hopefully he will pull through, but he will need all
the thoughts and prayers we can muster.
It wasn’t for lack of trying that it didn’t, actually. The original
“target market” for Logo was elementary school children, and the target
market for BASIC was undergraduates. It simply takes longer for an
elementary school child to become a decision maker than it does for an
undergraduate.
It wasn’t for lack of trying that it didn’t, actually. The original
“target market” for Logo was elementary school children, and the
target market for BASIC was undergraduates. It simply takes longer for
an elementary school child to become a decision maker than it does for
an undergraduate.
Along those lines, what do they teach undergraduates today? Mostly
Scheme and Java, I think.
Progression in the department I used to work in:
VisualBasic (101) -> C (102) -> Java (optional course) (103) -> C++
(121 and 221) -> Graduate.
Other courses were things like circuits and logic, operating systems,
compiler design, and so on. No Scheme, LISP, Ruby, or other solid
functional and/or dynamic languages.
It was a great engineering school, but had a really weak CS program…
On 2006-12-08 11:55:02 -0500, “M. Edward (Ed) Borasky” [email protected] said:
Along those lines, what do they teach undergraduates today? Mostly
Scheme and Java, I think.
Primarily Java and C++. I think Scheme is a quirk of some of the
tougher schools.
At my school - the University of Kentucky - C++ is taught from the
beginning and used in almost every undergraduate programming course
thereafter, with the occasional domain-specific exception. I think this
is a mistake, but nobody asked me.
Along those lines, what do they teach undergraduates today? Mostly
Scheme and Java, I think.
C in the freshman year. If I hadn’t had some PHP and Pascal before (i.e.
hadn’t mostly known the syntax and how to wrestle pointers), I’d prolly
have ran away screaming and was well on my way into middle management by
now.
It was a bad choice for a freshman language, with badly led courses -
the instructor was hopping rather erratically between stressing how the
point is to be able to develop the algorithms (which is a problem class
I don’t like solving as opposed to design and data modelling), and on
the other hand abusing pointer arithmethics with reckless abandon in
example code. Oh, and fighting with me over C syntax until I started
bringing my copy of K&R - which I had by then memorised - to class.
(Humiliating college instructors is so rewarding in a very wrong way.)
After that an optional Java course, and then the classes shifted into
hardware more, when I only had classmates to troll with Ruby.
The software specialisation had the usual Logical and Functional
Programming, led mostly in a homebrewn Lisp 1.5, which -coincidentally-
a high-up professor had written a textbook on fifteen years or so ago.
(Huh? What is this “move on” you speak of?). I find it highly amusing I
can work out Prolog homework for people taking that introductory course
worldwide despite never having passed it. (In horribly procedural
Prolog, but hey.)
Scheme I didn’t see any at all. If the Scheme courses are all similar in
structure to the SICP I know from the lecture videos, it seems more like
a course to teach how programs / programming languages work, than how to
program. Then again, it’s hard to say where one ends and the other
begins. (And I suspect they actually overlap or one is a subset of the
other ;P)
I only took one programming class in my life. I was 11. It was BASIC
on a TRS-80.
So, take it with a grain of salt, but I think programming classes
should start with something easy to read (like Ruby) and progress to
more complicated stuff like Java or C or whatever after students are
used to the basic task of programming. I mean it’s a way of thinking,
you start music students on recorders and xylophones. Ruby is of
course powerful but it’s still great for beginners because you want
beginners on something readable. I did some tutoring for a local
college, their CS students couldn’t handle System.out.println() yet
and they were asking me things like “what the hell is variable
type-casting?” That’s like teaching complex numbers before you teach
addition. Introductory courses shouldn’t be weighed down with arcane
complexities.
The other thing is, I had an interview once with this startup. They
had a really young guy as their main tech guy. Fresh out of school, no
work experience. Very smart guy, but I don’t think he had ever read
“Design Patterns” or “Refactoring”, and he wanted to know how I would
implement a tree sort.
I definitely think CS courses should be teaching Fowler before Knuth.
The number of times you’ll need to make good OOP design decisions is
probably going to many, many more than the number of times you’ll need
to cook up an efficient low-level tree-sort implementation. It almost
seems like, being self-taught, I might be better off.
True. I recall moving the turtle back in the day. That must have been
7th grade or so.
Hrm, early high school for me, which wasn’t THAT long ago (although I
was exposed to Speccy logo when I was about seven). It Still Lives On.
(Probably owed to a rather popular nationalised port the local
university made. Which seems to have become Imagine Logo nowadays. With
a web browser plugin. Oh dear ;P)
Followed by a Pascal course I couldn’t attend half of the lessons, the
teacher half of the others, making it a spectacular flop. And then a PHP
one, which made me responsible for horrors unseen And then a notably
more successful Pascal one, with a rather gruesome
lots-of-procedures-and-global-variables style. (But still probably more
readable than that of the rest of the class, which involved doing
everything inline.)
Along those lines, what do they teach undergraduates today? Mostly
Scheme and Java, I think.
At age 8, I started with BASIC (gwbasic, qbasic, etc.). I’m not sure who
recommended that language – it might’ve been an undergrad that my mom
hired to “tutor” me. At around 4th grade, I got private teaching from a
high school CS teacher, in Pascal (and a brief stint in Karel). 7th &
8th I took C/C++ in a high school CS course, an AP CS course, and a
community college course. In 12th grade, some teachers tried to get us
hooked on CLisp and Python, but it didn’t stick.
In college, we programmed in C++, with the exception of a Compilers
and Languages course, which had us writing parsers & interpreters in
OCaml (though, granted, with little O), with a little stint in Prolog,
just to show us what else is out there.
Finally, nowadays, I’m told that my alma mater is teaching in Java.
(Boo.) I imagine the same exception applies for the Compilers, course,
though.
And my opinion, FWIW: A combination of a language that maps closely to
how we think (say, Ruby), with a language that maps closely to how the
computer thinks (say, C, or even some assembly language).
Devin
PS–I saw LOGO, briefly, in some computer camp. Stayed away from it.
college, their CS students couldn’t handle System.out.println() yet
and they were asking me things like “what the hell is variable
type-casting?” That’s like teaching complex numbers before you teach
addition. Introductory courses shouldn’t be weighed down with arcane
complexities.
I guess any language that allows one to learn by typing stuff and
getting responses is suitable for beginners. So rather than “Ruby” I
would in fact say “irb”, any Lisp or Scheme with a REPL, Forth, APL, the
original BASIC, etc. Of course, if the goal is object-oriented
beginners, irb is clearly the winner.
to cook up an efficient low-level tree-sort implementation. It almost
seems like, being self-taught, I might be better off.
I guess I would counter that a CS course should teach the science of
computing. That includes data structures, recursive function theory,
automata theory, queuing theory, the Pi-calculus, etc. Now as a working
software engineer, I don’t use a heck of a lot of that, but my degrees
are in applied math and not CS. And a software engineering degree should
teach the stuff you’re talking about – OOP, design patterns, Fowler,
etc. And I think they do. We have a Masters’ program in Software
Engineering here at Portland State that does exactly that, plus process
and management.
have ran away screaming and was well on my way into middle management by
PS–I saw LOGO, briefly, in some computer camp. Stayed away from it.
i don’t know how many people realize that logo is in essence lisp.
t.
Logo has Lisp-like semantics at its core, but it is certainly not “in
essence Lisp”, any more than BASIC is “in essence FORTRAN” or C is “in
essence Algol”.
I definitely think CS courses should be teaching Fowler before Knuth.
The number of times you’ll need to make good OOP design decisions is
probably going to many, many more than the number of times you’ll need
to cook up an efficient low-level tree-sort implementation. It almost
seems like, being self-taught, I might be better off.
I guess I would counter that a CS course should teach the science of
computing. That includes data structures, recursive function theory,
automata theory, queuing theory, the Pi-calculus, etc. Now as a working
software engineer, I don’t use a heck of a lot of that, but my degrees
are in applied math and not CS. And a software engineering degree should
teach the stuff you’re talking about – OOP, design patterns, Fowler,
etc. And I think they do. We have a Masters’ program in Software
Engineering here at Portland State that does exactly that, plus process
and management.
Actually I think that makes perfect sense; the problem is Computer
Science is a catchall term and it’s generally taken to mean “I can
take any programming task you throw at me,” whereas to interpret the
degree literally, all of that stuff you mention would be very
appropriate, but in general the term isn’t usually taken literally.
Ideally, with your definition, CS courses would also include some
basic electrical engineering stuff and the science behind that. But
that would only make sense if people started using the CS literally,
and that would probably only happen if people stopped using CS as a
catchall for “competence in programming” and that will only happen
if a new catchall is devised.
My point is just that if your goal is to set up a basic curriculum at
the end of which a competent programmer emerges, fundamental
algorithms certainly belong in there somewhere, but Fowler et al are
probably a bit more essential.
Actually I think that makes perfect sense; the problem is Computer
Science is a catchall term and it’s generally taken to mean “I can
take any programming task you throw at me,” whereas to interpret the
degree literally, all of that stuff you mention would be very
appropriate, but in general the term isn’t usually taken literally.
In a major university, I think you would find that most Computer
Scientists would disagree. I know there are lots of debates about what
computer science is and what it isn’t and whether in fact it is even a
science, but I think there’s a broad consensus of what a computer
science undergrad program should be, and what a computer science
graduate program should be.
Ideally, with your definition, CS courses would also include some
basic electrical engineering stuff and the science behind that. But
that would only make sense if people started using the CS literally,
and that would probably only happen if people stopped using CS as a
catchall for “competence in programming” and that will only happen
if a new catchall is devised.
Well … I also thing Electrical Engineering is a well-defined
discipline distinct from computer science and distinct from “competence
in programming”. Competence in programming is a necessary condition
for success in computer science, and for all I know may be in EE as
well. But it is certainly not sufficient – I expect a lot more from a
CS or EE graduate than competence in programming!
My point is just that if your goal is to set up a basic curriculum at
the end of which a competent programmer emerges, fundamental
algorithms certainly belong in there somewhere, but Fowler et al are
probably a bit more essential.
I don’t think competence in programming requires anything more than
competence in programming – the ability to learn how to manipulate the
concepts of an imperative programming language and get non-garbage out
given non-garbage in. At least when I learned programming, it was unlike
mathematics and for the most part unlike the underlying symbolic logic.
Of course, I learned long ago and on what was very close to the
underlying symbolic logic – one of the original Von Neumann machines.
The assembler had symbolic addresses but the operation codes were
hexadecimal digits.
The whole magic of programming was to do math with such a tool –
differential and algebraic equations for the most part. That was Von
Neumann’s field of expertise – applied mathematics – and the machines
he and his contemporaries designed reflected that. But it really was
just ones and zeros back then.
And then a notably