It literally started with an explosion in a can, and then progressively enhanced that idea step-by-step: add a lid to the can to capture the energy, add a lever to keep the can lid from flying away, and then attach the lever to a wheel so that it returns the lid to the top of the can for another explosion, add walls to guide the lid, ta-da! Piston.

It goes on like that, adding each piece of the puzzle in a logical way, until you have a mental model of an internal combustion engine. You definitely feel like you could build one from scratch (if you had the metallurgy skill.)

Don't want to link it as I am at work, but it's on YouTube.

It follows the same philosophy--start with a tube. Add a bolt. Add a trigger. Add a magazine. Etc.

I was a kid when I read it, and the book was already old, so publication date circa 1970-80. Best I can do. I trawled through book cover images but no love.

- - - -

edit to add: It's probably "Auto Mechanics Fundamentals" by Stockel. I'm still looking for pictures of the insides of the book, but going by what I can see here, it's very likely:

https://archive.org/details/automechanicsfun00stoc/page/n5

The typography matches my memory, and the description in the introduction sounds spot on, eh? Cheers!

Maybe?

>>> "It is the aim of Auto Mechanics Fundamentals to provide a thorough understanding of the design, construction and operation of automotive units. Each unit is approached by starting with basic theory, then parts are added until the unit is complete. By following this procedure, the function of each unit is explained, and its relationship to the complete car is made clear. Hundreds of illustrations were drawn especially for this text. Important areas are featured in these drawings, and many are exaggerated to place emphasis on parts being discussed. Unfamiliar words are defined immediately following the words. In addition, the Dictionary of Terms in the back of the book defines more than 1,100 terms..."

https://www.amazon.com/Mechanics-Fundamentals-Construction-O...

(This one is blue but there is another version in red)

Mastery with SQL has over 150 exercises, ranging from easy to very difficult, where you're primarily working with a single database and trying to answer interesting questions about a business (which months saw the highest revenue, best sales employee, most watched movie, find missing records, etc.).

I spent an enormous amount of time working on the exercises for this course (more than the actual content itself) and people who take the course consistently tell me working through the problems helped them learn SQL more deeply than they've learned anywhere else.

Ben Eater has a series of Youtube videos that explores how computers work, starting from first principles, and in the process you build an 8 bit computer (or a 6502 computer in a different series). He actually sells kits of the parts to build it yourself, or you can buy the parts yourself.

It’s a deep dive into how computers work, but it’s very approachable. He’s an excellent teacher, and the video format works really well for what he’s teaching - it’s hard to imagine this working as well in book form.

Build an 8-bit computer from scratch: https://eater.net/8bit Build a 6502 computer: https://eater.net/6502 Let’s build a video card: https://eater.net/vga

I’ve watched a bunch of these videos in the past few weeks and I’ve learned so much from them. I can’t recommend them enough.

https://www.nand2tetris.org/

Could not recommend enough.

It takes you through implementing some classic AI examples (such as Eliza) and teaches you how to write code in a data-first style through Lisp.

I worked through the whole thing building it in Clojure and learnt loads (not just about AI, but about writing readable code in general). I can't recommend it highly enough!

The Go stuff is really just a means to an end, the real value comes from the practical learnings of how to build a functioning interpreter and compiler (and virtual machine!) for a programming language the author made up called Monkey.

It's not a book full of theory but it lays some nice foundations that might help you understand the theory better :)

Its not exactly from scratch as there is some boilerplate code to keep you focused on concepts. It was quite fun, except I didn't really like working with SML (OCaml would have been nicer IMO, and I think you can choose to use that by finding the ported boilerplate on Github). Also has C and Java versions of this book.

I really should kick myself up the arse and go beyond chapter 3, I'm doing Go in a real project now.

Here's a video of the author (me) interviewing a reader who did all the exercises, in the process going from (his words) below middle management to creating his dream project with his dream business partner https://youtu.be/zfV3yNKp0h8. The process costs nearly nothing in money and creates more time for his family.

Here are written reviews from NYU students and clients who took the project-based class the book is based on http://joshuaspodek.com/this-is-one-of-the-greatest-classes-....

If anyone has questions, I'm happy to answer here or by email. If anyone is interested but cost gets in the way, email me also and I'll try to work something out.

My book on WebGL2 (500+ pages) takes you from understanding the rendering pipeline, WebGL2 API, etc. and progressively walks the reader by building a feature-rich 3D graphics engine in WebGL2 (ES6) that includes cameras, lights, shaders, post processing, OBJ models, etc. with a final project of a 3D virtual car showroom.

https://www.amazon.com/Real-Time-Graphics-WebGL-interactive-...

https://en.m.wikipedia.org/wiki/David_J._Gingery

https://bigmachine.io/products/a-curious-moon/

This book (although an older edition) is largely what got me into programming, and taught me so much about Rails.

* Programming WebAssembly with Rust - https://pragprog.com/book/khrust/programming-webassembly-wit...

This book steps through learning about web assembly, writing it by hand, and then implementing a server for webassembly. I had so many misconceptions about webassembly/wasm before reading this.

2. Do you have a TOC or expected date for this to be out? Extremely interested!

via his comment history :)

- Elements of Computing Systems (Building a computer from scratch on a hardware simulator): https://www.nand2tetris.org/book

Over the course of the book you build a photo sharing application from scratch. Each chapter uses new "feature requests" from a fictional manager as a way to introduce and teach new Elm concepts.

https://www.manning.com/books/elm-in-action?a_aid=elm_in_act...

(It's technically in Early Access because the print book hasn't hit the shelves yet, but all the chapters are finished and available in the online version.)

https://www.nand2tetris.org/

[0]: http://aosabook.org/en/index.html

It would be cool to see something like this for data science projects. Like a recommender system in 500 lines or less.

It doesn't actually cover game programming per-se, it's more of an introduction to 3d graphics programming book, but each chapter builds upon the last and there are assignments at the end of each chapter that allow you to play around with concepts that he walks you through so you can build a good understanding.

I've seen other books that are often recommended, and they're great by themselves, and they are nowhere near as utilitarian as this book. I cannot recommend them to beginners even if they're marketed as such.

By the end of it, you have a very good handle on a variety of concepts that you can readily apply towards, say, building a modern-day PBR pipeline.

It was my first exposure to spaced repetition learning, before I knew such a thing existed.

There are a lot of "good" books on graphics that jump you from one topic to another but never really integrate what you learn or ask you to take something covered earlier, but now combine it with a newly-learned concept to create something novel (novel in the eyes of a beginner). We need more books that integrate, because a lot of very recent (as of SIGGRAPH 2019) graphics development is about taking a set of concepts you already know, and exploiting them in different ways.

I wish that there was an equivalent for learning OpenGL or Vulkan.

Soon to become a real book published by No Starch Press!

- Land of Lisp - http://landoflisp.com/ - watch the video, it's hilarious

- Build Your Own Lisp - http://www.buildyourownlisp.com/ - Learn C by creating a lisp in C

- In the spirit of making your own lisp, I would recommend https://github.com/kanaka/mal - learn any language, by making a lisp in that language

You can buy it or read it free online (thanks again to O'Reilly for allowing us to release it under creative commons):

https://buildingtoolswithgithub.teddyhyde.io/

No prior experience with the languages are required, so it is good for a beginner wanting to dip their toes into that language and/or facet of the API.

Building Machine Learning Powered Applications walks you through building an ML application end-to-end, from product idea to a (simple) deployed version.

The free first chapter is available here https://mlpowered.com/book/

The github is at https://github.com/hundredblocks/ml-powered-applications

https://aiprobook.com/deep-learning-for-programmers/

there are plenty of books around which can walk you through the whole thing, however, of late, i have found that this: https://pragprog.com/book/jbtracer/the-ray-tracer-challenge is a pretty comprehensive.

check it out !

approximately, on the same lines, nand-to-tetris is _very_ good as well.

I really like this book because it really takes you through all the steps. However, it's very readable and provides great examples of how to actually implement some of the components.

I also like it because it explains how to use tools like Yacc and Bison, while explaining how they work underneath and the motivation for using such tools.

I leaned on this book heavily in the class where the main assignment was writing our own compiler from scratch in C, and I'm currently using it now to make a compiler in rust for a custom language.

https://www.learnwithcoder.com/

It has currently Golang, Clojure & Clojurescript single page application development courses.

The only time it could start to matter is if you want to do server-side rendering of the React app, in order to serve complete static HTML for the first page load. It can matter for SEO and page load speed. If you need SSR, you need a backend that supports it. It looks like it's at least possible with Django, according to a 30-second google search: https://github.com/nielslerches/django-react-ssr (ymmv, that repo has 4 stars, so I dunno :)

https://www.amazon.com/Code-Language-Computer-Hardware-Softw...

From binary to a full computer

Many will probably recognize the author, Charles Petzold [2], from his Windows programming books.

[1]: http://www.cburch.com/logisim/

[2]: https://en.wikipedia.org/wiki/Charles_Petzold

Also I love Real World Haskell and Practical Common Lisp

I never did get a working Go AI though. I'm a Go beginner and never created an AI that was close to challenging to me. I didn't follow the book exactly though, I did my own thing loosely guided by the book, so my failures do not necessarily reflect poorly on the book.

Did you ever get a working Go AI?

It has several worked examples, including a key/value append-only database, a CPU emulator, an NTP client, a floating point implementation, multiple graphical applications, a binary files inspector and a few others!

https://www.amazon.com/Programming-Example-Wordware-Develope...

https://www.labri.fr/perso/nrougier/from-python-to-numpy/

A book teaching Numpy vectorization.

This book is especially good for beginners in python, it feels as if the author is teaching you in person. All the exercises in every chapter builds to a mini project by the end of that chapter. One can skip the basics section and jump into the projects section which has: Alien Invasion (game programming with pygame), Data Visualization, and Web Development (using Django).

[1] https://nostarch.com pythoncrashcourse2e

It's a 20+ video course where you build a real world SAAS app. We build up 1 big app through out the course.

There's also 30-40+ hours worth of self guided optional assignments to add features into the application based on what you learn in each section. It's all positioned in the form of specifications, similar to how it would be when doing any type of job or contract gig.

Funny enough, many people have contacted me saying they took the course but don't even use Python and Flask. They were just experienced programmers using other web frameworks but wanted to see how the app all comes together so they can use the same patterns in their framework of choice.

Splash of Code by Joel Dare

I’m writing one right now on building a mini trading bot platform.

It would be great to hear what you like/dislike in these types of books.

I don’t have any marketing website up at the moment but I created this mailing list if you’re interested in following the developments http://bit.ly/tradingbotplatformbook

(Link redirects to https://cdn.forms-content.sg-form.com/f306b813-475c-11ea-9be...)

The other way around might be, as rust semi-intentionally makes it difficult to do things like linked lists or big mutable graphs that other languages encourage.

But rust->c should be fairly easy if you know c and the book teaches enough rust. Sum types get replaced with null and unions, traits get replaced with functions that take that type, etc...

A fantastically written technical book that walks through writing an interpreter for a simple programming language. It's test driven and a great introduction to the core concepts. Also a good book to get hands on with idiomatic Go code.

https://interpreterbook.com/

Thorsten does a great job talking about the concepts in the book in this Go Time podcast: https://changelog.com/gotime/107

https://pbrt.org/

https://store.raywenderlich.com/

https://compilerbook.com/

I <3 these books. They're very well written, and I recommend them every time this question comes up. I also have https://github.com/cweagans/awesome-diy-software, which is similar to the project-based-learning link that you posted.

Now half way through this Phoenix book:

https://pragprog.com/book/phoenix14/programming-phoenix-1-4

Learning Elixir/Erlang/OTP has been a joy so far. It's a new and exciting world in the middle of so much js fatigue.

https://www.braveclojure.com/

In the first half of the book you write an interpreter for a simple scripting language; in the second half of the book, you write compiler to bytecode + vm.

Very clear, fun, excellent writing. Highly recommended.

It was also kind of amazing to very quickly have something that ran more quickly than python!

https://www.manning.com/books/data-science-bookcamp

You just set up a framework in the book, but this is all easily extendable to whatever you want. I'm not the best at Go, so it's a useful "nightly devotion" of time to spend working through it for an hour or so.

I've also been going through Writing an Interpreter in Go, and have picked up the companion to that Writing a Compiler in Go. So far, that's pretty good too, but I'm focusing on Black Hat Go first, to complete it.

Used to love building robots with Legos as a teenager, but alas the real world isn't so simple. ;)

Assembly Language and Computer Architecture Using C++ and Java , Course Technology, 2004

Compiler Construction Using Java, JavaCC, and Yacc, IEEE/Wiley, 2012

https://teropa.info/build-your-own-angular/

Also, thank you for posting this question, these are the kind of books that I yearn for when I want to understand how something works!

"...you'll test and build your knowledge of Python and learn to handle the kind of open-ended problems that professional data scientists work on daily."

https://www.manning.com/books/data-science-bookcamp

It's a pretty good introduction to embedded programming, with several projects included. Valvano's course at University of Texas is also available as a MOOC.

https://www.packtpub.com/application-development/d-cookbook

More substantial is the Linux from scratch series:

http://www.linuxfromscratch.org/

https://compilers.iecc.com/crenshaw/

One prominent candidate is Horowitz's Art of Electronics. Learning the Art of Electronics is a hands on lab oriented course with one project per chapter.

There was a whole series, "A Boy and a Motor", "The Boy's Guide to Gas Engines", etc. How to build your own toys if you have few tools but the skills of a master machinist.

I noticed that it was released Sept 2018. That's not too old, but I'm curious if there's a more up-to-date version.

In any case, thanks for the feedback!

There really shouldn't be any JS books in print...

But the core value of the book is not in the tools themselves, but the concepts and principles of these tools, and how these tools work with each other. And these don't get outdated as easily!

How to Make an RPG - Build a retro-style JRPG from scratch

https://howtomakeanrpg.com/

Mazes for Programmers: Code Your Own Twisty Little Passages by Jamis Buck - covers a whole gamut of different maze generation algorithms. This author also has a great book on doing a raytracer step by step.

https://www.amazon.com/Mazes-Programmers-Twisty-Little-Passa...

Rough Cut--Woodworking with Tommy Mac: 12 Step-by-Step Projects - very nice beginning woodworking book.

https://www.amazon.com/Rough-Cut-Woodworking-Tommy-Step-Step...

The Inform (6) Beginner's Guide - introduces the Inform 6 interactive fiction language through three successive text adventure games

https://www.inform-fiction.org/manual/IBG.pdf

My anecdote, since I already had projects in mind and just wanted to synthesize how things were glued together A to Z: I went to SourceForge/GitHub/BitBucket and cloned repos for projects for the language of choice, build them, run the tests.

Also, https://github.com/search and lookup stuff of similar topic / using the same libraries (words like MIT, ISC, Apache 2, BSD are a good sign). Then check if it's permissively licensed. Also, in the end, you likely won't ever end up forking or copying. You're just getting the knowledge of how it's glued, and probably will wire stuff in uniquely for your case.

Building these projects in itself teaches the ropes of getting an environment setup (googling build errors, checking issue tracker), dependencies, test suites, and building a production-ready package.

I kept the best projects I found at https://github.com/tony/.dot-config/blob/master/.vcspull.yam.... Purely for studying the source of.

Python : Flask, Werkzeug, Django, SQLAlchemy

JS : Express, Backbone, blog posts by Addy Osmani and JS enterprise architecture and Derick Bailey on Marionette (but i don't think the backbone would be as relevant today, it def paved the way to modern frontend we see today)

C++ : OpenTTD

In the end, there weren't many books I found espoused building projects. I already had an idea of what to build - I just needed enough to "ramp up", but if you want books:

JavaScript Patterns: Build Better Applications with Coding and Design Patterns

Examples applied directly to the task at hand. All about scoping.

A python book, that hits different areas than this JS book would be The Hitchhiker's Guide to Python: https://docs.python-guide.org/

C++: Scott Meyer books are great

General programming: Code Complete