Tradeoffs in Implementing Primary backup
Describes a fundamental approach to fault tolerance through primary-backup replication, where a primary server handles requests and backs up its state to secondary servers.
Bookmarks
Less is More: Recursive Reasoning with Tiny Networks
This is the codebase for the paper: “Less is More: Recursive Reasoning with Tiny Networks”. TRM is a recursive reasoning approach that achieves amazing scores of 45% on ARC-AGI-1 and 8% on ARC-AGI-2 using a tiny 7M parameters neural network.
Chain Replication for Supporting High Throughput and Availbaility
Presents a replication strategy that achieves high throughput and availability while providing strong consistency guarantees, forming the basis for many modern distributed storage systems.
Logchef v1.0: The Journey to a Real Log Viewer
a wonderful blog at a inhouse solution, deeper links to look at as well
Resources On Software Engineering
By Debashish - https://x.com/debasishg/status/1967908410302796031
Programming Massively Parallel Processors: A Hands-on Approach
https://x.com/sadernoheart/status/1976364231332397425
Nvidia CUDA C++ Programming Guide
https://x.com/sadernoheart/status/1976364231332397425
Game Boy Coding Adventure | No Starch Press
A comprehensive tutorial on programming in assembly using the iconic Game Boy, teaching the basics of computer science in a fun and engaging way.
Computer Architecture: A Quantitative Approach
John L. Hennessy (Author), David A. Patterson (Author)
GPU Programming Glossary
https://x.com/ludwigABAP/status/1873845449196790080
Game Engine Architecture
https://x.com/iHR4K/status/1892712182950793640
CppCon 2018: Matt Godbolt “The Bits Between the Bits: How We Get to main()”
Compilers: Principles, Techniques, and Tools
https://x.com/vaibhaw_vipul/status/1898015541643882789
Architecture of a Distributed Sytems
https://dsf.berkeley.edu/papers/fntdb07-architecture.pdf
Writing A Compiler In Go | Thorsten Ball
This is the sequel to Writing An Interpreter In Go and this time we’re writing a compiler and a virtual machine for Monkey. Same codebase, same approach, new goals. Code front and center, step by step explained, fully unit tested and runnable.
End-to-End Arguments in System Design , Saltzer, Reed, Clark,
Presents the fundamental principle that certain functions must be implemented end-to-end and cannot be completely satisfied by lower levels. This shapes how communication protocols are designed in distributed systems.
ZooKeeper: Wait-free coordination for Internet-scale systems
Shows how theoretical distributed systems concepts are implemented in a real-world system Good case study of applying theory to practice
Virtual Time and Global States of Distributed Systems
Alternative presentation of vector clocks Introduces the concept of consistent cuts and global snapshots
Practical Byzantine Fault Tolerance
Implementation of Byzantine fault tolerance for real systems More difficult, but provides practical implementation techniques
Detecting Causal Relationships in Distributed Computations: In Search of the Holy Grail
Practical techniques for implementing and optimizing vector clocks Discusses various implementation tradeoffs
Implementation Of Reliable Multiprocesss Distributed Systems
The paper explores how to actually implement distributed algorithms in real computer systems using Remote Procedure Calls (RPCs)
Design a Spell List
https://github.com/calmsacibis995/svr4-src/blob/main/cmd/spell/huff.c#L105 https://github.com/calmsacibis995/svr4-src/blob/main/cmd/spell/huff.c#L83 https://substack.com/@abhinavupadhyay/p-154139305
Byzantine General's Problem
This paper introduces fundamental concepts about achieving consensus in distributed systems with potentially faulty components
Bloom Filters , space time trade offs, hash coding with allowable errors
Unreliable Failure Detectors
Timestamps in Message Passing Systems
Introduces vector clocks, which capture causality more precisely than scalar clocks
Time, Clocks and Ordering Of Events
Paxos Made Simple
Operatinf System - Three Easy Pieces
virtualization , concurrency and persistence
Crafting Interpreters
Advanced Programming in the Unix Environment
definitive guide for the unix system programming
Types and Programming Languages
The core topics include the untyped lambda-calculus, simple type systems, type reconstruction, universal and existential polymorphism, subtyping, bounded quantification, recursive types, kinds, and type operators.
Time to upgrade your monitor @ tonsky.me
A non-comprehensive and opinionated guide to best monitor for programming
OSDev Wiki
How Unix Spell Ran in 64kB RAM - by Abhinav Upadhyay
How do you fit a dictionary in 64kb RAM? Unix engineers solved it with clever data structures and compression tricks. Here’s the fascinating story behind it.
Algorithms for Modern Hardware - Algorithmica
its intended audience is everyone from performance engineers and practical algorithm researchers to undergraduate computer science students who have just finished an advanced algorithms course and want to learn more practical ways to speed up a program than by going from O ( n log n ) O(nlogn) to O ( n log log n ) O(nloglogn).
A categorized list of C++ resources - MattPD
A categorized list of C++ resources. Contribute to MattPD/cpplinks development by creating an account on GitHub.
A categorized list of C++ resources - MattPD
A categorized list of C++ resources. Contribute to MattPD/cpplinks development by creating an account on GitHub.