#42 overallEvergreen
How to Code: Simple Data
edX
10 recommenders · 17 threads · recommended in 8 years, 2017–2026 · score 13.3
An introductory edX course from the University of British Columbia, taught by Gregor Kiczales, that teaches systematic program design using Racket and the How to Design Programs approach. It is the first of a two-part sequence with How to Code: Complex Data.
Commenters call it a very solid, learner-friendly introduction to programming based on How to Design Programs, and say it is free to take as individual course.
Algorithms & Data Structuresbeginnerfreeinteractive MOOC#racket#program design#how to design programs#scheme#kiczales#edx
Recommendations by year
20062026
I'd highly recommend looking at the edX course "How to Code: Simple Data" and "How to Code: Complex Data" as an introduction to computer science. Those two classes were created around a solid pedagogy of how students learn to break real world problems down into code. Dr. Kiczales is incredibly good at taking everything step by step and making sure nothing gets left out or missed.
I took CPSC 110 at UBC with Gregor Kiczales (who worked at Xerox PARC). It was the best course I’ve ever taken.
The course can also be completed for free: https://www.edx.org/bio/gregor-kiczales
How to code - simple data, and how to code - complex data together make up the material in CPSC 110 (though there are probably some differences). They’re completely accessible with no background requirements.
The courses are based on this curriculum, which uses HTDP: https://programbydesign.org/
The programming language used is based on scheme.
i highly recommend the courses how to code: simple data and how to code: complex data to supplement your learning to address the quoted goal. don’t be put off by the teaching language or the simplicity at the start. it gets more complicated as you go. the courses teach systematic program design and are based upon the book how to design programs.
everybody and their dog knows python. you will not separate yourself by just knowing python. so in the long term, you need other skills beyond “just programming”. and much of the industry is moving to functional-first multiparadigm langauges and more and more concurrent/asynchronous programming. python is a terrible choice for both of those and there is no clear evolution for python in those directions. it is a very outdated language in my opinion, its usage and amount of libraries available for it aside.
by all means, learn python, since there are a lot of resources and jobs that need it, but i highly recommend also learning a functional language. my recommendations would be f# (a .net language) and elixir. f# is a very ripe language for automation, probably even more so than python.
there are also python courses by MIT on edX you should check out. (actually, they are more computer science courses that use python, but there is an advanced one for using python for scientific applications.)
I highly recommend Gregor Kiczales‘s CS classes from UBCx as a starting point [0]
Gregor’s courses are based on the “How to Design Programs” book that Matthias Felleisen at Northeastern, Shriram Krishnamurthi at Brown, and others wrote.
They have a great paper discussing the pedagogical philosophy called The Structure and Interpretation of the Computer Science Curriculum [1]
[0] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x
[0] https://www.edx.org/course/how-code-complex-data-ubcx-
[1] https://www2.ccs.neu.edu/racket/pubs/jfp2004-fffk.pdf
For learning how to program, How To Code [1] (based on How to Design Programs [2]) is tragically underrated given that it's hands down the best approach to learn how to program (actually, more importantly, how to think about programming) of the many I have looked at. Wish I had known this years ago. Rarely the best learning resources are widely know, so sad.
I decided to give this course a go after reading the eye-opening paper The Structure and Interpretation of the Computer Science Curriculum [3], and then discovered the edx course in HN [4] [5].
Although having programmed for many years it totally changed the way I look at programming; I followed this with the sadly unfinished but still excellent How to Design Classes [6], which consistently extends this initially FP approach to OO. To check how this approach is language neutral, have a look at Design Recipes in C [7].
Another neglected but wonderful resource is MIT OCW Elements of Software Construction (the 2008 version) [8], which, like the above, is centered around design rather than coding.
What did I get out of all this? A systematic approach to programming.
[1] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x
[2] https://htdp.org/
[3] https://cs.brown.edu/~sk/Publications/Papers/Published/fffk-...
[4] https://news.ycombinator.com/item?id=9810542
[5] https://news.ycombinator.com/item?id=16455240
[6] http://www.ccs.neu.edu/home/matthias/htdc.html
[7] https://hci.uni-hannover.de/files/prog1script/script.html
[8] https://ocw.mit.edu/courses/electrical-engineering-and-compu...
Just wanted to note that HtDP is the best pedegogy for teaching the foundations of CS that I've ever found.
However, the book really needs professional editing.
Instead, take a look at the Intro CS classes from University of British Columbia [0][1].
They are taught by the excellent Gregor Kiczales, and directly follow the course structure from HtDP, in an extremely learner-friendly way. Absolutely the best online course I've ever done, Gregor really put an enormous amount of effort into doing this right.
[0] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x [1] https://www.edx.org/course/how-code-complex-data-ubcx-htc2x
The approach in this book is incredibly important and deserves far wider awareness than it has had so far.
Unfortunately the book itself is less than ideal for working through directly, it would benefit greatly from the polish of professional editing.
However, Gregor Kiczales of University of British Columbia has a absolutely top notch class he teaches based on the book. It's available free on EdX: https://www.edx.org/course/how-code-simple-data-ubcx-htc1x Don't be put off like I was at first by the mass-market title ("How to Code").
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.
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.
No one can convince me that Python is an easy or simple language.
For parentheses, I find Racket and in particular Scheme to be enjoyable. My primary reasons are that it creates a massive amount of regularity and consistency in the language, of which there is none in Python. I had my girlfriend at the time take the How to Code: Simple Data course on edX, which uses the Racket learning languages. Not once did I need to answer a syntax question. Not one complaint about parentheses. She had no prior experience programming.
I find the people who whine and moan about parentheses are usually ones who have massive preconceived notions of what programming should look like or are so deep in some other language they are resistant to change.
I honestly feel like the best textual syntax is something like ML (as found in F#) or Scheme. Anything else is basically just random tweaks and way too much time has been wasted on textual syntax, which is conceptually bounded in terms of its expressiveness. But programmers and computer scientists are extremely myopic. Somehow we graduated from punch cards to text files and have plateaued ever since.
I'm not really sure what the commenter meant by that, but in my experience, all I ever needed was the auto-formatter and parentheses matching DrRacket provides. Matching delimiters occurs in any language, it's just that you have more of them.
I recommend taking a look at the courses How to Code: Simple Data and How to Code: Complex Data on edX.
https://www.edx.org/course/how-to-code-simple-data
https://www.edx.org/course/how-to-code-complex-data
They use Racket and are based on the book How to Design Programs. I think they're a great supplement to SICP, which is an excellent book you should stick with. The book The Little Schemer is also helpful for solidifying recursion principles. The Programming Languages courses (Parts A, B, and C) on Coursera are excellent two. Part A uses SML, and is another good source for recursion practice, Part B uses Racket, and Part C uses Ruby.
Lastly, are you going through SICP using Scheme or Racket? If not, I highly recommend doing so (in the case you are using the Python version of the book, which has been modified heavily from the original).
I think the first question is scheme, or Common Lisp? The answer depends on what your style is. After trying both I like scheme better but I agonized over this decision for awhile, though I enjoy sbcl and CLISP is dear to my heart.
In terms of schemes you have a wide variety to pick from. Gerbil, Racket, Gambit, Chez, Chicken and many more. Racket is a great all around choice. There are schemes that do various things better than it, but it can do most things well. It has two great edX courses to learn from (How to design simple data, and how to design complex data) and is how I initially learned.
Chicken is one of my favorite schemes and is probably the one I would use if I wasn't using Racket. It's so portable since it compiles to C. I love the egg system, and I like the logo. Gerbil is a performant systems level scheme. I remember there being an article about someone in the Common Lisp community considering jumping to Racket, but ending up on Gerbil Scheme for what it's worth. I haven't used it
Chez is another super performant scheme, and is actually the backend for the Racket programming language as seen in the article above. It was only open sourced a few years ago so it might be difficult to find solutions or get answers. I've used Guile, I appreciate the mission, but I found it wanting. I've heard people ship Gambit scheme apps onto IOS so if you are looking at mobile apps that might be the way to go, I'm sure Chicken could do that to. I have also heard that Gambits Cffi is one of the best in the business, so if you need to interface with a lot of C code that might be the way to go.
If videos are okay i would recommend the course on edx.org taught by Gregor Kiczales "How to code: Simple Data" and the successor about complex data. They are based on the book "How to design Programs" also from MIT IIRC.
I'd say Racket is a general purpose multi-paradigm language that is well designed.
Good for use cases where you otherwise might find code written in JavaScript, Python, Clojure or Ruby.
You can do web development with Racket https://docs.racket-lang.org/continue/
One thing that makes Racket somewhat special is that it can be used to build your own languages (e.g. domain specific languages) with it as it comes with the tools and a community that has experience in it.
https://beautifulracket.com/
There also is a great introduction to programming online course with Racket by Gregor Kiczales https://www.edx.org/course/how-code-simple-data-ubcx-htc1x
I am not an expert, but maybe because of that I believe that I can offer valuable advice to those who are totally new to functional programming (or feel that they are missing something), and want to get the core basics down cold without getting drowned in accidental complexity, do yourself a favor and start with edx's free moocs "How To Code" [1] [2], which are based on "How To Design Programs" [3]. After that, you will cruise through the recommended classics above.
If interested in why if you are an FP newbie said material is superior to SICP , read the pdf paper "The Structure and Interpretation of the Computer Science Curriculum" [4]
[1] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x
[2] https://www.edx.org/course/how-code-complex-data-ubcx-htc2x
[3] https://htdp.org/
[4] https://www2.ccs.neu.edu/racket/pubs/jfp2004-fffk.pdf
Just to note, while the classes are part of a paid program at EdX, you can enroll in the individual classes for free. I went through the first one a few years ago and really enjoyed it.
https://www.edx.org/course/how-code-simple-data-ubcx-htc1x
Is this their first time programming? If yes, the approach to learning computer science is more important than the particular language used.
There's something to be said for David Malan's approach in Harvard's CS50 [0]. He and his team work very hard to make computer science exciting and get the students to have some results quickly. The production values are incredibly high. He takes the class through C and Python.
Coming from a very different approach, you have Matthias Felleisen at NorthEastern University and his How to Design Programs (HtDP) book [1]. Matthias has written extensively on the decisions behind HtDP [2][3]. HtDP uses teaching languages built into DrRacket (which was originally based on Scheme) to gradually introduce new concepts to students.
HtDP is based on the classic Structure and Interpretation of Computer Programs (SICP) from MIT [4], but it addresses some criticisms of SICP as an introductory text. Namely that SICP leans too heavily on domain knowledge outside of computer science.
The course webpage [5] for Fundamentals I from NorthEastern is not very useful for self-study. Instead check out the EdX course "How to Code: Simple Data and Complex Data" [6] by Gregor Kiczales at University of British Columbia.
Unfortunately the course has been branded as "how to code" for marketing reasons, but overlook that because it is a very solid offering that is directly based on HtDP. In fact, Gregor's page outlining and summarizing the HtDP design recipes for How to Design Functions, How to Design Data, and How to Design Worlds, is significantly clearer and easier to comprehend than the original explanation from the book.
The only limitation with the EdX How to Code course is that for some reason they are only "open" for enrollment once pear year. Fortunately the first course is currently open at the moment. Obviously don't bother with the verified certificate/MicroMasters stuff, the content is the only important thing.
Also of note if you're still looking for Python based, is the newish Berkeley CS61A course taught by John DeNero [7]. It is the most all-in-one option for self-learners as the book, the course assignments, and the videos, are all freely available online, and well organized. Similar to HtDP, DeNero's CS61A is also based on Structure and Interpretation of Computer Programs. I have not yet gone through this course so I can't speak to the content first-hand. Of historical note, the course was taught by Brian Harvey using SICP and Scheme up until he retired a few years ago. Brian wrote his thoughts on the change and there was a discussion here on HN [8].
DeNero has written his own book called Composing Programs [9]. Additionally the couse uses Phillip Guo's pythontutor.com for visualizing assignments.
All in all I would say if you are good at self-teaching and don't mind the lack of videos or course materials, check out SiCP. Otherwise, if high production values are appealing then check out CS50. And if you want an all-in-one package that has some of the same solid foundation as SiCP, then go for Brian Harvey's CS61A.
Hope this is useful to someone.
[0] CS50 at Harvard: https://cs50.harvard.edu
[1] How to Design Programs book: http://www.ccs.neu.edu/home/matthias/HtDP2e/
[2] Essay by Matthias on The Philosophy of HtDP: http://www.ccs.neu.edu/home/matthias/OnHtDP/turing_is_useles...
[3] Essay by Matthias on Growing a Programmer: http://www.ccs.neu.edu/home/matthias/Thoughts/Growing_a_Prog...
[4] The Structure and Interpretation of the Computer Science Curriculum: http://www.ccs.neu.edu/racket/pubs/jfp2004-fffk.pdf
[5] Fundamentals I at NorthEastern: https://course.ccs.neu.edu/cs2500/
[6] EdX course based on How to Design Programs: https://www.edx.org/micromasters/software-development
[7] John DeNero's CS61A at Berkeley in Python: http://www-inst.eecs.berkeley.edu/~cs61a/fa16/
[8] Brian Harvey: Why SICP matters https://news.ycombinator.com/item?id=4784827
[9] John DeNero's Composing Programs Book: http://composingprograms.com