How to Design Programs 2nd Edition
htdp.org
htdp.org
Speaking of which, here's a 2010 blog post about how Georgia Tech stopped using HTDP, featuring an argument in the comments between the author of HTDP and Alan Kay.
https://computinged.wordpress.com/2010/05/11/playing-the-car...
And then how to build and assemble those pieces into the running file (the executable)
When you open a Github project you are greeted with a file tree, not a function tree
we still program to disk not to a database, where functions exist in an abstract space
Also, there are quite a few sibling courses now in what I sometimes call the "How to Design Programs extended universe", and some of these are a bit more project-focused. In particular, there is Marco Morazan's Animated Program Design [1], which iteratively develops a multiplayer Space Invaders-type game called Aliens Attack through multiple sections over the course of the book. The main pedagogic aims of the Universe framework are to introduce students to both event-driven programming and distributed programming, and as far as I'm aware, the Aliens Attack program is the most complex tutorial treatment of an HtDP-style program that combines both aspects. Unfortunately, the book is quite expensive.
Personally, I didn't find HtDP to be a buzzkiller, but rather the textbook that helped me understand that programming could potentially be a joyful activity rather than drudgery. As a former music teacher, I loved its insistence on practice and process. But I was also a beginner who had tried and failed to learn to code a few times over the 15 years before I read HtDP/2e. A more experienced programmer surely might not have the same experience.
[0] https://www2.ccs.neu.edu/racket/pubs/icfp09-fffk.pdf
[1] https://link.springer.com/book/10.1007/978-3-031-04317-8
I had HTDP on my to-learn list and the parent comment somehow put a damper on it.
The space-invaders project sounds fun.
Personally, I wouldn't give Morazan's Animated Problem Solving a big recommend for someone trying to self-teach CS1, especially not when HtDP and How to Code are free. In my opinion, APS is a bit over-stuffed (it has a tendency to throw relatively advanced terms, like property-based testing, at the beginning student without much context or follow-through) and it can sometimes make exercises (including the Aliens Attack ones) overly complex and tedious.
I don't think HtDP is without criticism, but if you can get through the somewhat slow-going first section, it's a great textbook. Alternatively, you can work through UBC's How to Code (H2C), which has a brisker pace. I found the first section of HtDP a bit tough-going myself, so I ended up working through H2C first. I only came back to HtDP because I found some of H2C's explanations of later material shallow, but more importantly, I felt that its exercises were generally lacking in challenge. Nonetheless, I can't recommend H2C enough. Gregor is a friendly, patient teacher, and the H2C presentation of the design recipe somehow seems more fine-grained than HtDP's version but without feeling overly complicated.
Note that you can actually access the edX version of H2C for UBC students at the CS110 course page [0], just click on the link to enroll in the "edX Edge course". It appears to be an updated version of the original MOOC course with some small additions.
[1] https://www.cs.tufts.edu/comp/50PSS-2013f/homework/trigrams....
The preface explains the goals and ideas behind the book: https://htdp.org/2023-3-6/Book/part_preface.html
Additionally you have to use generics and trait bounds extensively for some equivalent function in rust.
it's also move by default instead of copy, that saves memory copies which is a good thing?
I'm lost in 'clone everything', not a rust programmer per se.
Haskell takes the crown for modularity and safety but as a result it is less performant then rust.
Move by default is not modular. Why? Because it is a mutation. The state of your program changes after a move and your program must be structured around that.
That variable that was moved can no longer be reused in the same context so your program is less modular as a result as the definition of modularity is high reusability of modules.
Clone just means pass by copy. Make a copy and then pass the value. Pass by immutable reference works too. Just keep everything immutable for maximum modularity. But if you want to mutate things and keep things relatively modular then pass by copy (aka clone) is the best alternative.
All in all rust is typically harder to program for and harder to make elegant because of all the anti-modularity features used to increase performance and safety.
The specific concepts in the book translate to other functional programming languages, and almost not at all to imperative programming.
The general thesis of the book, that you should follow a design recipe, is a universal one. It teaches you how to design your functions and write the documentation before you begin the implementation. This is also the part that students are the worst at, in my experience (as a TA for a first year course based on this book, twice).
isn't everyone?
as some one that worked for years as a trainer at a tech commercial training company, i eventually came up with two sort of realisations:
a) teaching HOW to program is really, really hard. i was never at all good at it, though i could teach programming languages and system architectures rather well.
b) when you start out, you cannot write too many functions.
i'm not sure that the book in question would entirely agree with this. any course using it for teaching would need lots of input from the physical human instructor.
…
a) teaching HOW to program is really, really hard. i was never at all good at it, though i could teach programming languages and system architectures rather well.
It really is a way of thinking. It takes deliberate practice to develop. Students are often uninterested in developing this kind of soft skill set because it doesn’t provide immediate returns when it comes to finishing assignments.
It’s a real shame. In the long run it pays huge dividends.
I actually think the materials in HtDP complements learning Rust pretty well. What makes Rust interesting exists almosy
[0] https://www.edx.org/course/paradigms-of-computer-programming...
[1] https://www.youtube.com/playlist?list=PLw454N-VXALSIzIe_eL5U...