Building a chess engine
Rough notes on board representation, move generation, search, evaluation, and the path from legal moves to an engine that can play.
#systems
21 items tagged with systems.
Building Fluffy, Part 1: The Smallest Useful React Framework
Fluffy is a learning-focused React framework. Phase 1 builds the first complete slice: scaffolding, file-based routing, server rendering, hydration, testing, and release automation.
Systems and architecture
Working notes on boundaries, contracts, scale, and how software changes over time.
What Large Codebases Teach Us
Large codebases teach a different kind of engineering: how to move safely when nobody can hold the whole system in their head.
Why Programmers Should Study Physics
Physics teaches habits programmers need badly: invariants, useful approximations, dimensional thinking, phase transitions, and respect for entropy.
Doubly Linked Lists
Learn how doubly linked lists work, why prev pointers help, and why bidirectional references make mutation more delicate.
Singly Linked Lists
Learn how singly linked lists work, including head pointers, next references, traversal, insertion, append, and deletion.
Arrays vs Linked Lists
Compare arrays and linked lists across random access, insertion, deletion, traversal, memory overhead, and cache locality.
Linked List Nodes and References
Learn the mental model behind linked lists: nodes, values, next references, head pointers, null, and how a list exists as a chain.
Why Linked Lists Exist
Learn why linked lists exist, how they differ from arrays, and when reference-based sequences are useful in programming.
Linked Lists for Programmers
Learn linked lists from first principles: nodes, references, arrays vs linked lists, singly linked lists, doubly linked lists, and practical tradeoffs.
Graphs as Search Spaces
Learn how graphs can model search spaces in games, compilers, planners, and workflows using generated neighbors, minimax, and pruning.
Weighted Graphs and Shortest Paths
Learn weighted graphs, shortest paths, edge costs, and Dijkstra's algorithm for programming problems where relationships have cost.
Topological Sort and Build Order
Learn topological sort with dependency graphs, build order examples, in-degree, Kahn's algorithm, and cycle detection.
Detecting Cycles in Graphs
Learn how to detect cycles in directed graphs using DFS, in-progress nodes, and done states, with dependency graph examples.
Representing Graphs in Code
Learn how to represent graphs in code using edge lists, adjacency lists, adjacency matrices, and reversed graphs for practical programming problems.
Walking Graphs with BFS and DFS
Learn graph traversal with BFS and DFS, when to use each search strategy, and why traversal order matters in programming.
Graphs vs Arrays, Maps, Tables, and Trees
Compare graphs with arrays, maps, tables, and trees, and learn when graph data structures are the right model for relationship-heavy problems.
The Math Root of Graphs
Learn the graph theory basics programmers need: vertices, edges, directed graphs, degree, paths, cycles, and weighted edges.
Why Graphs Exist
Learn why graphs are useful in programming, when arrays and maps are not enough, and how graphs model relationships in real data.
Understanding Graphs for Programmers
Learn graphs for programming from first principles: graph models, nodes, edges, graph theory basics, traversal, dependency ordering, shortest paths, and search spaces.