#2 overallClassic
6.001 Structure and Interpretation of Computer Programs
MIT OpenCourseWare
88 recommenders · 96 threads · recommended in 20 years, 2007–2026 · score 159.0
MIT's introductory course on Structure and Interpretation of Computer Programs, built around the SICP textbook and Abelson and Sussman lectures, teaching abstraction, recursion, interpreters and functional-style program design mostly through Scheme/Lisp. Lecture videos and materials are freely available through MIT OpenCourseWare.
Commenters repeatedly describe it as eye-opening and foundational, calling the lectures and book a must-study for anyone wanting to think more deeply about programming.
Programming Languagesintermediatefreevideo lectures#sicp#scheme#lisp#abelson#sussman#recursion#interpreters
Recommendations by year
20062026
By no means are you dumb. Some corollary of Dunning-Kruger Effect -- your frustration is probably proportional to your ability to think and to operate in this domain.
My summer project for myself last year was making a big working desk and a rack-mount setup for a workspace at home. I listened to Hal Abelson and Gerry Sussman, recording from 1989 (I think), when they taught on site for HP engineers; SICP in a week. I still had some surprises, things clicked for me.
https://overcast.fm/+Do0X1PN6k
https://groups.csail.mit.edu/mac/classes/6.001/abelson-sussm...
I was very fortunate to have been in the first or second batch of CS61A students that Brian Harvey taught at Berkeley. It's still my favorite class, and although it was challenging, I had far more difficult experiences with calculus.
Calculus almost broke me. The first time.
I completed some of the SICP exercises on morning train commute. Four years after seeing them for the first time. Five years after that, I returned to college for another try at linear algebra, having actually flunked it the first time.
All these people seemed to just cruise on by. But actually, everyone hits the wall at some point.
SICP is the one text I wish I'd known about when studying computer science at uni. When I finally discovered and read it, it was a truly eye-opening experience and revolutionised the way I thought about tackling problems and designing software. It may have been around for a while, but the ideas presented still hold water today.
As others have mentioned, the linked version has some definite improvements over the web version provided by MIT Press [0], which doesn't have particularly clear diagrams.
In fact, MIT Press does have an alternative version with larger diagrams [1], but the footnote links don't work.
Do also check out the 1986 Abelson and Sussman lectures [2] that accompany the text. Those two present the course in such an interesting and (dare I say it) fun way.
And for those who have already watched that and are curious, I've recently uploaded a 2004 version of the lectures to YouTube [3]. They're sourced from the SICP iCampus site [4], which is another fantastic resource, though I find the way that site presents the lectures to be a bit annoying. Completing the problem sets is a good way to check your understanding, though!
[0] http://mitpress.mit.edu/sicp/full-text/book/book.html
[1] https://mitpress.mit.edu/sicp/full-text/sicp/book/
[2] http://www.youtube.com/playlist?list=PLE18841CABEA24090
[3] http://www.youtube.com/playlist?list=PL7BcsI5ueSNFPCEisbaoQ0...
[4] http://icampustutor.csail.mit.edu/6.001-public/
Doing a BS in CS would be the best, otherwise you will need a ton of self-discipline to learn even a half of what you would learn in a degree program. If you decide to self study, and have enough "mathematical maturity", you will find everything you need on MIT OpenCourseWare, they have all the core courses available online with video lectures, solved homeworks etc. I would start with going through those two first:
Structure And Interpretation Of Computer Programs:
http://ocw.mit.edu/courses/electrical-engineering-and-comput...
Mathematics For Computer Science:
http://ocw.mit.edu/courses/electrical-engineering-and-comput...
The first one is pretty much a master class in software engineering, the other prepares you for studying algorithms, I would consider those the two main more theoretical facets of programming at a professional level. With that background you can try to work on their algorithms course:
http://ocw.mit.edu/courses/electrical-engineering-and-comput...
It would also be very valuable to eventually take all the core mathematics subjects from OCW: Single+multivariable calculus, linear algebra and probability theory - the profit is less immediate but those things do come very useful. All those six courses on the MIT OCW are top notch.
The way is Scheme -> Common Lisp -> Arc.
Scheme comes first because it is more refined and there are excellent courses and books.
CS61A probably the best introductory course. After that it is good to watch original SICP lectures by the two magicians and read the book. Then it is necessary to take a look at what HtDP team is teaching.
After this there will be no trouble with Common Lisp. Classic books are these by pg and Norvig. CLtL is just a reference.
Then, with all the knowledge so far one could understand arc.arc and appreciate what have been done there.)
With this background you will understand what Clojure really is and why, or what is Haskell, and why there is nothing special in it.
btw, there is a brilliant course by Dan Grossman on coursera covering FP. He is very clever and consistent. After this you will smile at Haskell guys.)
Update:
I forgot Emacs Lisp. An Introduction to Programming in Emacs Lisp is an excellent book that covers all the basic principles and gives a perspective how to use lisp in a real-world project.)
I'm not sure how much you'd get out of it by "banging" through it. I took SICP at MIT my first semester freshman year, and this class changed my life. I can't even begin to express how amazing I found it. I went to MIT because I wanted to study neutron stars and black holes, and I found SICP to be even more amazing than those, so I changed majors. Since I put a great deal of effort into the class, many of the techniques discussed in the book are still second nature to me.
In the the MIT class, you were expected to put in 15 hours a week for 14 weeks, which is the length of an MIT semester. I probably put in double that, because I loved the materials and exercises so much. (Due to my efforts I did get one of the very best grades in the class, out of 200+ students, but it wasn't necessary to work quite that hard to do well in the class. I'm sure that one could have learned a great deal with the recommendation of 15 hours.)
I'm sure that you can still get a great deal out of the book just by reading it carefully, and that would take a small fraction of the time that it would take to treat the book like a real class. But the best way to learn, of course, is always by doing!
P.S. Be sure to watch the lectures for the class, which are online, albeit in a somewhat abbreviated form. In fact, it might be best just to start with them, and see how you like them.
MIT hosts a lot of their course materials online at http://ocw.mit.edu/index.htm . Dig through some of their classes.
I'm not sure at what level you mean by 'beginner', but my recommendation is to run through 6.001 (Structure and Interpretation of Computer Programs). MIT has a new Python-based intro class that has since replaced 6.001, but the old class is still a very well-baked and well-respected curriculum.
After that, if you want, dig into a couple data structures and algorithms classes (like 6.006) to build up your theoretical background.
Next look into a software engineering course (theirs is 6.005). This should get you a bit of feel for diving into a large system without getting lost, or organising one of your own.
After that, just start poking around at things that look interesting. Build something shiny. (That's the great thing about our industry---you can get your tools for free, and build something useful without making a huge initial investment. That would not happen in a lot of other fields.)
There are a lot of good books here: https://pragprog.com/categories/architecture-design-and-test...
I second the comment (https://news.ycombinator.com/item?id=48327571) recommending How to Design Programs (HTDP) and Structure and Interpretation of Computer Programs (SICP). The former has an edX course (https://www.edx.org/learn/coding/university-of-british-colum... and https://www.edx.org/learn/coding/university-of-british-colum...) and the latter has online lectures (https://www.youtube.com/watch?v=-J_xL4IGhJA&list=PLE18841CAB...)
Head First Architecture (https://www.amazon.com/Head-First-Software-Architecture-Arch...) is good.
Reading about systems thinking would be useful.
Learning programming languages that have been well designed is helpful. I suggest Programming Erlang: Software for a Concurrent World and Elixir in Action.
This course has been a _huge_ help to me in my current project (a G-code previewer and programmatic 3D modeling system written for (Open)PythonSCAD).
I would recommend pairing it with:
https://ocw.mit.edu/courses/6-001-structure-and-interpretati...
and some additional online resources which I've found very helpful:
- https://mathcs.clarku.edu/~djoyce/java/elements/elements.htm...
- https://www.motionmountain.net/
and of course https://librivox.org/ and https://www.gutenberg.org/ --- for a benchmark on why, well, when my father retired to a rural Virginia county, the library was a metal carrel of books in the basement of the old courthouse, and my favourite books during the summer (when I didn't have access to the school libraries) were Hal Clement's _Space Lash_ (which my father found in a tower at the prison where he worked where reading material was forbidden) and an English textbook containing a number of short stories which my mother purchased from a table of remaindered books in a department store in a town 26 miles away to which we might drive once a month or so.
You keep saying there is some mythical "DSL" that isn't actually a new language, no new syntax, works will whatever tools (no word on what language or what tools), not an API, "adds semantic value", but there are no examples after all these comments.
Well actually it is.
This is conflating the term 'language' to mean whatever you want at the moment. There are things that execute and things that don't. These two should be kept as separate as possible, but this is a less that people usually need to learn for themselves after being burned many times by complexity that doesn't need to be there.
And data and code cannot be tell apart. I can only recommend to go throw the SICP lectures in youtube
A C program is also a data
You aren't the first person to be mesmerized by SICP, but if someone gets involved in thinking something is a silver bullet, they will tend to try to find information that validates this belief and reject info that doesn't. This pattern is found elsewhere in life too.
To understand some context, early in the life of LISP and Scheme, there weren't as many scripting languages and people mostly hadn't had a lot of experience with being able to eval tiny programs in their programs. These days that might be used to enable people to write small expressions in a GUI instead of a constant parameter. Many times in programming history people see something new and think it will solve all their problems.
Java went through the same thing. For a long time people though deep inheritance hierarchies would save them until gradually people realized how ridiculous and complicated it made things that could be simple. Inheritance from a base object let people use general data structures and garbage collection + batteries included seemed great, but programmers conflated everything together and thought this terrible aspect of programming was a step forward.
Lisp was very influential, people didn't have scripting languages back then but it isn't a modern way to program.
Data formats are a separate issue and mixing in execution to those is a bad idea too, because the problem they solve is getting data into a program. When you put in execution you no longer know what you're looking at. Instead of being able to see or read directly the data you want, now you need to execute something to see what the values actually are. When you need to execute something you have all sorts of complexity including the need to debug and iterate just to see what was once directly visible.
I would really want to have a face to face conversation, because I see you have genuine interest in the discussion, it seems we are talking past each other.
A language is more than the syntax. For example common lisp, emacs lisp, racket and scheme are different languages with exact same syntax. Java and C have very similar syntax, but are 2 languages. Source SICP https://web.mit.edu/6.001/6.037/sicp.pdf or the videos in youtube.
A DSL does not need to have a new syntax. Source wikipedia article, under embedded DSL.
If your DSL follows existing syntax, you can use the tools. Note my example with JSON.
Well actually it is. And data and code cannot be tell apart. I can only recommend to go throw the SICP lectures in youtube. Your example with GCcode is good, code is data, data is code. Also about the example, consider it is, as said, a great simplification, there are lots of details and constraints that I cannot possibly enumerate here. Also note that one way of passing data between 2 computers can by done via RPC which is a language (procedures and functions are called remotely, executing code in the remote computer, which works with the data) that was actually the case in the example.
A C program is also a data format. All is a data format. At the end in the compiler or interpreter the program is an AST, ALWAYS! And an AST ist just a data structure!
Anyone who wants to do a deep dive into understanding effective abstractions, I highly recommend SICP. The full book[0] and lectures[1] are available online for free. You don't have to know Scheme to follow along.
[0] https://mitp-content-server.mit.edu/books/content/sectbyfn/b...
[1] https://ocw.mit.edu/courses/6-001-structure-and-interpretati...
I tried getting into Lisp multiple times. Scheme was definitely the easiest way to get it to click with my brain that was used to C-like languages. If you want something more in depth, I also highly recommend SICP. There are a set of old lectures online on YouTube and MIT OCW, plus the SICP textbook is available for free online.
Have taken two of his courses (Compiler and SICP) and highly recommend them. The only thing that is stopping me from taking more is I live at the other end of the world and have to stay awake the whole night for 5 days.
Would strongly recommend watching the SICP video lectures: https://ocw.mit.edu/courses/6-001-structure-and-interpretati...
If your goal is specifically to learn functional programming, I recommend you consider Lisp-1 dialects instead of Common Lisp, like Scheme or Clojure. While CL supports functional programming (it supports literally everything) functions exist in a separate namespace, and treating functions as data can be a little extra confusing.
As for Elixir: it heavily leans on the actor model. Understanding this was the biggest hurdle for me, but once I got over that learning Elixir was a breeze (though I was already comfortable with FP by the time I picked up Elixir). If you want to go the Elixir route, I recommend trying to play around with an actor model system in a language you are familiar with first. I was familiar with Scala so I learned the actor model by playing with Akka.
My #1 recommendation to you though is to go with Scheme and watch the SICP lectures. That will sneak functional programming into your brain without you even realizing it.
I agree with the title, but not with the blog post. Strong typing is great. There is little reason not to use strongly typed systems.
The post adds "static" typing in too, modifying the argument. Dynamically typed languages allow you to easily have a very intimate understanding of your program; because you can write the program and modify it while it's running using a REPL. The post seems to conflate dynamically typed with untyped, which is very much not the same thing. The two are actually incompatible ideas.
OP: I highly recommend you look into SICP if you want a concrete counter argument to static typing for large systems. A main focus of the course is controlling complexity through abstraction as systems grow to be large, and the course was taught using Scheme, which is a dynamically typed language.
You probably know this already, but if anyone wants to learn “old-school” SICP with Scheme via video lectures, I recommend MIT 6.001 (taught by Abelson and Sussman themselves): https://ocw.mit.edu/courses/6-001-structure-and-interpretati...
The book is amazing, but it is also very extensive/overwhelming and I found that the lectures provide a better guiding structure for myself and the lecturers are also quite entertaining at times. The website also provides additional material related to the course such as exams, projects and lecture notes.
The concepts in SICP are timeless. There's nothing to be lost going through that book.
There are video lectures you can use to accompany the book: https://youtube.com/playlist?list=PLE18841CABEA24090
Also, I highly recommend the courses How to Code: Simple Data amd How to Code: Complex Data on edX that are based on HtDP.
There are SICP lectures on YouTube (I think it was classes to HP engineers?) that I find pretty entertaining. The flavor offered by the lecturers make it more worth it and can introduce you to some interesting vocabulary.
I recommend the lectures of "MIT 6.001 Structure and Interpretation" : https://www.youtube.com/playlist?list=PLE18841CABEA24090
it's not strictly about lisp but it's an eye opener to the power of the language
It's on-demand on YouTube[1] and an excellent course that is still very much relevant with very high production quality circa 1986. What makes it special is who is teaching it, which is the original authors of SICP. The course thus completely complements their book and is in the same style. The courses from later years are also on YouTube, but they don't feel the same.
[1]https://www.youtube.com/watch?v=-J_xL4IGhJA&list=PLE18841CAB...
It is much more programming specific focused, but I still think my favorite intro to programming course ever is the original 1986 Structure & Interpretation [1].
[1] https://www.youtube.com/playlist?list=PLE18841CABEA24090
Not much really; I would recommend working through SICP [0], it is fun and in the end you know a lot and can move on from there to even more advanced topics.
Together with the YouTube recordings of the lectures about the book will give you many AHA moments about why it’s so elegant etc.
Including topics like types and a prolog like logic language.
[0] https://en.m.wikipedia.org/wiki/Structure_and_Interpretation...
I'll recommend the videos from the 1980s and this version of the text, which is set nicely and has working footnotes.
Videos: https://ocw.mit.edu/courses/electrical-engineering-and-compu...
Text: https://github.com/sarabander/sicp (links to epub and html versions at the top of the README)
Simple digestable examples that show off power is kind of a cart before horse situation. However, I will try to feed your curiosity.
One simple example I can describe is from the book Practical Common Lisp and it is talked about to some degree in the SICP videos. The idea of the environment being captured as well as what it points to is a big idea. At the risk of not getting it explained 100% to everyone's satisfaction I would suggest reading about it.
I also would suggest the problem of the N queens board. It is a pretty good starting point into how this problem can be solved in lisp. I suggest the MIT SICP lecture on it because it is well paced and interesting. Also it shows off some, for the time, advanced language features.
Another good read is Norvig's PAIP book that you can read on Github. Lots of problems you can jump to with pretty good explanation in my opinion.
I'm sure there are more interesting things I could point to. However, I still consider a read of Practical Common Lisp a good starting point. The book is fairly well paced and not bogged down with learn all the language first-isms. Also, the SICP videos are pretty good to watch. I hope these points are helpful to you.
The real beauty is in how few operators you need to achieve maximal expressiveness in a programming language. It makes other programming languages seem extra. Highly recommend the SICP lectures https://youtu.be/-J_xL4IGhJA
You’re actually right, I had also taken very basic “intro” courses locally before taking the MIT course, and Grimson was the first person to explain Big O to me. Having already done some Python and C++ probably helped get more out of that course, as well.
But some people can’t drop thousands or even hundreds of dollars to have a prof or TA hold their hand as they learn programming essentials. They might have to put in more time on their own to do well in a course like 6.001, but that may be their only option. They could do Udemy courses, but the quality there seems to vary quite a bit (whereas with edX there’s some built-in vetting), and a complete beginner may be overwhelmed by the number of choices.
You could also try the MIT SICP course with accompanying lecture notes, video lectures, exams, etc.
https://ocw.mit.edu/courses/electrical-engineering-and-compu...
If you already know a little Lisp, The Joy of Clojure is a very good book to start at.
But I went through a complete journey of reading ANSI Common Lisp, The Little Schemer, The Seasoned Schemer, On Lisp and various other scheme material on the internet.
So syntax and other Lisp related stuff wasn't the problem. The Joy of Clojure book showed the Clojure way of doing things really well.
If you have to start on absolute basics of Lisp, I'd recommend watching the SICP lectures and reading PG's ANSI Common Lisp book.
If you tried reading SICP in the past but it didn't quite click, you might want to try watching the lectures as you read it: https://www.youtube.com/playlist?list=PLB63C06FAF154F047
If you are interested in SICP, I'd definitely agree with the recommendation on that page to watch the videos.
The SICP book reads like an old maths textbook (not surprisingly) and is written to accompany the course, so just reading the book without watching the lectures is unnecessarily hard work.
MIT OCW contains quite a few true gems. These lectures will still be worth watching 100 years from now.
- Differential Equations from 2015: https://ocw.mit.edu/resources/res-18-009-learn-differential-...
- The original SICP recordings from 1986: https://ocw.mit.edu/courses/electrical-engineering-and-compu...
If anyone is interested in SICP, I strongly recommend finding videos of the lectures (which are free online) and watching those, then going back to the book for reference and exercises. I found the SICP book very hard work until I discovered the actual lectures that it is meant to support.
Get a copy of SICP and do all the exercises (and or follow along with the MIT course videos on YouTube)
The article references the Henderson Escher example, which is nicely surmised in a SICP lecture from '86: SICP-3A video https://youtu.be/2QgZVYI3tDs?list=PL8FE88AA54363BC46&t=3678
I was instantly thrown back to my time watching this series and doing the exercises, which I highly recommend to anyone.
Here [0] is a video link to SICP lecture 8A about Logic Programming, which accompanies the section 4.4. It's an excellent lecture!
[0] https://ocw.mit.edu/courses/electrical-engineering-and-compu...
I read the book for the first time later in my career and for me the chapter 4 about metacircular evaluator combined with the video lectures was and still is mind blowing. When I was a freshman I was learning to do for loops with Java when SICP teaches how to create your own programming language...
It, obviously, depends. If you went through really good courses and extraordinary teachers, like old-school scheme-based Berkeley CS61A, then, perhaps, some AIMA based course with CL code, leave alone original SICP courses at MIT, then it definitely worth it. Berkeley CS188 (Python-based) is very good one too.
But if you just passed through some crappy courses which ends with "in Java" in some third-rate school, then you have, probably, wasted your time and money.
Good schools which still taught fundamental principles, like MIT, will always worth it.
The problem is we don't have much in the ways of examples.
I'd say one of the few people in the world who has given grade-a examples is Rob Pike. That said I don't agree with him on much but I do very much respect his talent for simplicity. I'm directly referring to his Regex parser. It's amazing work although I'd much rather see him implement it live from scratch.
Something like the SICP lectures on youtube. It's amazing what they go over and do in that class and how they teach you about abstracting your problem domain.
If you haven't watched the SICP video lectures [1], they are really great.
[1]: https://www.youtube.com/watch?v=2Op3QLzMgSY
There is an argument that it hasn't aged well and that with the advances of programming language design, libraries and hardware it is more of a historical look at the early days of programming. I disagree though as it gives the budding programmer a good foundation. I would also suggest SICP books/lectures. Also learn to program Visual Basic in 5 hours :-p
sicp is the best programming course hands down. https://www.youtube.com/watch?v=2Op3QLzMgSY&list=PLB63C06FAF...
This was pretty cool and seems great for young beginners.
I wonder, though, what is the modern equivalent of messing with BASIC after school? It certainly isn't Coding for Dummies is it? Would it be messing with the browser console? Messing with Python?
On a side note, I still think the beginning of the first SICP lecture is the best introduction to Comp Sci (I watch it to get motivated/inspired sometimes!). What got me into Comp Sci and programming was Ableson's quote:
Just made it feel limitless, because it really can be.
Also I am surprised that for "Expert" they recommend Coursera, edX, Udacity... but no books. In my experience, most "video courses" tend to be aimed at beginners or intermediates, with a few awesome exceptions like the Algorithms courses in Coursera and some on edX. Still though, I believe the most interesting and "Expert"-level knowledge of Comp Sci and programming is in dead tree format. But I guess it's hard to pick a few books to recommend.
Try Scheme aka Dr. Racket. It's up there as one of the "hacker" functional languages that everyone loves but no one really uses in production.
Scheme is deceptively simple though,.. so simple that you won't recognize it's beauty and uniqueness until you're really deep in. When I started learning scheme I quickly lost interest due to the fact that I felt I wasn't learning anything new.
It wasn't until I discovered sicp and had my mind blown again and again after every lecture did I realize how great lisps are. I recommend checking the course out: http://ocw.mit.edu/courses/electrical-engineering-and-comput...
These are great notes. Just bookmarked. I'm a self taught programmer (but have EE degree) and have just started to read SICP. I'm actually a Vim guy, but because it was awkward to use Vim, I've decided to use DrRacket. Why not MIT/Scheme? Because every single review would suggest me to use DrRacket, as it's more intuitive to use and it's still developed.
So what I'm doing is using DrRacket with this module: http://www.neilvandyke.org/racket-sicp/ This adds and makes the environment SICP friendly, and so far I didn't have any single problem (I'm at Chapter 1, page 67).
From Berkeley, the SICP lectures from Brian Harvey are highly recommended. You can watch them from: https://www.youtube.com/view_play_list?p=EC3E89002AA9B9879E And of course the lectures from MIT itself are good too: http://ocw.mit.edu/courses/electrical-engineering-and-comput... I'm going to watch those once I've finished Chapter 1 myself, to re-read and go over the chapter again.
Because it would be good to observe what I've done and track my progress I've setup a Git repo with my thoughts, notes and solutions about SICP and Scheme: https://github.com/fatih/sicp
This is the first time I'm exposed to Scheme/LISP and it's just wonderful. I really like the examples (though they to much based on mathematical proofs and functions).
For anyone with an interest in implementing a basic garbage collector, I recommend SICP[0], specifically section 5.3[1] and the lecture that goes along with it[2].
[0] http://mitpress.mit.edu/sicp/full-text/book/book.html
[1] http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-33.html...
[2] http://youtu.be/2s2_FAf-yQs?list=PL8FE88AA54363BC46
Yup, that's the source, thanks :).
I also highly recommend those lectures to everyone who haven't seen them. There's a lot of insight there (and even more in SICP book).
Well, I suppose the standard answer, if you have time to do the equivalent of a college course, would be "Structure and Interpretation of Computer Programs", aka SICP[1]. On the more practical side, you've got Steve Yegge's "Emergency Elisp" article[2].
In terms of your "brackety confusion", that's just a syntax issue. Just remember that you only have function calls, not anything else, and that functions appear inside their parentheses. Instead of infix operators like "+", you have functions; instead of control structures like if/while, you have functions (special functions called macros, but you don't care about the difference yet). So in your head, just convert an "operation" like "1 + 1" to a function call using the "+" function: "+(1, 1)"; then put the function inside the parentheses instead of outside and drop the commas between arguments, and you have a valid Lisp expression: "(+ 1 1)". Really, try evaluating that in the Emacs scratch buffer. Other than that, the syntax is pretty much the same as any other language. There's just less of it. If you did everything in Python/Perl/whatever using just functions, it would already look a lot like Lisp.
[1] http://mitpress.mit.edu/sicp/
[2] http://steve-yegge.blogspot.com/2008/01/emergency-elisp.html
One section of original lectures are freely available via MITs OpenCourseWare youtube channel: https://www.youtube.com/watch?v=2Op3QLzMgSY
It would be quite difficult to beat these lectures, while they appear a bit dated, the content is great.
SICP is a great way to learn about programming, although I am very surprised they got through the whole book in an introductory course. Chapters 4 and 5 cover some topics I was barely aware of nearing the end of my formal CS education.
IMO Scheme is one of the easiest languages to learn. Have a look at SICP (http://mitpress.mit.edu/sicp), one of the best introductory programming courses available, complete in Scheme. They just _use_ the language, without actually _teaching_ it, and students just pick it up on the go. Sure, there are lots of corners omitted, but at the end of SICP, you've written your own Scheme interpreter / compiler combo that you can build upon.
I'm not a fan of Scala and I absolutely loath sbt, but I absolutely recommend the FP Coursera Functional Programming Principles course[1] that uses both of them. There's an edition already running now but close to the end, however you can still join and work through it. Because it's an online course you'll find other people also working through it and, depending on where you're based, maybe some real world study groups as well.
I'd argue that the pain of downloading jars with JMV isn't that bad. Sure, it's a real pita to download them, but afterwards they're cached and immediately available. Also, if you're using Scala or Clojure then it's really easy to jump into the repl and start playing with the language.
If you're looking for "real world" fp then those may be your best bet. Haskell is a beautiful language and becoming a lot more real-world, especially compared to it's history and reputation as only an academic language. I'm not really a Haskell expert but I worked through Learn You a Haskell for Great Good [2] and found it to be one of the most enjoyable texts about a PL that I've ever found. You can read it all online for free or buy it in real-world book form.
As well as those I've worked through SICP in Racket (a lisp), SICP is a classic and well worth taking a look at even if you don't want to lisp.
I've written in all of the above with Emacs where there's great support, I'm sure there are vim equivalents of the language support, although I'll have to rely on some other HNer to point them out.
Finally, elements of FP are seeping through into non-fp languages, you can already see them in Java 8, C#, JS, Python, Ruby and more. No one can really call these languages FP languages, but if you know some of them then it might make jumping into FP seem a little less alien.
[1] https://www.coursera.org/course/progfun [2] http://learnyouahaskell.com/
I'd start with Haskell or Scheme. They are a lot easier to get started and learn than anything JVM. For Haskell, this course is awesome: http://www.seas.upenn.edu/~cis194/lectures.html
For Scheme, just do the first two chapters of SICP. In fact, do that anyway!
If a beginner does want to tackle SICP, I recommend they follow the MIT 6.001 lecture series on YouTube. It's much more manageable than simply diving into the text, but makes a great companion if you do want to keep up with all the exercises.
Granted, I'd recommend doing a L*THW or something before going to SICP, but you don't need a ton of programming experience to get something out of it.
Read SICP, take MIT's 6.001 and learn Lisp -- it'll get you ready for any other language you'll pick up. Then take any number of free courses online on Coursera, Udacity, Codeschool...
This is what I did after I quit being a trader at an Investment Bank, and moved to the Chinese country-side for 8 months of re-education :)
I was lucky enough to take a short-course version of 6.001 taught by some MIT 6.001 alums over MIT's Independent Activities Period (IAP). Materials are available here: http://web.mit.edu/alexmv/6.S184/
I really do recommend it for anyone trying to get into functional programming or to understand the nirvana of Lisp / Scheme.
Check out the first 20 minutes or so of this SICP lecture. In it, Abelson specifically mentions special relativity as a way for us humans to "model" the real world as immutable values over the continuum of time (in contrast to a mutable world that fits with OO).
http://ocw.mit.edu/courses/electrical-engineering-and-comput...
Wha-huh? Of course not. Neither is 35, 45, 55... I plan to work until I'm at least 80, if I live that long. I was still playing in the Army at 25. Take a look at MIT's Open Course Wear videos for Structure and Interpretation of Computer Programs - half the class looks past 30 and some have gray hair. Go for it.
I'm going to swim against the tide here and suggest that you might want to go back and play with Pascal some more. Pascal was the third programming language I learned (after machine language and Algol) and after all these years (including decades of working professionally with C, C++ and Ada) Pascal is still the language I have the fondest memories of. I loved it because it was simple and elegant and I could get my mind all the way around it (something I was never able to do with Ada).
There are still implementations of Pascal available, including Free Pascal and GNU Pascal. For more information about implementations, check out the Wikipedia article on "Pascal programming language".
Alternatively, if you want to get a solid foundation in Computer Science and algorithms, I would suggest you work your way through "Structure and Interpretation of Computer Programs" (abbreviated SICP). This was the textbook used for years at MIT for their introductory computer programming course, and the course materials are still freely available as part of MIT's Open Courseware program. I personally prefer the original version that used the Scheme programming language, but you could also go with the updated version that covers the same material using Python.
Edit: There are easier courses out there, but I think this one is the best if your are serious about getting a solid foundation in Computer Science.
The difference between CS50 and others is that CS50 gives you a similar experience of taking a class in flesh and blood, while offering all the flexibility of online education; in other courses, it feels like the professors are held at gun point and are asked to teach the material in 10-15 mins intervals.
It is awkward to both the teacher and the student, because teaching with a camera up so close to one's face is so, and just because Salman Khan (Khan Academy) did so, doesn't mean every Udacity, edx, and Coursera should. Remember that in the beginning, Salman Khan intended those videos for his cousins.
Just look at SEE[1], to see how effective a traditional class room style teaching can be. SICP[2], SEE and CS50 are hands down the best lectures I ever had the pleasure to learn from.
[1] http://see.stanford.edu/see/courses.aspx
[2] http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
"The Forever War" by Joe Haldemann. Possibly the best science fiction I ever read!
"The Structure and Interpretation of Computer Programs" and its video lectures[1]. Highly recommended!
[1]: http://ocw.mit.edu/courses/electrical-engineering-and-comput...
A beginner, who is willing to put in a bit of effort and that wants to discover the magic and beauty of programming?
Check out the Abelson/Sussman lectures: http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
If you wanted to get to that rather ambitious destination from your starting point, I would suggest that you would have to build a (very basic) product idea from scratch in JS + PHP + MySQL on month 2, or at the latest, month 3 -- just so that you know what the Web 1.0 technologies were. It would be one heck of a rush, but thankfully, you wouldn't necessarily have to market it. (Although you should spend a couple days learning XSS and XSRF and guarding your site against them, salting and hashing passwords against database compromise, and so on.) If you know that many-to-many relationships require a new table then you've at least got the basics down. If you can JSLint your code and understand which of the good parts of JS are good and why, then you've got those basics down, too.
As for the first month, it's worthwhile to learn two programming languages at once, so that you don't get "locked into" one particular way of thinking these things. Python's generators represent probably the prettiest iterative programming I have seen, so you might want to go with a functional language to balance it, so that you're forced to think recursively. If you're really ambitious you'll do Haskell, but that's a bit crazy, and more conservative would be to take the Abelson-Sussman lectures, crap though their audio might be, so that you learn a Lisp:
http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures/
Okay, so assuming that you've spent your first month learning two languages to tackle problems, then your second month learning the core web languages and getting some project done, what would you have to do your third month? There are a couple of options for an aspiring junior developer. One would be to write a totally new application in some other language, so that you can see what the other ones are thinking. You could go with the language that you started with, and code in Python's Django, or the confusing language that you only half-know, called JavaScript, by developing chat rooms in Node.js -- but those are probably boring, and you might want to spend a whole month learning Ruby and developing with Ruby on Rails. (It could make you much more attractive to a random employer.)
If you have done all of those and have not passed out from exhaustion, then you might start to refactor a project. Figure out the ugly stuff you did in month 2, and how to make it not so ugly. Ask people on IRC to look through your code. There is a central principle of writing good essays and novels: "There is no good writing, only good rewriting." If you come back with fresh eyes you can actually learn a lot. What library functions did you accidentally forget to use when you were writing PHP? (PHP has huge libraries and if you try to code something on them you're liable to end up on TheDailyWTF.)
And your fifth month, after all that work, should be devoted to some wild project which strikes your passion after the past four months. I imagine that you'll be lost and confused by month 3 and that month 4 will be a breather, then month 5 is to really take a new idea that's way out there, and make it shine a little.
At least then, you might have three projects you can point to with an employer and say, "look, here's a portfolio, it's not as visually polished as you might like but I was focused on functionality and it all works.
If you could really stay committed, then I think you could have a quite spectacular resume for applying as a junior developer in 5 months of full-time work.
awesome, 6.001 was one of the best courses I took.
I was in the same boat until I actually sat down and tried to do it. Look, the problem with being a self-learner is discipline, meaning discipline not to cheat by just Googling the answer. Discipline to swallow your pride that not everything will click at once so you may have to rewatch the lecture two or three times. And discipline to put your head down and go through the problems.
I'm doing 6.001 SICP course right now, the video lectures of Sussman and the other guy was mind blowing to me and most of it went over my head. I didn't quit though, found another resource for it in HTDP and am now going through it. The first part was easy, I could go through a chapter in 1 hour and do all the exercise. I'm now on the second part of the book and it's not so easy anymore, one chapter is now taking 3-5 hours to complete. But if I look at the big picture, it seems I'm par for the course as one is suppose to spend 10 hours a week per class.
I suggest you watch the original video lectures by Hal Abelson and Gerald Jay Sussman [1].
[1] http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
In my mind, SICP is better as a capstone, senior course. Think about all of us who defend it. Do we think that we could reach a better audience with that message if the audience were seniors looking for a summary/enlightenment, rather than freshmen exploring CS and engineering applications?
Indeed. I read SICP while in grad school w/ the online lectures. Frankly, I'm not sure I would have appreciated SICP nearly as much in my freshman year. With that said UCB and MIT are probably the two places you'd expect to find freshman that would appreciate it. But given the fact that the text is freely available online, and there are great lectures available for free online, it might be reasonable to say that for the inquiring student, they can use MIT's Open Courseware.
Here's an interesting direction to take SICP: http
The link you posted is dead. I'm interested in what it is. Could you post a new link?
If you really want something to change the way you think, I would suggest Scheme while reading SICP "Structure and Interpretation of Computer Programs". I believe MIT makes the newer version of the text available online, and the old MIT Open Courseware lectures that go along with the old version are very good. Also, the book "The Little Schemer" is a great way to get a handle on recursive thinking. Scheme is also very similar to the low level abstract syntax tree format of some kinds of compilers, so if you are interested in compiler theory it may be useful to know.
Erlang can be sort of considered a "Scheme with syntax". However, it is also somewhat weird, and if you're just starting with a functional language, you might as well go for Scheme.
I personally don't know that I'd recommend Haskell as a starting functional language. If you want to learn Haskell, I might suggest stating with Erlang as a baby untyped Haskell, and then move up to Haskell.
Also, Javascript is more functional than is generally realized, however, it's functional flavor may be more obvious after you have been exposed to an explicitly functional language.
One last thought, if you are interested in Web programming, Clojure is a functional flavored version of Lisp that runs on the JVM, and has a web framework called Compojure that seems well regarded.
What is remarkable about Khan Academy is that it was done. It was a huge effort. And it was done from scratch, out of nothing. Not in order to promote some crapware like Silverlight or Flash, but with commitment to teach poor people.
Collecting videos around the net and put it in one page is useless idea. There are plenty of really great courses from MIT, Yale, Berkeley and they were already aggregated on sites like academicearch.
And of course, no one could ever beat 6.001 from MIT ^_^ It is art. Btw, if you like to improve your education in CS courses from MIT are enough. For general education visit Yale. For everything else there is Berkeley. CS69A is a masterpiece.
I find these sensitivities quite amusing.
I use Java, PHP, Django, GAE, Zope and have done some Rails development too. I happen to prefer the Python-based stacks because they are very elegant and don't have the irregular syntax that bothers me on Ruby (and that Rails exploits).
And yes, from all these, PHP is the one technology that has the ugliest syntax and the most ill-conceived ideas I have ever seen this side of FORTRAN 77. Very competent people write very elegant PHP code, but a lot of people who should never been allowed to use a text editor also write a lot of PHP code that should have never seen the light of day.
Your criticism fits the clueless developer stereotype so well, in fact, that hadn't you written several posts in this line, I would have dismissed this one as a failed attempt at humor.
So, here is my advice: PHP is not the end-all web language. Nor is Ruby and Rails. Learn more stuff. Learn, not only Rails, but Ruby - and do so deeply. Learn Perl. Understand RDBMSs are not the only way to save data and why text files may be a better idea. Also, try to do the SICP path (there are very good video lectures free to download and the book is available in HTML, ePub and PDF formats). You'll emerge a better programmer.
See you on the other side.
I am also self-taught, although I dropped out of University two years into a CompSci/Engineering double major, so I will recommend some resources to you that helped me immensely. Each of these books has an associated MIT course with lecture video, notes, etc. available online.
First is Structure and Interpretation of Computer Programs[1], which you can read online, and the associated course at MIT, which is 6.001[2]
Second is the famous 'Dragon Book', Compilers: Principals, Techniques and Tools[3] and the associated course which is 6.035[4]
Extras would be the Python book 'How to think like a Computer Scientist'[5]. MIT course 6.00[6] uses the book as a reference, and the courseware is again available online.
Other than that - the usual suspects on learning C (K&R), UNIX (TAOUP[7]), the bash shell along with grep, sed, awk, more algorithms(CLRS[8]), functional programming and machine learning. Take your time, it takes years to build the relevant experience and knowledge and you are never done.
I love the MIT courses. Work and learn at your own rate. I feel that it is important to implement all the code yourself even if it looks easy in a lecture - there are little things you pick up as you write algorithms out.
Even though I had worked through SICP I still watched all the lectures again and implemented all the examples with benchmarks and unit tests. I usually set aside one day on the weekend to work on study, and usually an extra evening or two mid-week to read papers and books. Once you get into the routine it is great.
It might be the best approach to set yourself a timetable and weekly schedule, just like in UNI (ie. every Saturday plus Tuesday and Thursday nights) and work through the MIT courseware and associated books in order (6.00, 6.001, 6.035). The more advanced MIT courseware is an excellent bonus.
[1] http://xrl.us/sicp
[2] http://xrl.us/6001
[3] http://xrl.us/dragonbook
[4] http://xrl.us/6035
[5] http://xrl.us/thinkcs
[6] http://xrl.us/6000
[7] http://xrl.us/artunix
[8] http://xrl.us/clrs
That's true, and although I don't hate java or the technologies it has spawned (the JVM is a neat one, just look at it's finest offspring, clojure), trying to teach basic programming with it just seems bad. Maybe for an intermediate course on OOP, it does a good job if one wants to teach C++ or C afterwards; but as a first language, I have against it that it forces to spend too much time in syntax and inexplicable cruft (unless you're willing to explain the concept of class and static method the first day), and magic is never good for teaching if it's never explained. Just look at the classic SICP lectures: the syntax is done with in half an hour, then recursion and then higher order functions, and it doesn't feel like a brainfuck at all!
I would advise that instead of reading SICP, you should just take the class:
http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
Similarly, using available online courses to get through the crunchier topics (compilers, theory of computation, garbage collection, artificial intelligence, etc.) have always been more beneficial to me than just straight trying to read a book on my own.
You can always try starting with Lispbox - http://www.gigamonkeys.com/lispbox/
Another option is to download Franz Allegro CL Express - http://www.franz.com/downloads/clp/survey and Franz' own emacs package - http://www.franz.com/emacs/ They also have nice tutorials up there.
Or Lispworks personal edition - http://www.lispworks.com/downloads/index.html
I just set up slime into my emacs (which I use all the time anyways) and hooked up Clozure CL to it - http://www.clozure.com/clozurecl.html
On the other hand you could try Scheme, particularly Racket (ex PLT Scheme) - http://racket-lang.org/ (IDE is really nice, but sometimes confusing for newbies.. for example "Which Scheme? And why?")
Maybe your best bet would be to start either with Lispbox and some Lisp book (like the one linked on Lispbox page, it's free) - or Racket Scheme and its IDE (DrScheme) and try following SICP from here http://ocw.mit.edu/courses/electrical-engineering-and-comput... and especially here: http://academicearth.org/courses/the-structure-and-interpret... I'd recommend Racket+SICP at first, both because of less hassle with tools instead of language at first and for my personal bias toward Scheme. Just found some pointers for SICP and DrScheme here - http://stackoverflow.com/questions/939582/which-language-in-...
First of all, if SICP would take you months to go through, TAOCP will take you years-- let's not kid ourselves.
That being said: I'd definitely start with SICP, for one reason: the video lectures, available at http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
They'll take you about 20 hours to go through, and as far as I am concerned, are the best introduction to Computer Science you can get in that short a time-frame.
Don't get me wrong, recorded lectures are great. I love the SICP lectures and I'm really happy the web as given me the opportunity to see them. However if I was given the choice I'd far prefer to have had the chance to be there live and discuss the material with the lecturers, and if the lecturers at my university had said "I'm not going to given any lectures, since I recorded them a few years ago" I'd feel very ripped off. At the end of the, as good as recorded lectures are, they'll never replace "the best" teaching experiences.
I was learning Scheme from old SICP lectures online.
Best lecture EVER.
Why would professors need to make same lectures every year? It make more sense to make new lectures only when they have something new or better to say.
Sometimes video tutorials are good but my personal preference is to have a book. The best way would be to have a lecture and a book. Something like the SICP lectures and book.
I'm going to disagree, despite being one that typically doesn't learn well via video (ie peepcode, etc) I feel that I took quite a bit away from watching the original SICP lectures. To each their own, I supposed, but I'd highly recommend at least giving the first one or two a chance.
"I personally would never be the first programmer in someone else's company, many other hackers are similar."
Including myself; the one time I inadvertently violated that it ended in tears (the idiot penny pinching salesman who was the founder tried to put off really hiring the first programmer until he got at least 1 other programmer ... and the first got a better offer; I think the only benefit I got out of that was by the end of it I could port code between subtly different versions of UNIX in my sleep (1H83)). In that case, it turned out to be impossible to hire the 2nd programmer and the start-up never started up.
As for your sequencing recommendation, I think it's better to learn foundational CS with something like SICP/6.001 and then reifying it with C (this CMU course looks damned good: http://www.cs.cmu.edu/~213/index.html). I think it's easier to make your mental tool box bigger if you can do it this way.
A good CS degree will force you to do some things "for your own good" that will be valuable later. Working on the problems with others makes a difference, especially since you'll generally be working with others in real life projects. Just totally immersing yourself in the subject for a solid 3 years is significant, as is being around people who are doing serious research in the field (and ideally joining in). Having someone with a clue on tap to help you through difficult stuff makes a big difference. You need people to tell you what you don't even realize you're not getting.
On the other hand, the CS degrees at many, probably most schools aren't worth much. E.g. look at Joel S.'s essay on Javaschools, he makes the point that if you aren't taught both pointers and recursion you're wasting your time. But of course you have to learn a lot more.
To address the one school I'm familiar with:
MIT's old (and much better, in my personal opinion) curriculum is all on line at OpenCourseWare. At the very least you should do 6.001/SICP and then go from there (and you should do as much of the book as you can, the single semester course can't cover it all, especially after they had to add trendy OO to it). UCB is still teaching SICP and as I recall the lectures by Brian Harvey are on-line (and up to date, unlike the ones by Ableson and Sussman (for a class at HP), although learning 6.001 from Sussman is ... very good).
On the other hand, MIT teaches CS combined with EE; if you have no interest in or need for the latter, you can skip courses like 6.002-4 without too much harm (you do need to learn some basics, and there would be serious value to doing 6.004, it's just going to be a lot of work including the prerequisites, which include differential equations). But do 6.001/SICP first and then see what you think.
If you do want the SICP route, there's a free course going on right now at http://www.crunchcourse.com/ for SICP. I'm taking it at the moment ;)
I found this today and am going to take the course as a refresher. It's a crunchcourse for SICP, all free. And since other folks will be doing the same thing, it seems like it may have an active community paced along with it.
I work with another guy who has an EE MS, but is going to code for our startup (he's a cofounder). So we're going to do this course together, so that I can help bring him up to speed. Essentially, I'll be his more experienced study buddy, but there will still be a forum I can go to when I have questions.
URL: http://www.crunchcourse.com/class/structure-and-interpretati...
No, don't lower your expectations. If you want to get into programming, you can. It's not clear how much you've done already, but what you don't know you can teach yourself. First, start some programming projects on your own or contribute to existing free software projects. That'll force you to learn most of the practical skills you need. If you want jobs where you get to work on interesting problems, you should start learning computer science theory too. With your background you should find it fairly easy to pick up much of an undergraduate CS education from a few good books. (In your position I'd start with SICP, which is available online with video lectures by the authors at MIT OpenCourseWare.)
Even before that, you can apply for entry-level software development jobs. Companies that hire new graduates don't really expect them to have useful real-world experience. (It's a big plus if they do, but it's not necessary.) If you can learn basic data structures and algorithms, for example, you might well qualify as a college hire at a big shop like Google/Amazon/Yahoo/Microsoft that has the resources to hire a lot of junior programmers and train them on the job. And use your friends, professors, and alumni network to find companies that could use a good undergrad math student - these are rarer but they do exist. [Update: mga mentioned the financial sector, which is a great idea too. I was a joint math/CS major, and some of my math friends went straight from college to companies like Fair Isaac (FICO).]
You will need more experience before you can explore certain opportunities - an undergrad math degree doesn't open many doors by itself - but you should try to get that experience working in development, not in IT. Or if you're serious about working on research problems, also consider applying to grad schools in either math or CS.
I personally find scheme to be the simplest Lisp to learn (after working with Common Lisp, Clojure and Scheme). If you do want to learn scheme, I found the MIT lectures http://ocw.mit.edu/OcwWeb/Electrical-Engineering-and-Compute... brilliant and the little schemer http://www.amazon.com/Little-Schemer-Daniel-P-Friedman/dp/02... a lot of fun as well.
Fully agree with this, SICP won't make you an expert, but it will take away much of your feelings of being lost.
Text: http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#...
Videos: http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
I'd recommend at least the first video lecture and see if you like it.
Look at SICP lectures number 7a and 7b they are quite good at explaining this point.
Or you could just take the MIT OpenCourseWare class http://ocw.mit.edu/OcwWeb/Electrical-Engineering-and-Compute... (uses Scheme also)
In addition to the much venerated Abelson and Sussman 6.001 SICP course lectures - http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
There are 2 excellent interactive tutorial courses offered by the MIT iCampus tutorial server - http://icampustutor.csail.mit.edu/
The Introductory computer science tutorial is basically a set of audio lectures of the 6.001 course as well as interactive quizzes and problem sets.
It's very much worth the effort to go through the whole tutorial.
I'd suggest Scheme, just because the SICP videos make learning it easy and fun (http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...). And, once you get the functional concepts, Haskell and/or Erlang should be relatively easy.
The problem is not that you can't do this in Python, but that this is out of place in a Python course (you don't use linked lists in Python, for example). SICP shows that you need only a very small number of primitives to get a full programming language. You don't get this elegance with Python.
This may not be important if you teach programming to people who want use programming languages, but it is important for people who want to advance the state of the art in programming (i.e. CS students).
Maybe it's better if you teach Scheme in a seperate class class for CS students.
How do these compare to the SICP lectures, for beginners? Can anyone who has seen them both give a comparison?
(I've always recommended the SICP videos to beginners.)
I'd definitely recommend trying some self-study before grad school-- better to find out on your own if the work really interests you enough for the required investment.
As to recommendations, I second the recommendation for SICP, but I'd also suggest the video lectures: http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
Then, I'd move on to various online courses (with video)-- besides the MIT OCW resources, there are some good CS courses from UC Berkeley. Specifically, for someone getting started, I'd recommend MIT 6.046J (Introduction to Algorithms), and the Berkeley CS 61A/B/C and CS162, but your interest may vary.
Naturally, there are a lot of good video course for mathematics as well-- I enjoyed Gilbert Strang's Linear Algebra from course from MIT as a nice brush-up in Linear Algebra, for example (and as a companion to his textbook).
But the guiding thread has got to be your own interest.
My standard recommendation: begin with the SICP videos, which you can find at http://groups.csail.mit.edu/mac/classes/6.001/abelson-sussma...
I can't think of a more effective way to invest 20 hours.
im watching the videos from/about sicp now:
http://www.swiss.ai.mit.edu/classes/6.001/abelson-sussman-le...
amazing stuff, recommend everyone to watch.
I've been planning to do the same with several of the courses from AdUni.org (mainly the areas where I'm weakest--math and algorithms, in particular, but more Scheme/Lisp doesn't hurt and systems knowledge is always useful). I ordered the DVDs a couple of years ago and acquired all of the recommended texts (the ones that aren't available for free online, anyway), but only got through a few of the early SICP classes before getting sidetracked by other projects. This has inspired me to dig back in. I'll copy a few of them over to my lappy and head out to the park or a coffee shop--I'll enjoy the gorgeous weather and get some studying done.
I have not had that experience myself as I am pretty happy with the lisp books I have read. Maybe it's because I took lisp courses in undergrad, and then worked on projects where my figuring things out was driven by specific projects. I would recommend possibly a video course, and following like a real course, doing the work, and then coming up with a project where you apply it. Here is a free video course from MIT following the classic textbook, which is also available for free online http://www.swiss.ai.mit.edu/classes/6.001/abelson-sussman-le...
Adding in some practical pointers too. If you're not in a position to enroll in an accredited CompSci program, look at MIT's free online courses:
http://ocw.mit.edu/OcwWeb/web/courses/courses/index.htm#Elec... * Start with 6.001 * Make sure to hit one (or all three) of 6.042J. * I was about to claim the 6.171 (Software Engineering for Web Applications) was too out of date to bother with, being dated Fall 2003, but scanning the topic list of the course, everything listed there is still a concern in my day to day work. * Dewar and Schonberg would have you stress compilers. I would have you stress analysis of algorithms.
Computer Science is an unusually accessible field of engineering for self-learners. Purveyors of fine computer systems and programming languages market them by writing oodles of documentation, often free. There is an amazing amount to be learned just from reading the GNU manuals. All the machinery you need in order to play around with most of the latest new technology is available at Fry's.
But I should probably warn you against the idea that you can become a good programmer simply by learning to use some of the tools. That's like becoming a chess player by studying the rules of the game, and the mechanics of chess clocks. If you just want to make sure you can understand your more technical business partner when s/he talks shop, or even do some simple programming, surely, you can get a long way simply by knowing the syntax of a programming language or two and some basic UNIX. I've seen some self-taught programmers do amazing things. But for most jobs that are actually technically innovative, you're going to have to sit down and learn some stuff about algorithms, data structures, concurrency, and so on. (This is what I shall snobistically call "real CS".)
Fortunately, even "real CS" can, with lots of motivation, be learned outside of formal academia. I would recommend you start with Structure and Interpretation of Computer Programs (the book and three different series of free video lectures are on the net for free). In fact, even if your goal is just to understand the techies, SICP is probably still about as good as it gets, and the old Abelson and Sussman video lectures are quite amusing. Other great resources are ArsDigita University and OpenCourseWare.
I'd start with the video lectures of SICP:
http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/
After that you'd probably want to learn some web stuff like html, css and javascript. You can pick these up by looking at the sources of other peoples' pages, and by using w3schools:
http://www.w3schools.com/
Good luck!
There's not much theory (unless you want to do research). Common practical topics all base on history/cruft and "current vector"(like C, JavaScript, C++, Java, Python). In the end ability to solve problem wins and it's based on ecosystem size/polish mostly.
If you want fancier designs then look into less mainstream languages (elixir, pony, haskell, swift, rust, kotlin, ocaml, zig, julia, lobster). All of them have some innovations that try to solve common problems faced in (specific) software development or languages.
Generally tradeofs are between speed(runtime, compile), size, correctness and usability.
There are kinda two approaches to programming langs, one from CPU perspective(C) and other from math perspective(Haskell, Lisp, Prolog). There are also pragmatic langs for biulding bigger systems where readability and pragmatism is king (Java, Ada, Go) There's also handling of async/parallel stuff that's not well solved yet AFAIK but most developed is BEAM VM and Haskell/Pony.
To understand CPU perspective I can recommend book "CODE". Other perspecive probably SICP course.
I am average dev so maybe some lang researchers can provide more info.
Start with a refresher on calculus -- MIT's "Big Picture Calculus" video series is designed precisely for this: https://news.ycombinator.com/item?id=13634476
To develop your visual intuition, watch 3Blue1Brown's YouTube channel (he also has an "Elements of Calculus" series coming soon): https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw
Try to find the geometrical underpinning for each topic you learn. This will not only help you visualize what you're learning, but it will also help keep a red thread going as you traverse from topic to topic.
After calc, I would study Linear Algebra next since it's at the heart of numerical computing today, see: https://news.ycombinator.com/item?id=13620871 (note the comments, they also include many good pointers and references, e.g. here's a list of video's that help you visualize https://news.ycombinator.com/item?id=13623711).
The Numberphile channel is always good to keep your mind thinking in numbers: https://www.youtube.com/user/numberphile
Also, you can go through my HN stories profile -- there are a ton of math-related links and discussions in there, such as this one: https://news.ycombinator.com/item?id=13631213
Explore math topics on WikiPedia, YouTube and online lectures from MIT/Stanford/Caltech/Berkeley etc.
Group theory comes up often: https://en.wikipedia.org/wiki/Group_theory
Set theory is at the root of everything: https://en.wikipedia.org/wiki/Set_(mathematics)
Pay close attention to the concept of intervals: https://en.wikipedia.org/wiki/Interval_(mathematics)
Practice reading journal articles until you can start to understand the notation (this may take a while but persevere, the continual exposure will start building fluency).
Practice implementing the concepts you're learning in Python.
Ask questions on MathOverflow http://mathoverflow.net. Quora is also good: https://www.quora.com/
Get and read SICP and do the material for the online MIT SICP course (it's the all-time classic CS course, with a math bent): https://ocw.mit.edu/courses/electrical-engineering-and-compu...
...the SICP videos are on YouTube too https://www.youtube.com/playlist?list=PLB63C06FAF154F047
Explore and have fun!
Unfortunately, at least in my experience, most textbooks are rather unfriendly for self-teaching (including the ones very frequently recommended), especially in the more theoretical fields like algorithms, theory of computation etc. (no solutions to exercises, not enough worked out examples, general strong reliance on classroom usage), it takes a long time to find good ones and even then a very long time to get to a decent speed in a new field, surely much longer then when taking a course. Thus I would recommend relying more on some online courses at least initially:
http://ocw.mit.edu/courses/electrical-engineering-and-comput... - Very good course covering the most crucial theoretical things every programmer should now
http://aduni.org/courses/ - Good discrete mathematics, algorithms, theory of computation courses (I recommend "taking" them in this order) without assuming any prerequisites
http://ocw.mit.edu/courses/electrical-engineering-and-comput... - More sophisticated "CS 101" kind of course
I think almost everyone with some programming experience should be able to work through them in the sequence listed in one year perhaps, at a satisfying level of detail. At the same time, many people programming professionally lack mastery of this basic material.
Your attitude towards math/"timeless" cs is correct. Today's infrastructure, if you want to build something awesome four years in the future, is of little interest to you. Focus on learning general-purpose algorithms, maths, language concepts, and design sensibilities. When the time comes to pick up the technologies of the day you want to build in, you'll have an abstraction of those technologies ready to give you the context to totally own it.
This is not to say that you should totally neglect concrete tools. The strategy that I've followed in this case has served me well, and I'll outline it below:
First, learn a few "immortal tools" really well: emacs, some kind of revision control, and how to be fluent in a UNIX shell. This includes understanding the "unix philosophy," and shell scripting. None of these things are going anywhere anytime soon, and a deep understanding and fluency with them will boost your productivity by quite a lot.
Second, learn an orthogonal basis of programming languages to reasonable fluency. That is, identify the major families of programming languages, pick the one that most appeals to you in each family, and learn it. Do some project euler stuff, or hack out that application you wanted, or implement one of your favorite algorithms. The first thing I always write in a new programming language is a nondeterministic finite automaton description language and execution engine, for instance. Not only will this be fun, but it will prepare you to learn whatever is in vogue when you sit down to make your product by giving you broad context for programming languages in general.
Good luck. You have a good attitude and you're starting in the right place; linear algebra is great stuff, and so is CLRS.
Oh, and finally: for the love of god take a class that uses SICP. Or just work through it yourself with the online lecture videos. It teaches programming by giving you a series of ever-more-elaborate models of program evaluation. It will give you a deep understanding of how programming languages work, in general, which it sounds like you'd really enjoy.
https://www.mail-archive.com/mit-scheme-devel@gnu.org/msg015...
vs
https://docs.racket-lang.org/guide/scripts.html
MIT scheme does not love us as users. That's fine. That's entirely their decision of which this is one example. This aspect of the mit-scheme culture is a pretty significant hurdle to it gaining popularity. Probably one that was simply too big. I believe it has been replaced with python for 6.001 nowadays too.
Another example of the same mentality can be seen in the really great SICP video lectures. Jerry Sussman treats the audience like a compiler. He takes the view if he says it once correctly, successful communication of the idea is no longer his problem. That's a lot easier for the audience now we can rewind videos and listen to some small number of sentences again, and again until we get it. It's not exactly a fun way to learn things. It is also a massive contrast to the way say Larry Wall or Guido Van Rossum went about things. I've noticed since Perl ever single new language trumpets how friendly and /helpful/ the community is. I think that's probably pretty significant. This is not a criticism of Jerry, I don't know what his objectives with the language and SICP course were. Hard to get into is hard to get into whatever the reasons.