
Programming by poking: why MIT stopped teaching SICP - brunoc
http://www.posteriorscience.net/?p=206
======
jdmoreira
Reading this made me so so sad, I do agree with the reasoning.

I learned to program on a course that follows SICP, I spent all my college
years learning how to program from first principles, building all the pieces
from scratch. Building compilers, soft threads implementations, graph parsing
algorithms... and I was happy with that way of programming!

Today I'm an iOS developer, I spend most of my day 'poking' at the Cocoa Touch
framework whose source I can't even read because it's closed source. The
startup I work for moves so fast that I'm forced to use other peoples open
source projects without even having the time to read the source. I feel
miserable doing the kind of programming I do nowadays! I wish I could go back
to simpler times, where I actually had to reason about algorithms, data
structures, hardware, etc...

~~~
kajecounterhack

        I feel miserable doing the kind of programming I do 
        nowadays! I wish I could go back to simpler times, where 
        I actually had to reason about algorithms, data 
        structures, hardware, etc...
    

I don't subscribe to the school of thought that values engineers lower on the
stack more than those higher up, especially since there seem to be a lot more
new jobs of the latter sort and we all need to make a living, and there are
plenty of cool problems in those spaces (algorithms, data structures,
performance... it's all there).

But I think the lucky ones are people who get to work low enough _relative to
their knowledge_ where it doesn't feel they are dealing with endless
abstractions and layer upon layer of magic.

    
    
        The startup I work for moves so fast that I'm forced to 
        use other peoples open source projects without even 
        having the time to read the source.
    

:( sounds to me that this might be more the problem. And worse is I suspect
it's common.

~~~
SomeCallMeTim

        I don't subscribe to the school of thought that 
        values engineers lower on the stack more than 
        those higher up
    

Meaning developers who understand low-level details vs. developers who just
wire up high level libraries?

I've done the full range, from entire games written in assembly language and
embedded C code, through high level full stack development with NodeJS,
Python, and other languages.

The low-level coding is _far_ more skilled work than the high level coding.
Instead of most of the work being "how do these plug in to each other?", it's
how _exactly_ does my code function with respect to all of the potential
events additional threads, and how all of the edge cases interact, and what is
causing this obscure bug?

While that may not seem intrinsically harder, none of these are typically
something you can Google or search StackOverflow for the answers on. So you're
really just on your own. And developers who have grown up on "Google all the
answers!" often hit a wall when they need to apply real problem solving
skills.

Luckily I can find enjoyment in many levels, since a lot of the jobs I've
found recently have been more of the "full stack" or "mobile development'
category. It's easy and fun work.

I also have little problem piercing the magic and understanding how things fit
together, but that means that I end up with opinions on many topics divergent
with the crowd. For instance, I avoid writing Android/Java or iOS/Swift, and
instead use cross-platform development stacks exclusively. Yes it means an
entire extra layer of complexity, but it also means I write the app _once_ for
all target platforms. Far too big of a win to ignore.

~~~
rimantas
Sorry, that way you do not write an app for all of the platforms. You write
for none of them it just happens to run on one of them.

~~~
SomeCallMeTim
I test on iPad, iPod Touch, a half dozen Android devices, and on emulators.
Works well everywhere, even with platform-specific differences in design to
match different platform paradigms. And I have happy clients.

I've run into this attitude before, though. It seems to be the last bastion of
denial of folks who have spent a lot of time learning one platform and who
don't want to learn something new. Sorry, but there are better ways.

------
GrumpyYoungMan
I'm surprised and a bit dismayed to read Sussman's reasoning:

 _"...Sussman said that in the 80s and 90s, engineers built complex systems by
combining simple and well-understood parts. The goal of SICP was to provide
the abstraction language for reasoning about such systems.

Today, this is no longer the case. Sussman pointed out that engineers now
routinely write code for complicated hardware that they don’t fully understand
(and often can’t understand because of trade secrecy.) The same is true at the
software level, since programming environments consist of gigantic libraries
with enormous functionality. According to Sussman, his students spend most of
their time reading manuals for these libraries to figure out how to stitch
them together to get a job done. He said that programming today is 'More like
science. You grab this piece of library and you poke at it. You write programs
that poke it and see what it does. And you say, ‘Can I tweak it to do the
thing I want?''. ... "_

Surely graduates of MIT, of all places, would be the ones building the
libraries that ordinary programmers are stitching together and would still
need the ability to build complex systems from fundamental CS abstractions?
I'm absolutely baffled.

~~~
hga
Calling it his "reasoning" with all the connotations that come with that word
goes way too far.

This was his polite implicit criticism of the new core, which among other
things also teaches much less in the way of EE fundamentals, a topic he's
cared about very much since at least the late '70s (i.e. 6.002 is no longer a
required course for all EECS majors).

The bottom line is that in the post-dot.com crash panic which saw MIT EECS
enrollment drop by more than half, after it had been steady at 40% of the
undergraduates for decades, one result was "MIT" deciding that what a MIT EECS
degree meant would be substantially different.

~~~
bps4484
It may have been that it just took 7 years to actually get a new course in
place, but it wasn't until fall 2007 that MIT officially got rid of 6.001 as
required course, well after the dot com crash.

There were a TON of changes that happened with the MIT EECS curriculum at that
time, so perhaps it was a holistic response to the dot com crash that was
beyond just 6.001.

~~~
hga
I think "panicked spasm" is more accurate than "holistic response", at least
in connotation, but as I recall the only real changes were in what was
required, terminating the use of Scheme in the entire required curriculum with
_extreme_ prejudice, and adding, what, 6.005? Where they claimed to teach most
of what was in 6.001/SICP, but using Java, a language which is "not even
wrong" for that purpose.

Yeah, MIT has become a Javaschool, plus Python....

And just when the failure of Dennard scaling was making functional programming
a lot more important.

~~~
bps4484
No, there were many changes to the curriculum, and for a variety for reasons.

They created 6.01, which serves at an "intro to EECS" so it involves both EE
and CS, as opposed to the old intro 6.001 which was really an introduction to
CS. Some argue that this course is easier (I never took it, so I can't say)
which could definitely be argued is to make EECS a little more gentle and open
in response to the dot com crash.

They also broke up 2 very difficult courses, 6.046 introduction to algorithms
and 6.170 lab for computer science, and at least put _some_ of their course
work into new courses. Again this could be seen as making the entire major a
little gentler.

They also changed requirements. In the past there had been a lot of CS focused
students who were uninterested in doing any EE, and were choosing to major in
18.c (math with computer science) to avoid an EE course load. The department
right thought it was a little crazy that people were leaving the CS department
in order to focus more on CS, so they lightened the required EE coursed for
6.3 (a major focused on CS) and vice versa.

This is all my recollection from the 07-09 era and from talking to some
students since. There could be some errors in details.

------
ng12
Eh. Many students will have the rest of their lives to perfect the art of
poking at a library. Getting the chance to play with the more sublime CS stuff
is much harder outside of university.

~~~
argonaut
Students also have the rest of their lives to learn the sublime CS stuff.
Getting as many students motivated to learn CS, with Python, is a perfectly
reasonable goal for a college.

~~~
swiley
That's a perfectly reasonable goal for a high school or someone performing
self study. The whole point of a university is to impart knowledge of subtle
things.

~~~
argonaut
The majority of CS students (including MIT) never studied CS before coming to
college. Unless you propose MIT/CMU/Stanford/Berkeley/etc. only admit people
to their intro CS classes who have studied CS before (chicken and egg problem,
anyone?).

~~~
thaumasiotes
Well, MIT's intro calculus classes are overwhelmingly for people who have
studied calculus before. Making it an actual requirement wouldn't change much.

~~~
argonaut
1) MIT definitely offers calculus classes for people who haven't taken
calculus, although obviously these people are in the minority.

2) Most high schools don't offer CS. 99% of high schools offer some form of
calculus.

~~~
thaumasiotes
I'm just pointing out that there's no "chicken-and-egg problem" with MIT
requiring CS exposure for its intro CS classes.

------
mattlong
I really wish SICP had been a 2nd year course (with a requisite increase in
difficulty) instead of my very first course in the EECS department. Not having
had a ton of background in programming beforehand, I feel that a lot of what
SICP has to offer was lost on me to some degree due my not appreciating it at
the time.

I suppose the same could probably be said for any intro course or just college
in general...

~~~
shepardrtc
My university used to have an Engineering Fundamentals class that all
Engineering students were required to take their first year. Among several
other things, it taught how to use Excel and more importantly, programming
using Fortran. It wasn't in-depth, but you learned what programming was in a
pretty easy environment.

~~~
thrownaway2424
We had a similar freshman pan-engineering course at Texas A&M that taught both
excel and fortran among other things. Probably the most practically useful
course in the entire program.

~~~
thaumasiotes
My university offered "intro to unix". It wasn't required for anyone, but it
did fill a general education requirement.

It was also one of the most practical, useful classes they had. A CS student
who didn't take it (probably most of them) would still pick up most of the
material by osmosis, but I think that class was a great idea.

------
stepvhen
All that said, it is still worthwhile to work through all of SICP, if you want
a deeper understanding of how certain tools work. Writing your own interpreter
is a very rewarding experience.

~~~
yolesaber
Having to write my own shell in C for my operating systems class absolutely
blew my mind. And then after that my professor made us implement a quine in
the shell we just wrote. Yes, he was insane.

~~~
chubot
Which class/university was it? Any chance the materials are online?

I'm actually writing my own shell now; I'd be interested to compare :)

The fork/exec/pipe/dup calls are definitely an unusual and powerful paradigm.
I think too many programmers don't know this because we were brainwashed to
make "portable" programs, and that's the least portable part of Unix.

~~~
brunoc
CS61 at Harvard covers that stuff, building your own shell (and memory
management, etc) in C and it's an introductory class. There is a lot of hand
holding of course but I really loved that class.

~~~
yolesaber
Harvard? Never heard of it. Good school?

~~~
hga
Does not have an ABET accredited CS major, for what that's worth.

------
reuven
Wow.

I took 6.001 as an undergrad at MIT. It changed my view of software forever.

Years later, I now spend most of my time training programmers at hi-tech
companies in Python. The ideas that I got from 6.001 are pervasive in my
training, and are fundamental (I think) for programmers to understand if they
want to do their jobs well.

Given that I teach tons of Python, you might think that I'm happy that they
switched to Python as the language of instruction. That's not the case; I
think that Lisp offers more options for thinking about programming in
different ways.

One of the great things about 6.001 was that it didn't try to teach you how to
program for a job. It taught you how to think like a programmer, so that you
could easily learn any language or technology they threw at you.

Oh, well.

------
qwertyuiop924
Poke all you like. I'll just be over here writing software that isn't a broken
pile of hacks. SICP is one of the most important books I haven't read. It's
actually on my shelf right now. I still haven't finished it.

The fact is, as a self-taught programmer, programming is intimidating. I can
reason about code, and write it, and understand it if I squint at it long
enough, but I still choke on any production code I read, and have trouble
solving complex problems. SICP is a book all about this. It's about building
better abstractions, and despite having not yet finished it, is probably the
most helpful books on programming I've read. Many books can teach you how to
program. SICP teaches you how to program /well/, and why.

Along with The Lambda Papers, it taught just how powerful Scheme could be. And
I maintain that Lambda the Ultimate Declarative contains the only good
explanation of what a continuation DOES.

It was the book that made me want to go to MIT. I don't know if I'll ever go
there (I'm still in high school), but if the people there are advocating
"programming by poking," it probably wouldn't be worth my time.

This book changed my life, and I haven't even finished it yet. It should be
Required Reading™, and the thought of doing it in Java makes me sick. And not
just because I despise Java. Java is probably the worst language for this sort
of book. SICP is an exploration of programming paradigms and concepts. Java is
married to one set of paradigms and concepts, and won't budge an inch against
even a hydrogen bomb.

Besides, imagine a metacircular evaluator in Java. Yuck.

------
fvt
Some day we will recognize that some areas of "programming" are very different
and require different skill sets, and eventually different titles.

We tend to call everything "software engineering" so that everybody can feel
proud of such a title ("I'm an engineer"), but engineering is certainly not
about figuring out how to vertically center divs with CSS (and it's also not
about proving algebra theorems either -- even if it can be essential when it
comes to specific problems that require it).

I can't imagine Linux and PostgreSQL being built without "science", they use a
lot of it, and I'm pretty sure the authors all have read SICP and those
theoretical books. Poking at things proved to be efficient to building things
quickly, but it's just not how one builds critical systems/software that are
robust, efficient and maintainable.

~~~
taneq
Engineering (no matter whether mechanical, electrical, software...) is the
process of designing an artifact to be constructed out of available materials,
which meets a set of requirements while minimizing cost.

In mechanical engineering you design your artifact using off-the-shelf
bearings, motors, pumps, etc.

In electrical engineering you design your artifact using off-the-shelf cables,
contactors, relays, VSDs etc.

In electronic engineering you design your artifact using off-the-shelf ICs,
resistors, capacitors, resonators etc.

In IC engineering you design your artifact using off-the-shelf silicon wafers,
etching chemicals, core/logic designs etc.

It's turtles all the way down, and software is no different.

~~~
Retra
Most engineers are working under some quantifiable or standard set of
requirements, rather than ad hoc "make it work good and look pretty"
requirements. Most engineering disciplines also have processes to ensure that
its adherents take the proper precautions to avoid poor and unsafe designs,
delivered in standardized sets of guidelines and recommendations.

And many programmers aren't engineers, they're just interested tinkerers;
people who play around in their free time enough to know how to make something
work. Not unlike if you went to the store, bought some wires and batteries and
tools, and then played with them until you got hired as an electrician.

Sharing culture is _instinctive_. People will do it. You might as well try to
tell people they can't have sex without your permission unless they pay first.
Oh wait, that's the porn industry. Everyone pays for porn, right?

------
ehudla
There's a quote I love from the book "The Idea Factory: Learning to Think at
MIT":

 _Freshman double E 's take six double oh one (a.k.a. six double no fun) to
learn to program in LISP... This is also where they begin to leave the rest of
the world behind them in their ability solve problems and make things work._

He goes on to describe how the course instills the virtues and limits of
abstraction.

~~~
ChicagoBoy11
Would you recommend it for people thinking about institutional culture/school
design?

~~~
ehudla
The MIT book? No, it's just a fun book about MIT culture, the analysis doesn't
run very deep IIRC.

------
jeffreyrogers
I read about half of SICP and thought it was OK. Not great, but okay. The
programmers I've met fall largely into two groups, those who like systems
level programming, knowing how the OS works, how it interfaces with the
hardware, what the memory layout is like, etc. and those who like abstraction
and the things that SICP values. I'm definitely in the former group (but I
certainly appreciate people who prefer the SICP approach).

There's room for both of course, but for people like me SICP was really a
slog. Some of the exercises were hard sure, but more than that the material
just wasn't that appealing to me. I don't have any comment on whether MIT's
decision was the correct one, but liking SICP or working through SICP is by no
means a prerequisite of being a good programmer.

~~~
shiro
Hmm, I didn't get your dichotomy... By "half" did you mean the first half?
IMHO the main dish of SICP is chapter 4 and 5 (ch1-3 is just laying
foundations), and the content of latter chapters is strongly connected to
system-level things like compilers, run-times, processor design etc.---it's
not as immediately applicable as like the Dragon Book, but SICP gives you the
perspective, in a sense that it shows broader possible design space within
which you can locate the current OS / hardware / language technology.

~~~
jeffreyrogers
I meant roughly half by page count. I stopped after that point because I was
bored.

~~~
shiro
Yeah I agree that the first 3 chapters are somewhat archaic, and especially if
the reader already has programming experience it looks like it is reinventing
some mundane features.

------
bawana
This is the way of real life. We breathe, eat, excrete all without
understanding or knowing. We poke at our bodies with junk food, exercise,
video games, and other stimuli. Sometimes we achieve the desired effect, most
times not. We still do not really know how we work. Poking at complexity is
ALWAYS how science was done.

And the high priests of computer science strove to build a corpus that was
intimidating, complex and beautiful. They tried to be gods and birth a new
form of life. That computer scientists applied Socratic and Aristotelian
principles to their framework is hubris. Human individuals really cannot be
gods to machines that are useful. We have constructed masses of spaghetti code
into libraries that no one has the time to read or understand and it is our
own fault. These are tools and should have been kept simple and open and easy.
Perhaps AI will evolve to save its parents.

I have a dream of the day when I can talk to Alexa, and write code for her in
English just by speaking. Her built in projector would show me what I said. My
words would be translated into correct Python, c++, or JavaScript. She would
highlight errors that would lead to build failures. Point out race conditions.
And tell jokes along the way.

------
shepardrtc
> Sussman admitted that the SICP curriculum was “more coherent” than what they
> have now and that they still don’t know what the right curriculum should be.

The article should have led with this because I believe it would have framed
the rest of it more accurately.

------
fintuple
Did SICP at Berkeley. Really awesome course. Thanks MIT for not teaching it
anymore. Makes me a better programmer than your new grads now. Hah!

~~~
dimino
It doesn't, is the point that the folks who came up with SICP are trying to
make.

~~~
ccalf
Well the real issue is defining what's better. And the worry some of us have
is this new trend of grappling with increased complexity seems short-sighted;
we don't like the direction it's going. As much as Sussman shows understanding
of the current situation, what he's saying is also a criticism--doing this
sort of ad hoc "science by poking but not really science" is the heart of the
issue.

And what's interesting is if you look at actual scientific research around
programming, say dealing with concurrency and advanced tools like model
checking, etc—all of that is very theoretical stuff that assumes you know SICP
or have equivalent foundations. So it's not really an argument that theory is
dying; in face of this new level of complexity in practice, perhaps we could
benefit from theoretical research now more than ever.

~~~
dimino
It's hard to argue with productive results, however. If this "poking" results
in valuable engineering more than SICP does, then "poking" needs to at least
be seriously looked at and understood, if not outright taught to the next
generation of software engineers.

The real problem, I think we can all agree, is the lack of widespread
specialization of degree programs. Computer Science is still the blanket
degree everyone gets, when in reality, some kind of trade program is likely
sufficient to train many of today's "developers" (the "pokers").

------
Animats
_" Programming environments consist of gigantic libraries with enormous
functionality._ Some of which works. This leads to what I call ritual-taboo
programming. People follow the rituals and avoid things they're told to avoid.
This is reflected in programming books. Programming books were once reference
manuals, which listed each function and what it did. Now, they're enormous
compendiums of examples.

It's sad, but MIT made the right decision. MIT used to produce people who
designed elegant, perfect little jewels of code. There just aren't many jobs
for those people. Algorithm design just isn't that big a deal any more. Most
of the useful ones have been written and are in libraries. Who reads Knuth any
more?

------
benwr
The article is based on this video segment, from GJS:
[https://vimeo.com/151465912#t=59m36s](https://vimeo.com/151465912#t=59m36s)

------
rhinoceraptor
If you haven't watched the SICP video lectures [1], they are really great.

[1]:
[https://www.youtube.com/watch?v=2Op3QLzMgSY](https://www.youtube.com/watch?v=2Op3QLzMgSY)

------
Const-me
Looks like another face of a centuries-old debate between theoretical and
experimental science.

The theoretical scientists play with abstractions they fully understand.
Experimental scientists poke at things they don’t fully understand. They tend
not to do well with each other.

When computers were in the infancy, they were viewed primarily as a scientific
tools to crunch numbers and play with abstraction. That’s the theory-oriented
view that I think is shared by the SICP authors.

Then computers became complex, fast, and capable of doing much more than
crunching numbers and evaluating those S-expressions. While you can view a
modern web browser, or MS Word, or a videogame, as a program for a Turing
complete machine, this does not mean you should. Too little value in that:
sure there’re instructions and state, but now what? More experiment-oriented
mindset usually works better with those kind of problems.

------
sitkack
> “More like science.

ummm, I hardly see anyone and by anyone I mean even people > 20 years of
experience doing empirical research while solving problems. Maybe the _like_
needs more emphasis? We don't really teach science or the design of
experiments. This is arguably the most important intellectual tool we have
ever developed and it should be the core of all education.

Programming by poking that I see folks doing, isn't science. It is stabbing in
the dark until something appears to work. There is more to computational
thinking that throwing some APIs together in a blender and making a cool demo.

As a longtime Python programmer, I wish more people would start with Scheme.
Most Python is written like some dynamically typed Java; people are using
maybe 30% of the power of the language.

I really wish I could have experienced those SICP lectures in 86.

------
wellpast
> The “analysis-by-synthesis” view of SICP — where you build a larger system
> out of smaller, simple parts — became irrelevant. Nowadays, we do
> programming by poking.

I imagine many of us do programming by poking. But the skill set referred to
here is essential if you're going to build (create/construct) a complex system
or architecture.

To say the skill set is irrelevant is to say we as an industry are doing
things more or less right. But when I look around, I see that we're making a
huge mess of things everywhere or are at least sorely inefficient when it
comes to building and growing systems. That is to say, I believe (I know) that
we could be doing much much better than we are now -- and I believe the skill
set being dismissed here is a large key to doing better. So I'm sad to see it
dismissed like this.

------
Hydraulix989
That's a shame because the theoretical grounding that comes from SICP is
enough of a clue to tell you why black box library X is crashing, runs too
slow, lacks feature Y, etc. and maybe even enough of a clue to help you
modify/hack it to get feature Z as a workaround.

------
techonup
This isn't entirely accurate- SICP is still taught as a 4-week intensive
during MIT's IAP (January) term. It doesn't fulfill any requirements, but the
student evaluations are excellent (averaged a 6.7/7 over the last two years).

[http://web.mit.edu/alexmv/6.037/](http://web.mit.edu/alexmv/6.037/)

[http://student.mit.edu/catalog/search.cgi?search=6.037](http://student.mit.edu/catalog/search.cgi?search=6.037)

------
erikb
I think it's also very natural for this time that "[the past solution] was
“more coherent” than what they have now and that they still don’t know what
the right [current solution] should be." If you ask around you that's how most
people feel about their job, their families, some more advanced people even
feel that way about their gender, political position, life goal, philosophy.

------
zerr
I was wandering what happened to those HP employees from SICP lecture videos.
Where are they now, what careers they had, etc...

~~~
gshubert17
I took the course in Fort Collins in the 1980s. (I think it may have been
before 1986? I left HP in 1986 to stay home and raise my daughter, and went
back to software development at other companies in the 1990s. I have taught
college-level intro programming part-time for 25 years, and high-school level
computing (including Java and Python programming) for 13 years.

I was greatly impressed then with 6.001 and still am today. I have worked
through most of TECS [0] within the last year, and I want to go back through
SICP next year (after I retire :-)

[0] The Elements of Computer Systems
[http://nand2tetris.org](http://nand2tetris.org)

------
blktiger
Personally, I think CS students need to understand both programming by
abstraction and programming by science (poking). The abstraction stuff is
important for designing maintainable code. The science stuff is important for
maintaining code.

------
kreek
If you're learning Clojure there's a site/book that incorporates much of the
original SICP text:
[http://www.sicpdistilled.com/](http://www.sicpdistilled.com/)

------
linhchi
I'm not techie, so i'd like to ask if my interpretation is ok. The switch from
scheme to python is in the tidal change of conceptual thinking? Previously,
giants & pioneers approach AI systematically, w consistent logic and clean
structure (like maths language).

However, for now, the narrative shifts to "poking around, hoping to poke the
right thing"?

I use Racket & its thinking for research. I think that structured thinking is
still intellectually important. So it'd still survive, as there'd still be
people sticking w it.

------
kulpreet
As someone who took the replacement 6.01 Intro to EECS, I would have much
rather taken 6.001 SICP.

I'm sorry to say, but I feel very strongly about 6.01 being the least useful
course I took at MIT.

------
varadg
As a college student who followed along Berkeley's SICP lectures online in
2015 (taught by John DeNero), I am kinda confused by the Scheme v/s Python
debate. Did I miss out on something having used Python in the entire first
half of the course v/s say CS61A taught completely on Scheme (like when taught
by Brian Harvey)?

~~~
cbHXBY1D
Yes, I believe so. I think Brian Harvey puts it aptly, "The big ideas in the
book — the ones that alumni in the real world tell us they’re using in their
work — express themselves best in Scheme."

[1]
[https://www.cs.berkeley.edu/~bh/proglang.html](https://www.cs.berkeley.edu/~bh/proglang.html)

~~~
varadg
Ahh. Do you think it will really add value to re-take the course under Scheme
exclusively?

------
benwr
Google cache:
[http://webcache.googleusercontent.com/search?q=cache%3A%2F%2...](http://webcache.googleusercontent.com/search?q=cache%3A%2F%2Fwww.posteriorscience.net%2F%3Fp%3D206&oq=cache%3A%2F%2Fwww.posteriorscience.net%2F%3Fp%3D206)

------
chris_wot
The book can be found here:

[https://media.githubusercontent.com/media/sarabander/sicp-
pd...](https://media.githubusercontent.com/media/sarabander/sicp-
pdf/master/sicp.pdf)

------
topkekz
Hal Abelson on the end of SICP at MIT (2011)

[http://codequarterly.com/2011/hal-
abelson/](http://codequarterly.com/2011/hal-abelson/)

------
shitgoose
"in the 80s and 90s, engineers built complex systems by combining simple and
well-understood parts.... Today, this is no longer the case."

yep:(

------
bparanj
Great concept! Soon monkeys will do all the poking. Humans can just watch.

------
vu3rdd
I wish the original course is offered in an alternate platform like edX.

~~~
sokoloff
The course material from 2005 (original 6.001) is available on OCW at MIT,
including videos of the lectures.

[http://ocw.mit.edu/courses/electrical-engineering-and-
comput...](http://ocw.mit.edu/courses/electrical-engineering-and-computer-
science/6-001-structure-and-interpretation-of-computer-programs-
spring-2005/index.htm)

That's an older and less polished online courseware system than edX, but it's
perfectly workable. There are also VERY old videos of Sussman himself giving
the .001 lectures. Those were easy to find, but I'd recommend the OCW site
over the original lectures.

------
dschiptsov
Yes yes.

Old school, understanding based, composable via interfaces components gave us
things like R4RS, Plan9, git, LuaJIT, nginx, Erlang, you name it.

That packing or poking crappy mindset produced so called eneterprise software
with all its ole, jdbc, javaee, corba, NodeJS, and all the other meaningless
bloatware.

BTW, this a human-universal law. Lack of understanding of grounded in reality
fundamental principles will enivetably produce piles of abstract nonsense, be
it philosophy (of Hegel), [Java] programming, theoretical physics or even math
(500 pages Coq "proofs" of abstract nonsense).

There is the law of cancer (in terms of 4chan) - any branch of human endeavor
will be ruined with enough of cosplaying idiots.

BTW2: teaching of principles is too difficult, because, like a good
philosophy, which is a study of principles, it requires extraordinary trained
and lucid mind habitually trying to separate underlying principles from human-
made "higher" or "pure" nonsense.

This habitual mental hygiene, which guards the principles from contamination
by popular memes and waves of mass hysteria is very rare trait, impossible to
sell or monetize. To teach it requires a similar mindset in students. Packers
would be unable to grasp what is it I am talking about.

The Motorcycle Maintenance book, and that part of Atlas about modern
philosophers will be a much better illustration.

------
kamran20
So painfully true. This is one of the very first things I try to determine
when I'm interviewing someone: do they have the capacity to actually figure
out how things work, or are they doing something rote that they picked up
along the way and will just blindly change code until "it works" when they hit
a serious obstacle?

And I've also worked with plenty of very senior engineers who will blow smoke
up your ass when you're really down in the weeds and you want to do "root
cause" analysis.

------
yarou
I still swear by SICP and TAOCP for anyone who wants to learn CS seriously.

~~~
mavelikara
For working as a professional programmer, SICP, sure. But TAOCP? Why?

~~~
yarou
I wrote that for anyone interested in learning CS seriously, I swear by those
two books.

I would recommend an entirely different set of books for someone who wants to
work as a professional programmer.

That being said, TAOCP really gave me a clear understanding of algorithmic
analysis. It's a hard book, but after you finish it, you won't look at
programming the same way again. Especially when it comes to design decisions
for systems where efficiency is a must.

~~~
abc_lisper
So, did you read the backflap and sent the email to Bill Gates as he suggested
;).. jk.. jk

How do you about working with such a hefty tome. I only use it a
(light)reference. Any tips on how you went about it?

~~~
pakled_engineer
I got up early everyday and read a chapter before work and tried many of the
exercises. Now I use the whole set as an almost daily reference where I work.
The prelim math you can get from MITs 6.042 either on OCW or the reg school
site [https://courses.csail.mit.edu/6.042/spring16/class-
material....](https://courses.csail.mit.edu/6.042/spring16/class-
material.shtml) if you just want to understand on an applied level what's
going on. I did it in MMIX using the book 'The MMMIX Supplement' by Ruckert to
check answers.

Re: SICP I noticed Harvard and other schools typically have an intro to CS
course then a course after in abstraction using OCaml or other functional
language. The syllabuses I've found for these second semester CS intro courses
looks almost identical to SICP ToC except no hand rolled compiler which is
probably the single most useful chapter I've ever read in any CS book.

