hckrnws

I wonder if there are still undergraduate CS programs that use a functional programming language in the intro course? MIT switched away from SICP (Scheme) to Python back in the late 2000s, and Berkeley switched away from Scheme sometime afterwards. Shriram Krishnamurthi has heavily promoted Racket in education and continues to do so, but for introductory CS he has moved on to Pyret, which has Algol-like syntax as opposed to S-expressions and doesn’t require programmers to think in terms of functional programming; for example, Pyret has loops and mutable variables.

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.

There's an interesting historical angle here: Church's lambda calculus actually predates Turing machines by a few months (both 1936), and they're provably equivalent in computational power. Church even proved undecidability of the Entscheidungsproblem first, using lambda calculus.

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.

I don’t necessarily feel the need to ban loops and variables, but I do kind of wish schools didn’t start with object-oriented languages. My undergraduate program started with Scheme but I actually think a proper procedural language would be a fine choice too.

(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.

Or Shenzhen I/O - I tried to get my son into it for just this reason.

Grinnell College's (my alma mater) CS program first intro course is entirely in Racket. The program basically has three sequential intro courses: functional programming with Racket, imperative programming with C, and OOP with Java.

I wonder whether it's easier at small liberal arts colleges – my alma mater has a second-semester course teaching SML, Go, and PDP-11 assembler.

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!

Grinnell 17' here. At first I didn't enjoy intro with Racket. But by the end I changed my mind and it ended up being one of my favorite courses. In retrospect that class easily had the most impact on me during my CS major... I still have quite a few functional programming habits. These days I like to code in elixir for side projects, which has quite a few similarities.

Anyways, cool to see another alum here! I hope the department keeps it around for a while longer :)

UBC’s CPSC 110 uses Racket. It was built around How to Design Programs when I took it years ago, and at a glance I think it still is.

I know I am biased both by my education and my chosen path. My first computer class was pascal based,my second course was intel based assembler. These were both in community college. When I started my degree in Computer Engineering, the microprocessor course was essentially an assembly course using the Motorola 6800 chip. I was lucky that the main CS courses were taught using C, course work was compiled on Vax mainframes running some unix variant. I used Borland C/C++ 3.0 to do my homework, then would have to figure out what changed when I used the Vax compiler to turn in my work. I really think it is worthwhile to get an understanding of the low level workings of computing. Every now and then I see a nice article comparing different access times for disk, ROM, DRAM, cache which is also important to know for critical code. Embedded for Telecom, Medical,etc.

My school switched to C++ for intro stuff right before I enrolled, and egad, I still think it's a horrid choice. It required learning, or at least memorizing, a significant amount of boilerplate before a freshman could even start to consider writing their logic. I'd already written an awful lot of programs before I got there so it wasn't too awful for me to make the leap. I spent a lot of time helping my fellow students get over the massive speedbumps they faced so they could start learning.

C++ is not my favorite language, and if I had full control, I’d prefer a more beginner-friendly language. However, most of our students intend to transfer to a university. We have articulation agreements with universities defining what is transferable. Most undergraduate CS programs in California teach their intro courses in Python, Java, or C++; there’s even the rare intro courses taught in C. Some universities don’t care about the intro language from community college intro courses as long as those classes teach their same concepts of programming, but there are other universities that insist on particular languages. What’s nice about C++ is that it pleases most universities. If a student can grasp C++, then that student could easily learn Python or Java.

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…

Your discrete mathematics class has programming and is taught by the CS department? I can't say I have seen that. My Discrete mathematics class was taught in the Math department, no programming, and we had a few CS theory courses in the CS department which are basically Discrete++ but they were all sans programming.

We teach discrete structures as mostly a math class with problem sets, but we have some programming exercises to help “concretize” some of the more abstract portions of the class and to also provide motivation to students who want to see practical applications of discrete math.

At Brown university there are 3 intro courses you can choose from. Two use functional programming languages.

my high school still uses simply scheme and SICP for the fall semesters of its CS sequence I believe, but granted it's in an affluent city in the Bay and its recently retired teacher came from UCB

Northeastern held out for a long time, only switching away from Racket, despite the protest of students and professors alike, in the last year or two.

>...despite the protest of students...

I work closely with Northeastern CS students (via co-op program) and haven't heard anything but negative opinions about Racket.

I enjoyed my work with Scheme, having received my instruction in the early 2000s. I'm not a functional language or lisp language advocate in any way, and I don't even dislike Python for professional work, but I do regret that it is not taught anymore: Python's management of scopes is not as good for the instruction.

If anyone wants to try the flavour of Scheme used in the book, install Racket and use:

    #lang simply-scheme

Note that it doesn't get installed by default. You must download the package https://pkgs.racket-lang.org/package/simply-scheme

The 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-sheme

Cool, I just started using Racket this week, for prototyping an S-expression based DSL.

The full PDF is available here: https://ia800200.us.archive.org/13/items/SimplyScheme/Simply...

Love the site, but seems a shame not to link to the full (~460 page) pdf for offline perusal.

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)

The full PDF is available here: https://ia800200.us.archive.org/13/items/SimplyScheme/Simply...

Ah, Scheme was part of a programming language course, studying CS in ~ 1990. We students struggled to match all the parenthesis on our VT100 terminals. And to understand the intended purpose of the functions, which are not attached to modules or classes (without macro's)..

I have fond memories too, we used to follow "The little Schemer" for Scheme, but we had a PC lab running Windows.

“Simply Scheme” was a foundational work on my path to a parenthesta.

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.

I'm to understand this is meant to prepare new learners for SICP? Cool!

I'm currently teaching an introductory programming course in Python, and I definitely feel the allure to teach using a simpler language like Scheme.

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.

OTOH I work in Python and I’ve seen that recent graduates who were only taught Python and Java in school are often in for a nasty shock when they first encounter (for lack of a better term) real-world code.

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.

Indeed. It's hard to teach Python as it's idiomatically used in the wild. There's just so much stuff going on (iterators, generators, async, context managers, comprehensions, annotations etc etc), it takes a lot of study/experience to learn it all.

Yes, so the point is that teaching it at all is a choice of style not substance.

Not sure I 100% believe that, but buy-in (and LLM help) are significant parts of a successful onboarding.

There is at least something to be said for having spent a semester starting with a bare-bones but malleable language like Scheme, and then building up your own libraries to implement more advanced features like object-oriented programming and list comprehensions.

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.