Engineeringenterprise infrastructurefor the intelligent digital era.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.