HN Academy

Really? I'm a self taught programmer, and one the best MOOC courses I took was How to Code taught by Gregor Kiczales.[^1] I believe it's based on HtDP. I thought it was great experience. Although, I did no know a little Python coming in.

[1]: https://www.edx.org/course/how-to-code-simple-data

⬐ mynameisvlad

I was one of the first people to take that course when it first launched in person at UBC! There were a dozen people in that first year pilot program.

It gets so much hate for not being a “traditional” Intro to CS course. And yet, learning about recursion so quickly and getting such a strong foundation with it is invaluable for figuring out new ways to solve problems. It’s one of the only courses that I personally think taught me something so fundamental that I still use all the time.

Gregor is also a gem of a human. I’m incredibly grateful I’ve been able to get to know and learn from him while at UBC.

* How to Code: Simple Data and How to Code: Complex Data on edX. Taught by Gregor Kiczales, of Common Lisp and CLOS fame. Uses Racket and graphical programs to teach.

https://www.edx.org/course/how-to-code-simple-data

https://www.edx.org/course/how-to-code-complex-data

* The From Nand to Teris project, The Elements of Computing Systems: Building a Modern Computer from First Principles book, and/or Coursera course. Builds a hardware stack for a CPU and then a software stack (assembler, VM, high-level language).

https://www.nand2tetris.org/

https://www.coursera.org/learn/build-a-computer

https://www.coursera.org/learn/nand2tetris2

https://www.amazon.com/Elements-Computing-Systems-second-Pri...

* The How to Design Programs book. What the edX course above is based upon.

https://htdp.org/

https://www.amazon.com/How-Design-Programs-Introduction-Prog...

* Structure and Interpretation of Computer Programs (SICP). Uses Scheme. One can use Racket with the `#lang sicp` language.

https://mitpress.mit.edu/sites/default/files/sicp/index.html

https://www.amazon.com/Structure-Interpretation-Computer-Pro...

YouTube playlist of the course by the authors: https://youtube.com/playlist?list=PLE18841CABEA24090

* Thinking as Computation: A First Course. Uses Prolog to solve problems of thinking.

https://www.amazon.com/Thinking-Computation-First-Course-Pre...

https://www.cs.toronto.edu/~hector/PublicTCSlides.pdf

* Turtle Geometry: The Computer as a Medium for Exploring Mathematics (shares an author with SICP). Uses Logo to explore turtle geometry/graphics. Can use any modern Logo implementation.

https://www.amazon.com/Turtle-Geometry-Mathematics-Artificia...

https://direct.mit.edu/books/book/4663/Turtle-GeometryThe-Co...

* Starting Forth. Uses Forth.

https://www.forth.com/starting-forth/

https://www.amazon.com/Starting-Forth-Leo-Brodie-ebook/dp/B0...

* Learning Processing: A Beginner's Guide to Programming Images, Animation, and Interaction and also The Nature of Code: Simulating Natural Systems with Processing. Uses Processing and p5.js (the JavaScript version of Processing).

http://learningprocessing.com/

https://natureofcode.com/

https://www.amazon.com/Learning-Processing-Beginners-Program...

https://www.amazon.com/Nature-Code-Simulating-Natural-Proces...

The author's YouTube channel: https://youtube.com/c/TheCodingTrain

https://processing.org/

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).

⬐ Decabytes

I second this. The first course was a gentle enough intro that I finally “got” Racket. I also learn some good design principles along the way

I think these are the 2 courses OP is talking about:

https://www.edx.org/course/how-to-code-simple-data

https://www.edx.org/course/how-to-code-complex-data

⬐ hackermailman

I believe op is talking about the entire sequence where after those 2 you learn java and typescript. I also took the entire sequence the java one was really good at explaining aliasing problems, how to figure out an existing codebase by yourself, and all taught by UBC profs.

The two intro courses that use htdp are not nearly as rigorous as the book, you never get to see anything difficult enough to warrant using the design recipes where the book you begin to appreciate that style more and more as it gets harder.

⬐ grey4228

The two courses of your parent comment are 2 out of 6 courses of this program [1]. It mentions Java and Typescript. It seems like all 6 can be taken for free if you click the individual links. Is this what you took?

[1] https://www.edx.org/micromasters/ubcx-software-development/

That indeed is the course the top comment is talking about.

The instructor Gregor Kiczales has a youtube channel named 'Systematic Program Design' [2]. His 5 minutes intro video [3] is really good IMO - one can send it to ones relatives or friends who ask you what the heck you are doing in your job.

[2] https://www.youtube.com/channel/UC7dEjIUwSxSNcW4PqNRQW8w

[3] https://www.youtube.com/watch?v=dJbpHukiQ7I

⬐ ralphc

Kiczales also wrote the Common Lisp classic "The Art of the Meta-Object Protocol"

⬐ hackermailman

Yep well 5.5 courses I took as the last one is a big project and I already was doing one so skipped it. The java courses are good in teaching how to properly make an abstract object iirc, was many years ago I took them. Probably the best intro to programming sequence you can find though maybe not enough assignments

⬐ stanulilic

Are the 2 courses sufficient on their own? or do I need to read the book as well?

⬐ drchap

The 2 courses are based on the book, but do not require, or even refer to the book.

⬐ grey4228

Those 2 are part of 6 courses. See my comment above:

https://news.ycombinator.com/item?id=26515981

⬐ theprotocol

Do you think these courses would be worthwhile for a seasoned software engineer?

⬐ ddek

I followed them a long while ago, they're fun but you'll probably find they move too slowly.

Seriously though, they are fun. Racket's way of programming with pictures is great. Maybe following the book at your own pace would be more rewarding.

There are 2 edx courses based on the book too for those who prefer video instruction.

[1] https://www.edx.org/course/how-to-code-simple-data

[2] https://www.edx.org/course/how-to-code-complex-data

I don't think there's an easy answer to this question. Software engineers still don't know how to exactly or even efficiently communicate with each other. It's still an evolving field and process. In general, it is helpful to understand software development as a sub-field of systems theory and design, so any book that discusses systems should help one better understand software development.

In general, I do also echo some of the other comments. If you are helping to design the app, you shouldn't necessarily need to understand the implementation details. In my experience, clients, whether they be external or internal or colleagues, getting too involved into what they think the implementation should be is usually a disaster. It puts pressure on the system to conform to how they think it should be, which is usually not necessarily how it should be, and it basically adds unnecessary constraints. The real constraints should be what the software should do and specifications on that, including how the software is intended to be maintained and extended.

Some thoughts on some specific courses and books that I think would be helpful to better understand the goals of software development and design and ways to think about it all:

Programming for Everyone - An Introduction to Visual Programming Languages: https://www.edx.org/course/programming-for-everyone-an-intro...

I think this course should be taken by managers, designers, and even software engineers. The primary result is that you'll come out of it knowing state charts, which are an extension to state machines, and this will be very useful for thinking about software and organizing what the software should do. Handling state is one of the primary problems in software, and you might notice that all of the various paradigms (OOP, functional, imperative, actors, etc.) in computer programming relate to the various ways people think about handling state in a computing system.

How to Code: Simple Data and Complex Data:

https://www.edx.org/course/how-to-code-simple-data

https://www.edx.org/course/how-to-code-complex-data

https://www.edx.org/micromasters/ubcx-software-development

These courses are taught by a designer of the Common Lisp language and based upon the excellent book How to Design Programs. It is essentially a language agnostic course that uses Racket to build up design paradigms that teaches you how to sort out your domain problem and designs into data and functions that operate on that data. The courses are part of a MicroMasters program, so if you really want to get into Java, that is taught in the follow-on courses.

Based upon your last comment, here are some book suggestions on how computers work:

Code: The Hidden Language of Computer Hardware and Software: https://www.amazon.com/Code-Language-Computer-Hardware-Softw...

The Pattern On The Stone: The Simple Ideas That Make Computers Work: https://www.amazon.com/Pattern-Stone-Computers-Science-Maste...

But How Do It Know? - The Basic Principles of Computers for Everyone: https://www.amazon.com/But-How-Know-Principles-Computers/dp/...

The Elements of Computing Systems: Building a Modern Computer from First Principles: https://www.amazon.com/Elements-Computing-Systems-Building-P...

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

⬐ nikofeyn

the course is very, very good. it is based upon the book how to design programs.

as a small correction though, it really doesn't teach racket in terms of #lang racket. it uses a succession of teaching languages that are implemented as #lang languages in racket. however, you do pickup pieces of racket (basically racket used as just a scheme), some of the libraries/frameworks like 2htdp, and DrRacket, the ide.

⬐ JadeNB

> 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

Probably anyone who would be interested knows it without its needing to be pointed out, but I mention in case it entices anyone that Gregor Kiczales is one of the authors of "The Art of the Meta-Object Protocol" (https://www.amazon.com/Art-Metaobject-Protocol-Gregor-Kiczal... ; edited to remove abbreviation).

⬐ jimhefferon

> The art of the MOP

Please, what does that mean? I program in Racket, and have enjoyed the vidoes but googling this phrase suggests either Prof Kiczales likes to clean floors in an innovative way, or else he is a member of Hip-Hop group. I'm not finding either terribly credible.

⬐ AareyBaba

The Art of the Metaobject Protocol https://www.amazon.com/Art-Metaobject-Protocol-Gregor-Kiczal...

⬐ sea6ear

He is the author of the book The Art of the Metaobject Protocol

⬐ dreamcompiler

The MOP is the Meta Object Protocol, which is the meta-language for controlling how CLOS operates internally. How exactly are classes, inheritance, instances, slots, method dispatch, method combination, etc implemented? In most object-oriented languages, you have very little insight into these issues and certainly no control over them. In CLOS you have both, thanks to the MOP. Just one more reason why CLOS is the most powerful OO system ever devised.

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

I have found that the best way of learning the HtDP approach to program design, at least for me (I find the book itself a bit dry), are the EdX "How to Code" free moocs [1] [2]. The instructor is fantastic. It completely changed the way I program and design.

If you like the approach and want to learn more, like, for instance, how to extend it to OO design, I list below links to several courses (most, except for the last one, offer enough material to complete them on your own, but I couldn't find any videos) at the university where HtDP's main author, Matthias Felleisen, is tenured (North Eastern). The courses are listed in the order in which they should be taken, and the rationale is explained by the professor in the paper "Developing Developers" [3]:

* CS 2500 - Fundamentals I [https://course.ccs.neu.edu/cs2500/]

* CS 2510 - Fundamentals II - Introduction to Class-based Program Design [https://course.ccs.neu.edu/cs2510/index.html]

* CS 2800 - Logic and Computation [https://course.ccs.neu.edu/cs2800/index.html]

* CS 3500 - Object Oriented Design - Spring 2018 (scaling up the 3 previous courses) [https://course.ccs.neu.edu/cs3500/]

* CS 4500 - Software Development [http://www.ccs.neu.edu/home/matthias/4500-f18/index.html]

[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] http://felleisen.org/matthias/Thoughts/Developing_Developers...

⬐ philonoist

I happen to best learn through video lectures more than reading.

Thank you for your effort. I am starting with these.

⬐ hackermailman

Could try both, the book (HtDP) is more rigorous than those two MOOCs as they're meant just as an intro where you progress into many more courses (as part of the micromasters on software development) while the book is a full grounding in CS 101. Somebody correct me if wrong but I don't remember any big-O analysis in the MOOCs or the parsing XML chapter, traversing graphs, the content on fixed-size arithmetic, plus the 500 or so exercises the book has compared to the three or four at end of each unit in the MOOCs. For example the sierpinski triangle assignment in the MOOC is pretty straightforward, but in the book you also generate a fractal savannah tree using trigonometry functions that isn't so straight forward, but when you see how they do the generative steps in the book you get that 'eureka' moment learning about Bézier curves. https://jeremykun.com/2013/05/11/bezier-curves-and-picasso/

⬐ charlysl

Agreed. But I would still recommend those interested to start with the online courses. The reason is that they hammer in the core principles that underlie all of systematic program design, with plenty of hand holding and exercises, and spending the right amount of time on each new concept, which is a lot harder with the book alone. The instructor is so good that in 10 mins one will understand what would otherwise take more than one hour with the book, at least in my case. After completing the moocs one will have a rock solid foundation from which to tackle more ambitious problems, including the ones you mentioned. Only then would I open the book.

Seems to be a newer version of what I did, so my gripes might be fixed. https://www.edx.org/course/how-code-simple-data-ubcx-htc1x

I can fully recommend HtDP for beginning programming - tried various options for my 11 year old. I needed it to involve very little help from me - tried some scratch, mit50x, both which helped but did not spark and sustain interest.

Then we came across https://www.edx.org/course/how-code-simple-data-ubcx-htc1x - love it and does not need any help from me :) planning to move on to https://www.edx.org/course/how-code-complex-data-ubcx-htc2x after that!

edit: corrected typos

⬐ jimhefferon

> we came across

There are YouTube videos (I don't know how well they fit with the current course) and they are excellent.

⬐ PopeDotNinja

+1 to learning programming thingies from YouTube videos.

⬐ rz2k

Do you mean the online HarvardX CS50 course? I started it when MOOCs were first appearing, and it includes Scratch. It looked very enthusiastic and buzz-worthy to me (which can be very good for a lot of people). However, past students doing a music and dance routine on stage about how exciting it had been, and the first lectures concluding with announcements of pizza parties with Facebook recruiters was too much for me, in that I felt too old.

Alternatively, the MITx 6.002 course on Computational Thinking is also for undergraduate students, but it had a greater focus on programming being integral to the sciences and other fields. I don't recall the the curriculum exactly, but even though the course is an introductory one I think some of the concepts might be a little daunting for a young teenager.

In addition to the UBC courses, another introductory treatment that won't overwhelm to a committed young learner is the DartmouthX C Programming with Linux. One of the instructors, Petra Bonfert-Taylor, taught a very accessible introductory complex analysis course on Coursera, and seems especially interested in first experiences students have with topics so that they are not discouraged. She has written a number of articles on teaching an introductions to new subjects.

⬐ tshanmu

my bad - yes, I meant the Harvard CS50 course. Thanks for MITx 6.002 and DartmouthX C Programming with Linux - The DarmouthX one would be a good second course if the interest still continues.

SICP, although an excellent book, is not a good introduction to programming.

[1] thoroughly explains why

[2,3] based on How To Design Programs [4] is a much better intro; you should read SICP after completing this

[1] https://www2.ccs.neu.edu/racket/pubs/jfp2004-fffk.pdf

[2] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x

[3] https://www.edx.org/course/how-code-complex-data-ubcx-htc2x

[4] https://htdp.org/

DrRacket IDE [0] + the SICP compt language [1] and you can start writing it instantly in a well built and maintained environment that’s racket based and pretty fleshed out library wise, certainly nothing compared to Clojure but among the rest, it’s the best (imo), I recall Carmack writing a server in Racket for fun and praising the experience a few years back.

[0] - https://racket-lang.org

[1] - http://docs.racket-lang.org/sicp-manual/index.html?q=sicp#%2...

Additionally, if SICP proves too slow going or difficult math wise [3] you can always use drracket for HtDP [4] and it’s corresponding misnamed edX course(s) [5] and later on, PLaI [6].

[3] - http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-h...

[4] - https://htdp.org/2018-01-06/Book/part_preface.html

[5] - https://www.edx.org/course/how-code-simple-data-ubcx-htc1x

[6] - http://cs.brown.edu/courses/cs173/2012/book/

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

⬐ Serow225

Thank you so much, that sounds like exactly what I need to make a (successful this time) deep dive into FP. Cheers!

⬐ tosh

The course is taught by Gregor Kiczales (https://en.wikipedia.org/wiki/Gregor_Kiczales) prvsly at Xerox Parc and co-author of the CLOS specification.

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...

⬐ joshcanhelp

Thank you for this. I've been programming for a while and always appreciate another perspective on things. Starting with 3 now!

⬐ charlysl

It is great that I have helped you learn about 3, enjoy!

⬐ kakaorka

Thank you for this valuable advice. I always love to learn more about programming.

Thank you for adding that — I didn't know the edX courses were still online under a different name! The links from wikibob's comment for those interested:

https://www.edx.org/course/how-code-simple-data-ubcx-htc1x

https://www.edx.org/course/how-code-complex-data-ubcx-htc2x

I also love Gregor's teaching style and philosophy. It clicked with me and felt obvious and natural in a way the book never did.

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

⬐ noelwelsh

Can you expand on what you found lacking in the book that the online courses provided?

⬐ stronglikedan

If I understood the parent comment correctly, it's not that the book was lacking anything, it's just that the online courses were more accessible.

⬐ baldfat

I wouldn't say it needs an editor. It is dense! Very dense. I started the book 20 times. I would go from page one till I got stuck and then go back and see what I missed. Took forever to get through it but it was the best thing I have gone through learning anything in computer science.

⬐ skrishnamurthi

Are you looking at the first edition or the second? The first is very dense early on. The second was rewritten to avoid that. Take a look at the second edition instead: I'm confident you'll find it qualitatively very different. https://htdp.org/2018-01-06/Book/

[Disclaimer: co-author, so I'm biased.]

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

You can take a look at the book How To Design Programs (HTDP) [1]. It's similar. The 2nd edition printed book is going to be released soon [2]. There is a paper from the authors of HTDP comparing it to SICP [3]. By the way, there is an couple of online courses at EDX that covers content of HTDP [4][5].

[1] http://www.ccs.neu.edu/home/matthias/HtDP2e/

[2] https://www.amazon.com/How-Design-Programs-Introduction-Prog...

[3] https://en.wikipedia.org/wiki/The_Structure_and_Interpretati...

[4] https://www.edx.org/course/how-code-simple-data-ubcx-htc1x

[5] 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").

⬐ tapanjk

Thank you for the pointer to Gregor Kiczales's EdX course. I am a few modules into this course and find it valuable.

⬐ punchclockhero

Where did you find trouble in working through it? I think the design recipe was insufficiently explained, which was fixed in Kiczales' course, but I found it too slow paced and without challenging exercises. The tight integration with the Racket manual is the book's greatest strength IMHO. That and the Bob Ross-like style.