Knowledge
Open knowledge repository.
A continuously expanding archive of free, public-facing technical notes — JavaScript, DevOps, Linux. Engineering thinking in the open.
All publications
15 publications
- DevOpsGit — Engineering Notes for OperatorsA field-tested Git reference distilled from operating engineering teams across telecom, enterprise and infrastructure programmes — terse on theory, dense on commands and operator patterns.Twenty chapters moving from first repository and history browsing through remotes, staging, diffing, undoing and merging, into rebasing, cherry-picking, squashing and recovery — closing on worktrees, hooks and a 120-command cheatsheet. Written for the engineer who needs the right command under pressure, not a tour of the object database.20 chaptersGitWorkflowHooksWorktrees
- JavaScriptJavaScript — Engineering Notes for Working CodeA working JavaScript reference written from the angle of shipping production code — language fundamentals through async, performance, modules and tooling.Twenty-three chapters on an ES2024 baseline: the core language and its data types, then arrays, objects, Map and Set, then functions, classes, prototypes and context binding. The last third is where production actually hurts — promises, async/await, error handling, regular expressions, performance, debugging, modules and tooling.23 chaptersLanguageAsyncModulesTooling
- AlgorithmsAlgorithms — Engineering Notes for Working CodeA working algorithms reference — complexity first, then sorting, searching, graphs, dynamic programming and the design paradigms underneath them, each paired with a clean implementation and its real cost.Complexity and recursion first, then the sorts — elementary through heapsort and the linear-time cases — binary search and two-pointer windows, and the four design paradigms: divide and conquer, greedy, dynamic programming, backtracking. Structures and graphs follow (hashing, heaps, BSTs, union-find, BFS/DFS, shortest paths, MST, topological sort), each idea paired with a clean implementation and the cost you actually pay.24 chaptersComplexitySortingGraphsDynamic Programming
- TypeScriptTypeScript — Engineering Notes for Typed CodeA working TypeScript reference — inference first, then the generics, narrowing, conditional and mapped types that make a large codebase safe to change.Twenty chapters on a TypeScript 5.x baseline, ordered inference-first: basic types and annotations, interfaces, aliases and unions, then generics, classes and narrowing. The type-level layer follows — utility, mapped, conditional and template-literal types, discriminated unions — closing on modules, declaration files, tsconfig and a strictness-and-migration chapter for codebases arriving late.20 chaptersTypesGenericsInferenceTooling
- PythonPython — Engineering Notes for Working CodeA working Python reference — the data model, the idioms that separate fluent Python from translated Java, and the standard library to reach for before installing anything.Twenty chapters on a Python 3.12 baseline: syntax, types and control flow, then lists and tuples, dicts and sets, comprehensions and slicing; then functions, args and kwargs, classes, dunder methods and decorators. It ends on iterators and generators, context managers, exceptions, packaging, the standard library and typing — with the data model as the through-line.20 chaptersLanguageData ModelStdlibIdioms
- Node.jsNode.js — Engineering Notes for Server CodeA working Node reference — the event loop and why it matters, streams and backpressure, the module systems, and the operational concerns that keep a service alive under load.Twenty chapters on the current LTS: the runtime and module systems, the event loop and why it decides everything, emitters and async patterns, then streams, buffers, filesystem, path and both sides of HTTP. It closes operationally — error handling, process and environment, child processes, worker threads, clustering, npm, testing, debugging and production hardening.20 chaptersEvent LoopStreamsAsyncProduction
- CSSCSS — Engineering Notes for Real LayoutsA working CSS reference — the cascade and specificity that decide who wins, modern layout with Grid and Flexbox, custom properties and the container/logical features that replaced a decade of hacks.Twenty chapters starting where CSS arguments are actually settled — selectors, specificity, cascade and inheritance — then the box model, units, colour, typography, custom properties and functions. Layout gets display and flow, Flexbox, Grid and positioning; the final stretch covers backgrounds, transforms, transitions and animations, media queries, container queries and :has(), and stylesheet architecture.20 chaptersCascadeGridFlexboxModern CSS
- CC — Engineering Notes for the MachineA working C reference — the memory model, pointers without mystery, the undefined behaviour that bites in production, and the sanitizers that turn silent corruption into a loud, located failure.Twenty-eight chapters on a C17 baseline: the compile model, types and storage classes, operators, control flow and functions; then arrays, strings, structs, unions, bitfields and enums; then pointers properly — arithmetic, pointer/array duality, dynamic memory, function pointers, const and restrict. The last section is the honest one: undefined behaviour, memory bugs, sanitizers and defensive practice.28 chaptersPointersMemoryUBTooling
- C++C++ — Engineering Notes for Modern CodeA working reference for the C++ worth writing today — RAII as the organising principle, value semantics and moves, templates without fear, and the STL that means you rarely write a loop.Twenty-eight chapters on a C++20 baseline organised around RAII: types and references, const and constexpr, classes, the rule of five/zero, move semantics, inheritance and polymorphism, then smart pointers and ownership. Generics follow — templates, concepts, variadics, lambdas — then containers, iterators, algorithms and ranges, closing on exceptions, optional/variant/expected and undefined behaviour.28 chaptersRAIIMove SemanticsTemplatesSTL
- C#C# — Engineering Notes for Modern .NETA working C# reference — value vs reference semantics, records and immutability, LINQ, and async/await without the deadlocks, on modern .NET.Twenty-eight chapters on .NET 8: build and runtime, value versus reference semantics, strings and null handling, then classes, properties, structs, records and interfaces. The middle is generics, delegates and events, lambdas, collections and LINQ; the end is tuples and pattern matching, nullable reference types, exceptions, IDisposable, async/await without the deadlocks, and spans for the performance work that follows.28 chaptersRecordsLINQasync/await.NET
- LinuxLinux — Engineering Notes for OperatorsA working Linux reference — the shell and its expansion rules, permissions, processes and signals, systemd, the grep/sed/awk toolkit, and the troubleshooting habits that resolve incidents fast.Twenty-eight chapters written for the operator: how the shell actually runs, filesystem layout, navigation, globs and expansion, then permissions, users and privilege. Pipes and redirection open the text toolkit — grep, find and xargs, sed, awk — before the systems half: processes and signals, systemd, packages, networking, SSH, disks, journald and timers, closing on Bash scripting, hardening and troubleshooting.28 chaptersShellsystemdgrep/sed/awkTroubleshooting
- HTML5HTML5 — Engineering Notes for the DocumentA working HTML reference — semantic structure machines understand, forms that validate themselves, the browser APIs worth knowing, and the accessibility and loading details that separate a page from a product.Twenty-eight chapters treating HTML as a platform rather than markup: document and doctype, the head, text, links, lists, tables and semantic sectioning; then images with srcset, audio and video, SVG and embedding; then inputs, validation and submission. The last third is the platform itself — DOM, events, Web Storage, history and routing, fetch, templates and device APIs — plus accessibility, loading performance, SEO and security.28 chaptersSemanticsFormsPlatform APIsAccessibility
- HTML5 CanvasHTML5 Canvas — Engineering Notes for PixelsA working Canvas 2D reference — the immediate-mode model, paths and transforms, pixel manipulation, a correct animation loop, hit-testing, and the high-DPI and performance details that decide whether it's smooth.Twenty-eight chapters on the Canvas 2D API: context setup, the coordinate system and high-DPI handling first, then rectangles, paths, curves and arcs, fills and strokes, gradients, patterns, shadows, line styles, text, images and sprites. The second half is the moving part — transforms and save/restore, compositing, clipping, pixel manipulation, a correct animation loop, redraw strategy, hit testing, particles, performance and export — ending on when to reach for SVG or WebGL instead.28 chapters2D APITransformsAnimationPerformance
- jQueryjQuery — Engineering Notes & the Way Off ItA working jQuery reference for codebases that still run it — selectors, traversal, events and Ajax done correctly — paired with the native-DOM equivalent for every pattern and a migration path.Twenty-six chapters for codebases still running jQuery 3.x: setup and ready, selectors, the jQuery object, traversal and chaining, then content, attributes, classes, dimensions, element creation and .data(); then events, delegation, effects, Ajax, deferreds and forms. It ends as an exit plan — a jQuery-to-native map for every pattern, a migration strategy, and the pitfalls encountered on the way out.26 chaptersSelectorsEventsAjaxMigration
- ReactReact — Engineering Notes for ComponentsA working React reference — UI as a function of state, hooks without the footguns, effects that don't lie, and the composition and performance patterns that hold up past a few hundred components.Twenty-eight chapters on React 18+: the mental model, JSX, components, props, state and events, then conditional rendering, lists and keys, forms, lifting state and composition. Hooks get their own arc — the rules, useEffect and honest dependencies, useRef, useContext, useReducer, memoisation and custom hooks — before refs and the DOM, error boundaries, Suspense, portals, performance, data fetching and state management.28 chaptersHooksEffectsCompositionPerformance