12 ms·

Ask HN: Books like “Crafting interpreters” or “The ray tracer challenge”?

• abhijat 4y ago
  Hands On Rust: walks you through building a dungeon crawler game.
  • garren 4y ago
    Multiplayer Game Development in Rust (early access) - haven’t read it, but related to your post. https://www.manning.com/books/multiplayer-game-development-in-rust https://www.manning.com/books/multiplayer-game-development-i...
  • metadat 4y ago
    Wow, this sounds super cool for rustacean noobs like me. https://pragprog.com/titles/hwrust/hands-on-rust/ https://pragprog.com/titles/hwrust/hands-on-rust/ If you have an O'Reilly membership the ebook is available at no additional charge: https://learning.oreilly.com/library/view/hands-on-rust/9781680508796/ https://learning.oreilly.com/library/view/hands-on-rust/9781... Otherwise $30 is a little steep for an ebook.
    • garren 4y ago
      Keep an eye on their twitter, pragprog occasionally has coupons, usually on holidays. Manning always had coupons and deals. Both pragprog and Manning blew past O’Reilly in terms of quality of content years ago. In both cases you’re paying for non-DRM’d media: mobi, pdf, epub. O’Reily’s Safari service is okay, but last I checked you’re stuck reading online (not bad, but not ideal), or using their reader app (not great). Huge selection though, and I think some manning, pragprog, and no starch books are included. If the book is good, ebook or physical, I generally won’t blink at $30.
  • nouryqt 4y ago
    The author of the book also has a different, free version in the same direction where you build a roguelike. https://bfnightly.bracketproductions.com/rustbook/ https://bfnightly.bracketproductions.com/rustbook/
• busterarm 4y ago
  From Nand To Tetris, the Book: https://www.amazon.com/Elements-Computing-Systems-second-Principles/dp/0262539802/ https://www.amazon.com/Elements-Computing-Systems-second-Pri...
• bmitc 4y ago
  These types of books are my favorite style. I typically use whatever language I'm trying to learn and get more practice with (usually F#, Elixir, or Racket) instead of whatever the book suggests, if it does suggest one (usually Python or some OOP language). But sometimes the language used in the book is fun, like Logo or Prolog. * Mazes for Programmers (by the same author of The Ray Tracer Challenge but is not as language agnostic) * The Elements of Computing Systems: Building a Modern Computer from First Principles * Programming Machine Learning: From Coding to Deep Learning * Writing an Interpreter in Go and Writing a Compiler in Go (both by the same author) * Introducing Blockchain with Lisp: Implement and Extend Blockchains with the Racket Language * Exploring Language with Logo * Visual Modeling with Logo * Turtle Geometry: The Computer as a Medium for Exploring * Thinking as Computation: A First Course (uses Prolog to solve various problems in small projects) * Functional Web Development with Elixir, OTP, and Phoenix: Rethink the Modern Web App
  • troymc 4y ago
    I would second the recommendation of Mazes for Programmers. The author used Ruby, but I used Python and that was actually good, because it forced me to really understand the algorithms, rather than just giving up and copying the Ruby code.
    • bmitc 4y ago
      Nice. I have the book but haven't gone through it yet. I still need to finish up my F# and Racket ray tracers from his ray tracer book (a decent way in but was refactoring last). I actually could stand to learn Ruby but I'd probably still do it at least in F# or Racket. I found out about the book from an F# implementation that was posted on Reddit.
  • schnitzelstoat 4y ago
    The Elements of Computing Systems is the book from the Nand2Tetris course. I can absolutely recommend it, 100%. I think it's the best course I've ever done, ever. Including all of my courses in University and Graduate school let alone Coursera.
• shreyshnaccount 4y ago
  Is there any book for web dev (maybe Django?) that uses this method? Should we write one?
  • killingtime74 4y ago
    https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial...
    • shreyshnaccount 4y ago
      LOVE THIS. I'm going to curate such resources. Maybe make an awesome list.
  • clawlor 4y ago
    "Practical Django Projects" by James Bennett was very good, but was released back for Django 1.1 and I don't know how much it's been updated since. Walks the reader through creating the prototypical Django application: a blog. Still maybe worth a read, as the core concepts haven't changed all that much.
• FiberBundle 4y ago
  Appel [1] is fairly good for learning compilers. He leaves a lot of the material to the exercises, which are somewhat frustrating,but if you fight through them you'll definitely be rewarded. [1] https://www.cs.princeton.edu/~appel/modern/ https://www.cs.princeton.edu/~appel/modern/
• smueller1234 4y ago
  Not particularly hip anymore, but "Higher Order Perl" was great fun and has a bit of that style both in the incremental construction and also a little bit in the writing style. But it's been over a decade since I last picked it up.
  • khrbrt 4y ago
    Seconding this book. The section on closures helped me solve a tricky parsing problem for a research project.
  • dd444fgdfg 4y ago
    How did Perl "lose"? It's such a great tool, super powerful and concise. One of the best languages out there, but doesn't seem to have much adoption these days.
    • dragonwriter 4y ago
      > How did Perl "lose"? It lost by, as you say, it... > doesn't seem to have much adoption these days.
      • dd444fgdfg 4y ago
        but it's such a shame, it's a lovely tool
• rohitpaulk 4y ago
  You'll love codecrafters.io
  • thundergolfer 4y ago
    Seconded. Not a book, but the first thing I thought of to recommend OP.
  • dprophecyguy 4y ago
    I tried codecrafter but it has too much of a jump without providing any guidance or anything for a person who might not have much knowledge about building complex projects. I really love the idea of building small projects where you conquer one problem at a time. As an idea there could be nothing better than codecrafter but i would like some additional reading material / guidance in terms of moving forward when you are stuck. If i am doing something wrong let me know, would love to know how can i tackle these kinda problems.
• jamessb 4y ago
  500 Lines or less [1,2] might be of interest: it doesn't build up a single complex project from scratch, but it several show the core implementation of various complex types of software. [1]: https://aosabook.org/en/ https://aosabook.org/en/ [2]: https://github.com/aosabook/500lines https://github.com/aosabook/500lines
• chillpenguin 4y ago
  Fractals, Visualization and J By Clifford Reiter
• agarren 4y ago
  Build a Blockchain from scratch in Go [0] - don’t own it, haven’t read, looks interesting. Distributed Services with Go [1] - build a logging service, get it on the network, modify for distributed access, make deployable. Loaded with tests. Have read most of it, haven’t completed, very impressed. Fun. Build an Orchestrator in Go [2] - own it, started it, haven’t completed. Like it so far. Early access, so not finalized yet. Would also second both Crafting Interpreters and Write an Interpreter in Go. [0] https://web3coach.gumroad.com/l/build-a-blockchain-from-scratch-in-go https://web3coach.gumroad.com/l/build-a-blockchain-from-scra... [1] https://pragprog.com/titles/tjgo/distributed-services-with-go/ https://pragprog.com/titles/tjgo/distributed-services-with-g... [2] https://www.manning.com/books/build-an-orchestrator-in-go https://www.manning.com/books/build-an-orchestrator-in-go
  • rschachte 4y ago
    Distributed services with go was incredible. Really made me think any software abstractions more. Also I kept getting motivated to dive into things deeper like RAFT consensus, etc
• sarupbanskota 4y ago
  Here's like a 100 resources: https://github.com/codecrafters-io/build-your-own-x https://github.com/codecrafters-io/build-your-own-x
• mhh__ 4y ago
  The struct and interpretation of classical mechanics is a good one. The only thing I'd say is that complexity in this styles of projects is not in the code. Unless you start a new compiler from scratch I'd say something like 70% of my time not thinking about language semantics are spent thinking about target semantics, not anything you'd see in a book. Any I almost literally do mean anything. One slightly left field approach is that although Leslie Lamport has a very math-first writing style he actually typically does build up to the analysis of more and more practical systems when he writes about TLA+. Knuth sort of does this with the caveat that you have to be very good at reading through the lines if you want a tutorial-esque experience.
• rg111 4y ago
  1. Nature of Code- simulating and modeling many things in nature. 2. Data Science from Scratch- building a Data Science library from scratch. 3. Deep Learning from Scratch- building a Deep Learning library from scratch. 4. Realm of Racket and 5. Land of Lisp- developing games with Racket and Lisp. 6. The Little Schemer- not only teaches you to think recursively, but also how to implement basic functions like addition, multiplication, list-related function from using Scheme for Scheme. 7. Genetic Algorithms in Elixir 8. Genetic Algorithms and Machine Learning for Programmers
• ThePhysicist 4y ago
  "Physically based rendering: From theory to implementation" by Humphreys and Pharr.
• abhijat 4y ago
  There's also a book called "building git" on writing git from scratch in Ruby.
• deleted 4y ago
  [deleted]
• cben 4y ago
  "Understanding Computation: From Simple Machines to Impossible Programs". I knew many of topics and enjoyed it nonetheless. Highlights: + Very insightful chapter on different flavours of language semantics, and specs vs implementation. + The standard CS automata/ grammars stuff, but with working code. + Fun chapter on FizzBuzz in lambda calculus (it's also the free sample+video). Whats vool there is not just showing you _can_ compute everything (of vourse you can) but that you can build high-level constructs so the resulting code is todally clear. + A bit of the standard CS computability stuff, but then gets into esoterically minimalistic yet turning-complete stuff like 1D cellular automata. + Type checking as a form of partial evaluation, and some other "symbolic" stuff you can do with partially-evaluting interpreter. Some overlap with dependent types - but a more pragmatic less type-theoretic angle. Author uses a carefully selected subset of ruby, introduced in a short intro - big props for being thoughtful about that. P.S. +1 to Mazes book too (which is not as conscious about its ruby use, fun anyway)