Playing the Cards You’re Dealt: A Story of GT and HtDP

May 11, 2010 at 11:06 am 19 comments

A colleague of mine sent me a link to a piece written by Matthias Felleisen with his explanation for why Georgia Tech switched from his text How to Design Programs (HtDP).  Matthias is a visionary educator who is the winner of this year’s ACM Karlstrom Award for contributions to education, for which I congratulated him here.  I wrote a commentary on an article that they published last year in CACM, and I posted here Matthias’s response. I admire HtDP.  The story (as I know it) of why Georgia Tech moved away from HtDP connects to some themes that I want to talk about.

Georgia Tech taught using HtDP from 2000 (or thereabouts) through 2003 (when we started our MATLAB and Media Computation classes) until 2004 or 2005.  We used HtDP in the course that everyone on campus was supposed to take.  We moved away from HtDP for two reasons mostly: (1) Some majors (like all of the Colleges of Liberal Arts, Architecture, and Management) were failing the course at higher than 50% rates. (2) Engineering faculty, particularly, wanted us to teach something that could be used in their classes, and they weren’t willing to learn Scheme.  We had a cheating scandal that led to a Campus Task Force, which recommended that we abandon the one-size-fits-all strategy that we had used previously. (We already knew that were were going to have to abandon that strategy, and been planning on it.  The Task Force forced the issue.)  We developed the new courses after this decision was made. I had been playing with the idea of media in CS1 for awhile, including a Scheme-based version. This happened after our Founding Dean, Peter Freeman, left Georgia Tech, while Ellen Zegura was Interim Dean, and before Dean Rich DeMillo arrived.  The decision to build the new courses was Jim Foley’s, with encouragement from Kurt Eiselt, for which I’m grateful. (I told this story in the May 2009 CACM.)  We explored using Scheme and Squeak in our MediaComp class, but ended up going with Python (discussed in a 2005 SIGCSE paper).

In the original plans for the Media Computation course, I did think that we would reduce the cheating rate.  I was wrong.  Students cheat in computing courses, and Media Computation is no exception.  We did design the Media Computation course explicitly to be relevant, and Lauren Rich led an effort to interview women in the MediaComp course and in the HtDP course, to test whether we achieved that goal.  (I think that’s where the “making up lists of friends” comment came from.)

We did continue to use HtDP for the CS majors until Kurt Eiselt left for a better job at UBC (not fired). The decision to switch to Python made by lecturers who had taken an HtDP workshop, but probably were influenced by the new Dean who did not like Scheme in our intro course. Except for Kurt, I think that all the lecturers who took HtDP training are still here.  When David Smith wrote the MATLAB text for our Engineering CS1, he explicitly aimed to make it “HtDP in MATLAB.”  Today, we teach our CS majors using Python and the robotics approach developed by IPRE. People at Georgia Tech value HtDP, even if we don’t teach it.

For me, here is the critical part of the story.  When we switched from HtDP to Media Computation (for Liberal Arts, Architecture, and Management majors), the pass rate rose dramatically.  (I can’t claim that they learned the same — that’s what Allison Tew is trying to measure.)  When we switched from HtDP to MATLAB (for Engineering majors), the pass rate rose.  And when we switched from HtDP to Python (for CS majors), the pass rate rose again.

Why did that happen?

Lots of things might have influenced our outcomes, and I’m sure that many variables did.  I know that Kurt now feels that we didn’t implement HtDP correctly, and I am sure that he’s right.  What I’m interested in exploring here are the factors influencing the students’ decision to give up on a class or stick with it, which influences those pass rates.

At the end of their Senior year, our Computational Media majors write a long term paper about what they learned over their four years here and what they will carry with them into their career.  Of the 25-30 papers I graded this year, maybe 5-7 were wonderful and insightful.  Two common themes among the best of them: (1) They “got” Ian Bogost’s “Introduction to Computational Media” class for introducing them to different ways of thinking about programming. (2) They appreciated the course where they had to do team software development for the first time, using a language that they didn’t know previously (Smalltalk).

Then there are the rest.  The students who say that appreciate the course where they first used Maya or Adobe After Effects “because I’ll use that a lot in my career.”  My least favorite was the student who said that she most appreciated the “Digital Video Special Effects” course (a really tremendous course, BTW) because the instructor used a Macintosh, and the student only used Windows  Her great insight on the course was that the student was better off knowing how to use a Mac. We are giving Computational Media degrees to students who find the point of a class is to learn to use a Macintosh. These students talked about Smalltalk differently: as something that wasn’t used by anyone and was frustrating.

The one that has me thinking the most talked about CS1315, the Introduction to Media Computation class.  She said that she felt it was useful, led to skills that could be used in future classes.  She felt it gave her insight into how other applications she used worked.  But she also felt that learning “Jython” was a waste of time, because she’s never used it in another class.

On the one hand: Yay!  She totally gets the course and why we do it!  It’s that last part that I have been thinking about.  Jython is Python. Learning Python is useless knowledge for a Computational Media major?  This is the only essay that mentioned Python or Jython.

When I told this story to my colleague, Amy Bruckman, she said that we should really have these students write these essays five years later.  She’s right, of course.  The Seniors really have little idea what’s going to be useful to them later on in their career.

The problem is that students are making decisions now based on what they believe is going to be important to them.  Thus, students abandon classes that they perceive as being irrelevant to them.  When we switched from Scheme to something else, students stuck with the classes and didn’t give up.

Is this a Georgia Tech phenomenon?  Georgia Tech has had a vocational flavor since its creation, often being referred to as “The North Avenue Trade School.”  Maybe our students are particularly attuned to relevance in their future life.  Maybe students at MIT or Harvard are more willing to trust their faculty and pursue classes that will be useful to them, even if the students don’t see the value or relevance.

I think the pursuit of relevance is common today.  The rhetoric of College has changed.  Did you read about President Obama’s Commencement Speech at Hampton College this last weekend?

For much of the 20th century, a high school diploma was a ticket to a solid middle class life. That is no longer the case. Jobs today often require at least a bachelor’s degree, and that degree is even more important in tough times like these. In fact, the unemployment rate for folks who’ve never gone to college is over twice as high as it is for folks with a college degree or more.

Students seek a bachelor’s degree for a job and a middle class life.  That’s why the President is telling them to go to college.  If students perceive that the courses don’t lead to that goal, they will seek other classes.  Yes, it’s short-sighted.  Yes, they don’t know what they need to know.  But those are the students we have, these are the cards we are dealt, and that’s what American leaders are sending us.  We have to make the case for relevancy, because students have choices. They do need their bachelor’s degree, and we are preparing them for successful careers. But our job is harder now, because we have to make the case.

Entry filed under: Uncategorized. Tags: , , , .

Seeking National Lab Day Volunteers Preparing for Today and for the Future in Qatar

19 Comments Add your own

  • 1. Alfred Thompson  |  May 11, 2010 at 12:50 pm

    I agree with asking students 5 years later. I remember that after I graduated university I was asked which courses were the most useful to me. I changed my answer every couple of years. The more I did the more I appreciated different things in my education. That is the value of a broad education beyond a narrowly focused short term goal education.

  • 2. Alan Kay  |  May 11, 2010 at 12:52 pm

    Central questions here are along the following lines.

    Suppose you have a calculus course that less than half the students pass. Is it a good one wrt the content? the pedagogy? no better one that preserves the content can be readily imagined?

    If yes, yes and yes, then flunk the students. If a better approach can be devised that preserves the content, then make that work.

    From the peanut gallery here, I’d say that Felleisen’s approach is “not the best approach” (though quite a bit better than most). And that a better one that has even more of the important content in a useful form for students could be devised.

    It’s quite possible that more than 50% of the students would flunk the better course, and it’s important to see whether that is the case.



    • 3. Mark Guzdial  |  May 11, 2010 at 1:21 pm

      Hi Alan,

      I disagree. Not everyone needs or wants the same content. If I have a calculus course that has less content than a Mathematics major needs, but provides insight to that bottom half of the students, then I teach that calculus course. There isn’t only one threshold for everyone. I’m not willing to write off the 50% of the students who would flunk the better (covers more of the important content) course. We should offer the better course, and encourage students to take that. For those who can’t succeed there, I want to offer a course that facilitates their understanding which they can succeed at.


      • 4. Alan Kay  |  May 13, 2010 at 10:18 am

        Hi Mark,

        I’ve been trying to think of good reply to this and haven’t come up with one (this is not it).

        I would say that in the case of a first course for all CS (or math) majors (do they really know enough to declare a major in their first year?) my comments would still hold.

        As to the other case of trying to find a course for non-majors that has appropriate content … I’m still pondering this one.

        In both the calculus and the computing fields, I think the deep content is what is most important, and so I would try to teach this for both groups of students (maybe differently). But the level and amount of detail could easily be very different for the two kinds of courses.

        And, there is also a question of what kinds of fluency the students bring into the course. My (limited) experience here is that the diversity of fluency is pretty wide for both groups, and can have some overlap.

        I don’t think it is worth teaching a course for non-majors that is not about the deep stuff. So I like Jerome Bruner’s idea that “you can teach any subject to any person at any age in an intellectually honest fashion if you are willing to base your pedagogy on their level of development”.

        This would imply that you might have to do a lot of work for the non-majors to get them to understand some of the most important things in computing (or calculus) — and some of these things seem not to be taught to computing majors either, judging by their approach to computing after they get their degrees (I think mathematics departments are still a lot tougher on their majors than CS departments).



        • 5. Mark Guzdial  |  May 13, 2010 at 12:24 pm

          Hi Alan,

          I struggle with the same issues when I work on non-majors classes: Of wanting to get to the deep-content, of the wide variance in previous background and fluency. If we include K-12 classes (where the vast majority of the students will not go on into CS), then most of the interesting and challenging issues in computing education are for the non-majors.

          I agree that first year is too early to declare a major. At Georgia Tech (and most Engineering schools, I think), students have to declare their major even earlier, at time of application. That’s a real hindrance for us trying to draw students into CS through engaging first courses.

          Another issue that we deal with in non-majors courses is time. It does take a lot of work to get to the important ideas in CS, but we still only have our 3 contact hours per week and 15 hours of homework time per week. How do we use those most efficiently to get students to grapple with the important stuff? That’s where I’ve been spending my effort lately — how do we allocate our scarce resource, time, in order to maximize learning?


    • 6. Tucker Balch  |  May 11, 2010 at 11:24 pm

      One aspect of this discussion that people sometimes miss, is that we’re talking about a CS-1 “for all” versus a CS-1 for majors. At Georgia Tech we teach an intro CS course to all majors on campus. These are indeed smart kids, and we felt the 50% failure rate we were seeing had more to do with the course than the students.


  • 7. Mike Lutz  |  May 11, 2010 at 8:41 pm

    I teach at RIT, another school denigrated as vocational, with all the associated stereotypes. Might I suggest something that quells the demand for “relevance” among most of our students? That something is required cooperative education.

    In our world, every graduating student must complete at least 40 weeks of paid industrial co-op in, interleaving work and study during the upper-division years. I cannot overstate how different (and exciting) classes are with juniors and seniors having even a modicum of experience vs. classes with freshman and sophomores accepting everything on faith. Not the least of these differences is a recognition of the need for breadth and depth in computing concepts and technologies.

    Indeed, our undergraduate student software engineering group holds biweekly, student-led talks on a variety of topics, from concurrent functional languages (think Erlang), through distributed version control and continuous integration, to new technology such as CourchDB. In general, conversations with these students is similar to those with savvy developers after a couple of years experience.

    I know Georgia Tech has co-op, but it’s voluntary and, as far as I can tell, restricted to the cream of the crop. Perhaps this should be reconsidered as a way to broaden student perspectives?

    • 8. Mark Guzdial  |  May 12, 2010 at 7:45 pm

      Hi Mike,

      I agree that a co-op experience is a terrific thing. I worked through undergrad, including two summer internships, and it literally changed my life.

      I’m not sure that the work experience is relevant to the issues I’m raising here. CS1 is taken in the 1st or 2nd year, typically. Students wouldn’t have had co-op experiences before then to give them insight into relevance (or not) of CS1. I’m also talking about Liberal Arts, Architecture, and Management majors here, who would have internships in their field, not in Computer Science (which is a general-education requirement for them). A co-op experience would probably not inform them about what’s relevant in computer science. Thus, it’s unclear that a co-op program at GT would help students to realize that a Scheme-based CS1 is helping them learning computer science generally, not any job skill specifically.

  • 9. Ajai Karthikeyan  |  May 11, 2010 at 11:21 pm

    Mark, you know who I am. For everyone else, I am currently a Senior CS major at Tech.

    A very insightful post about what the mindset of our professors was when they create our coursework. A student’s opinion/reply follows;-)

    A couple things I want to point out:

    “They appreciated the course where they had to do team software development for the first time, using a language that they didn’t know previously (Smalltalk).”

    Having taken this class and with the input of a lot of my peers, I can say that most of us despise Smalltalk (more so the IDE visualworks that we use actually). One of the most valuable things we learn from this class is the “TEAM software development” aspect of the class and not the “new language” aspect of it (though this might be considered the bias of a CS major). I will also like to point out that not all students in the teams for the Smalltalk class work on all aspects of the class. I have know teams where the CM major in the team took care of all the documentation while the CS majors focused on the code. I know more than one team with only CM majors that has suffered in the class. The main reason most of the grades in the class are high is because of the structure of the class where students are allowed the opportunity to have EVERY group milestone regraded at a later date. FYI, I made a high B i the class (not complaining cause I messed it up 😉

    “The Seniors really have little idea what’s going to be useful to them later on in their career.”

    I disagree. A majority of Georgia Tech students have work experience by the time they are serious. We have a very good internship program and our co-op program is the largest voluntary one in the US. Most of them have been in situations where they have come to know what they need while employed.

    “…students abandon classes that they perceive as being irrelevant to them.”

    I will start off by saying that sometimes, the most unexpected of classes help us. An example would be Steve Jobs pointing out the influence of a calligraphy class he audited after dropping out on the development of the Macintosh. I will agree that the biggest motivator for me in a class is seeing a practical use for the class in my life (my life, not my career). Many classes that tend to lose students interests are those where professors tend to not communicate this relevance to the students. There obviously exists a purpose! But it might help to have the students know what it is.

    Also, not all students will have the same need for some of our required class. I personally have a really big problem getting through Calculus 3, not because of me being bad at Math (other than this class a Majority of my math grades are As). How is me knowing linear algebra going to help me? I can agree for certain threads that deal with computation but how would this affect a student focusing on the People thread? I personally am a Dual Major between CS and Management (management does not require calculus 3) and so, my apparent need for this class is even less so from my point of view.

    I am of the mindset that a college education in computing doesn’t teach you programing languages but what you learn is a way of thinking. I personally like to call this the computing/engineering mindset.

    • 10. Tucker Balch  |  May 11, 2010 at 11:31 pm


      Regarding “seniors have no idea what will be useful.”

      I’ll bet that comment arose from Mark’s own life experience: Discovering later the value of a course he didn’t appreciate at the time. I know I’ve had that experience myself several times. Probability and Statistics comes to mind.


  • 11. Matthias Felleisen  |  May 12, 2010 at 1:39 pm

    Mark and everyone:

    I taught (and developed) the HtDP curriculum at Rice (a top-tier CS
    department) for eight years, and for the past seven years, I have
    synthesized it with the curriculum at Northeastern University.

    Northeastern is a co-op university. Students are required to work at three
    co-ops for six months each during their five years here. The employers
    report back to our co-op faculty who collect a portfolio on each student.
    These students know what’s practical, they know what works, they know
    what’s relevant.

    What they also know is that Northeastern taught a standard curriculum for the two decades prior to HtDP: three terms of the currently fashionable language (Pascal, C++, Java); extremely graphics rich; intertwined with lessons on practical applications. It didn’t work. Only around one third of the students got programming co-ops with the extremely demanding employers that work with NEU.

    After running HtDP for a couple of years, the ratio of programming on the
    first co-op went up to two thirds and higher. After another few years, our
    co-op employers started complaining that our MS students were worse
    programmers than our third-year undergraduates (on their second
    co-op). When these complaints got really bad, the graduate dean asked me whether I could condense the three-semester HtDP curriculum into a one-semester “boot camp” for MS students.

    Northeastern isn’t the only place where HtDP is interpreted for its
    context. It is taught at technical institutes (e.g., WPI); at large public
    universities with a science bend (e.g., UBC);
    at small private places (e.g., Chicago);
    at liberal arts schools (e.g., Vassar);
    at industrial bootcamp courses for newbies;
    at the high school level;
    at the middle school level;
    by private, public, and stay-home programs.
    And it is almost always successful beyond expectations.

    I am sure one “could do better”. And that’s why we continue to work on HtDP and related subjects.

    • 12. Mark Guzdial  |  May 12, 2010 at 7:56 pm

      Hi Matthias! Thanks for responding and engaging.

      I have a meta-level question about the results you describe here about the wide range of places where HtDP has been successful. I wrote a blog article a while ago ( about places that had tried Media Computation, then given up on it for reasons that have nothing to do with learning. One of the things that I’ve been thinking about lately is what research on curriculum really tells us.

      So that’s my question to you: What does your long list of successes with HtDP tell you? That HtDP can be effective? That it always will be effective? If the second, is that success guaranteed despite underprepared or undermotivated teachers, goals that vary from teaching computer science (e.g., to teach the latest and greatest production tool or IDE), or underprepared students? That last question is obviously rhetorical — no curriculum, no matter how high-quality, can guarantee results if the teacher, learning goals, or students are against it. Then what’s the next step in the research? To identify the boundary conditions, when the approach is successful, and when it’s not?

      More concretely, what do you hope to achieve with the second (or third, or subsequent) editions of HtDP? In what ways does a successful curricular approach get better? For example: to cover more content, to be clearer, or to engage a wider variety of students?


  • 13. Matthias Felleisen  |  May 13, 2010 at 10:46 am

    A curriculum focused on applicability will die with even the slightest
    hick-up in the classroom and change in current fashion. I don’t have time
    to read your columns, but here are my reflections on the revision process
    of HtDP.

    HtDP is about principles of program design as opposed to learning
    programming from lots of examples via variation. Our JFP
    on this idea spells out the details in comparison with MIT’s
    SICP. I am sure your readers can use the article to compare the HtDP
    approach with their favorite curriculum.

    In HtDP, program design principles are expressed via design recipes, which
    address two essential dimensions of program design: process and data
    representation (atomic, structured, union, “inductive”, arrow). The latter
    chapters demonstrate how to extend the ideas to stronger forms and to
    stateful data. For the OOP fans out there: while design recipes are our
    distillation of 50 years of FP theory, it is wonderful to see that design
    recipes and OO design patterns, derived from practice, arrive at the same
    points. I will claim, however, that design recipes are more systematic than

    Deploying HtDP has demonstrated that there are different ways to express
    and teach the process elements. For example, one of the intermediate steps
    demands a leap from a template to a full expression; we now teach how to
    organize the examples in a table and to use this table for inspiration. So
    one focus of the revision is to improve this aspect of the presentation of
    the design recipes.

    Like all other curricula, HtDP must also address the “fun factor” of
    teaching. In the past we have focused on “intellectual fun”, not unlike
    SICP. The next edition–in process since 2003–will use a functional
    approach to graphical animations, interactive games, and distributed
    concurrent programming.

    It is because of this switch that we can teach middle school kids in
    nine-week after-school courses. And these kids are from inner city
    districts such as East Palo Alto or Harlem or Dorchester. One of their
    first programs make cars drive across the screen or simulate a rocket
    lift-off. What these kids don’t know, and what we tell them only at the
    end, is that their programs are written in plain old pre-algebra (with a
    better syntax). But you should see the effect it has on their attention and
    grades in math courses.

    Of course, these fun experiences encouraged us to integrate as much as
    possible into the revised book, languages/libraries, and IDE— the three
    essential component of our curriculum.

  • […] particular, this anecdote about what female students are looking for relates to my point in “Playing the Cards You’re Dealt” — students are looking for relevance, even if they themselves don’t know where […]

  • 17. Alan Kay  |  May 15, 2010 at 9:55 am

    To Mark (May 13th, currently number 5 here).

    One of the best examples I’ve seen of making curricula of a deep subject work for a non-pro audience without diluting the important principles, was Jerome Bruner’s Man A Course Of Study, a brilliant effort in the 60s to find how to teach the important ideas of cultural anthropology to 5th and 6th graders.

    Jerry and others have written extensively about how they went about this, and many of the preliminary and intermediate ponderings are available as essays and chapters in books.

    I think we really need to see what this would mean for computing — both in the light of what computing thinks it knows today, but what it is likely to find out tomorrow. I think it should be done (first at least) without worrying about all the side-conditions that bedevil thinking about this in high school and university.

    I think identifying the content (and some of the concrete examples) is quite a bit easier than understand both sequencing and (especially) the durations and latencies required.

    Seems very important to do this.



  • 18. Mark Miller  |  May 15, 2010 at 9:50 pm

    “Engineering faculty, particularly, wanted us to teach something that could be used in their classes, and they weren’t willing to learn Scheme.”

    When I was taking CS in the late 80s at a basically no-name state university, engineering students were learning Scheme. In fact it was the only language the College of Engineering taught at the time. I talked to a friend who was an ME major at the time. He found it hard to deal with but doable.

    Now that I think about it, I don’t know if things have changed in engineering schools, but at the time the College of Engineering where I went to school was not squeamish about 50% or higher failure rates. It was fairly common for engineering majors to fail a class or two and have to retake it, or reconsider their major.

    Maybe the reason you’ve heard this objection is because engineering colleges have moved towards modeling systems that focus more on classical algebra, such as MATLAB?

    What I’ve found ironic years later is that CS majors at my school were not given an emphasis in Scheme at all. I’d say I got exposure to FP, using Lisp and SML, for a grand total of about a month while I got my undergrad degree. The whole time we were told, “These are research languages, and you won’t be using them out in the work world,” which did lead me to wonder, “Then why are we learning them?” There didn’t seem to be a point to showing them to us (none were articulated), beyond just exposing us to different ideas. It didn’t help that most of the “research languages” ran slowly on the hardware we had at the time. That only reinforced the notion of “impracticality” in using them. Nonetheless there was something about them that interested me, even though I sometimes found them hard to understand.

    I remember REALLY struggling with Lisp when I was first introduced to it as an undergrad, but I largely chalk that up to having a bad teacher. When I had the opportunity to learn from a good teacher about FP, in a senior level course on programming languages, it made more sense to me.

    I think the main thing that interested me in these languages at first were the problems that were posed in association with them. In the other languages like Pascal, C, or assembly we were asked to write programs that did some calculation, translated something from one form into another, or maintained a data structure. When I was learning Lisp, were asked to solve the n-queens problem, or do symbolic differentiation (and to simplify the algebraic result). They were at a higher level of problem solving. When I learned Smalltalk we were tasked with a simple problem, the Prime Sieve, but we were taught a unique method for solving it, using objects as “little machines” that did one or two things relative to what they were and what their purpose was. It felt like I was dealing with a living organism which “grew” according to internal processes that were isolated in “cells”. To me that was a very intriguing idea! Also, in Smalltalk we were asked to build a program that would analyze a context-free grammar. The problem in itself wasn’t that interesting. The interesting part was realizing that I was building my own domain-specific language for specifying a grammar.

    Looking back on it now, I think this is the level I always wanted to work at. I wanted to work with these kinds of problems, not the make-work stuff they had us do by and large to earn our degrees. It was the stuff that was emphasized the least. Maybe I would’ve found the lower level stuff more interesting if we had had more interesting computing models to work with. Or maybe that would’ve been beyond me.

    I had a lot of preconceived notions about what computers were and what programming was when I entered college, and I think that was a good part of what made learning FP and stuff hard. I was reflecting on this recently, that FP felt so foreign to me at first that it was impossible for me to complete my Lisp assignments. Just the idea that programs could be made up of symbols inside of lists was a bridge too far at first. I was much more familiar with notions that were typical of most of the machines that were commercially available: that programs were made up of a fixed set of instructions that the machine understood (opcodes), and that everything that we thought was symbolic was really a bunch of binary numbers, stored at addresses, which were unique, fixed locations in physical memory. I didn’t have the notion at all that “the job of computers is to execute our programs,” as Dijkstra described it, meaning, “It’s the job of the computer to execute (or simulate) whatever model we want to give it.” Using your phrase, I thought, “This is what a computer is,” and we just have to “deal with the hand we are dealt.” That view only changed in my course on programming languages, because I got to experience some more beautiful models. I wanted more, but I didn’t see any more offered, either in school or out in the work world. This actually felt a bit sad to me at the time.

    Maybe the situation has changed, but as far as my experience is concerned, my view of what I learned as valuable from my CS education would not have changed 5 years after graduation. By then I had found a job, and was working in professional development, and that would’ve been my reference point. I would’ve said the most valuable courses were: Data Structures, basic notions of what stacks and heaps were (probably learned in Computer Architecture), Discrete Structures (for its notions of set theory–useful when dealing with relational databases), notions of optimal algorithms from a course called Fundamentals of Computer Science, and then Compilers. These courses stood me in good stead in my software development work for 7 years. What I’ve been more thankful for in the last 4 years (this is 13 years on from when I graduated) is the little bit of exposure I got to those “research languages”, because I’ve realized there’s some really beautiful stuff that can be done with them that just wouldn’t be realized as well in the languages that most undergrads take to be the “worthy” languages.

    The first experience that began to change my mind about what I thought I knew was Paul Graham’s article “Beating the Averages”, which I’m sure you’re already familiar with. This ran totally contrary to what my CS professors told me: “All languages are basically the same. It’s just a matter of taste”, and “These languages are not used in the work world”. Graham’s thesis was, “No, language does matter,” though I realize now what he should’ve said was, “System architecture matters.” What was great about Graham’s article is he kind of spoke my language, from a set of priorities I could recognize as “relevant” at the time: “Hey, this made this guy competitive.” It challenged my notions of what was worth learning. I also remember he used a quote from Eric Raymond, which basically said, “Learning Lisp is valuable, because the experience of using it, and what you will be able to learn with it will make you a better programmer, even if you never use it again.” The same could be said for Scheme, I’m sure.

    Like I said, this is a starting point. It’s not the end point. I don’t mean to say that any particular language is “the bees knees”. My suggestions are often based in the gratefulness that I’ve had that I was able to find “bridges” from my old notions of computing to what I’m able to understand now, which is not married to any particular language. But I think with most students, one would have to start with a language focus as an intermediate step, because that’s where most students who have some notions about programming are at.

    I recognize I come from a “different upbringing” with respect to computers than your students. I agree with Alan Kay’s comment that it’s important to find ways to provide intermediate steps that students can take if they’re struggling, so that they can realize the important ideas. A good part of that I think is helping them realize that this IS worth it in some way that they can relate to, to motivate them to want to learn. For me it took challenging what I thought was worth learning from the POV of what was relevant to me, not challenging what I thought was relevant. I had commercial aspirations at first like a lot of your students in relation to what I was learning. “Finding the scientist” in them that sees the ideas as beautiful and having their own merit is a different challenge. That’s more complicated than showing them a few examples. Finding something that’s fun and experimental at the same time might be a start.

  • […] not all students, and I’m sure that different schools have different cultures (e.g., Georgia Tech tends to have a practical/pragmatic culture).  But it’s probably worthwhile asking the non-major students what they’re interested […]


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 )

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,185 other subscribers


Recent Posts

Blog Stats

  • 2,060,309 hits
May 2010

CS Teaching Tips

%d bloggers like this: