Hacker News Reader

Comment by treprinum | Hacker News Reader

I would never get into programming if all I was shown were some quixotic features of Scheme I couldn't use for anything in the real-world. What attracted me to programming was to quickly enable me how to draw a graph of a function, how to make a simple worm-like game, how to dream about creating a flight simulator and drawing the plane dashboard with all its dials and make them move even if the flying part was deep in dreams, drawing a car on a screen with some air arrows to simulate aerodynamics and dream how to build a software for it. But dry string manipulation with weird syntax was not very interesting and in fact rather repulsive.

View on HN

I love SICP, but I will say this: there's a certain class of "great" textbooks that sometimes get recommended by experts, that aren't actually that great for someone learning something for the first time. They get the reputation as being "great" because they are great for people that already have a good basic grasp of the material: They are precise and pithy, and they contain insights that are deep and useful, but hard to appreciate if this is your first encounter with the material. (Kleppner & Kolenkow would be a good example of a freshman physics textbook in this category.) With all due respect, I would put SICP in this category. Which, of course, is a noble and important category, but maybe not the most important category if you're just starting out on a topic.

Discussing these textbooks - and more generally discussing education - also seems to reveal a lot of weaknesses in how people think about the world. There's a tendency to think that because something is difficult it's worthwhile. There's a tendency to ignore opportunity costs, or consider alternative efforts. There's a tendency to frame on cool concepts that are intellectually fun and more pleasing to the ego as "real learning," when most CS graduates are likely going to be running into much more trouble on less glamorous stuff like navigating frameworks.

I'm definitely coming from my own perspective, having initially been self-taught, and then finding myself with the opportunity to go back and academically study CS at a well ranked university. Supposedly, this would fill all of the "holes" in my knowledge (you see this sentiment a lot). I found the classes fun, and I did well in them. But I was also constantly trying to find usefulness in them when it came to work I actually was doing, and didn't find any. Though I don't regret doing it as an interesting life experience, it was honestly a waste of time and money when it comes to my CS skills.

Which isn't to say that SICP is useless for everyone, or that no one will get value out of it. But reading the article in the link, as well as all of the replies, it's telling that people are writing so many paragraphs but aren't able to say anything concretely. Even multiple paragraphs accusing people of looking for excuses not to do it - but not providing any concrete examples of its usefulness. This should set off red flags.

Yes, there are people who are completely clueless about core concepts. Though SICP is obviously not the only place to learn about those concepts. Further, most people hanging out in places where those concepts are discussed and are considering whether or not to do SICP in their free time likely have been exposed to the concepts already (and might already have a pretty good grasp on them).

There always is a bit of posturing and ego involved when some of these things come up, and they often lead to people giving very poor advice.

SICP uses Scheme in the same way all programming must use some language, but it's not a book that is primarily about Scheme. The problems in this book are challenging in any language and the ideas around computation are more or less universal -- see editions and derived books in Python and JavaScript[1][2]

Also, YMMV: I have a math background and got sucked into programming because the appeal of being able to hold an idea in my hands by writing a program that I could poke and prod and play with was really exciting. The quixotic spirit of the book fed my enthusiasm. (And this is neither here nor there, but I think pedagogy in a first course should probably skew quixotic)

People get into programming for all kinds of reasons -- I recognize that SICP isn't the right book for everyone, and that there is a lot of elitism around this book. Nobody should feel bad about not getting much from it, and I think it has severe pedagogical flaws, but I'm very glad and grateful that it exists because for me, personally, it was exactly what I needed.

[1] http://www.composingprograms.com/

[2] https://sourceacademy.org/sicpjs/index

Quixotic features like functions and variables.

Edit: Sorry, was cranky from being hungry. I take issue with “useless in the real world.” The first chapters introduce variables, functions, recursion, and lambdas, and not much more than that. That’s the beauty of the book. Flexible ideas that are immensely useful and form a great foundation for learning computing. It’s not the best total beginner book, I’ll admit, but it’s a great beginner-intermediate book for those who seek mastery.

This seems like a misunderstanding of what other people find limiting. The problem some people have with this book is that it’s about computing in isolation. Scheme is an island with text-based I/O (as far as the textbook is concerned). You interact on the command line and do calculations. The ideas you learn about are deep, but internal, disconnected from other systems. There are engineering problems, but they aren’t about building systems, they’re about doing calculations or simulating systems using math. Functions and data structures and a bit of text data is all there is.

This is great in its own way, but nowadays, there’s a preference for a programming course that’s more extroverted, that lets you build interesting things by including a program as one component of a larger system. I believe even MIT switched to an introductory course where they program robots using Python, or something like that?

That’s fine, but it feels a bit like getting annoyed at a Drawing Fundamentals course for not teaching Photoshop. I understand the pedagogical advantages of fun, API-based project learning. I just reject the implication that what SICP has to teach is ivory-tower theory. It’s stuff programmers use every time their hands touch the keyboard.

> Scheme is an island with text-based I/O (as far as the textbook is concerned).

See section 2.2.4: https://mitp-content-server.mit.edu/books/content/sectbyfn/b...

> there’s a preference for a programming course that’s more extroverted, that lets you build interesting things by including a program as one component of a larger system.

Black box abstraction is a huge theme throughout all of SICP.

Neat! I had forgotten about that. Not entirely text-based, then.

I went looking for what primitive drawing commands it was built on, and it’s barely mentioned:

> The details of how primitive painters are implemented depend on the particular characteristics of the graphics system and the type of image to be drawn. For instance, suppose we have a procedure draw-line that draws a line on the screen between two specified points. Then we can create painters for line drawings.

That’s a pretty typical avoidance of I/O. (Also, generating static pictures is rather different than reacting to input.)

The danger in demanding to just be taught how to be a good code monkey is that that increases your risk of getting stuck just being used as a code monkey.

My intro CS class was taught in Scheme. I haven't found what I learned in that class to be quixotic at all. Instead, I view it as setting me up with a strong foundation that colleagues of mine who learned in a more "popular" language lack. It's put me at a permanent advantage for designing and building software - even decades later, I find that there are ways of decomposing problems that I can understand easily, and colleagues of mine who learned on Java still have trouble with, because they simply lack the "design vocabulary" that would enable them to think about the problem in the right way.

We never again used the language past that first introductory course, but I still don't think it was a waste of time, because it allowed us to cover so much ground so quickly. In 3 months we went from basic fundamentals to building our own object-oriented programming system from scratch. That's amazingly powerful. A deep knowledge of what object-oriented programming actually is, and how it works under the hood, is usually considered an advanced and esoteric concept that few people really understand. Fast forward about 15 years, and having that kind of knowledge in my head allowed me to take a job at a Java shop, having never touched the language previously, and then within just a few short months have a deeper understanding of how Java works than colleagues of mine who had been using it on a daily basis for 20 years. So that they were coming to me for help with Java problems, despite having an order of magnitude more experience with the language.

Rewind back to school, and it's the same story. The second class in the freshman curriculum used C++. It was not a course in C++, mind - it was a class on algorithms and data structures. Learning C++ was just the first couple of weeks. And learning it mostly consisted of being taught the syntax and the build and debugging tools. The semantics for everything - pointers, classes, templates, etc. - took a negligible amount of time because it could be explained to us in terms of concepts we had already learned by building ourselves - in a 3 month intro class.

When I was first introduced to computers, I was shown BASIC and Logo (Apple II plus). Logo felt a lot like a LISP (at least, that's how it was presented to me... ) with a very easy way to make graphics (turtle model).

I couldn't really get into Logo- it felt too indirect, too computer-sciencey, so I went into BASIC and later Machine Language to learn how to build games (I was influenced by Choplifter, Lode Runner, Wizardry, and Ultima). It wasn't until some time later that I learned LISP and began to appreciate functional programming and the turtle model (I still am amused at how much I learned on that original Apple II that still applies today to tech like SVG).

I reflect a lot on how Norvig was a LISP guy and then when he saw what was happening in scientific computing, pivoted to treating Python like LISP (https://www.norvig.com/python-lisp.html and https://www.norvig.com/lispy.html) although I don't know that anybody really anticipated we'd have systems like Jax which really turn functional programming in an imperative language on its head.

Very good point. That was literally the magic of early Basic. One could do something quickly. And the imperative nature of the language gave a simple point of attention mental model. I feel that point is lost in many criticisms.

I always dislike it when people emphasize "applications", as if those were the only valuable things to learn. Nothing in my professional and academic life has been as valuable, as a strong conception of various theoretical concepts.

What SICP is about, is programming theory. How data structures can be formed and manipulated to solve abstract problems and how these programs are executed.

Sure, nothing in this book will tell you the best way to program a video game, but the presented concepts are of genuine importance and can be seen in a wide area of circumstances. Ultimately the book want's you to think more abstractly, which is great way to understand things.

GP mentality is prevalent and the reason why the "big ball of mud" article and the "worse is better" blog post are so relevant. People don't want to understand computers and computation they just want to get some stuff done. Companies just want to put out a product. They never seem to realize that following their noses and not thinking too much about the underlying tools is what landed us with this mess of ever changing, overly complex frameworks and nightmarish levels of insecurity increasingly surrounding more and more critical infrastructure.

It's more like SICP is a bad intro but a great outro to programming studies. First get some simpler basics allowing you to understand what can be done with computing and apply to some of your hobby ideas, then dive deep to actual low-level details and various approaches to understand all the trade-offs and applicability of each. Overwhelming freshmen with SICP is not the right approach for most.

I ought to think university aged adults should be on the point of doing deep conceptual dives on the fields they chose... dive deeper into. I get what you're saying and it makes sense given the realities of CS programs. But I can't help but feeling that freshmen being overwhelmed by SICP is a symptom of a problem and not some limitation of the young adult mind.

Reply on news.ycombinator.com