
Lisp and Smalltalk are dead: It’s C all the way down - seiji
http://computinged.wordpress.com/2009/08/14/lisp-and-smalltalk-are-dead-its-c-all-the-way-down/
======
ajg1977
I think that all comp sci students should begin by learning to become
competent in C. Aside from having the widest support across platforms, and
being syntactically similar to many other languages, it's the closest you can
get to understanding how computers work at a low level without dropping into
asm. Frankly, knowing these things will make you a better programmer.

That said there is definitely a benefit to exposing students to higher level
languages, both for productivity in solving more complex problems and
understanding what the syntax and expressions of these languages have to
offer. And by higher language I don't mean C++ :)

~~~
ynniv
Everyone says that C is as close as you can get to how computers work, but I
can't agree with this anymore. C stack management and function calling
requires work that is not part of a CPU. malloc and free do not map to
anything at the hardware level, these are OS calls. The closest C gets you to
the "computer" is pointer arithmetic and manual memory management. If you want
to teach someone how basic hardware works, start with an arduino and assembly.
If you want to learn how to program modern applications, use a modern language
(Java, C#, JavaScript, python, ruby).

I think that people talk about C as an important language because it is
difficult to write programs in. To these people it is a badge of honor to
write clean, correct C code. Here's the rub: C absolutely sucks at networking,
and concurrency, security and readability.

Every year that goes by, C becomes less useful. How is this a good language to
teach students? (Edit: BTW, This is the Computer Science curriculum, which is
separate from Computer Engineering. Georgia Tech's CS curriculum had no
mandatory hands on hardware classes.)

~~~
wcarss
I think that any programmer worth their weight must disagree with the larger
message you're giving here.

C does _not_ suck at networking, concurrency, security, or readability.

Most code you write in a 'modern language' like Java, Python, or something
similar, is implemented on a very low level in C. So those nice, clean, safe
networking functions Python pulls out of nowhere are just well written C code
being presented to the user through layers of abstractions. The same goes with
modern type-safety and security (that 'proofed' kernel from a few days ago was
Haskell mapped into C).

From a readability standpoint, C represents a tradeoff. The core C API can be
kept in its entirety in a programmer's mind. Starting from scratch, you are
able to know (essentially) every language feature C has, how to use it, and
what side-effects it could cause. Compare this to Java, Python, or even C++,
and you get into a scary world that's just too big to keep in mental RAM all
at once - but a lot closer to english and more compact.

There was an article which came out a few days ago talking about how C has
been and will continue to be the top choice for software over C++ _and_
assembly in embedded projects over the past 12-15 years. Given that embedded
systems make up something like 98% of the computer market and the number of
computers grow with each passing year, the argument should flow the opposite
way:

Every year that goes by, C becomes more useful.

In addition, it's an ideal language for teaching the notion of pointers, the
reasons for security, the value of good program structure, and yes, it's
difficult. If you teach people to be comfortable dealing with C, they'll feel
like Python is pie. (or.. py :P)

All that said, I cannot disagree with the value of functional, object
oriented, or other paradigms being taught to students. Many people do not
really learn to deal with recursion until they've learned a dialect of Lisp.
Many people do not really learn the power of design patterns and the object
model until they've written something in a high level language that uses it
(take your pick).

The fact that these are good things to be exposed to and to use does not in
any way diminish the importance or usefulness of C for both career programmers
or computer scientists.

tl;dr: "C is still good too homg"

~~~
defunkt
I took classes on C in school. I never really "got it." I then re-learned C
after learning Python (and other higher level languages).

I found it much easier to learn on the second try. On the first try I was
learning about syntax, functions, loops, variables, and types as well as
memory management, header files, and pointers. On the second try I was only
learning about memory management, header files, and pointers - I already knew
about the other stuff. On top of that, pointers were much easier to grasp
because I had experience with 'references' in higher level languages.

It's great to learn C, but I always recommend people learn to program by way
of something like Python or Ruby. It's hard to beat _print "hello"_ when
you're just starting out.

~~~
cema
(Almost) everything is easier to learn on the second try.

Also, keep in mind you learned Python after C, so your experience is not
clearcut.

~~~
defunkt
Except I never learned C the first time. That's the point.

~~~
cema
So you did not learn it, but you were learning it. Maybe you could not write a
good working program in C, but you became aware of a number of concepts that
you could build on later when learning other languages and when learning C the
second time.

------
ynniv
The College of Computing has been alienating their more academic members in
favor of "industry" orientation. I suspect that this comes from trying to
increase funding, but more simply it is indicative that those making the
decisions no longer have a clear vision of what they are teaching students. It
isn't enough to say that they are showing preference to C based languages, as
one of the primary "weeder" courses which was taught in C was discontinued
years ago.

I don't know if this uncertainty and doubt of academic computer science is
limited to Georgia Tech. Just recently, MIT dropped their scheme course for
one in python, with the goal of being more "practical". Is it better for
undergraduate computer science to be practical or academic? I will suggest
that if students don't learn abstract computing when they are undergrads, they
are never going to.

~~~
jsolson
To be fair, when 2130 (along with the ECE2030 requirement) was cut they
replaced it with 2110 and 3240. As I understand it (I tested for standing, so
I can't claim first-hand knowledge), 2110 does a very good job of combining
the relevant parts of ECE2030 and the C bits of CS2130. That, to me, makes it
a solid replacement for those concepts.

The first time 3240 was taught, Olin was the professor teaching it. It covered
a fair chunk of the material you'd expect to see in CS4510 that semester while
also being an excellent class on lexers, parsers, and interpreters (not so
much on compilers, but of course it's not a compilers course). I can
comfortably say that it was by far the most interesting and educational course
I took during my undergrad career. Since Olin's unfortunate departure, 3240
has apparently turned into just another lexer and parser course.

On the whole I'd say the changes they made w.r.t. CS2130 were good. However...

Threads has made it so that you can get a CS degree without taking an
algorithms or data structures course above the 1000 level, which I find wholly
disappointing. It's not that the degrees these students are walking away with
aren't perfectly valid things to have degrees in, but I have a hard time
calling a lot of these undergrads "computer scientists".

</rant>

------
naz
Smalltalk may be dead but there are millions of smartphones using Objective C
which is in many ways a direct descendant.

~~~
parenthesis
Not to mention the influence of Smalltalk and Obj-C on Java.

(See, e.g., <http://www.virtualschool.edu/objectivec/influenceOnJava.html> )

~~~
capablanca
Sometimes I feel like any newer language is said to be influenced by an older
one...

------
gruseom
At least this way our secret weapons remain intact.

~~~
swolchok
C (not C++) can be a secret weapon too, if it absolutely has to be as fast and
efficient as possible.

------
pcc
One train of thought seems notably absent in this discussion:

The skill a good school attempts to teach has very little to do with any
particular language. Instead they are seeking to teach you the one skill "to
rule them all":

To learn how to learn, how to acquire new skills, how to analyze, how to
synthesize and how to think systematically;

or said another way

the ability to identify and understand the problem space, to identify a tool
that fits the problem well (even though you've perhaps never used it before),
to acquire that tool quickly, and to wield it powerfully.

Consider that in your typical engineering degree, the half-life of your direct
knowledge is but a few years -- half of what you "know" is obsolete within
years. At the same time schools do want you to be "rapidly productive" in
something that sees relatively wide use, or the job market gives them hell,
and there just isn't enough time to cover all possible principles from all
scenarios.

So they can but strive to stimulate your intellect and pique your curiosity so
that you will naturally want to be aware of the possibilities and be open
minded to all the various tools out there; and that you will have some
framework available to you to understand what you will come across.

------
cstew
I took CS 2340 in Smalltalk a year ago at Georgia Tech. I think most people in
the class disliked the IDE more than Smalltalk itself. Visual works was
absolutely unusable on a mac and the Windows version certainly had its quirks.
That, coupled with the fact that Smalltalk isn't used too often anymore led to
students being really unsatisfied with the language.

I do think that the language needed to be changed for that class. The College
of Computing is not entirely C though; I did learn lisp for an Artificial
intelligence class, but not all students are required to take it.

------
JBiserkov
At my university we still have Functional programming (Scheme/Lisp), but the
message is "what C++ can compute, Scheme can compute, only a bit weird, e.g.
tail recursive factorial".

We have an OOP "course" that teaches code like this

    
    
      class People
      {
        char* name;
      }

The course's mantra: OOP is syntax, syntax, syntax.

The Prolog course was even more weird - the message was "what Lisp can do with
lists, Prolog can do too", but it was implicit because the Prolog course was
_before_ the Lisp one.

The electives were only marginally better, with Python being the stellar
exception.

~~~
twopoint718
I had a similar experience, if I'm interpreting this correctly, in that my
university was pretty focused on the theory. I had a lot of CS courses where
we were programming in "pen and paper." When we did write code it was often
Java, but you knew that any course you took the professor could swap in pretty
much anything else. Depending on the AI professor, you'd work in Java or
Scheme. Compilers class could be a C-like language targeting MIPS with the
compiler written using C++ or it could be a Java-like language targeting the
JVM with the compiler in Java (though I should say these "little languages"
were probably very similar because they were a very small subset of their
respective languages).

I think if you learn the fundamentals (and that often means having a good
grasp on C) it shouldn't be too terrifying to pick up at decent grasp on lots
of languages.

------
thunk
CS departments are just less and less able to maintain illusions about what
they really are -- trade schools for cranking out interchangeable corporate
programmers. And there's nothing wrong with that. Honesty and unity of purpose
are good things. Lisp and school never got along anyway. Lisp is for hacking.
Its interests have moved elsewhere.

------
WilliamLP
> e.g., Lisp programmers are more productive and generate fewer bugs

Lisp programmers _tell themselves_ they are more productive and generate fewer
bugs.

~~~
erlanger
You must not be familiar with this study.

<http://www.flownet.com/gat/papers/lisp-java.pdf>

~~~
WilliamLP
Is that study a joke? Do you really take it seriously?

~~~
erlanger
No, but when people bring up "C vs Lisp" or "Java vs Lisp" it comes up. I
don't give it much due however.

------
richcollins
How is the choice of C/C++ a decision in favor of simplicity?

~~~
SwellJoe
He references Richard Gabriel's "Worse Is Better", which compares the
simplicity of implementation model (C/C++) with the simplicity/correctness of
interface model (Lisp). C/C++ are "simple", ya know, kinda like Cletus from
the Simpsons.

One could also generally argue that C _is_ simple to use, as well. K&R is a
tiny book, and it covers most of what you need to know to read C, and a good
bit of what you need to know to write it (some of the ancillary tools, like
cpp, make, libraries, etc. complexify things a bit, though).

C++, on the other hand, is a huge pile of interwoven concepts and is extremely
complex, so I don't think it's polite to combine them in to C/C++, but I don't
get to make that call.

------
smithjchris
I agree entirely with this. I am not intending to start a flame war here, but
this is how I see it:

My rationale is that C/C++-based software powers nearly of all computer CPU
cycles these days either directly or indirectly.

From mobile phones to massive distributed systems like Google, it's there.
It's probably even there in your fridge or smoke alarm these days albeit
somewhat feature constrained.

For the Ruby, PHP and Python users, most of your language is written in C!

The .Net framework is mostly C/C++ underneath (Google for shared source CLI).
Even the C# compiler is written in C++.

Java is mostly written in C as well.

The iPod software is written in C (not it's not objective-C - check out the
About/Legal section for the libraries it uses).

Objective-C even started as a load of C preprocessor macros.

Ultimately, C/C++ is the foundation of the most software in frequent use, the
Internet and our society. That's why they should teach it over
Lisp/Scheme/Smalltalk/etc etc.

Oh and possibly just as importantly, it works.

~~~
jimbokun
"For the Ruby, PHP and Python users, most of your language is written in C!"

Are you seriously trying to suggest that understanding the concepts behind C
teach you the concepts behind how Ruby works, just because Ruby has a runtime
written in C? If not, what are you getting at?

"That's why they should teach it over Lisp/Scheme/Smalltalk/etc etc."

Are you seriously trying to suggest that _Computer Science_ students should
learn only one language, or only closely related languages?

That is the part that bugs me. That GT is deciding that their Computer Science
students are too dumb to learn more than one kind of language. I wish someone
at that school had read Joel's rant about "Java schools."

~~~
erlanger
> Are you seriously trying to suggest that understanding the concepts behind C
> teach you the concepts behind how Ruby works, just because Ruby has a
> runtime written in C?

That sounds reasonable to me...certainly not ripe for a "seriously?" label. Of
course knowing C would help one to understand how Ruby, Python, etc. work,
just like knowing assembler helps one to understand what C is doing. Rich
languages like these don't just happen out of the blue.

------
ilyak
This is downright dumb considering the recent surge in Ruby and Javascript.

And please, please, no C++ unless you understand what you're doing.

However, I think nobody cares about this particular university anyway?

~~~
inaka
US News says georgia tech is the #4 engineering school in the US...

~~~
ynniv
General engineering and computer science are separate rankings. For 2009, they
are #6 in "Computer Engineering", behind MIT, Stanford, CMU, UC Berkeley, and
UIUC. This is actually a substantial improvement from the 12th place that I
remember. Maybe "industry orientation" improves your US News ranking :-/

~~~
cema
They are pretty high in Computer Science too. US News ranking for 2008
([http://grad-schools.usnews.rankingsandreviews.com/best-
gradu...](http://grad-schools.usnews.rankingsandreviews.com/best-graduate-
schools/top-computer-science-schools/rankings)) places them at the 9th place,
shared with UT Austin.

