Simply Scheme: Introducing Computer Science (1999)
people.eecs.berkeley.edu
people.eecs.berkeley.edu
At my institution (Ohlone College in Fremont, California), we teach the intro courses in C++. However, for discrete math, a sophomore-level course, each instructor is allowed to choose the language. I chose Haskell the last time I taught the class, and I plan to use Haskell again, since I believe it’s a great vehicle for coding discrete math, plus I believe it’s a great thing teaching undergraduates functional programming early on.
I work closely with Northeastern CS students (via co-op program) and haven't heard anything but negative opinions about Racket.
I've seen more praise than criticism from employers.
I've seen more positive reflection than regrets from students.
(also true of Scheme based 6.001 and CS61A and HtDP)
This discussion at lobsters suggests the decision to change the curricula was political and business driven, not based on the merits of the "Fundies" course series:
https://lobste.rs/s/els8k7/northeastern_s_redesign_khoury
See also:
Northeastern's redesign of the CS curriculum (huntnewsnu.com)
162 points by nickmain on Jan 12, 2025 | hide | past | favorite | 185 comments(Or even - and I know this is a spicy take - assembly language. An intro-level course that takes students through games like TIS-100 and Human Resource Machine might have a lot of pedagogical value.)
What I’ve observed is that people who have had to spend some time working in a language that maintains a clean separation between functions and data tend to be better at domain modeling, which ultimately enables the to produce designs that are simpler and easier to maintain. OOP can be a powerful mechanism, but it seems like, perhaps ironically, people who only know OOP tend to have a harder time reasoning about information flow, control flow and state. Perhaps because object-oriented language features are mostly meant as a way to abstract over those concerns. Which does have some value, but maybe also discourages learners from thinking about them too deeply.
The issue is that "CS 110" gets used by a lot of STEM students in other departments that require computational methods and statistical tools, and that require you get to a CS course taught by actual computer scientists. I don't necessarily think that it's a bad thing that you'll need CS 101 before a higher-level biology elective that needs R!
Anyways, cool to see another alum here! I hope the department keeps it around for a while longer :)
I have a feeling we’ll have to revisit this topic in the next five years as college and university CS departments grapple with the implications of generative AI coding tools such as Claude Code, but that’s another story…
Yet despite this head start, the Turing machine formalism became the dominant framework for CS theory—complexity classes, computability, formal verification. Whether that's path dependence, historical accident, or something deeper about how humans reason about computation, I'm not sure.
But it does make me wonder: if the imperative, state-based model proved more tractable even for theorists, maybe FP's learning curve isn't purely about unfamiliarity. There might be something genuinely harder about reasoning in terms of pure functions and recursion vs. "do X, then Y, update Z."
Fully acknowledge this is handwavy—curious if others have thoughts.
See his talk at RacketCon a couple years ago:
#lang simply-schemeThe easiest way is to go to inside DrRacket and open the menu File > Package Manager and add "simply-scheme".
Or if you prefer the command line, something like
raco pkg install simply-shemeThe full PDF is available here: https://ia800200.us.archive.org/13/items/SimplyScheme/Simply...
EDIT: this might be it: https://people.eecs.berkeley.edu/~bh/ss.pdf
(saving to laptop and phone; perfect for passing time on a long haul flight)
Simply, for me it was a Rosetta Stone that put Lisp/Scheme concepts into ones that I already understood. Simple things like using “function” instead of “lambda” were Aha moments that lead to breakthroughs.
Super helpful for me.
Python has become a huge language over time, and it's really hard to make a syllabus which isn't full of simultaneous "you'll understand when you're older" concepts. OTOH students don't seem to mind it much and they do seem to learn to write code even with very shakey fundamentals.
When I’m helping them understand some subtle point about async/await, I sure do wish they had a semester’s worth of Scheme in their background so I could rely on them already having a crystal-clear understanding of what a continuation is.
Not sure I 100% believe that, but buy-in (and LLM help) are significant parts of a successful onboarding.
Because then you’re interacting with these things in a really concrete way rather than just talking abstractly about what’s going on inside the black box. And I’m fairly well convinced at this point that mechanisms like virtual method tables and single dispatch functions are the kind of thing where an hour or two just making one yourself will go a lot farther than many days’ worth of lectures. Perhaps even many years’ worth of hands-on experience.