Lisp and Smalltalk are dead: It’s C all the way down.

August 14, 2009 at 12:09 pm 64 comments

Georgia Tech’s College of Computing is now considering a proposal to remove Smalltalk from the required curriculum in favor of C++.  When I got here in 1993, we taught Pascal (mostly) and had required courses in C, Lisp, and Smalltalk.  The faculty explicitly valued that students see more than one school of programming thought. I took over the Smalltalk-using course from John Schilling and Richard LeBlanc, and moved it from ObjectWorks to Squeak. When we moved to semesters in 1999, Lisp got dropped, and we’d moved from Pascal to Java as our main teaching language.  When we drop Smalltalk (now using VisualWorks), we will have a first semester in Python, and the rest of the required curriculum will be Java, C, C++, and C#.  We will explicitly tell students “C and C-like languages are all that there is.”

Why drop Smalltalk?  Students and teachers view it as “a dead language, not worth learning.”  It is the case that there are concepts in Objects and Design (the name of the course) which can most easily be discussed in C++. C++ is wildly popular in industry, so it’s not surprising that some language-specific techniques have developed, techniques that our students should probably know.

It’s reasonable to teach a course on object-oriented analysis, design, and programming in C++ rather than Smalltalk.  I’m more disappointed that we will have a curriculum that is all about C.

Richard Gabriel has been thinking a lot about the C-ness of our discipline.  If you have not read Richard Gabriel’s articles on “Worse is Better,” I recommend them. Dan Weinreb has a nice overview, and there’s a list of all the various pieces in Gabriel’s debate (some of which was with himself!). Gabriel has been trying to understand why Lisp, despite its many measurable benefits over C (e.g., Lisp programmers are more productive and generate fewer bugs, Lisp environments are amazingly powerful, Lisp code is small and runs fast), has so clearly lost the battle over hearts and minds.

Gabriel contrasts two design philosophies, the MIT/Stanford philosophy (which he calls “the right thing“) and the “New Jersey” C/UNIX philosophy (which he calls “worse is better”).  In short form, the MIT/Stanford philosophy (which he associates with Lisp, and which I also associate with Smalltalk) is that correctness and consistency are the most important design quality. In Lisp and Smalltalk, we have S-expressions and objects consistently.  The C/UNIX philosophy places simplicity in interface and implementation as the most important design quality.

Python is a mishmash of the two design philosophies.  Yes, you get lambda and map/reduce and objects and classes.  But you lose the consistency and syntactic flexibility of Lisp and Smalltalk.  What’s interesting is that Python, being the least C-like of the popular languages in computing education today, is mostly seen as a language for the NON-computing major.  It’s like faculty are saying, “Oh sure, those simpler and more conceptual ways of programming are fine for people who won’t be real programmers.  For our students, it’s C all the way.”

I don’t dispute that Unix/C philosophy has won the marketplace. I worry about only teaching that to our students. I think it’s important for Computing  majors to understand Gabriel’s debate, to understand what’s valuable about Lisp, Smalltalk, APL, and other high-power, lots-done-in-few-lines-of-code, flexible languages and environments.  We want our students to be thought leaders, to think about possibilities that aren’t currently in vogue in the marketplace. They should know about lessons of history, to avoid repeating mistakes and to resurrect old ideas when technology and opportunities fit.

The political forces are lined up to make the Georgia Tech change likely.  In comparison with the departments that I had contact with this summer, we’re late.  The C-only train has left the station.  Few departments teach surveys of programming languages anymore, and I don’t know of any department that teaches a required course in history of computing. I worry about what this means for our discipline.  Are we really going to tell students that the peak of human expressibility for computation was in 1973?  That all programming language research from here on out is wasted energy?  That simplicity is all that we can ever hope for, and correctness and consistency just aren’t worth working on? Are we forever stuck with 30+ year old ideas and don’t even teach that anything else is possible?

Entry filed under: Uncategorized. Tags: , , .

Fashion counts: Cell phones vs. Calculators The Whole Package Matters

64 Comments Add your own

  • 1. Santi  |  August 14, 2009 at 1:48 pm

    This seems to me a rather industry focused curriculum. For those students who want to start an academic and research oriented career, there are ideas such as resolution, unification, currification, tableau calculus, lazy evaluation, etc. which are better taught with other languages. Additionally, variety enforces open-mindedness.

    If lisp and smalltalk are seen as old. Then pick OCAML, Haskell, LIFE, or any of the new functional or logic programming languages, which will do as well, and are not outdated at all.

    • 2. Antonio Salazar Cardozo  |  August 14, 2009 at 3:05 pm

      The curriculum isn’t even really industry-oriented. Yes, all the listed languages are in widespread use in the industry, but so are plenty of dynamic languages, including Python (the depth of whose use is limited by the fact that a lot of students are learning the concepts of programming at the same time as they are learning the language itself), Ruby, (dare I mention it?) PHP, etc.

      That’s leaving aside the well-made argument above that students should have exposure to programming styles different from those most commonly put forth by the C-based languages. Smalltalk itself offered people who were receptive to it the revelation of using blocks to handle iteration instead of primitive loops.

      Ultimately, though, it has to be said that a lot of the students *weren’t* receptive to it. I’m sure if a lot of them had Lisp thrown at them, the end of the semester would be rife with complaints about, as mentioned above, how the language is useless and whatever. Whatever happened to the idea that even if you never use the *language* in production, the mere exposure to its way of thinking will shape your programming in other languages in positive ways?

      One last thing is that even in the current courses, not enough emphasis is placed on `why would I use *this* language’. There is some merit to saying that often it’s simply because it’s what your company uses, but there should also be some consideration applied to what the strengths of the language are. A survey course that gave brief exposure to a wide array of such languages would, of course, be the ideal vehicle for that information.

      But I digress. That Smalltalk is being dropped isn’t the best thing ever, but it is not unexpected either. That it is being replaced with C++ is, however, a much larger problem, when even dynamic languages, which are in widespread use, are barely represented as it is in the curriculum.

  • 3. JoshJ  |  August 14, 2009 at 1:58 pm

    GT still uses Lisp in CS 3600, the intro to AI programming course.

    I’d personally like to see some more use of dynamic languages (Ruby would be a nice replacement for Smalltalk!) or at the very least courses which explicitly teach how to program webpages (PHP, Ruby on Rails, Javascript+CSS+HTML, etc).

    • 4. Mark Guzdial  |  August 14, 2009 at 2:08 pm

      CS3600 isn’t required for even most CS students at Georgia Tech. There are other languages used in electives. My point is what everyone graduates with.

  • 5. Eric  |  August 14, 2009 at 3:31 pm

    Mark, I hated Squeak when I took your class (largely because I didn’t put in enough effort to really learn what I was doing), and to this day I’m glad I don’t ever use it. That being said, I am glad that I had to learn it in school, along with Lisp, Perl, Prolog, and a few other languages that I’ve since forgotten about. Having such a diverse background, with exposure to so many different programming philosophies, has been a hugely positive thing now that I’m out in “the real world.”

  • 6. Mattox Beckman  |  August 14, 2009 at 3:34 pm

    You may have heard the saying: “When the only tool you have is C, then every problem begins to look like a thumb.” Certainly C is a “need to know” language for a CS student. But to teach only C/C++ will cripple the students’ ability to think about what they are doing as scientists and as programmers. In my own teaching I have seen a profound difference in the ability of students who have been exposed to functional programming vs. the students who have not; even in an imperative context. (Insert ‘Chicken and Egg” debate here.) We learn other language paradigms for the same reason that we teach Latin or French in high school: even if you never use it in “real life”, it helps you understand the languages you do end up using, and use it more effectively. To willfully ignore the studies that show the benefit of learning and using other language paradigms is to do a great disservice to the students.

    I think part of this debate touches on the purpose of education. As you said, “We want our students to be thought leaders, to think about possibilities that aren’t currently in vogue in the marketplace.” The question seems to be: is the purpose of educating students to produce new thinkers and generators of new ideas (long term horizon), or to produce useful laborers for industry (short term horizon)? We need both, and I would submit that to ignore one to gain the other will result in losing both.

    I’ll get off my soap box now. I hope you are able to convince people to rethink this issue.

    • 7. Carl  |  July 16, 2012 at 4:59 pm

      Perhaps those who run universities are not interested in what’s best for their students, or perhaps we’re simply falling prey to an unenlightened system of centralized control?

  • 8. Ian Bogost  |  August 14, 2009 at 3:34 pm

    One of the things Nick Montfort and I have run into in soliciting proposals for the Platform Studies book series is an overall lack of interest in history in computing in general.

    While computer scientists generally like our book Racing the Beam (on the Atari VCS), we’ve experienced a general reluctance among CS folks to consider participating themselves. I think part of the reason for this is that CS overall (yes, I’m unfairly generalizing) is almost exclusively interested in “progress,” with the tacit assumption that progress means building on what we know today.

    It’s possible to argue that the book is a non-standard way to produce scholarship in CS, and that’s partly true. But we’ve had a strong interest from EE/ECE, where the situation is much the same. It’s also interesting to note that the latter field does have an interest in history, as evidenced by volumes like the IEEE Annals of the History of Computing.

    Here’s another, related premise: the rising disinterest in CS is partly caused by its ahistoricity. People are curious, and when a field is explained in terms of where it came from and how it got the way it is, it is hard not to be interested. When it is explained only in terms of arbitrary, ideologized routines and methods, then it seems intractable and closed.

  • 9. ellie  |  August 14, 2009 at 4:47 pm

    echo the first comment. is this change so that gatech can better compete with devry? computer science != programming… and being a good programmer/software designer/coder is not really about language mastery anyway. languages come and go and are project specific. imo, the best thing a computer science degree – even one aimed at creating industry workers – could teach is the ability to understand common concepts and paradigms broadly and learn new languages as needed. for that, a degree program needs variety as different langs stress different things, plus practice at transferring knowledge from one paradigm to another? no? sad to hear…

    on another note, have been quite entertained with writing mini games in lua with when bored at work. insanely quick and easy. was thinking it could be a cool intro to programming for a media-comp style class even if not *the* teaching language for an entire semester (or summer camp type thing?). quick rewarding results 🙂 plus nice intro to the idea that there are many small communities of random people making random software out there and you could participate if you want… wonder if you do anything like that?

  • 10. James Robertson  |  August 14, 2009 at 4:57 pm

    I will point out that Smalltalk use is growing, and that Cincom’s most successful product right now is Smalltalk. I think that might run counter to the “dead” notion 🙂

  • 11. Sean Caulfield  |  August 14, 2009 at 5:27 pm

    This makes me so very sad. I will be the first to admit I was a major Squeak-hater while at Tech, but I do not fault the faculty for forcing it upon me. It increased the breadth of my practical programming knowledge.

    Languages are tools. We should be educating tool-makers, not tool-users.

  • 12. Gabe da Silveira  |  August 14, 2009 at 6:15 pm

    As someone who learned Scheme in my first CS class, this is truly disturbing. I understand the desire to move away from SmallTalk and even LISP in some ways, but how about replacing it with something modern and worthwhile.

    We should start a movement to teach Haskell to undergrads. I think there is enough wow factor and modernity there to ensure that CS students don’t graduate having internalized the peculiarities of current C-like languages as being somehow immutable limitations of programming languages.

  • 13. Mark Guzdial  |  August 14, 2009 at 7:02 pm

    Thanks to all of you alums who are voicing your support for Smalltalk. Do realize, though, that students today like Smalltalk no better than you did when you were using Squeak with me. Faculty teaching those classes are responding to students who complain, just as you did. Should the students be ignored, or should they be responsive to the students? How should the faculty know that the students should be ignored, in favor of the professionals that they will become?

    • 14. Mark Miller  |  August 14, 2009 at 8:18 pm

      When I went into college in the late 1980s they had just started instituting student evaluations of teachers. It’s been a long time, but what I remember is the questions had a lot to do with how well the teacher conveyed the material and if the teacher encouraged student participation–more “class dynamics”. They didn’t get into the “relevance” of the course or how hard the material was.

      I don’t think that CS, or any discipline for that matter, should be left up to the “wisdom” of the students. I mean, if it were up to me back when I was in college they would’ve been teaching C in their introductory CS course rather than Pascal, and we would’ve used that language throughout the curriculum, without bothering with the “research languages”, because that’s what I thought industry was doing, and I thought that was most important. I’m so glad they didn’t take such an approach. I think MIT had it right for a long time using an approach like SICP. Maybe that’s too rough an introduction, but I think getting to principles of computing as early as possible without totally alienating the students would be a good step among others.

      • 15. Mark Miller  |  August 14, 2009 at 8:50 pm

        To expand on my point, if I had had my way back then I would’ve also eliminated the Calculus requirement, because it seemed pretty pointless at the time, and for several years after I got out of college. In all of my work I didn’t use it once (the most relevant math I used was algebra and Discrete Structures), though now I feel like a more educated and well-rounded person for having taken it.

        The point is there’s a lot that’s taught in college that can seem irrelevant. One of my college friends who was also taking CS asked me what the point of learning history was (my alma mater is a liberal arts college). The question is does it expand how students think? Does it help them realize an ability and/or perception they didn’t know was possible? At a minimum I think that should justify teaching something. If input from industry can help in that regard (which in most cases I doubt), that’s all fine and good. Whether students think it’s relevant shouldn’t be the point. If it is you have larger problems.

    • 16. Vinny Fiano  |  August 15, 2009 at 11:01 pm

      I personally remember being lost in Squeak. Development in the SqueakVM prevented me from using the tools that I was familiar with, particularly my text editor (, but also source control. Have tried teaching Smalltalk using an interpreter that accepts external text files?

      • 17. Mark Miller  |  August 16, 2009 at 9:09 am

        This is a common complaint I’ve heard with Squeak. One of the purposes of its design was to get people out of their conventional thinking about how a system should be structured, and how it should operate. For example, most everything being an object–rather than a process, a folder/directory, or a file.

        If you insist, there is an implementation of Smalltalk that takes external text files, called GNU Smalltalk. It has a scripting mode that allows you to specify an external file, which will be interpreted.

      • 18. Vinny Fiano  |  August 17, 2009 at 10:04 am

        From a theory standpoint, I appreciate that everything inside Squeak is an object. Yet, every time that I revisit Squeak (which I have done even after finishing school), I am struck by how useless I am at basic operations. After making a few mistakes, you start to question everything: how do I move the cursor forward a word? Can I undo? Cut, copy, paste? Print? I’m lost.

        To fully appreciate Squeak, you have to be a frontiersman, to be prepared to gather food before you are hungry and build a camp before nightfall. By itself, that is okay for a single class, but this is just the base on top of which something completely different is expected of you.

  • 19. HFh  |  August 14, 2009 at 7:06 pm

    Well, it all went off the rails when GT stopped teaching Scheme in CS1.

    I would love to see a survey of programming languages class.

    • 20. Mark J. Nelson  |  August 15, 2009 at 12:02 am

      There isn’t one of those? I had assumed a survey-of-PLs class was a core part of most CS curricula. Harvey Mudd requires *two* as part of the non-elective curriculum, the first focusing on a survey of programming paradigms (functional, OO, imperative, logic, etc.), and the 2nd focusing on actual languages and how their type systems work, what a compiler is, etc.

  • 22. Chris Lewis  |  August 14, 2009 at 7:52 pm

    I think Antonio is the one that nails it: “One last thing is that even in the current courses, not enough emphasis is placed on `why would I use *this* language’.”

    I was taught C in my first semester, then Java and Haskell concurrently in my second semester. Often the homeworks in that second semester would be to implement the same program in Java, then the next week Haskell.

    Throughout the course, I found myself banging my head against the keyboard, wondering why on earth I was learning this po-faced Haskell language, which made it hard for me to express what I wanted. It’s only now that I’m older and a little wiser that I realize how important it was to expose me to other ways of programming.

    I think the vast majority of undergraduates want practicality and are (rightly) thinking about how their work affects their job prospects. They think teaching “dead” languages like Smalltalk, or “obscure” languages like Haskell are simply jaunts for old, stuffy professors who haven’t moved with the times.

    It’s on the professor’s shoulders to properly illustrate why these languages are relevant and why they make you a better programmer in all languages. This is the step that often goes unspoken, and why the feedback from students is going to be overwhelmingly (rather than unavoidably) negative.

  • 23. Mark Miller  |  August 14, 2009 at 7:59 pm

    I would not take the fact that CS departments at most other universities have already taken the “C-only” approach as meaning that GA Tech is “behind”. I would rather take it as a sign that CS is regressing.

    I am on the other hand happy to hear that up to now GA Tech had been teaching other “research languages” to expose students to them. I was a bit shocked to see messages from former students saying that they *hated* Lisp or Smalltalk, but then I remembered back to my CS experience, and it was similar. I hated Lisp when I was first exposed to it my sophomore year, but this was because of two factors: 1) I had never seen a language work like it before. I was so used to imperative languages like Basic and Pascal. I thought that’s all programming was, and trying to grasp the way Lisp worked made my head hurt. I didn’t succeed in learning it at that point. 2) I had a terrible teacher for it (not implying anything about the teachers at GA Tech). My experience with it was so bad I vowed I would never look at it again, and I was glad to hear that when I went out into industry I wouldn’t have to use it. I heard the same thing from my CS professors in the late 80s/early 90s: “You won’t be using this language when you get out in the work world.” They made it pretty clear that they were only used in academia.

    I didn’t really begin to understand Lisp until I got into a senior course on programming languages, and I finally learned how functional programming is different from the imperative languages I had experienced. We used SML for functional programming, and I found it rather easy to learn. For whatever reason I found Smalltalk very easy to learn as well.

    The reason it worked out so well may have been that we talked about how language interpreters worked in that class, how they parsed the input and how they interpreted the resulting structures. Lisp and Smalltalk are really what I’d call “architectural systems”. I think that’s one of the ideas that is really difficult for beginners to learn if they haven’t been exposed to how interpreters do what they do, especially if they’ve already gotten imperative languages ingrained in them. Lisp and Smalltalk emphasize that you are working with a particular kind of computing system, not a language, per se. One thing I realized about Smalltalk that I really fell in love with was that I could make my own domain-specific language with it. That was a “a-ha!” moment. When I had experiences like this I began to regret that I wouldn’t be able to do these things in the work world.

    C, Ruby, and Python also kind of convey this idea of working with a particular kind of computing process, but there’s enough high level structural programming stuff in them (which they require you to use) that make them look like “normal” imperative languages. They abstract away some of the underlying computing process so that it *looks* like the language is what’s driving it. That’s probably the reason why students like these languages more, since they give the feel that “you can do computing by speaking the computer’s language,” and it looks a little like the language they already know.

    I didn’t change my mind about Lisp (vowing to never look at it again) until I saw Paul Graham’s essay, “Beating the Averages” 3 years ago. It really turned my thinking around.

    Here’s an excerpt from it that agrees with a point that’s been made here. It starts with a quote from Eric Raymond’s How to Become A Hacker:

    “‘Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.’

    This is the same argument you tend to hear for learning Latin. It won’t get you a job, except perhaps as a classics professor, but it will improve your mind, and make you a better writer in languages you do want to use, like English.”

    This wasn’t what really grabbed me. Graham used this as a “base” for a larger point, which is that he managed to create a successful start up in the mid-1990s using Lisp almost exclusively. It was so successful that he beat out all of his competitors in his market category, who were mostly using C++ and Perl. He attributed his success in large part to the architectural advantages that Lisp gave his company. This really runs against the grain, because I was told when I took CS that “all languages are basically the same. It doesn’t matter which one you use. It’s more a matter of taste.” If your fellow CS professors have not read this yet I would encourage them to do so. It might give them pause about throwing Lisp and other languages like it out the window. It does convey the idea that there are higher aspirations that people can look forward to in computing, and proves the point well with a real world example.

    • 24. Ian Bogost  |  August 14, 2009 at 8:30 pm

      I dislike the “just like Latin” argument (and this is from someone who learned Latin and Greek in addition to C++ and Lisp and the like), and I enjoyed the way Graham’s anecdote turned from an “it’s good for you” position into a “this is useful in the right circumstances” argument.

      But I’m also skeptical about the “better programmer” position, which Graham advances explicitly, and Mark implies a little in the original post. The useful thing about Latin is that it’s the language the Romans spoke, and that the church used, and if you want to know things about either of them, it’s easier to do more deeply in Latin. The reasons to know Lisp are not “if you like it it will be easier to program fast,” but rather that functional programming is beneficial in certain situations.

      Knowing both the skill and the situation is needed. We don’t want random people wielding Lisp at any old programming problems anymore than we want them wielding Latin at any old historical one.

      And moreso, it’s not really the Lisp specifically (or the Smalltalk, or whatever), but rather having seen both specific non-imperative languages and their uses, and having the overall knowledge that there are different programming paradigms, not just one, that they are invented and largely arbitrary, and that you could even invent one yourself if you had reason to.

      • 25. Mark Miller  |  August 18, 2009 at 6:06 pm

        Hi Ian.

        I agree with what you say here in that people should not just apply Lisp to every problem. I like your analogy to Latin as well. Coupled with something like SICP (using Scheme) one can get a historical grounding in why software architecture evolved the way it did in the scientific context.

        As I talked about in a later comment here, Lisp and Smalltalk can be described as “architectural systems”, not so much languages. Architects know that certain architectures are more appropriate to certain situations. Software engineers should think along these lines. They don’t more often than not. What I was responding to was the idea many in CS apparently have, which is that “Lisp is irrelevant except in AI because no one else uses it”.

  • 26. damirhorvat  |  August 14, 2009 at 8:40 pm

    I am sorry to read this.

    I believe we are always learning and to be honest, I wish I had someone open my eyes with programming language differences when I was still in college (or even while in high school).

    I am now, 10+ years later, discovering this differences by myself through trial & error. I stumbled upon Lisp while reading PG’s essays. I found Erlang while fiddling with Jabber. I was amazed when I found Smalltalk (it was this thing that kept popping up when I was searching resources for Lisp and Erlang).

    If someone would, 10 years ago, tell me about those languages and where they are of best use and encourage me to explore it and try and find solutions to class assignments in various programming languages, that someone would save me a whole lot of time…

    Success is rarely achieved by believing there’s only one way. This is the “sheep” mentality and it robs you by far greater amount of wealth then making occasional blunder by daring to think different and setting your aim higher.

    I am sorry to read your university will teach this “sheep” mindset of looking at problems and solutions. I am sorry to read your university aims to teach “employee-way” of thinking.

    I believe it is better to teach people how to use their own heads and think for themselves. I believe restraining to only use C/C++ in classes is theft. The worse kind.

    Let students experiment and find better and worse solutions by themselves. Let them think. That’s how, I believe, progress is done.

  • 27. David Hilley  |  August 14, 2009 at 8:48 pm

    Yuck. Just another step for Georgia Tech’s undergraduate Computer Science program transitioning to something more akin to “Computer Scientology.” Computer Science isn’t about the language, sure, but there is something to be said about the value of exposing students to language diversity. I agree with ellie — learning to problem solve in substantially different languages broadens your understanding of the basics. Thinking about a problem in a different light deepens your understanding. At the very least this is a step towards more parochial graduates, and Paul Graham would say we’re churning out “blub” programmers. That language diversity doesn’t have to come from Smalltalk or Lisp, specifically, but something please.

    Mark, I think they should be responsive to the students but take everything they complain about with a big grain of salt. Surely they must realize that students ALWAYS complain. You can set the bar as low as you want and students will still bitch. Its their job. And grad students are even better at complaining because they have more experience.

    If the language is preventing the students from learning the actual content of the class, then fine — change it. I think a lot of these complaints are more about perceived external value or “real world” appeal, though (e.g. “I’d rather put C++ on my resume than Smalltalk”). And regarding the language inhibiting the students from learning course concepts (in the context of CS2340), I’m of the opinion C++ is palpably worse in that context, requiring more attention to lower-level details. Wait until they get their first page-long botched template instantiation because they missed a semi-colon.

    As far as complaining about Squeak during the class, I can only speak for myself, but I liked Smalltalk the language just fine. It was the larger context of the Squeak implementation and the fact that we had to be beta-testers for some rather green functionality that was irksome (like voice synthesis stuff, certain things in Alice, not to mention the first release of Ecode). Smalltalk itself is an elegant language.

  • 28. Mark Volkmann  |  August 14, 2009 at 9:02 pm

    “C++ is wildly popular in industry”

    Really? I think its use is shrinking rapidly. Maybe you could say that Java is wildly popular.

    I think it is essential to teach at least one OO language and at least one functional language. You should also teach at least one statically typed language and at least one dynamic language.

    Java could be both the OO and statically typed language. It seems you’ve already chosen Python for the dynamic language. That leaves choosing a functional language. My choice would be Clojure.

  • 29. Ashwin Bhat  |  August 14, 2009 at 9:34 pm

    I’m currently a third-year CS major at Georgia Tech, and I’m somewhat upset about this decision as well. I’ve already taken Objects & Design, and while I was at many times frustrated with Smalltalk (this may actually be because of the user interface of the IDE), I did find the language very interesting conceptually. It definitely seems like a lot of the same concepts could be taught with Ruby, and with more and more software moving to the web, Ruby could arguably be more useful than C++, industry-wise.

  • 30. BigLinuxGuy  |  August 14, 2009 at 11:37 pm

    I would suggest that the colleges are more concerned about turning out computer programmers who can find a job in industry (oh wait, those are the jobs that are being offshored) rather than computer scientists or software engineers (although the title software engineer has little real meaning these days since companies hand it out to everyone who writes code regardless of whether or not they follow any particular engineering discipline). Interestingly, I’m seeing a return of functional programming due to the inherent over-complexities associated with the current languages and approaches. Sadly, when I’ve asked many computer science heads why they’ve chosen to teach a monolithic curricula, the response often boils down to:

    1) It teaches the students the skills they’ll need to find a job
    2) It’s easier for the faculty to just teach concepts in a single language
    3) All of the above

    As you note, the issues associated with this type of blinder-driven thinking is that you produce robots, not thought leaders. It’s similar to the somewhat absurd notion that all development should be based on web technologies (these days called “cloud”).

    The web is a huge kludge of incompatible browsers and so-called standards that have enough holes to resemble a swiss cheese. It’s another case of no real engineering and watered down “standards” created by a committee composed of individuals with different agendas that result in something that is barely usable in the best case. However, that hasn’t stopped the religious fanatics, er, evangelists from proselytizing their particular brand of snake oil, er, “faith”.

    In short, we’re surrendering creativity and innovation for hacky, organic systems that have to be constantly rewritten (under the heading “refactoring”) and nobody really seems to care that it’s costly and inefficient.

    Hurray, we lose again……

  • 31. Alan Kay  |  August 14, 2009 at 11:54 pm

    I don’t think either Lisp or Smalltalk are the issue here. There are better ideas now. But the proposed solutions for the most part fall very short (and these better ideas haven’t been mentioned in the replies to Mark’s posting.

    As long as computing is treated as a pop culture by most concerned it will continue to be dominated by desires and rationalizations which go no higher than they ever do in pop cultures. This includes desires to “be popular”.

    I think the real issue here has to to with the meta-capabilities that languages can have — including “architectural-meta — and whether students are able to deal with the meta-capabilities. Lisp and Smalltalk are more meta than most, and this is their main interest wrt real computer science.

    However, a few things have been learned since then, and a curriculum that includes these should be of prime import to any real school of computing. (Note that in the 60s when things were difficult in many dimensions and not so much was known, many universities actually built their own computers and software and programming languages. Today when both hardware and software are extremely easy to do (better tools, better knowledge) it is hard to find any so-called educational institution which has both the courage and ability to pull this off with their professors and students. The outlook (certainly) and the general quality (probably) has deteriorated.

    For example, wrt programming, why not take another shot at the admirable plan that Abelson and Sussman took with SICP? There is no reason to burden the student with trying to read S expressions, and there are many other things that could be done to make the entry into such a curriculum easier, but it’s hard to beat the idea of starting with a really extensible language kernel and extending both progressively and sideways to deal with the wide variety of needs and useful programming and systems design styles.

    That universities that call themselves “technical” don’t feel up to this — both in terms of seeing the strong merit of the idea and to actually going about doing it, and then to say “this is what it means to learn about programming languages” — is quite shocking to me.

    Why am I shocked? Because as I said, in the “difficult old days” the good institutions did this as a matter of course. (And it also provided some of the greatest practical experience both in doing and in thinking.)

    Best wishes,


  • 32. The Becker Blog » Blog Archive » Is Computer Science Dead?  |  August 15, 2009 at 10:53 am

    […] heard on Mark Guzdial’s blog that “Georgia Tech’s College of Computing is now considering a proposal to remove Smalltalk […]

  • 33. Ken Forbus  |  August 15, 2009 at 11:47 am

    Alan’s comment re popularity raises an interesting point. My bet is that there are actually MORE lisp programmers today than there were in the 1980s. The population of programmers has grown immensely, so the fraction of Lisp programmers is almost certainly smaller than it used to be.

    Can one still work in Lisp effectively? Oh, yes. There are enough commercial and free implementations of Lisp, with environments that are better than what we had in the Symbolics days, to do all sorts of productive things. Our engineering thermodynamics software and sketch understanding systems are written in Allegro Common Lisp, for example. Allegrocache really rocks as a persistent object store, and Allegrograph is a darned cool semantic web triple store. So the software is out there, if you want to go that path.

    I do see the failure of computer science education to focus on ideas rather than on teaching people the “practical language of the day” as a problem. It seems odd to me that Georgia Tech would go with C++ instead of Java, though, given that Java seems somewhat cleaner while still being object-oriented. Mark’s media computing is a good start to hook students, but courses in all areas of CS should be stretching students’ ways of thinking. And that often requires other languages. In Building Problem Solvers, the textbook Johan de Kleer and I did, we use Lisp because there isn’t anything else that lets us write languages so compactly. To be sure, some techniques, like open-coded unification, were originally in other languages. But for making a version that a student has a chance of understanding quickly, I think Lisp is the best starting point.

    At Northwestern we expose students to a number of languages, and expect them to learn more “on the street”. Ian Horswill’s Meta is a arts-centric Scheme, Common Lisp is used in several AI courses, Java and Python here and there, etc. A linguistic monoculture is intellectually problematic, to us.

    • 34. Alpheus  |  July 20, 2019 at 2:23 pm

      To add to your and Alan’s comment about popularity: there’s also something wrong with chasing what’s “popular”. It’s been ten years since you’ve made this comment, and in the meantime C++ has been declining. To what degree did GT make their decision right when C++ was peaking, or perhaps even beginning its downward trend?

      Popularity is fickle, and what’s worse, academic committees can take years to make a decision like this. If you really want to make “following popularity” the goal, this is one of the problems you are inevitably going to have.

      Sigh. One of Alan’s greatest observations has been that computer science has been driven more by pop culture than by history or what’s best. The third-saddest side effect of this is that we have seen the rebuilding of the entire software industry from the ground up at least twice. The second-saddest side effect of this is that it seems as though pretty much everything worth knowing in computer science was discovered in the 1970s, which, in turn, were really just re-discoveries of things done in the late 1950s.

      And the saddest thing about all this, though, is that despite knowing about wonderful things like closures and lambdas, actors, object capabilities, and other simple yet very effective ways to safely and securely handle computational complexity, we generally don’t get to use them, because they can only be found in “academic” languages, and adopting them means we have to leave behind the “popular” ones, which are so useful in no small part because of their network effects, aka their popularity!

      And I have no idea how we can escape this popularity trap, and actually have sensible tools at our disposal.

  • 35. Alfred Thompson  |  August 15, 2009 at 6:32 pm

    IN some ways this ties back to the earlier “Trust me I’m a Computer Scientist” doesn’t it? Students think they know better what industry is looking for. But they really don’t. I agree with Alan that industry doesn’t really know what they need. They may know what they want but want and need are not always the same. Having spent 18 years writing code for a living I’m pretty convinced that there have to be better ways than what is done in most shops. Universities tend not to understand how industry works though. University projects are very small by industry standards (1-5 people working for 6 months to a year rather than 100-1000 people for multiple years) and things do not always scale. I’ve heard senior industry people claim that it takes a year and a half to bring the graduate of a top CS program up to speed. Not a sign that students are graduating ready to soar. I’m not convinced that is a huge problem BTW. A university program should prepare a student to grow over the next 30 years; not just be ready for the first 18 months after graduation. They seem to be doing ok at that.

    Moving to one family of programming languages and one programming paradigm seems a step backwards though. In hindsight the programming languages survey course I took as a university senior may very well have been the most useful of my career. I’ve had to learn new programming languages every couple of years for the last 30+ years. That course gave me a good knowledge base for that. It also helped open my mind to multiple ways to do things. More than that it helped me to look for the right tool for the problem rather than looking for problems to fit the tools I had.

    BTW does GT require Assembly language at any point? I’m old school enough to find it hard to think of a computer scientist as prepared without some exposure to low level programming.

    • 36. Ian Bogost  |  August 15, 2009 at 7:32 pm

      I don’t think it’s required, but some do see it. This is a good opportunity to remind Mark of my suggestion that we try to do a Freshman class in 6502 asm on the Atari.

    • 37. Mark Guzdial  |  August 15, 2009 at 9:31 pm

      Alfred, I think you got it spot-on — yes, we’re really talking about trust issues. When do students trust us that something is valuable to learn and worth investing time?

      All CS and Computational Media majors take a course where they program at a low-level in C (e.g., on a Gameboy) and cover how the C is compiled to assembly language. So yeah, they see it.

      I take your point, Ian. 6502 assembly is small and understandable (and remarkably sticky — I don’t know how I still remember that A9 is LDA immediate and 20 is JSR). Alan has conjectured previously the value of learning two levels simultaneously in a first course: Assembly and Lisp, for example.

  • 38. Nick tfm Black  |  August 15, 2009 at 7:19 pm

    Hey, great post! I’m glad to have found this blog.

    Alfred: yes, some assembly is used in undergraduate systems classes.

    I’m still furious about Prolog leaving the curriculum upon the elimination of 3411. Prolog was one of the most thrilling, moving experiences I had as a CS undergraduate.

    Perhaps we could teach Objects and Design using CLOS =].

  • 39. Top Posts «  |  August 15, 2009 at 8:21 pm

    […] Lisp and Smalltalk are dead: It’s C all the way down. Georgia Tech’s College of Computing is now considering a proposal to remove Smalltalk from the required […] […]

  • 40. anon  |  August 16, 2009 at 11:14 am

    Every language that survives the rigors of use by the computing world* has its place. Lisp is great for teaching data structures, smalltalk for object oriented-ness. C++ for its sheer size and library availability, Python for its ease.

    * In other words, it is used by a significant population in some capacity or another for a significant amount of time.

    • 41. Mark Miller  |  August 18, 2009 at 6:31 pm

      I agree that these languages “have their place”. The problem I see is that the places that have been chosen for them are not necessarily good fits. It’s been my observation that which language becomes popular is only partly based on their technical merit–what they can accomplish with finesse. A lot of it has to do with the ability of a language’s library to solve problems that most people want solved, how well it’s marketed, or how accessible it is (ie. whether it’s free), and whether our limited minds can understand them and thereby create a large community around them. Educational and socioeconomic factors (I’m using this term literally, not just in the vernacular) play a significant role in this. This results in languages becoming popular because “it’s easy to learn”, or “It has the best tool support”, or “it has the best industry support”, not whether it leads to better systems in the technical sense–just “good enough” to get something running within cost constraints.

  • […] Lisp and Smalltalk are dead: It’s C all the way down. « Computing Education Blo… […]

  • 43. anon  |  August 17, 2009 at 9:33 am

    I feel the pain. LAPACK is under heavy pressure to move entirely to C; we cannot find developers who can / are willing to learn Fortran for dense linear algebra. And no programming language people are willing to work on the tools that are obvious, low-hanging fruit because it’s not Haskell.

    Are we doomed? Perhaps. Possibly to multiple monocultures.

  • 44. webb mcdonald  |  August 17, 2009 at 1:57 pm

    Squeak was my favorite computer science class at Georgia Tech.
    Squeak eToys is still part of the OLPC XO Sugar Activities and is an important learning tool available to the world.

    I can’t believe they would not teach Squeak anymore. Most people will continue writing declarative code in whatever system they are given because they were never exposed to functional or true object-oriented programming until it was too late. That’s been my experience so far. It takes a very open mind and lots of initiative on the learner to get that knowledge on your own. In the “real world” very few opportunities exist to challenge your conception of the computer and how it may relate to the world and solve the problems you want solved. Wasn’t the university designed to provide this exploration for the student?

  • 45. The Whole Package Matters « Computing Education Blog  |  August 18, 2009 at 8:06 am

    […] 18, 2009 The enormous discussion on “Lisp and Smalltalk are dead” (latest count: over 2,900 views) has spawned a parallel thread of discussion within the […]

  • 46. Tony Hursh  |  August 23, 2009 at 11:23 pm

    I second Mark Volkman. Clojure is a real Lisp which runs on the JVM. It provides easy (and non-ugly) access to the standard Java library and also the vast collection of third-party libraries that are available.

    It’s very pleasant to use.

  • 47. polypus  |  March 10, 2010 at 3:12 pm

    3rd for volkman. you could start with java, to learn static typing & OO, in a relatively friendly GC’d environment, all while keeping the ‘what is useful for industry’ crowd happy. then branch out from there to teach C and clojure. the C course could concentrate on what was not covered in java, like pointers, memory management and close to the metal numerics. the clojure course would then move on to cover the more spiritual dimension of comp-sci 🙂

  • […] Lisp and Smalltalk are dead: It’s C all the way down. […]

  • 49. gasstationwithoutpumps  |  September 12, 2010 at 12:07 am

    Coming to this dialog a year late, but …

    I agree with the need to teach many different styles of programming, which requires using different languages.

    Professionally, I use c++ and python, but these were by no means my first languages, and I am glad I learned languages that I would not choose to program in today (like Franz LISP).
    i never really liked programming in LISP or Smalltalk, but it was fun to play with the ideas and hit the limitations of the languages. (And they were quite limited in the early days, before they came with huge libraries.)

    I’ve been teaching my son to program, and he has gone through many programming languages. The ones he’s had the most practice with are Scratch, C, and Scheme, but he has also used Logo, NQC, Alice, Javascript, and various drag-and-drop Lego robotics languages. He is currently learning Python.

    I’ve decided to put off Java for another year or two, because I think it provides more of a barrier to learning than an aid. He won’t appreciate the need to declare complex types until he is writing programs complex enough to need that sort of compile-time checking.

    More at

  • […] students for what comes next.  This is particularly salient for me because, as of this semester, we no longer teach Smalltalk to students at Georgia Tech.  Lisp died from our curriculum about a dozen years ago.  Now, the required courses teach (in […]

  • […] As I’ve mentioned, when I first got here to Georgia Tech, we taught Lisp and Smalltalk in required courses.  We did that explicitly to show students that there were multiple ways of thinking about programming. Every student used multiple styles of programming.  I taught a computer music class using CSound and Squeak, and people were able to handle it.  But we don’t teach that expressive purpose for programming any more, and few departments do.  I’ve even heard faculty talk about their departments as being “a Java shop” or “a C++/C# shop,” as if students should get a union card for finishing their undergraduate apprenticeship. […]

  • 53. Antonio Salazar Cardozo  |  July 17, 2012 at 10:51 am

    I do find it interesting to come back to this post three years later with the interesting knowledge that Clojure as a language and ecosystem is rapidly growing, and therefore Lisp is (rather unexpectedly) gaining ground once more. Clojure also provides a fascinating opportunity to teach development for the web without having to teach JavaScript (thanks to ClojureScript).

    This was also posted a year after the iOS app store came into being, and since then that has also become a massive ecosystem. iOS apps being built on Objective-C, which of course fuses concepts from C and Smalltalk.

    It’ll be interesting to see what happens to the curriculum in response to these shifts and broadening bases of the languages used in practice.

    • 54. Stephan Wessels  |  July 22, 2012 at 1:02 pm

      iOS development (iPhone/iPad/iPod) is the hottest market out there for programming jobs. The core of all iOS, and Mac OS-X, is written using Objective-C. Yes I know that there’s C and C++ and assembler under the covers. But if you pick up any iPhone/iPad programming book from Apple, you program in Objective-C.

      As I recall, when Brad Cox created Objective-C it was to bring Smalltalk’s elegance to C. Here we are many years later and Georgia Tech drops Smalltalk in favor of teaching C/C++ because of applicability to the jobs market for graduates.

      Having worked side-by-side with programmers taught on the cascading-train-of-least-training-resistance provided by C, C++, then Java (each time trying to fix the issues with the previous iteration — well, at least they are iterating), I rarely see good Object Oriented design because objects are “tacked on”.

      I’d hope to see some effort to at least teach Smalltalk’s C-Cousin: Objective-C, which does have relevance in today’s job market.

      • 55. Mark Guzdial  |  July 22, 2012 at 1:17 pm

        Just to make clear, this post was written in August, 2009. I’m not sure why it got picked up now. It’s certainly not the case that Georgia Tech just decided to stop teaching Smalltalk. No, as far as I know, none of our classes teach Objective-C either.

        • 56. Stephan Wessels  |  July 22, 2012 at 11:02 pm

          Thanks for the clarification. I could tell it had happened at some time in the near-to-recent past and must have missed the actual date.

          I got into a similar discussion with a friend of mine that teaches at a technical college (where I also taught for a little while). The whole discussion revolved around the perception of why students choose one schools over another. The technical college in question saw their mission as more of what I would call a “Trade School”, not higher education. Perhaps I rush to judgement but it seems that Georgia Tech has the same focus.

          Seems to me if a college wants to teach useful trade skills in computer programming, they should be including Objective-C now. Smalltalk and Lisp are ways to think different about programming and provide their own value. For getting a job, if that’s what the schools is trying to promote, I’d teach Objective-C. Even Java education has little value to me if someone is seeking a job. The plain truth is that companies are outsourcing Java work to where the labor is cheap. Java work has become a bottom-dollar occupation.

          By the way Mark, we met way back at SqueakEnd. I still have both your Squeak books and pass them to friends wanting a good introductory book.

          • 57. Mark Guzdial  |  July 23, 2012 at 2:10 am

            Hi Stephan — I do remember! And I do appreciate your viewpoint. I share your concern and wish that languages focusing on broader ideas were still emphasized.

  • 58. Christer Assmundsson  |  July 26, 2012 at 2:36 am

    What is important is not WHAT students think, it’s THAT students think.

  • […] are well worth watching.  Bret is critiquing the same mindset I was reporting on when I said that Lisp and Smalltalk are now dead in undergraduate computer science.  ”We don’t know what we’re doing” is the most important phrase for […]

  • […] talk to a computer, and how should it help you express yourself? As I have complained previously, everything but C and C-like languages have disappeared from our undergraduate curriculum. Bret Victor has explored why we talked about expression in those earlier years. I have a different […]

  • […] But what if we took Andy Ko’s argument seriously?  What if we designed programming languages like we defined good user interfaces — working with specific users on their tasks?  Value would become more obvious.  It would be more easily adopted by a community.  The languages might not be anything that the existing software development community even likes — I’ve noted before that the LiveCoders seem to really like Lisp-like languages, and as we all know, Lisp is dead. […]

  • […] Bertrand Meyer is making a similar point to Andy Ko’s argument about programming languages.  Programming does matter, and the language we use also matters.  Meyer’s goes on to suggest that those saying that “code doesn’t matter” may be just rationalizing that they continue to live with antiquated languages.  It can’t be that the peak of human-computer programming interfaces was reached back in New Jer…. […]

  • […] think LiveCode, Smalltalk, and Lisp are all excellent pedagogical programming languages, but our teaching decisions in secondary and post-secondary CS education are rarely based on what […]


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Trackback this post  |  Subscribe to the comments via RSS Feed

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 10,184 other subscribers


Recent Posts

Blog Stats

  • 2,049,219 hits
August 2009

CS Teaching Tips

%d bloggers like this: