This is a curated list of things I have discovered on the web and found useful or thought-provoking, there is also some fun stuff.
Potential subjects include, but are not limited to, programming, engineering, technology, and woodworking.
The list is sorted by date of addition (latest first), expect for my favorites wich are pinned.
A deep dive into how exactly your program can “run”on a machine. It’s simple question but it will lead you to explore a lot of interesting things: what’s is an instruction? How can we multitask on a CPU if its execution is sequential? How do memory isolation between kernal and different process work? What is a dawn syscall actually? And how to become an Elf-lord?
It’s well written and beautifully presented which make it approachable despite being very detailed ( if you wonder how detailed, there is a function by function analysis of how linux implement system call in chapter 3). If you’re anything like me and want to understand how your programs run all the ways down from your code to the hardware level then, this is for you. This has actually improved my understanding of how computers work and what the role of an kernel is. I cannot recommend reading it enough!
PS: I realised after reading the entire thing the the research and the writing was done by a 17 year old with the help of hackclub. This person probably has a bright future ahead of her, I wish I could have been so dedicated when i was 16 year old!
PPS : there is another one by same person about networking called how did I get here?. It’s on my reading list!. It’s also very cool.
Schemathesis is an incredible fuzzer for REST and GraphQL API. It can be used through CLI or integrate directly with your unit test in python. Thanks to it’s property-based testing, I have found numerous bug, including inside my dependencies, . It also help me catch bad documentation with it’s response schema validation. I definitly integrate it inside my CI/CD pipeline whenever I can.
If you have been impressed by schemathesis capability like me and you want to know more about it’s conception I would recommend reading the paper published by its creators “Deriving Semantics-Aware Fuzzers from Web API Schemas” by Zac Hatfield-Dodds and Dmitry Dygalo.
A good article against the necessity of horizontal scaling and deploying on the edges.
Indeed, I think that for most applications you might want horizontal scaling but you don’t actually need it, worst than that, it can actually hurt your application by adding unnecessary complexity and remember what Grug told use: complexity is the enemy.
Distributed systems are everywhere now, if you are working on a web application now, chances are it is distributed or someone will ask you to make it distributed at some point. Probably most systems should not be distributed, as it adds an incredible amount of complexity, but the promises of fault tolerance and scalability are hard to ignore, we are only human after all, and we have a hard time not imagining the grass is greener elsewhere. Also, sometimes systems actually need to be distributed to meet some constraints.
But distributed systems are hard and often counterintuitive. So I’m currently trying to learn more about distributed systems theory so that I don’t shoot myself in the foot when I try to design and build them. This reading list is a good place to start, as it references a lot of foundational papers. But more than the references, what I really like about this page are the definitions. On this page, the author defines most of the vocabulary commonly used to talk about distributed systems. These definitions are concise, understandable, and often accompanied by insights into what a concept actually means for real-world applications. I highly recommend reading the whole page before you start reading papers, it will give you the basics.
Excalidraw is amazing. It’s very simple, it doesn’t have all the features of other big diagramming tools, it doesn’t even have a grid, and yet you’ll make better diagrams faster with it. It’s like using a real whiteboard, expecting that it’s infinite and you don’t have to rewrite everything if you’ve misplaced something.
Excalidraw is such a good example of UX: you open it and you are ready to go, no need to register, no need for a tutorial. It’s low fidelity style will make all your diagrams beautiful without effort and without the need for precision. All the tools are intuitive and immediately usable, yet when you start using exclidraw more you will discover a lot of shortcuts to work faster (see the help in the bottom right corner for a full list of keyboard shortcuts).
Excalidraw is also fully collaborative with it’s Live Session: just share the link and you can instantly see other people working in your workspace. Then there is the fantastic library functionality that allows you to share and reuse components with ease.
Finally, there is the mermaid support, which will turn your text-based, simple-version, easy-to-maintain but ugly diagram into something nice and pleasing.
It’s lovely.
Restic is the tool you should use for your backups.
Restic, what else?
A series of vulgarisation comics on all sorts of topics related to programming. I think it’s an excellent ressource for beginner programmers, it lets you ask some questions about basic things that you usually don’t have time for or, maybe too afraid to ask, like: what is http? or what is memory allocation?
When I deploy a new app in production, I like to do a quick load test to have an idea of how much traffic I can support while staying under my latency target.
Hey is an excellent CLI tool for that. You give it the URL of the page you want to test and it will generate some load for it. You can easily configure the load (number of requests, headers, rate limit…) with flags. Once the loading is finished, you received a very readable report with the latency distribution and other key indicators.
Another practical tool to have in the toolbox!
I considered myself pretty up to date with the functionality offered by HTML but HTMLHell show me I was wrong. Notably I discovered the existence of download links (how did I miss that all this time?!) and how to use <picture> for progressive enhancement.
The site has two main section:
There is also an advent calendar with tips and tricks in December. I highly recommend exploring this site if you want to deepen your understanding of what HTML has to offer.
Sometimes, you have a basic website or a small application, and all you need is a way to receive alerts if it goes down. In such cases, you probably don’t want to deploy the entire OpenTelemetry stack with all the required infrastructure and integration. Sometimes, all you want is something simple. This is where “tinystatus” comes into play; it couldn’t be simpler.
Tinystatus is a compact 130-line Bash script that queries a list of URLs and generates an HTML report. You can effortlessly set it up in cron or systemd and direct your HTTP server to the generated index.html. Voilà, you’ve got yourself a status service. Moreover, by redirecting its stderr output to a mail service, you can receive real-time alerts if your website or app experiences any downtime.
index.html
stderr
Because it’s so concise, you can easily customize it to your preferences by adding extra checks or tweaking the styling. And if you don’t want to deal with setting up cron, systemd or the web server, it’s also available as a Docker container or as a Go implementation, aptly named “go-tinystatus”, which embeds the HTTP server for your convenience.
FoundationDB is a distributed transactional key value store created in 2009 wich guarantee ACID transactions at scale.
This is paper published by the FoundationDB team summarising there approach to building a distributed database 10 years after building it. There is a lot of interesting things inside it but here are my main takeaway:
Because the web has been build with a set of value at it’s core : the web is open, it’s for everyone and everything. By accepting those value we must, at the same time, accept that we loose some degree of control, we don’t choose who will look at our website and on what devices. That lake of control means we must build websites for an infinite canvas with unknown constraints and capabilities. But designing for the unknown is hard, for that, we need flexibility, and this is where CSS come in.
The Cascade in Cascading Style Sheets is the process of assembling styles from different inputs. You gain from that process the capability to merge intent from different sources: the Author, the Browser and remarkably, the User.
It also allows us to fail gracefully by cascading upward wich is good for resilence and backward compatibility. But the tradeoff is that your instructions can be overridden, they became suggestions. This is one of the pitfalls of CCS and why we sometime have to use the infamous !important. The other consequence is that everything is hierarchically linked. This is great, as one style can be reused in many similar places to achieve consistency, but this is also another big pitfall of CSS as a style might impact elements it was never meant to.
!important
Overall some might think that we made a bad tradeoff with CSS by loosing too much control, but I don’t think so. As John Allsopp said, “Control[…] is a limitation of the printed page”, when a book is produce and sold only the editor can make it accessible, and he fails to do it most of the time whether it’s diagrams with bad contrast or the absence of braille editions or other things. But with the browser and CSS the user has the last word, he can make it feet it’s need, whatever it is.’
One of the best resource I could find on modern CSS practice. It goes deep on how css properties function and interact, provide some general design rules and propose solution to a lot of common layout problem in a flexible and reusable way.
A collection of tools to test website accessibility. There browser extension is great and give an instanious and detailed feeback on accessibity isssues on a web page. (Try it here and you wont find any error!)
A fun guide on managing complexity in software for all of us small brained developers. Remember: complexity is the enemy; complexity is very, very bad.
There are currently no standard ways for API to communicate there domain specific error where HTTP status is not enough. This RFC hopes to remedy that with a proposed schema for error response. I think it’s a good proposal, it give enough feedback and it’s flexibility enough to work in most API. The one thing I really like is that it forces you to document your API’s specific errors because a link to documentation about the error is included in the schema.
Minimalist, fast, single-file, UI for RDBMS. phpMyAdmin but way better. I love there interface, it’s very clear and readable. Adminer is simple but also fully featured. It is customizable and extendable throught themes and plugins. It also integrate very well with docker and help access the database for debugging. Overall a very practical tool to have in the toolbox.
Make the web simple again! Alpine.js provide DOM reactivity and two-way data binding thought a lightweight framework. It’s build on top of the @vue/reactivity package, which is it’s only dependency, and the whole framework is ~16kb minified and compressed. Alpine.js work very well on it’s owm but I think it would be very interesting to see if it synergize well with HTMX for the place where client site reactivity is absolutly needed.
@vue/reactivity
CSS Bed is a collection of classless CSS theme, it let you test each of them by effortlessly changing the stylesheet of the site. I am a big fan of classless CSS for small and static website (like this one), it reduce unnecessary complexity by not having to think about class at all and only concentrate on semantic HTML. Also modern framework provide CSS isolation wich mean class are not as much of a necessity to avoid colision between components.
In reaction to the Snowden’s revelation in 2013, Phillip Rogaway started to reconsider his role and social responsibility as a cryptographer. This paper focus on the discipline of cryptography but the first part does an excellent job at explaining why any technician has a social impact, whether that’s on purpose or not, and therefore should be conscious of his political responsibility.
Most practical badge generator I have used yet.
This is an online and open-source tool for parametric voronoi generation. Voronoi is a diagram derived from a mathematical equasion that look like cells, there is a lot of applications for it, but I mostly use it for visual design. With the real time editing and SVG export it’s really handy for that use case.
This article discusses the trade-off between implementation simplicity and interface simplicity and argues in favor of implementation simplicity. Despite being published more than 30 years ago it is still interesting and relevant. If you find it interesting you can also read the counter argument “Worse is Better is Worse” by Nickieben Bourbaki (it’s the same author under a pseudonym).
Make the web simple again! HTMX is a framework for building frontend with the hypermedia design philosophy. It’s dependency free and weight only ~14k minified and compressed wich is really nice. It’s not for every project, for example if you want offline support it’s not what you should use, but it can be used in way more applications than people realize, especially CRUDish apps or data exploration apps.
It’s perfect, what else is there to say?