How do modern compilers choose which variables to put in registers? - Programming Language Design and Implementation Stack Exchange (https://langdev.stackexchange.com/questions/4325/how-do-modern-compilers-choose-which-variables-to-put-in-registers)

String vs &str (https://blog.sulami.xyz/posts/string-vs-str/)

Intro - Operating System in 1,000 Lines (https://operating-system-in-1000-lines.vercel.app/en)

Mistakes engineers make in large established codebases | sean goedecke (https://www.seangoedecke.com/large-established-codebases/)

A Simple ELF - The Ivory Tower (https://4zm.org/2024/12/25/a-simple-elf.html)

purplesyringa's blog (https://purplesyringa.moe/blog/)

Advent of Code on the Nintendo DS (https://sailor.li/aocnds.html)

Traits are a Local Maxima · thunderseethe's devlog (https://thunderseethe.dev/posts/traits-are-a-local-maxima/)

I made a lifting app that makes $3k MRR , r/SideProject (https://www.reddit.com/r/SideProject/comments/1gr5lso/i_made_a_lifting_app_that_makes_3k_mrr/)

Algorithms we develop software by (https://grantslatton.com/software-pathfinding#algorithms-we-develop-software-by)

The history of the Monokai color scheme (https://monokai.pro/history)

Async Rust in Three Parts (https://jacko.io/async_intro.html)

Practices of Reliable Software Design (https://entropicthoughts.com/practices-of-reliable-software-design)

Wumpus Cave (https://wumpus-cave.net/post/2024/10/2024-10-01-death-of-cobol/index.html)

Rewriting Rust (https://josephg.com/blog/rewriting-rust/)

Possibly all the ways to get loop-finding in graphs wrong (https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/findloop/)

the Fennel programming language (https://fennel-lang.org/)

Let's build a browser engine! Part 1, Getting started (https://limpet.net/mbrubeck/2014/08/08/toy-layout-engine-1.html)

Rust in Detail, Writing Scalable Chat Service from Scratch (https://nbaksalyar.github.io/2015/07/10/writing-chat-in-rust.html)

dnsguide/README.md at master · EmilHernvall/dnsguide (https://github.com/EmilHernvall/dnsguide/blob/master/README.md)

Good Refactoring vs Bad Refactoring (https://www.builder.io/blog/good-vs-bad-refactoring)

Simulating worlds on the GPU, Four billion years in four minutes (https://davidar.io/post/sim-glsl)

After 10 Years, Yelp Gave My App 4 Days ~ Observational Hazard (https://www.observationalhazard.com/2024/07/after-10-years-yelp-gave-my-app-4-days_29.html)

The UNIX Pipe Card Game (https://punkx.org/unix-pipe-game/)

staniks.github.io (https://staniks.github.io/articles/serious-engine-networking-analysis)

So You Want To Build A Browser Engine (https://robert.ocallahan.org/2024/06/browser-engine.html)

From Scratch - Generative Adversarial Networks (https://ym2132.github.io/GenerativeAdversarialNetworks_Goodfellow)

Rust is for the Engine, Not the Game - Barrett's Club (https://barretts.club/posts/rust-for-the-engine/)

A Whirlwind Tutorial on Creating Really Teensy ELF Executables for Linux (https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html)

The best engineering interview question I've ever gotten, Part 1 – Arthur O'Dwyer – Stuff mostly about C++ (https://quuxplusone.github.io/blog/2022/01/06/memcached-interview/)

Why choose async/await over threads? – notgull – The world's number one source of notgull (https://notgull.net/why-not-threads/)

Antithesis of a One-in-a-Million Bug, Taming Demonic Nondeterminism (https://www.cockroachlabs.com/blog/demonic-nondeterminism/)

Exercism (https://exercism.org/)

I Patched R to Solve an Exercism Problem - (https://jcarroll.com.au/2024/02/26/i-patched-r-to-solve-an-exercism-problem/)

Array Languages, R vs APL - (https://jcarroll.com.au/2023/07/07/array-languages-r-vs-apl/)

Neet detail with domain appearing next to every link

How I Improved My Rust Compile Times by 75% (https://benw.is/posts/how-i-improved-my-rust-compile-times-by-seventy-five-percent)

Compiling With Constraints | Hey There Buddo! (https://www.philipzucker.com/compile_constraints/)

The Mythical Non-Roboticist - by Benjie Holson (https://generalrobots.substack.com/p/the-mythical-non-roboticist)

My favourite animation trick, exponential smoothing | lisyarus blog (https://lisyarus.github.io/blog/programming/2023/02/21/exponential-smoothing.html)

What is GP 2? | GP 2 (https://uoycs-plasma.github.io/GP2/)

The Hunt for the Missing Data Type (https://www.hillelwayne.com/post/graph-types/)

gaultier.github.io/blog/you_inherited_a_legacy_cpp_codebase_now_what.html (https://gaultier.github.io/blog/you_inherited_a_legacy_cpp_codebase_now_what.html)

Game Programming Patterns (https://gameprogrammingpatterns.com/)

Planner programming blows my mind (https://www.hillelwayne.com/post/picat/)

htmz - a low power tool for html (https://leanrada.com/htmz)

akalenuk/the_namingless_programming_language, Naming is hard. How far can we go without? (https://github.com/akalenuk/the_namingless_programming_language)

The History of Python: Why Python's Integer Division Floors (http://python-history.blogspot.com/2010/08/why-pythons-integer-division-floors.html)

Why Bloat Is Still Software’s Biggest Vulnerability - IEEE Spectrum (https://spectrum.ieee.org/lean-software-development)

From Go to Rust: The Two Types of Readable Code - Earthly Blog (https://earthly.dev/blog/readability/)

Not just NVIDIA: GPU programming that runs everywhere (https://pythonspeed.com/articles/gpu-without-cuda/)

Is something bugging you? (https://antithesis.com/blog/is_something_bugging_you/#ref2)

The Algorithms (https://the-algorithms.com/)

Figure out who's leaving the company: dump, diff, repeat (https://rachelbythebay.com/w/2024/02/08/ldap/)

RustPython (https://rustpython.github.io/)

Crafting Interpreters (https://craftinginterpreters.com/)

Maman, comment on fait les langages de programmation ?

Falling Sand (https://jason.today/falling-sand)

The overengineered Solution to my Pigeon Problem Max Nagy (https://maxnagy.com/posts/pigeons/)

J’adore ce projet.

Collapse OS (http://collapseos.org/)

Un OS pensé pour tourner sur les machines de fortune post-effondrement.

Présentation de RFC (https://www.bortzmeyer.org/rfcs.html)

Une introduction aux RFC, en français.

Anatomy of a Terminal Emulator (https://poor.dev/blog/terminal-anatomy/)

100R (https://100r.co/site/home.html)