what are some other tutorials for implementing a toy version of a hard thing in a short amount of time? Like https://implement-dns.wizardzines.com or https://raytracing.github.io
I’m especially interested in the “in a short amount of time” aspect, I think nand2tetris is extremely cool but you definitely can’t do it in 3 days.
If possible I'd love to hear about a project you personally did and how long it took you.
@b0rk
This is a great resource!
Reminds me of a class I'm taking, where we are building a programming language. The Selene language from that class is less than 500 lines, but it takes eight weeks of class time to replicate it.
https://github.com/classpert/bapl2-class-language/blob/master/lesson-8/interpreter.lua
As the aphorisms go, brevity can be more time consuming. https://news.ycombinator.com/item?id=770109
@b0rk I’ve been following a “write Doom using Python” series, and it’s shocking. Those videos and you could have a passable Doom renderer, reading from WAD, in an afternoon or two. It’s a really great series, going step by step. (2.5d helps a bit.)
It’s almost like “anyone can write a ray-tracer/caster teapot/sphere/plane demo” (fun challenge: write one in PostScript) but a game feels more… tangibly “useful”? (Edit: practical?)
@b0rk Here's a tutorial for implementing a toy disassembler in at most a few hours:
https://briancallahan.net/blog/20210407.html
It's actually the first in a series of posts on demystifying programs that create programs. It further teaches how to code an assembler and linker, which may be weekend projects.
@b0rk For a more personal example, with notes… I read HTTP: The Definitive Guide in a night (yes… I speed read) then the next day wrote a more functionally complete HTTP/1.1 server in pure Python than I was able to find in Python. (Mine did chunked requests and responses, not just responses.)
The protocol bits compile to 191 opcodes.
Hybridises async and threaded execution.
And survives C10K consuming ~11MB of RAM.
https://github.com/marrow-legacy/server.http/blob/develop/marrow/server/http/protocol.py
Benchmark: https://gist.github.com/amcgregor/707936 (13 years ago)
@b0rk You can see from mine that I’m handing off request processing (the WSGI API side of things) to a Futures thread pool. From the benchmark, you can then run multiple processes sharing the same listening socket to let the kernel itself distribute incoming connections between them. All communication happens asynchronously within the main thread of a given process.
HTTP: The Definitive Guide is an incredibly good resource. Chunked transfer, header trailers, and some TCP–specific quirks…
@michaell @b0rk I often use that, or my 1.9 million DRPC/second pure Python implementations as counter-examples to cries of “Python is slow”. I even micro-optimised these things.
Split? Partition?
Partition is WAY faster.
Uppercase or lowercase a mostly lower-case string?
Always faster the fewer characters require replacement; lowercase.
&c. https://gist.github.com/amcgregor/405354
Then there are the examples where Python is faster than C. My web server contains one. (But also malloc elimination, inlining…)
@alice @b0rk And then there are the new not-quite-ready-for-prime-time subinterpreters in 3.12:
“Snow's own initial experiments with subinterpreters significantly outperformed threading and multiprocessing. One example, a simple web service that performed some CPU-bound work, maxed out at 100 requests per second with threads, and 600 with multiprocessing. But with subinterpreters, it yielded 11,500 requests, and with little to no drop-off when scaled up from one client.”
Sub-interpreters. 😐 I get 38,775 generations/second (Python 2.7) or 45,679 (Pypy) or 55,385 (CPython 3.8) without any additional magic. And yup, cinje (my template engine pseudo-DSL) is cross-compatible back to Python 2 without code modification. (Not like that matters any more, but it's demonstrative of a few points.)
That HTTP service C10K test, under Python 2.6, and with an overwhelming 10,000 concurrency, netted 6K r/sec again, like, 13 years ago. It'd be far faster today.
We can then agree to disagree.
I'm talking about baseline performance; it can only get slower from there. How you manage blocking activity is up to the application; I'm a fan of thread-based Futures pools for most long-duration activities; even just enqueueing e-mail deliveries. (Also used for long-duration HTTP requests for data acquisition and processing for scheduled ingest.)
Though admittedly, my dynamic scaling thread pool is FAR more efficient than the built-in.
The HTTP service test is performing the full WSGI pipeline, using a thread pool within each primarily async process to execute the WSGI endpoint, if you look very closely. (And kernel-level socket sharing for pre-fork/multi-process.) Very hybrid. 😜
And the template performance is based on the "de-facto standard" "Bigtable" test, that is, rendering a 100-column, 1000-row HTML table.
Django renders 2/second.
Two.
Insert "come at me bro" Monster (muppet drummer) GIF here. 😝
@b0rk I love “The Super Tiny Compiler” project.
Learn how to implement a compiler in a few hours: https://github.com/jamiebuilds/the-super-tiny-compiler
@b0rk I did a couple of “code offs” with my kid. He coded in Scratch. I used JavaScript (with a reactive library). Time limit one hour. We did snake and ping. Not “hard things”, but fun to make.
https://code-off-pong.netlify.app
https://code-off-snake.netlify.app
@b0rk With all the AI hype lately, could you write a SLM (Small Language Model)?
I wrote a chatbot framework in around 120 lines of JS too. Perhaps there's something in that?
https://peekobot.github.io/peekobot
Again, maybe not the complexity your after, but might spawn other ideas.
@b0rk I did all of them. Yeah, "Crafting Interpreter" takes significantly longer, though "Ray Tracing in One Weekend" can also be a rabbit hole that takes a long time if you consider later books.
I think on average each project can take one or two months of spare time, though it depends on how much time you can spend on it (I can rarely reserve a whole weekend on one task)
Maybe a bit too long?
@b0rk This might be the wrong layer compared to what you did, but: I'm surprisingly proud of the SNMP book catalog agent I wrote in one day (and polished the next morning).
It's Perl, and silly, and taught me a huge amount about how SNMP actually works. People actually use this sort of thing in production.
I left it up as an Easter egg for the book.
@b0rk It certainly pales in comparison to other guides, but you can complete my guide to raytracing in a few hours. I wrote it over the course of a week.
Since I started programming I’ve had a dream in the back of my mind: raytracers are super cool, and I’d like to build one myself. But with that dream accompanied another thought: raytracers are nearly a pure expression of math, a discipline I am poorly qualified for. However this winter I discovered a new programming community, OneLoneCoder, and its leader, javidx9. Watching the videos produced by javidx9 inspired me to take a leap of faith in myself and start this raytracing project. The result has been amazing to see unfold as I developed first a working prototype in C#, then in C++, and finally as I produced what hopefully is an easy to follow “tutorial” style Git repository. So, lets dive in!
@b0rk I'm not quite sure if this counts, because it's a "tutorial" only for people who are already familiar with parsing jargon and algorithms, and "hard" only because you have to discover and dig through the several kinda obscure papers that the details are scattered across...
But I wrote my Pint-sized Earley Parser article in two days and over the years a surprising number of people have found me and told me it was helpful: https://joshuagrams.github.io/pep/
@b0rk Like a kernel in Rust?
https://os.phil-opp.com/
Just to clarify, not mine.
A from scratch GPU-free introduction to modern machine learning. Many tutorials exist already of course, but this one aims to really explain what is going on, from the ground up. Also, we’ll develop the demo until it is actually useful on real life data which you can supply yourself. Other documents start out from the (very impressive) PyTorch environment, or they attempt to math it up from first principles. Trying to understand deep learning via PyTorch is like trying to learn aerodynamics from flying an Airbus A380.
Raghav Agrawal
Julia Evans
Mark W. Gabby-Li 🐌
Greg Wilson
mhoye
Rev. GothAlice
Paolo Amoroso
gallaugher
Darrel Miller
michaell
yosh
Ben Bradley
Ross Wintle
Lesley Lai
Marius Kimmina
Michael W Lucas 
[𝚜𝚒𝚍𝚗𝚎𝚢𝚜𝟷@~/𝚜𝚛𝚌]$
matheus lessa
Josh Grams
Starr Horne
0xA1E8
Leon Overweel
bert hubert 🇺🇦🇪🇺🇺🇦
jairtrejo
ednl 🇪🇺
some kind of orange shape
Jed Brown