Hacker News

Ive broken my hand punching a wall, its not nice :/. Also I hated scheme in first year uni, my brain just did not get the pattern matching required... Australian uni's probably just copied the syllabus from US ones at that time.

"it was all data/signal flow and intercoupled and layered differential equations from sensors to actuators anyways."

And the you need a pure CS dude like me to turn that into readable, maintainable, efficient code.

(I work with these guys who just see the differential equations... Leave them a few years on their own and they produce a huge pile of code and then wonder why none of the students use it :-)

(it's just my own experience, and although I'm a bit cynical here, I like that job and these guys a lot, we learn a lot from each other)

Wow, no idea highlights existed. Glad you used this opportunity to …uhh… highlight it via this great post.

I was at MIT just before this switch, and treasure having gotten to take these deep dive courses, even if .002 and .003 kicked my ass.

6.004 (followed up by 6.033) is probably the course that really drove my career into systems dev.

Neat. Is there any way to search the highlights?

("What are the most noteworthy things that have been said on HN about ...?" "I remember reading an excellent comment that had something to do with ..., but all I can remember is that it used the word ..." "Do I have any comments in the highlights?")

Would love an RSS feed.

Not OP but in general sourcing software and hardware radios in that time was very difficult. There weren’t good open-source implementations and everything had to be sorta reverse engineered which meant that anyone with the skill to do that was selling it for a lot of dollars.

Source: did 10 years in telecom land.

I'm a bit disappointed by some of the responses you received and that you were apparently downvoted.

Here's some text from Chapter 1 of the book that might make this clearer:

> Procedures, as introduced above, are much like ordinary mathematical functions. They specify a value that is determined by one or more parameters. But there is an important difference between mathematical functions and computer procedures. Procedures must be effective.

> As a case in point, consider the problem of computing square roots. We can define the square-root function as √x = the y such that y≥0 and y^2 = x .

> This describes a perfectly legitimate mathematical function. We could use it to recognize whether one number is the square root of another, or to derive facts about square roots in general. On the other hand, the definition does not describe a procedure. Indeed, it tells us almost nothing about how to actually find the square root of a given number. It will not help matters to rephrase this definition in pseudo-Lisp:

    (define (sqrt x)
      (the y (and (>= y 0)
        (= (square y) x))))

> The contrast between function and procedure is a reflection of the general distinction between describing properties of things and describing how to do things, or, as it is sometimes referred to, the distinction between declarative knowledge and imperative knowledge. In mathematics we are usually concerned with declarative (what is) descriptions, whereas in computer science we are usually concerned with imperative (how to) descriptions.

[There's more after this, but it is off-topic for our purposes.] IMHO you're not wrong and you shouldn't've been downvoted. I think there's just an issue with semantic drift and evolving terminology and map-is-not-the-territory and so forth going on.

You're absolutely right that "procedural", at least as I understand the word in 2025, is a poor label for 6.001.

6.001 taught 'define' and 'let' but didn't teach 'set!' until week 6 or so. So we learned functions, variables, scopes, recursion, lambdas, strings, numbers, symbols, lists, map, filter, flatten, and more - all without ever modifying a variable. That's very "functional".

Once we learned that it was possible modify existing variables, we learned object-oriented programming; objects were just lambdas with closures that took messages indicating which function to call. We then learned a fake assembly language written in scheme that had both an interpreter and a compiler, also written in scheme. While "procedural" feels wrong, I'm not sure what label one could apply to all this...

SICP is fundamentally about the notion that programs are primarily a means of communication between people, being written by people for other people to read, and only secondarily a thing for computers to execute. And it really opened my eyes to the landscape of programming paradigms that exist—indeed, it continues to do so!

But your comment is completely off-base.

In Circuits and Electronics, as I understand it, the "structures" being discussed are circuit schematics, things like this keyboard I designed last month https://tinyurl.com/23tdsm4c. While SICP does talk about circuit schematics, I don't think anyone would claim that S-expressions are a reasonable alternative way for people to read and write such things.

You're completely confused about Signals and Systems, because you said "functionality", a word which refers to the kind of "functional" a machine might be. In that context, saying that something is "functional" means that it works. But the "functional" that describes Signals and Systems is the mathematical idea of a "function", which is a not-necessarily-computable relation of each possible input to one (possibly not distinct) output. The kinds of "functions" we're talking in S&S are the kinds of functions where you can take the Laplace transform or plot the frequency and phase response. It isn't about functionality at all!

While S-expressions are perfectly capable of expressing ideas like these, and indeed SICM investigates those possibilities in much more detail, SICM hadn't been written yet, and SICP and 6.001 touch on them only briefly. Following SICM I think even its authors were doubtful about whether Scheme was a good medium for working with those ideas.

I don't know anything about Computation Structures, so I can't really say anything about it. Maybe you're right that it would fit perfectly well into 6.001. Apparently it survived the purge; https://ocw.mit.edu/courses/6-004-computation-structures-spr... says:

> This course introduces architecture of digital systems, emphasizing structural principles common to a wide range of technologies. It covers the topics including multilevel implementation strategies, definition of new primitives (e.g., gates, instructions, procedures, processes) and their mechanization using lower-level elements. It also includes analysis of potential concurrency, precedence constraints and performance measures, pipelined and multidimensional systems, instruction set design issues and architectural support for contemporary software structures.

I think the solution is to have, as is the case in math/physics, an honors intro CS sequence compared to the regular intro CS class. The latter would be the recommendation for all non-CS majors, and the former would be for CS majors. I've always thought that those who are focusing on more vocational training should not be in what is called the CS program, maybe there are other majors called "software development" or "data science" or the like. Undeniably most prospective CS students are not aiming to go into academia, but we shouldn't adapt to this majority and then leave behind those who do want to do more academic things.

My background is in physics, where this sort of dual-track curriculum is well-established, and the physics taught to physics majors is very different from that taught to engineers. Unfortunately the difference is often boiled down to rigor or difficulty (and this will be reinforced if it's physics professors that have to teach both of the tracks), but in reality it is a value-neutral split which is based on pragmatism. CS should have one too.

The only point I really have an issue with is #2, where the focus seems to be on “weeding out” students as a sign of rigor. I would much prefer that some kind of pedagogical motivation replace this point.

Edit: I take that back.

> Once you learn Scheme, well now you've learned Scheme.

(Not from SICP but How to Design Programs): The claim is that you’ve learned how to THINK about programming. You understand how to organize and test your code so you can make a larger project.

I think the dismissal of a Scheme-like language as a dead end is shallow, and includes a large assumption about the (lack of an) ecosystem of the language. I think saying more will turn this into a rant.

help motivate undergrads to learn about computation. Once you learn Scheme, well now you've learned Scheme. But at the time if you had learned Python you could then use something like Python's system and socket APIs to play around with the lab or personal Linux systems

that's a good point actually. i had scheme, modula and others i don't remember in my undergrad classes. i remember almost nothing from that time. but at the same time i met some students running an LPmud, where i learned LPC, and then i discovered roxen and pike (which is based on LPC) which i used in all my volunteer and fun programming work. in other words all my motivation for learning stuff came from the outside.

>Once you learn Scheme, well now you've learned Scheme.

There is something really joyful in learning a new language and then implementing a well-known protocol, like HTTP, in that language. You can pick either the agent or server side, and check your work with other well-known agents and servers. In my experience this tends to happen when students like the language they've just learned, regardless of the direction their given by staff. In fact, I'd almost consider it definitional of what it means to like a language - that you'd consider implementing a well-known protocol in it in your free time.

I think he meant software engineering.

> You could probably define a Baby Python subset of the language that's just as simple and rigorously defined as Scheme and teach that

Pyret https://pyret.org/ started out with more or less that ambition I think. IIRC its author had previously tried to work with Python (and its dev team) but gave up.

Python was invented as a language for newbies. It's come a long way!

https://en.wikipedia.org/wiki/History_of_Python#Version_1

> During Van Rossum's stay at CNRI, he launched the Computer Programming for Everybody (CP4E) initiative, intending to make programming more accessible to more people, with a basic "literacy" in programming languages, similar to the basic English literacy and mathematics skills required by most employers. Python served a central role in this: because of its focus on clean syntax, it was already suitable, and CP4E's goals bore similarities to its predecessor, ABC.

https://en.wikipedia.org/wiki/ABC_(programming_language)

> It is intended for teaching or prototyping

I always found this to be a shortsighted complaint. Getting exposed to languages where computation models are clear gives you an excellent background to switch to the language du jour and become a master. Going through e.g. HtDP or CTM makes it easy to transition to Python and write excellent code, whereas traversing the opposite path is going to be tough.

There were plenty of less rarefied CS departments that were concerned about this, and they taught C, C++, or Java in their introductory classes.

Ultimately, it doesn't matter. It's your first language, not your last.

I think someone who learns computer science well from the theoretical side can pick up a new language quickly. After all, if it's turing complete, it's turing complete, they're all the same at that level.

Problems creep in when the person doesn't learn CS well, chooses an approach that is deeply reliant on overly complex/opaque libraries without good documentation, or the like.

To be fair, if you learn computer science well enough to thoroughly understand Scheme, I don't think it'll take more than a few weeks during the summer to learn Python.

indeed. The problem with being expose do to something so much more clean/elegant/powerful than the languages employers are using is that you no longer want to do it. It's like having tasted good whisky. You no longer think Jack's acceptable.

These days, employers more or less get what they wanted. We're doomed.

I'm not so sure someone who's good with Scheme will be bad with Python or Java.

On the contrary, I suspect that such a person is likely to be better suited to build software in either of the latter two.

I also suspect that Python is not a particularly good first language for someone who aims for a professional career building software.

I always found scheme to be a clean slate where no one’s high school experience benefited them in the first year.

My program did Java for the second course, which was very popular in industry and I loathed it.

I do think Python is not so bad to standardize on because it’s stood the test of time and is one of the most popular ways to write code for many disciplines and has applications outside of computer science so it helps everyone that takes the cs requirement even if they aren’t a cs major.

What im saying is Python can even serve as a better version of spreadsheets for folks that aren’t cs.

That's kind of a useless argument. Universities often also don't teach people any web development. In many cases a graduating student has never worked on any real project. If the university's idea is, that the student can learn those things in their free time, then surely asking someone to learn a little bit of Python or another language is not too big an ask either. So which one is it? Learn that stuff at home on your own time, or university should teach it, because it is needed on the job? Then what other things are they not teaching that is used on the job?

> I'd argue that SML (or derivative thereof) would make for a better teaching language, for both the lambda calculus aspect and the type theory aspect.

https://news.ycombinator.com/item?id=13098598

A critique along those lines which suggests KRC and Miranda which are in the same vein as SML.

I attribute the curriculum shift to something slightly different, which is the changing perception of CS as a career.

When I was in college in the late 1980s, CS was not perceived as the moneymaking career it is today. Accordingly the kids who went into CS were typically the nerds and hackers who truly loved the field.

Many kids now perceive CS as a safe, lucrative career option akin to becoming a doctor or lawyer. It attracts many students who are smart but perhaps not as intrinsically excited about the field. The universities adjusted their curricula to what these students care about: Less beautiful theory, and more practical training.

A similar thing happened in statistics. At one time it was hardcore stats nerds. Now "data science" has brought a ton more people into the field and the teaching methods have changed dramatically.

I suspect you might be observing two correlates and picking one as the cause of the other in a way that is ahistorical.

Specifically, it seems to me that colleges becoming more vocational and colleges becoming more expensive are both natural outcomes of the neoliberalisation of all things. I am aware that some students now rationalise their educational investments with the logic you describe above, but I think it's a post-hoc rationalisation.

You can get a good job without going to college, and you can get a good education without paying a gazillion bucks.

A side point, but calling it "vocational" seems a bit euphemistic too. Learning carpentry is a vocation. Getting a business degree is not equivalent to learning carpentry. I might say colleges have become commercialised, rather.

College becoming more vocatioanl is a consequence of colleges becoming more accessible to a much larger population, beyond the already wealthy.

Community colleges are the cheapest colleges, yet the most vocational.

The most expensive colleges are the Liberal Arts Colleges and the Ivy League, which are the least vocational.

> I think it's absurd to start with Scheme. A graduate who knows Python but not Scheme has a hope of doing something with computer science. A graduate who knows Scheme but not Python is basically unable to use computers at a technical level.

What language you start with and what languages you know on graduating are going to be different. It takes 4 years to get through most bachelors programs (without taking summer terms, very high course loads, or coming in with a bunch of transfer credits). It's no more absurd to start with Scheme than to start with Python when there are at least 7 semesters remaining to learn more.

If a graduate only knows what they learned in CS 1, they aren't a CS graduate even if they got that slip of paper. They conned the school, or the school conned them.

I think it is absurd to fail to learn the basics and focusing on 'deliverables' from day one.

You need to get the ideas first. The language used is the least of your concerns.

This is even more poignant on this era of vibe coding.

It's easier to explore deeper concepts learning with scheme because the language is such a simple and introspective encapsulation of generalized computer science concepts.

I and about a million other programmers started with BASIC. My second language was Pascal. I don’t imagine I’d be very employable if that’s all I knew, but it turns out that you can learn many programming languages and it’s not all that much effort after the first two or three. There’s no reason to think the language you start with should be one that you could get paid to use.

And no, I wouldn’t recommend starting with BASIC. But starting with Scheme seems like a great choice.

Formal reasoning about functional programs in terms of their (denotational) semantics is normal in a functional programming class (e.g. it's about a quarter of our mandatory-for-undergrads FP course).

Formal reasoning about imperative programs in terms of their (e.g. axiomatic) semantics is only in a grad-level course, and the programs you can reason about are really, really limited compared to the functional ones. (The last time I TA'd the FP class, one of the homeworks involved proving a simple compiler correct. When I took the grad course, I think the most complicated program we proved correct was selection sort.)

I think "reasoning about programs" is more computer-science than "writing programs," and choosing an imperative language signals that you're not emphasizing the former.

It's one way of modelling the broad notion an algorithm, but it isn't the only one, and it's odd to treat it as the one true expression of computer science when essentially all modern computing follows a different model.

Depends on which part of the theory you care about. Lists in Python are a magic structure that can grow and shrink at will. That's a bit too high level to be useful for learning the theory.

And so is Python in many ways. The shoe fits.

"essentially", come now.

The point is that python's syntax reads a lot more plainly and logically for learning than something like Java.

> Haskell

https://book.realworldhaskell.org/

That kinda defeats the purpose of why scheme was the language of choice in the first place! The goal was for us to fall in love with programming, not a programming language.

>You can fit War and Peace on one page if you condense it enough.

"I took a course in speed reading, learning to read straight down the middle of the page, and I was able to go through War and Peace in 20 minutes. It's about Russia." —Woody Allen

That should be the beginning of the formative experience for that kid rather than the end. Yes, you can. How often do you? What are you missing by not thinking about problems in that way more often? What idioms could be unlocked that way? (How many Python programmers out there are aping wholly unnecessary "design patterns" created for C++ or Java? Or rather: shouldn't a design pattern be about the design rather than the implementation? What is a design, in the pure abstract, really?)

oldpersonintx2, your account is shadowbanned.

Which colleges did you send your kids to, what kind of degrees (just bachelors? undergrad and grad?), and how many kids?

The $800k figure without that context tells us nothing. If that's for 2 kids to get a BA/BS/BE, you got ripped off. If it's for 4 or 5 kids it makes much more sense when examining current costs.

> But this is the problem. Our premier academic institutions shouldn’t merely exist as job training programs for big tech.

meanwhile, in the real world...I just finished putting all my kids through college

I spent $800k. EIGHT HUNDRED GRAND.

I'm laughing at your naive take

if schools want THAT MUCH money, they must provide something actionable in the real world

if you want to pretend university is like some ancient greek academy, enjoy paying for the toga

I certainly consider myself a software engineer first and programmer second, and you’re right, the language doesn’t matter. I recently got a position developing in Python having never really used it professionally, but it’s so similar to other interpreted languages I knew so I was able to jump right in and start making meaningful contributions. Often we are expected to learn new languages, which is exactly how I picked up the 10ish languages I can confidently say I’m good in, despite never having been formally trained in those. Most common languages don’t stray from certain basic principles anyway.

Given a day, top students can understand enough of Python to write enough code to get the point about how programs rely on abstraction and composition.

(Of course, the latter part of the course, describing the implementation of the runtime, would need considerable rethinking.)

Yep, and there's a Texinfo version too. With Chicken, 'sudo chicken-install srfi-203 ; sudo chicken-install srfi-216; Emacs, Geiser and this ~/.csirc, you can run SICP exercises on really constrained environments.

~/.csirc

   (import scheme)
   (import (srfi 203))
   (import (srfi 216))

https://zv.github.io/sicp-in-texinfo

Run Emacs. Press

   Ctrl-u Ctrl-h i 

Then, run:

Alt-x

package-refresh-contents

Alt-x

package-install

geiser-chicken

wait.

Run Alt-x geiser, and if it ask you which Scheme interpreter to run, choose 'chicken'.

Later,

press Ctrl-x f

to choose a file, create a new one called "hello.scm".

Write in that file:

(display "Hello world").

Run Ctrl-c Ctrl-c

and then the Scheme code in that file will be evaluated. To choose the running Chicken interpreter, press

Ctrl-x b

and choose the Geiser buffer.

Run Ctrl-h t for the Emacs tutorial, it will be handy.

If you want the same tutorial in Spanish, Japanese, French...

press

Ctrl-u Ctrl-h t

and just input your language, press [TAB] to autocomplete.

Happy Hacking.

The point of Scheme SICP is that it will teach you these CS principles.

Shouldn't that be the point?

Honestly, the new professor wasn't too far off. I've often referred to "The Little Schemer" as "the best javascript book that isn't about javascript."