←back to thread

284 points borski | 1 comments | | HN request time: 0.222s | source
Show context
MontyCarloHall ◴[] No.44685710[source]
Isn't this just part of the broader trend of CS departments switching away from teaching computer science to teaching computer engineering, which in turn is part of the more general trend of colleges becoming more vocational?

LISP dialects like Scheme are excellent for teaching pure computer science because they are the closest thing to executing lambda calculus expressions. Whereas Python is excellent for teaching applied computer engineering, because it's essentially executable pseudocode for imperative languages, and imperative languages are the most common language a computer engineer encounters in the real world.

replies(18): >>44685819 #>>44685842 #>>44685939 #>>44686019 #>>44686088 #>>44686154 #>>44686222 #>>44686308 #>>44686321 #>>44686533 #>>44686596 #>>44686808 #>>44687195 #>>44687197 #>>44688209 #>>44688239 #>>44688473 #>>44688736 #
Karrot_Kream ◴[] No.44686321[source]
When this kind of switch was happening in CS departments, as a graduate student I was part of a "movement" that advocated for switching away from things like Scheme to Python for introductory classes in my elite CS institution. (We focused on other things as well such as more interdisciplinary research, which was where I was more passionate, but that's a separate matter.)

My reasoning at the time in this order was:

1. Widely used tools and practices offer a flywheel of usefulness that can 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. On the web side, there was web.py or Flask (haha this was the late 2000s/early 2010s) to motivate yourself to keep going. The student could spend their summer building apps and tools so that they appreciate computation for more than just its "aesthetic" beauty.

This was a time when CS wasn't all that prestigious on its own and salaries weren't as high as they are now, so many folks who banged their head against Scheme or MMIX or LC3 would just churn to the EE or MechE departments.

2. As a grad student it was almost trivial to set an exam paper that could weed out most of the class. This was especially trivial at the introductory class level where Scheme would be taught. If the concern was rigor it was very simple to maintain the rigor in other ways.

3. For better or for worse many undergrads had no intent of going to grad school, and many of the undergrads taking our classes weren't even students of computer science. They were electrical engineers or industrial engineers who wanted to learn enough programming to automate things in their field but were more interested in their actual areas of concentration.

In the years since my thinking around this evolved, but I still share the same conviction I did then. Probably moreso given the sheer ubiquity of Python now.

replies(4): >>44686586 #>>44686642 #>>44686697 #>>44687847 #
simpaticoder ◴[] No.44686697[source]
>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.

replies(2): >>44687355 #>>44687667 #
1. Karrot_Kream ◴[] No.44687667[source]
Maybe this is due to my interests (I specialized and published in distributed systems) but it's always been the opposite for me. Implementing HTTP/1.0 or IRC clients is one of my favorite ways to learn a new language (albeit it's a bit heavy on the IO which can be unfair to functional languages that model effects.) My interest in network software is that I can standup the software and have it participate in the network immediately. It's the application that leads me to appreciate the language not the other way around. My interests in theorem proving and program verification came from debugging heisenbugs in the wild and wasn't motivated by the algorithmic complexity or mathematic sympathy.

But I dabbled in PLT in my grad days and have no doubt that there are folks who have your mindset as well.