rgoussu.dev
rgoussu@goussu: ~/library/recent
❯ ~/library tail -f log.md

Recent acquisitions

# What arrived on the shelves, newest first.

2026-08-20

  • Creation: Added concept group Developer environments — the layer above every language toolchain: what version managers, dev containers and cloud environments each guarantee, and picking the lowest one that closes the actual failure.
  • Creation: Added concept Version managers — universal vs ecosystem-native — mise and asdf against nvm, Corepack, SDKMAN!, rustup and Go's built-in mechanism; the native-file table, coverage as the deciding question (no partial covers, combinations as compositions), and lockfile-order prefix resolution.
  • Creation: Added concept Dev containers — devcontainer.json and features, the standalone vs compose-attached shapes, docker-outside-of-docker, and what the layer does not buy.
  • Creation: Added concept Version pinning & currency — consistency and currency as two problems with different mechanisms: a single-source registry checked in the fast gate, and drift-from-latest-stable as a scheduled report rather than a gate.
  • Creation: Added concept Test-suite scheduling & job partitioning — the runner's unit of scheduling as the atom, the slowest unit as the floor, amortizing setup before changing layout, dividing along an axis that makes a failure a diagnosis, and the enumeration hazard (work no job names runs green).
  • Creation: Added concept Patterns for tools that generate configuration — render the target's native format, orchestrate rather than implement, never offer a partial answer, compositions not copies, sticky decisions with the record as source of truth, stable-first resolution of derived values, and the owned/seeded/merged stance for generated files.
  • Update: Folded the version-manager layer into the per-language toolchain notes — rustup gains the missing "series" channel (only stable or an exact version; no latest 1.x), The Go toolchain and go mod state the toolchain directive as a floor, not a pin plus GOTOOLCHAIN, and Package managers records packageManager as a CI provisioning source and the nvm+Corepack pairing.
  • Update: Settled the JVM's JDK-provisioning asymmetry across the build ecosystem, Gradle and Maven — Maven compiles with whatever JDK runs it (JAVA_HOME is the setting; <release> only sets the target), Gradle provisions a compile JDK via toolchains but must still start on the launching JVM, so its version and that JDK stay coupled; also added SDKMAN! and the sdk-is-a-shell-function trap.
  • Update: Added a # Details → "The boundary tax" section to Microservice architecture — every boundary buys independent deployment/scaling and charges for it in serialisation, network transfer, orchestration state, request volume and failure handling, with the Prime Video serverless-to-monolith cost story as the citation.

2026-08-14

  • Update: Settled the layout dial across all four references — every stack offers both basic and modulith, basic default, reversing the earlier "modulith only" rulings for Go and the frontend. The correction recorded in the comparison: manifest count measures the cost of building a layout, not of reading it — the facade, the modules/<ctx>/ level and a peer seam with no peer are indirection a single-context project can decline however cheap its build files are. The per-language cost figures become guidance on when to turn the dial.
  • Update: Revised the TypeScript package shape in the comparison and the frontend reference after testing a third option — a bounded context is one workspace package (@acme/<ctx>) whose exports map publishes only the facade, the peer seam and the element registrations, not a cluster of four or five. Verified that deep imports past the map fail in tsc and Node alike; the cluster bought four manifests per context and zero extra enforcement, since the package graph checks nothing.
  • Creation: Added concept The four hexagonal references compared — the four realizations graded side by side on what actually holds each wall (compiler / resolver / linter / review), what each costs, the per-stack ruling on whether to offer both layouts, and each language's version of the JVM's hand-computed-path trap. Findings established by compiling throwaway two-context skeletons in Go 1.24.7, rustc 1.94.1 and Node 22 + TypeScript 5.9, plus browser runs under Chromium.
  • Update: Corrected the Go reference against the compiler — driven adapters move to modules/<ctx>/infra/ (outside the context's internal/, or the assembly cannot construct them), and the facade must re-export nothing, which turns "only the consumer's own directory may implement the consumer's ports" into a compile error; added the settled ruling that Go ships the modulith layout only.
  • Update: Corrected the Rust reference — the orphan rule (E0117) forces the gateway to be a real crate, boxed-async is mandatory because async fn in traits is still not dyn-compatible on 1.94, and the contract/core split is bought for rebuild blast radius rather than for a wall module privacy already gives; recorded a new open question: nothing on stable stops a peer service crate leaking a domain type across the seam.
  • Update: Closed the frontend reference's last open question — cross-bundle deduplication of element-defining packages is a correctness requirement (a duplicate customElements.define throws and silently kills the rest of that bundle), settled on import maps, with the guarded-define workaround rejected; also corrected the enforcement claims — the workspace graph and TS project references enforce nothing, dependency-cruiser is the only wall and fails open unless its resolver is configured.
  • Update: Settled where persistence sits in the modulith across the infrastructure layer and the domain layer — the adapter owns the mapping and the assembly owns the connection (pool, credentials, profile config), migrations are their own deployment unit, and the transactional boundary is a dedicated UnitOfWork driven port rather than unit-of-work semantics on the repository port; also recorded the nested infra/<port>/<technology> naming as the same (port × technology) rule.
  • Update: Made the modulith the favored layout in Hexagonal architecture — one hexagon per bounded context under modules/, shared modules under platform/, and one assembly per delivery typology under application/; the flat trisection is now recorded as the degenerate single-context case, with the full dependency-rule table and the user-side/service composition seam.
  • Creation: Added concept Modulith & microservices — why the house layout starts as a modulith, the six-step extraction procedure, what it genuinely costs (data separation and re-reading a port's failure semantics), and why the move is reversible.
  • Update: Rewrote the Java group onto the modulith — the reference tree (platform/ + modules/ + application/, per-module dependency table, ArchUnit slice rule), user-side adapters & assemblies (adapters are libraries; the assembly absorbed the configurator), the domain layer (per-module mediator over platform/kernel; a repository-wide command bus ruled out), the infrastructure layer (infra belongs to its context; ubiquitous ports moved to platform/commons; no shared schema between modules) and deployment & IaC (Dockerfiles key off the assembly).
  • Creation: Added concept Module composition — the in-process service seam — the consumer-owned driven port, the infra gateway, the peer-facing service adapter, and the Gradle implementation-scope rule that keeps a provider's domain off a consumer's classpath.
  • Update: Re-homed the Go reference onto the modulith — a context is internal/modules/<ctx>/ fronted by a facade package, two nested internal/ walls (peers, then the core), and gateway/<peer>/ as the one package naming two contexts.
  • Update: Re-homed the Rust reference onto the modulith — per-context crate clusters, so "billing must not touch ordering's domain" is a missing Cargo.toml edge; command enums scoped per context; the in-process and HTTP gateways given identical port signatures.
  • Update: Re-homed the frontend reference onto the modulith and closed most of its open question — a micro-frontend is a carved-out module, with per-context tag prefixes and subtree-scoped Context providers doing the work; only cross-bundle dependency deduplication stays open.
  • Update: Cross-linked Microservice architecture with the new modulith note in both directions.

2026-08-11

2026-08-10

  • Creation: Added concept The TypeScript build ecosystem — the layered TypeScript toolchain — runtimes, package managers, compilers, bundlers — across the frontend and backend worlds, and the artifact formats they produce.
  • Creation: Added concept Building TypeScript for the backend — the spectrum from tsc-as-the-whole-build to type-stripping runtimes to bundled lambdas, with ESM vs CJS as the central pain and orchestrators caching monorepo task graphs.
  • Creation: Added concept The bundler world — why bundling exists, the generational story from webpack through esbuild to the Rust rewrites converging on Rolldown, and how apps and libraries bundle differently.
  • Creation: Added concept Package managers: npm, pnpm, yarn, bun — one registry, four clients — semver ranges and lockfiles, node_modules layouts from hoisted flat trees to pnpm's symlinked store, workspaces, Corepack pinning, and the lifecycle-script supply chain.
  • Creation: Added concept Vite deep dive — Vite's dev/prod split — a native-ESM dev server with esbuild pre-bundling, Rollup/Rolldown production builds — plus the plugin API, the framework ecosystem built on it, and Vitest.
  • Update: Cross-linked the new group both ways with The Java build ecosystem, The Rust build ecosystem, Modules & the Go build ecosystem, and TypeScript deep dive — the cross-language build-set contrast now spans all four ecosystems.

2026-08-09

  • Update: Hexagonal architecture — settled the command-dispatch stance across the references: business logic enters the hexagon as command/query data through one explicit dispatch seam; the mechanism is per-language (Java: registry Mediator; Rust: per-use-case traits, enum + exhaustive match when a unified seam is justified; Go and frontend: no mediator object — per-use-case ports + decorators).
  • Update: Domain layer — contract & implementation — Command/Query + Mediator ruled the Java default: Mediator driving port + sealed command records in domain-api, self-declaring handlers + RegistryMediator in domain-core; per-use-case driving interfaces demoted to rejected-as-default. Application layer adapters now dispatch through the Mediator seam.
  • Update: Go reference implementation — mediator object ruled out: commands as structs, per-use-case driving ports wired in main, decorators for cross-cutting; rejected because a heterogeneous handler registry can't be typed in Go (erasure to any) and the indirection is anti-idiomatic.
  • Update: Rust reference implementation — the compiler is the registry: per-use-case driving-port traits by default, commands as an enum with one exhaustive match when a unified seam is justified; the dyn registry probed via supports() ruled out (Any downcasts, result-type erasure).
  • Update: Frontend reference implementation — mediator ruled out: the dispatch seam is the per-use-case driving port behind its typed context key; a central dispatcher would defeat tree-shaking, collapse the context keys, and weaken subtree scoping; cross-cutting via factory decoration in main.ts.
  • Creation: Added concept Hexagonal reference implementation — Frontend (web components) — the house reference realized for the browser: web components as driving adapters, a DOM-free domain enforced by tsc's lib dial, browser APIs behind driven ports, npm workspace + TS project references as the walls, definition-time closure injection as the wiring stance.
  • Update: Hexagonal architecture — the hub now counts four standalone reference implementations; cross-linked both ways with the new frontend note.
  • Update: Wired the frontend reference implementation into the Frontend theme — both-ways links with Component architecture & state management, TypeScript deep dive, Browser internals, Frontend testing, and Design systems.
  • Update: Frontend reference implementation — DI stance settled: the WCCG Context protocol (context-request) is the wiring mechanism, with the provider a plain listener at each unit's assembly point; closure injection demoted to rejected alternative alongside code-only constructor injection and property injection; upgrade-ordering caveat and the ports-once/reactivity-separate discipline stated. The protocol is built from baseline DOM events — no browser-support surface.
  • Update: Frontend reference implementation — settled where atomic design fits: the hierarchy organizes the driving adapter's interior; port-awareness (not atomic level) draws the line — domain-blind levels in the design-system package, port-bound organisms/templates/pages in their deployment unit. Cross-linked both ways.
  • Creation: Added concept group Hexagonal reference implementation — the house layout for a hexagonal monolith/microservice in Java: Maven multi-module, application/domain/infrastructure trisection, one deployment unit per primary adapter.
  • Creation: Added concept Application layer — primary adapters as deployment units — one module pair (API + implementation) per user-side adapter, each a single unit of deployment, plus the optional configurator.
  • Creation: Added concept Domain layer — contract & implementation — domain-api (ports, command DTOs) vs domain-core, and what crosses that line.
  • Creation: Added concept Infrastructure layer — secondary adapters & the granularity debate — the open question of the reference, with the house position: one module per secondary adapter.
  • Creation: Added concept Deployment & IaC — Dockerfiles beside their deployment unit, OpenTofu stacks in a deployment folder.
  • Creation: Added concept Hexagonal reference implementation — Go derivation — the same principles with packages, cmd/ binaries as deployment units, and lint-backed boundaries.
  • Creation: Added concept Hexagonal reference implementation — Rust derivation — a Cargo workspace mapping almost 1:1 onto the Maven layout, traits as ports, the dyn-vs-generics wiring choice.
  • Update: Cross-linked Hexagonal architecture both ways with the new reference implementation notes.
  • Update: Wired the Rust derivation into the expanded Rust theme — both-ways links with Cargo in depth and Async runtimes, plus a pointer to Backend protocols in Rust.
  • Update: Reference rulings from the derivation discussion folded in — the layout and application layer adopt pair-only-where-the-contract-is-real (cron units are a single module, Java included).
  • Update: Go derivation settled — nested internal/ hides the domain core behind exported factories (compiler-enforced), depguard keeps only the softer rules, go.work split rejected.
  • Update: Rust derivation settled — object-safe dyn ports by default with the boxed-async cost stated, generics documented as the measured hot-path escape hatch; configurator module confirmed as a Java-only construct.
  • Update: Remaining open questions of the reference closed — infrastructure layer: granularity is an ad-hoc per-context decision (single ↔ granular), ubiquitous ports harbored in a commons module, contract testing between infra and the domain contract ruled out (also reflected in the domain layer and the layout).
  • Update: Go derivation — DTO↔command mapping duplication between deployment units accepted by design; Rust derivation — many-small-crates compile cost accepted as the price of crate-graph enforcement. Nothing left open across the reference.
  • Update: Cross-linked the hexagonal reference both ways with the new per-language API documentation notes — the contract formats the -api modules/crates and Go's root api/ directory carry.
  • Update: Reframed the hexagonal reference as three standalone implementations — Java, Go, Rust each stand on their own and reference only Hexagonal architecture, which now carries the shared house principles and back-references all three.
  • Update: Go reference implementation — DI stance settled: dependency injection as a pattern (constructor wiring at each main), google/wire as the sanctioned compile-time escalation, reflection containers (fx/dig) ruled out.
  • Creation: Added concept group Java memory & garbage collection — the map of Java memory: where objects live, the lifecycle from allocation to reclamation, and how the memory-model and GC notes fit together.
  • Creation: Added concept JVM memory anatomy — heap, stacks & metaspace — the runtime data areas, object layout, TLAB allocation, reference strength and the OutOfMemoryError flavours.
  • Creation: Added concept The Java Memory Model — happens-before & visibility — the JMM contract — happens-before, volatile, final-field semantics and safe publication — that makes concurrent Java analyzable.
  • Creation: Added concept GC principles & algorithms — reachability, the generational hypothesis and safepoints, then mark-sweep, mark-compact, copying, tri-color concurrent marking and the barriers that keep it honest.
  • Creation: Added concept Garbage collectors compared — G1, ZGC, Shenandoah & the rest — HotSpot's collectors compared on algorithm, pause profile and throughput, with guidance on choosing and first-step tuning.
  • Update: Cross-linked the new group both ways with Deep dive Java, JVM implementations compared, jstat, jmap, Concurrency and Parallelism, and Deep dive Go.
  • Creation: Added concept How a computer works — processor architecture, binary logic & arithmetic — the foundational layer: binary and two's complement, floating point, logic gates, the fetch-decode-execute CPU, and the memory hierarchy.
  • Update: Broadened the Fundamentals theme scope (root index & AGENTS.md) to include "how a computer works"; cross-linked the new concept both ways with Unicode & text encoding, Time, timezones & datetime, Linux deep dive, and Algorithms and data structures.
  • Creation: Added exercise DST-safe scheduler — the time note's loose practice drills consolidated into one flagship build: RFC 3339 parser, instant/civil type model, tzdb-update drill, DST-edge recurrence expander.
  • Creation: Added subject DST-safe scheduler — subject — gap/overlap resolution semantics, the future-meeting storage drill, and the hostile-zone acceptance fixtures.
  • Creation: Added exercise Build a DNS resolver — the networking module's flagship build: hand-packed packets over UDP, name compression, the root-to-authoritative walk, annotated captures as proof.
  • Creation: Added subject Build a DNS resolver — subject — wire-format rules, the pointer-compression contract, the no-glue delegation case, and the two-capture proof.
  • Update: Foundations path — modules 2 (time) and 5 (network) promoted from concept-note drills to the new flagship exercises; proofs upgraded from written answers to passing acceptance suites and annotated captures.
  • Update: Time, timezones & datetime — # Practice now points at the DST-safe scheduler exercise, replacing the three loose drill bullets it consolidates.
  • Update: Networking fundamentals — # Practice now points at the DNS resolver exercise, which subsumes the Wireshark dissection and the external DNS tutorial bullets.
  • Creation: Added concept OpenJDK & the JEP process — how Java evolves — how OpenJDK is organised, how JEPs move features from draft to shipped, and what preview/incubator/experimental stability levels promise.
  • Creation: Added concept The JDK, the JRE & their tools — what the JDK ships beyond the compiler — the runtime, and the full catalog of command-line tools grouped by purpose.
  • Creation: Added concept jar — archives & manifests — the jar tool — creating and inspecting archives, MANIFEST.MF semantics, executable jars, and multi-release jars.
  • Creation: Added concept java — the launcher — the java launcher — running classes, jars, modules and source files, plus the JVM flag families that matter.
  • Creation: Added concept javac — the Java compiler — the JDK compiler — compilation model, classpath vs module path, --release, annotation processing, and lint flags.
  • Creation: Added concept javadoc — API documentation — the javadoc tool — doc comments and tags, doclets, JEP 413 snippets, and publishing API docs from builds.
  • Creation: Added concept javap — the class file disassembler — the javap disassembler — reading bytecode and the constant pool to verify what the compiler actually generated.
  • Creation: Added concept jcmd — the JVM diagnostic command hub — sends diagnostic commands to a running JVM — flags, heap info, thread dumps, JFR control — superseding most older j* tools.
  • Creation: Added concept jconsole — the JMX console — the JDK's Swing GUI for browsing JMX MBeans and live memory, thread and class charts on local or remote JVMs.
  • Creation: Added concept jdb — the CLI debugger and JDWP — the JDK's command-line debugger and the JDWP/JDI machinery behind it — the same wire protocol every IDE debugger speaks.
  • Creation: Added concept jdeps — dependency analysis — the jdeps analyser — class, package and module-level dependencies, JDK-internal usage, and feeding jlink.
  • Creation: Added concept JDK Flight Recorder & Mission Control — always-on, low-overhead JVM event recording (JFR) and its analysis GUI (JMC) — the built-in production profiling stack.
  • Creation: Added concept jlink — custom runtime images — assembles a trimmed, self-contained Java runtime from a set of modules, replacing the standalone JRE for application distribution.
  • Creation: Added concept jmap — heap histograms and heap dumps — produces class histograms and full hprof heap dumps for leak analysis in MAT or VisualVM, at a real pause cost on large heaps.
  • Creation: Added concept jmod — the JMOD format and tool — link-time packaging format for modules that can carry native libraries and config, consumed by jlink but never shipped to run.
  • Creation: Added concept jpackage — native installers and app images — packages a Java application with a bundled runtime into platform-native installers (deb, rpm, msi, exe, dmg, pkg) per JEP 392.
  • Creation: Added concept jps — listing JVM processes — lists running JVMs with pids, main classes and arguments, backed by the JVM's shared-memory perfdata files.
  • Creation: Added concept jshell — the Java REPL — the jshell REPL — exploratory snippets, /commands, feedback modes, and scripting use.
  • Creation: Added concept jstack — thread dumps — captures platform-thread stack traces with lock and deadlock information; superseded by jcmd, and blind to virtual threads.
  • Creation: Added concept jstat — GC and class-loading statistics — samples HotSpot perfdata counters at intervals — GC utilisation, class loading, compilation — as a lightweight live-monitoring CLI.
  • Creation: Added concept jwebserver — the minimal static file server — jDK 18's zero-config static HTTP file server (JEP 408) for prototyping and local file serving, not for production.
  • Creation: Added concept keytool — keystores and certificates — manages PKCS12 keystores and truststores — keypairs, CSRs, CA imports, cacerts — and underpins most JVM TLS debugging.
  • Creation: Added concept JVM implementations compared — the JVM specification versus its implementations — HotSpot, OpenJ9, GraalVM, Azul — and the OpenJDK distribution landscape.
  • Creation: Added concept GraalVM deep dive — the Graal JIT, Truffle polyglot layer, and Native Image AOT — closed-world compilation, its wins, costs, and framework support.
  • Creation: Added reference The Java Virtual Machine Specification (JVMS) — the authoritative Oracle specification defining the class file format, bytecode semantics, and verification rules every conforming JVM implements.
  • Creation: Added concept The Java build ecosystem — the three ways to build Java — bare JDK tools, Maven, Gradle — and the artifact formats they produce.
  • Creation: Added concept Gradle deep dive — gradle's task DAG, Kotlin/Groovy DSLs, configuration vs execution, caching and incrementality, version catalogs, and convention plugins.
  • Creation: Added concept Maven deep dive — maven's POM model, fixed lifecycles, plugin-goal bindings, dependency mediation, BOMs, multi-module reactor, and the plugins worth knowing.
  • Creation: Added concept Java application frameworks — the landscape — how Spring, Quarkus and Micronaut differ in DI approach, footprint, native-image story and standards adherence, and where Jakarta EE sits.
  • Creation: Added concept Frameworks × Jakarta EE — who implements what — spec-by-spec correspondence of Jakarta EE and MicroProfile APIs to their Spring, Quarkus and Micronaut implementations or equivalents.
  • Creation: Added concept Micronaut deep dive — micronaut in depth — compile-time DI and AOP with no reflection, Micronaut Data, declarative HTTP clients and GraalVM affinity.
  • Creation: Added concept Quarkus deep dive — quarkus in depth — build-time augmentation, ArC CDI, RESTEasy Reactive, Panache, Mutiny, Dev Services and first-class native image.
  • Creation: Added concept Spring deep dive — the Spring stack in depth — IoC container, AOP proxies, Boot auto-configuration, MVC vs WebFlux, Data, Security, transactions and testing.
  • Creation: Added concept Testing in Java — strategies & tooling map — map of Java testing strategies — unit to security — with the standard tools for each and links to the deep-dive notes.
  • Creation: Added concept End-to-end testing — REST Assured, browsers & contracts — whole-system testing with REST Assured, Selenium/Playwright and Karate, contract testing as the leaner alternative, and flakiness discipline.
  • Creation: Added concept Integration testing — Testcontainers & framework test support — testing against real dependencies with Testcontainers, Spring test slices, Quarkus Dev Services, Micronaut Test and WireMock.
  • Creation: Added concept Mutation testing — PIT — pIT mutates production bytecode to measure whether tests actually assert behaviour, giving a mutation score stronger than line coverage.
  • Creation: Added concept Performance & load testing — JMH and Gatling — microbenchmarking with JMH and system load testing with Gatling/k6/JMeter, plus latency methodology and profiling with JFR.
  • Creation: Added concept Property-based testing — jqwik — testing invariants over generated inputs with jqwik — properties, generators, shrinking, and model-based stateful testing on JUnit 5.
  • Creation: Added concept Security testing — SCA, SAST, DAST & fuzzing on the JVM — security testing for Java builds — dependency scanning, static and dynamic analysis, JVM fuzzing, secrets scanning, and CI wiring.
  • Creation: Added concept Unit testing — JUnit 5, Mockito, AssertJ — the Java unit-testing stack — JUnit 5's Jupiter model, Mockito's disciplined use, AssertJ assertions, and test-double taxonomy.
  • Creation: Added concept Backend protocols in Java — the map — how the main service protocols — REST, GraphQL, gRPC, WebSockets/SSE, messaging — map onto Jakarta, Spring, Quarkus and Micronaut.
  • Creation: Added concept GraphQL on the JVM — graphql-java as the shared engine beneath Spring for GraphQL, SmallRye GraphQL, Micronaut GraphQL and Netflix DGS, plus N+1 and subscriptions.
  • Creation: Added concept gRPC in Java — protobuf contracts, grpc-java, streaming modes and deadlines, with the Spring, Quarkus and Micronaut integrations and when to prefer gRPC over REST.
  • Creation: Added concept Messaging in Java — Kafka, JMS & AMQP — kafka clients and their Spring, Quarkus and Micronaut integrations, JMS and AMQP alternatives, delivery semantics, Avro serialization and broker testing.
  • Creation: Added concept REST & HTTP APIs in Java — jakarta REST (JAX-RS) and its framework equivalents — Spring MVC/WebFlux, Quarkus REST, Micronaut HTTP — plus clients, OpenAPI and error conventions.
  • Creation: Added concept WebSockets & SSE in Java — jakarta WebSocket, Spring's STOMP layer, Quarkus WebSockets Next and Micronaut WebSocket, with SSE as the cheaper one-way option and fan-out scaling.
  • Creation: Added concept Storage access from Java — the map — how Java reaches every storage kind — drivers, mapping layers, and the Spring, Quarkus, and Micronaut integrations for each.
  • Creation: Added concept Document and NoSQL stores from Java — mongoDB, Cassandra, Couchbase, and DynamoDB access layers per framework, and how document modeling and tunable consistency surface in the client.
  • Creation: Added concept Graph databases from Java — neo4j via Bolt, Cypher, Spring Data Neo4j and OGM, TinkerPop/Gremlin as the vendor-neutral layer, and when graphs beat recursive SQL.
  • Creation: Added concept Redis from Java — jedis vs Lettuce vs Redisson, Spring Data Redis and Session, Quarkus and Micronaut clients, plus cache, lock, rate-limit, and messaging patterns.
  • Creation: Added concept Relational databases from Java — the JDBC-to-ORM stack — HikariCP, JPA/Hibernate and its pitfalls, jOOQ/MyBatis alternatives, framework data layers, R2DBC, migrations, and transactions.
  • Creation: Added concept Time-series stores from Java — influxDB and QuestDB clients, TimescaleDB over plain JDBC, and Micrometer as the JVM metrics facade feeding Prometheus and friends.
  • Creation: Added concept Security in Java applications — the map — how the recurring security concerns map onto Spring Security, Quarkus and Micronaut modules and the standards behind them.
  • Creation: Added concept Cryptography in Java — JCA/JSSE in practice — the JCA provider architecture, the core crypto APIs, TLS via JSSE, keystores, Vault integrations and the classic pitfalls.
  • Creation: Added concept OAuth2 & OIDC in Java — the OAuth2/OIDC roles — resource server, client, authorization server — and how Spring, Quarkus and Micronaut implement each.
  • Creation: Added concept Web security in Java apps — the OWASP-top-10 concerns as they surface in Java stacks, and which parts Spring, Quarkus and Micronaut handle for you.
  • Update: Deep dive Java — # Related now maps the expanded theme: the JDK toolchain, JVM implementations, build ecosystem, JEP process, frameworks, testing, protocols, storage, and security groups.
  • Creation: Added concept How Go evolves — the proposal process & community — go's governance and proposal pipeline, the Go 1 compatibility promise, release cadence, and the community organs around them.
  • Creation: Added concept The Go toolchain — the single go command as the entire build system — distribution, environment, and the catalog of built-in and companion tools.
  • Creation: Added concept Delve — the Go debugger — delve (dlv), the goroutine-aware Go debugger — debug/attach/test/core modes, DAP for IDEs, conditional breakpoints, and remote debugging in containers.
  • Creation: Added concept Execution tracer — go tool trace — the runtime execution tracer — scheduler-level event recording, go tool trace analysis, flight-recorder capture, and when tracing beats profiling.
  • Creation: Added concept go build, go run, go install — the compile trio — build cache, build tags, ldflags stamping, first-class cross-compilation, race builds, and PGO.
  • Creation: Added concept go doc & pkg.go.dev — documentation — doc comments, go doc on the CLI, testable ExampleXxx functions, and pkg.go.dev as the ecosystem's shared API reference.
  • Creation: Added concept go generate — explicit, committed code generation via //go:generate directives — Go's answer to annotation processing and reflection-heavy magic.
  • Creation: Added concept go mod — the daily dependency interface — init, tidy, download, why, graph, vendor, edit — over go.mod and go.sum.
  • Creation: Added concept go test — the built-in test runner — test binary model, run/bench/fuzz selectors, caching, race detection, and coverage flags.
  • Creation: Added concept go tool cover — coverage — test coverage in Go — coverprofile collection, HTML reports, coverage modes, binary coverage via GOCOVERDIR, and what the numbers actually mean.
  • Creation: Added concept go vet — the static analyzer shipped with the toolchain — catches likely-wrong code, runs under go test, extensible via go/analysis.
  • Creation: Added concept go work — workspaces (Go 1.18+) — go.work wires multiple local modules together for development, replacing the replace-directive dance.
  • Creation: Added concept gofmt & goimports — canonical, non-configurable formatting as a language feature, goimports for import blocks, and gofumpt as the stricter superset.
  • Creation: Added concept gopls — the language server — gopls, Go's single official LSP server — completion, refactors, inlay hints, diagnostics, and module-aware workspace handling for every editor.
  • Creation: Added concept govulncheck — vulnerability scanning — call-graph-aware vulnerability scanning against the Go vulnerability database — only reachable vulns reported, in source or binary mode.
  • Creation: Added concept pprof — profiling — go's built-in profiler — profile kinds, runtime/pprof and net/http/pprof collection, go tool pprof analysis, continuous profiling, and PGO.
  • Creation: Added concept staticcheck & golangci-lint — the lint ecosystem — static analysis beyond go vet — staticcheck's check catalogue, golangci-lint as the meta-runner, and keeping lint sets small and intentional.
  • Creation: Added concept Go compilers & runtimes compared — the Go specification versus its implementations — the gc reference toolchain, gccgo, gollvm, TinyGo — and the WASM targets.
  • Creation: Added reference The Go Programming Language Specification — the authoritative definition of Go's syntax, type system, and semantics, maintained alongside each release at go.dev.
  • Creation: Added concept TinyGo deep dive — the LLVM-based Go compiler for microcontrollers and WASM — dead-code elimination, selectable GC, the machine package, and its limits.
  • Creation: Added concept Modules & the Go build ecosystem — go's single first-party build path — the go command plus modules — and the artifact formats and module ecosystem around it.
  • Creation: Added concept Building & releasing Go software — from go build to shipped release — reproducible builds, cross-compilation, GoReleaser automation, container patterns, and supply-chain posture.
  • Creation: Added concept Go modules deep dive — how Go modules actually work — go.mod directives, semantic import versioning, Minimal Version Selection, the proxy and checksum database.
  • Creation: Added concept Go web frameworks — the landscape — how Go's stdlib-first web culture shapes the field — net/http, thin routers like chi, full frameworks Gin and Echo, and the fasthttp outlier Fiber.
  • Creation: Added concept Echo deep dive — echo's Context interface, centralized HTTPErrorHandler, binding and validation hooks, middleware set with stdlib adapters, and how it compares to Gin.
  • Creation: Added concept Fiber deep dive — fiber's Express-style API on fasthttp — what abandoning net/http buys, the recycled-context hazard, and when the throughput trade is worth it.
  • Creation: Added concept Gin deep dive — gin's Context model, radix-tree routing, binding and validation, middleware ecosystem, and when it earns its keep over chi plus stdlib.
  • Creation: Added concept net/http deep dive — the stdlib HTTP stack in depth — Handler contract, 1.22 ServeMux patterns, middleware, server timeouts, client pooling, HTTP/2, and graceful shutdown.
  • Creation: Added concept Frameworks × the stdlib contracts — who honors what — contract-by-contract table of how chi, Gin, Echo, and Fiber honor, wrap, or replace Go's stdlib interfaces, and why compatibility pays.
  • Creation: Added concept Testing in Go — strategies & tooling map — map of Go testing strategies — unit to security — built on the stdlib testing package, with tools and deep-dive links per strategy.
  • Creation: Added concept End-to-end testing — API clients, browsers, contracts — go end-to-end testing — API-level E2E with plain net/http, browser automation via playwright-go/rod/chromedp, pact-go contracts, and flakiness discipline.
  • Creation: Added concept Integration testing — httptest, testcontainers-go, real databases — go integration testing — httptest.Server for real HTTP in-process, testcontainers-go and dockertest for real dependencies, suite segregation and DB patterns.
  • Creation: Added concept Mutation testing — gremlins and go-mutesting — mutation testing in Go with gremlins and go-mutesting — mutation score over coverage, cost controls, and why the practice is rarer than on the JVM.
  • Creation: Added concept Performance & load testing — testing.B, benchstat, vegeta — go performance testing — testing.B microbenchmarks and their traps, benchstat for statistical honesty, profiling under benchmark, and load testing with vegeta/k6/hey.
  • Creation: Added concept Property-based testing & fuzzing — rapid and go test -fuzz — generated-input testing in Go — native fuzzing since 1.18 (f.Fuzz, corpus, crashers) and property-based testing with rapid, and when each fits.
  • Creation: Added concept Security testing — govulncheck, gosec, scanning — security testing for Go — reachability-aware govulncheck, gosec static rules, fuzzing at trust boundaries, dependency and image scanning, and CI wiring.
  • Creation: Added concept Unit testing — the testing package, table tests, doubles — go unit testing with the stdlib testing package — table-driven tests, subtests, golden files, the assertion-library debate, and test doubles.
  • Creation: Added concept Backend protocols in Go — the map — how REST, GraphQL, gRPC, WebSockets/SSE and messaging map onto Go's stdlib and the dominant community libraries.
  • Creation: Added concept GraphQL in Go — gqlgen's schema-first codegen as the de-facto GraphQL stack, the runtime-first alternatives, dataloaders, subscriptions and federation.
  • Creation: Added concept gRPC in Go — grpc-go and the buf toolchain, streaming modes, interceptors, connect-go and grpc-gateway, and load-balancing realities in Kubernetes.
  • Creation: Added concept Messaging in Go — Kafka, NATS & AMQP — the four Kafka clients, NATS as the Go-native option, RabbitMQ via amqp091-go, watermill, delivery semantics and broker testing.
  • Creation: Added concept REST & HTTP APIs in Go — building REST services on net/http and chi — JSON realities, validation, OpenAPI tooling, error conventions, clients and middleware.
  • Creation: Added concept WebSockets & SSE in Go — gorilla/websocket and coder/websocket for bidirectional push, SSE from the stdlib, goroutine-per-connection economics and backpressure.
  • Creation: Added concept Storage access from Go — the map — how Go reaches every storage kind — database/sql, per-store drivers, and the raw-driver-to-ORM spectrum, mapped store by store.
  • Creation: Added concept Document and NoSQL stores from Go — mongoDB, Cassandra/Scylla, DynamoDB, and Couchbase clients — struct-tag mapping, per-call consistency knobs, and modeling with structs instead of entities.
  • Creation: Added concept Graph databases from Go — neo4j's official driver and Cypher transaction functions, Gremlin via gremlin-go, Dgraph's dgo client, and when graph beats recursive SQL.
  • Creation: Added concept Redis from Go — go-redis as the default client, rueidis and redigo alternatives, and the cache, lock, rate-limit, and streaming patterns built on them.
  • Creation: Added concept Relational databases from Go — the database/sql substrate, pgx for Postgres, and the query-layer spectrum — sqlc, sqlx, GORM, ent, builders, migrations, and explicit transactions.
  • Creation: Added concept Time-series stores from Go — prometheus as Go's native habitat, OpenTelemetry as the converging facade, and the Influx, Timescale, VictoriaMetrics, and QuestDB client paths.
  • Creation: Added concept Security in Go applications — the map — how the recurring security concerns map onto Go's stdlib and de-facto libraries, composed as middleware rather than a framework.
  • Creation: Added concept Cryptography in Go — the stdlib way — go's curated, misuse-resistant crypto stdlib, x/crypto extras, TLS configuration, FIPS 140-3 mode, and key and secret management.
  • Creation: Added concept OAuth2 & OIDC in Go — the OAuth2/OIDC protocol family in Go with x/oauth2, go-oidc, JWT libraries, resource-server middleware and embeddable providers.
  • Creation: Added concept Web security in Go apps — the OWASP web attack surface in Go idiom — injection, XSS, CSRF, CORS, headers, sessions, file handling, SSRF and request limits.
  • Update: Deep dive Go — # Related now maps the expanded theme: toolchain, compilers & runtimes, modules & build, the proposal process, web frameworks, testing, protocols, storage, and security groups.
  • Update: Cross-linked the eight Java group summaries (JDK & tools, JVM implementations, build ecosystem, frameworks, testing, protocols, storage, security) to their new Go counterparts, both ways.
  • Creation: Added concept The Rust toolchain — rustup, the release channels, and cargo as the single front door — the catalog of built-in and companion tools from rustc to miri.
  • Creation: Added concept rustup — toolchain management & the release channels — the toolchain multiplexer — stable/beta/nightly channels, components, cross-compilation targets, and per-project pinning via rust-toolchain.toml.
  • Creation: Added concept cargo — the front door — the daily interface to everything — build/run/test/bench/doc, dependency management with cargo add, and the cargo-* plugin convention.
  • Creation: Added concept rustc — the compiler behind cargo — the compilation pipeline — HIR/MIR, borrow checking, monomorphization, LLVM codegen — and the knobs that matter.
  • Creation: Added concept rustfmt — formatting — canonical formatting as a rustup component — cargo fmt, the rustfmt.toml escape hatch, stable vs nightly-only options, and the CI check.
  • Creation: Added concept clippy — the lint collection — Rust's official linter — 750+ lints in leveled categories from correctness to pedantic, cargo clippy --fix, clippy.toml, and sane CI policy.
  • Creation: Added concept rustdoc & docs.rs — documentation — doc comments to rendered API docs — doctests that actually run, intra-doc links, and docs.rs building every crates.io release automatically.
  • Creation: Added concept miri — undefined-behaviour detection — the MIR interpreter that catches undefined behaviour in unsafe code — aliasing-model violations, use-after-free, data races.
  • Creation: Added concept rust-analyzer — the language server — the official LSP server — on-the-fly analysis, proc-macro expansion, assists and inlay hints, flychecks via cargo check.
  • Creation: Added concept cargo-nextest — the test runner — the community-standard test runner — process-per-test isolation, retries, CI partitioning — and what it doesn't run (doctests).
  • Creation: Added concept cargo-expand — macro expansion — prints your code with all macros and derives expanded — the essential debugging view for proc-macro-heavy code.
  • Creation: Added concept Profiling & debugging Rust — perf and cargo-flamegraph, samply, debug info in release builds, rust-gdb/rust-lldb, heap tools, and tokio-console for async.
  • Creation: Added concept Rust compilers & the language definition — rustc as the single implementation — with gccrs and mrustc as the outliers and the WASM targets — and the spec situation: the Rust Reference versus the Ferrocene FLS.
  • Creation: Added concept Editions — Rust's compatibility mechanism — how editions let Rust make breaking changes without breaking the ecosystem — per-crate opt-in, guaranteed interop, cargo fix migrations.
  • Creation: Added concept Async runtimes — Tokio, smol & the runtime-agnostic tension — Rust ships async/await without an executor — Tokio as the de-facto standard, smol, embassy, and the unresolved runtime-agnostic library problem.
  • Creation: Added reference The Rust Reference & the Ferrocene FLS — the two documents defining Rust — the project's non-normative Reference and the certification-grade FLS, now adopted as the seed of the official spec.
  • Creation: Added concept The Rust build ecosystem — cargo as the one build path — crates.io as the single registry, the artifact formats from bin to cdylib to WASM.
  • Creation: Added concept Cargo in depth — workspaces, features, profiles & publishing — the cargo project model — workspace inheritance, additive features and unification, profiles, build.rs, publishing, lockfile semantics.
  • Creation: Added concept Building & releasing Rust — cross-compilation and the linker problem, cross and cargo-zigbuild, cargo-dist, and the supply chain: cargo-audit, cargo-deny, cargo-vet.
  • Creation: Added concept How Rust evolves — RFCs, teams & the release train — the RFC process and team governance, the Rust Foundation's role, nightly feature gates and stabilization, and the six-week train with editions on top.
  • Creation: Added concept Rust web frameworks — the landscape — how the tower/hyper substrate shapes the field — Axum as the Tokio-native default, Actix Web's own stack, Rocket's ergonomics-first lineage.
  • Creation: Added concept Axum deep dive — the Tokio team's framework — extractors and IntoResponse, Router composition, State, and tower/tower-http middleware for free.
  • Creation: Added concept Actix Web deep dive — the own-stack incumbent — actix-http engine, extractors, its Transform middleware model, the actor heritage, and where it beats axum.
  • Creation: Added concept Rocket deep dive — the ergonomics pioneer — attribute-macro routing, request guards, fairings, and the async 0.5 rebirth on stable Rust.
  • Creation: Added concept Frameworks × tower/hyper — who builds on the contracts — contract-by-contract table of how Axum, Actix Web, Rocket, warp and poem honor, wrap, or replace the tower/hyper substrate.
  • Creation: Added concept Testing in Rust — strategies & tooling map — map of Rust testing strategies — unit to security — built on the built-in test harness and cargo-nextest, with the tools per strategy.
  • Creation: Added concept Unit testing — the built-in harness, organization & doubles — #[test] and #[cfg(test)] modules — assertion macros, rstest parameterization, insta snapshots, doctests, and trait-based doubles.
  • Creation: Added concept Integration testing — tests/, in-process routers & testcontainers — the tests/ directory model, tower::ServiceExt oneshot, #[sqlx::test] databases, testcontainers-rs, and wiremock.
  • Creation: Added concept End-to-end testing — whole systems & contracts — reqwest smoke suites, browser automation with thirtyfour, CLI testing with assert_cmd, and where contract testing stands.
  • Creation: Added concept Mutation testing — cargo-mutants — judging the test suite by mutating the code — cargo-mutants' approach, missed-mutant reports, CI economics, and the type-system twist.
  • Creation: Added concept Property-based testing & fuzzing — proptest & cargo-fuzz — invariants over generated inputs with proptest and coverage-guided fuzzing with cargo-fuzz — and how the two share targets.
  • Creation: Added concept Performance & load testing — criterion, divan & friends — microbenchmarks with criterion and divan, iai-callgrind instruction counts, black_box discipline, and load testing with goose and k6.
  • Creation: Added concept Security testing — audit, unsafe hygiene & fuzzing — the Rust security-testing portfolio — cargo-audit/deny/vet, cargo-geiger and miri on unsafe code, fuzzing the input surface.
  • Creation: Added concept Backend protocols in Rust — the map — how REST, GraphQL, gRPC, WebSockets/SSE and messaging map onto the de-facto crates — axum/reqwest, async-graphql, tonic, tokio-tungstenite, rdkafka/lapin/async-nats.
  • Creation: Added concept REST & HTTP APIs in Rust — building REST services on axum/actix — serde realities, validation, utoipa and the OpenAPI workflows, error shapes as IntoResponse, and reqwest.
  • Creation: Added concept GraphQL in Rust — async-graphql as the modern default and juniper as the elder — code-first schemas from derives, dataloaders, subscriptions, and the client crates.
  • Creation: Added concept gRPC in Rust — tonic & prost — tonic as the de-facto gRPC stack — prost codegen, all four streaming modes on Tokio, tower middleware sharing, and the operational endpoints.
  • Creation: Added concept WebSockets & SSE in Rust — tokio-tungstenite as the protocol workhorse, axum's WebSocketUpgrade and Sse built-ins, connection-state patterns with channels, and backpressure.
  • Creation: Added concept Messaging in Rust — Kafka, AMQP & NATS — rdkafka over librdkafka, lapin for RabbitMQ, the official async-nats — consumer patterns on Tokio and offset/ack discipline.
  • Creation: Added concept Storage access from Rust — the map — how Rust reaches every storage kind — no stdlib layer, per-store drivers, the sqlx/diesel/sea-orm spectrum for relational — mapped store by store.
  • Creation: Added concept Relational databases from Rust — sqlx, diesel & sea-orm — the relational spectrum — sqlx's compile-time-checked SQL, diesel's DSL, sea-orm's async ORM, tokio-postgres underneath — plus pooling, transactions and migrations.
  • Creation: Added concept Redis from Rust — redis-rs & fred — the redis crate as the default client and fred as the batteries-included alternative — connections, pub/sub and streams, and the cache/lock patterns.
  • Creation: Added concept Document and NoSQL stores from Rust — the official mongodb driver with bson/serde mapping, ScyllaDB's shard-aware scylla crate, and DynamoDB via aws-sdk-dynamodb with serde_dynamo.
  • Creation: Added concept Time-series stores from Rust — Prometheus exposition with prometheus-client and the metrics facade, InfluxDB via influxdb2, the PG-wire stores through sqlx, and Rust as the new TSDB implementation language.
  • Creation: Added concept Graph databases from Rust — neo4rs as the community Bolt driver, Gremlin via gremlin-client, embedded RDF/SPARQL with oxigraph, and the thin-but-workable state of the corner.
  • Creation: Added concept Security in Rust applications — the map — how the recurring security concerns map onto Rust's crates — composed as tower middleware and typed APIs, with memory safety covering some fronts and none of the others.
  • Creation: Added concept OAuth2 & OIDC in Rust — the oauth2 crate's typed flows, openidconnect for discovery and validation, jsonwebtoken for resource servers, and session auth with axum-login.
  • Creation: Added concept Web security in Rust apps — the OWASP concerns in Rust idiom — what memory safety does and doesn't buy, injection and XSS by construction, tower-http hardening, panics as DoS.
  • Creation: Added concept Cryptography in Rust — rustls, ring & RustCrypto — the crate-first crypto landscape — rustls and its providers, ring versus RustCrypto, age for file encryption, and zeroize/secrecy hygiene.
  • Update: Deep dive Rust — # Related now maps the expanded theme: toolchain, compilers & the language definition, build ecosystem, how Rust evolves, web frameworks, testing, protocols, storage, and security groups.
  • Update: Cross-linked the Java and Go group summaries and both correspondence tables (JDK & tools, JVM implementations, Java build ecosystem, OpenJDK & the JEP process, Java frameworks, Jakarta correspondence, Java testing, Java protocols, Java storage, Java security, Go toolchain, Go compilers & runtimes, Go modules & build, how Go evolves, Go web frameworks, Go stdlib correspondence, Go testing, Go protocols, Go storage, Go security) to their new Rust counterparts, both ways.
  • Creation: Added concept Ownership, memory & concurrency — the model — the map of Rust's core model — how one compile-time mechanism, ownership, answers both the memory-management question and the memory-model question.
  • Creation: Added concept Ownership & borrowing — the rules and the fights — the core rules in depth — moves and Copy, Drop and RAII, the borrow rules, NLL and Polonius — plus the recurring borrow-checker fights and their idiomatic resolutions.
  • Creation: Added concept Lifetimes — elision, 'static, variance & the craft — what lifetime annotations actually are, the elision rules, the two meanings of 'static, variance and HRTBs, and when to restructure instead of annotate.
  • Creation: Added concept Memory without GC — layout, smart pointers & interior mutability — Rust's memory anatomy — stack vs heap in the types, niche optimization, the Box/Rc/Arc/Cow ladder, interior mutability from Cell to Mutex, leaks, and allocators.
  • Creation: Added concept Fearless concurrency — Send, Sync, threads, channels & atomics — how ownership crosses thread boundaries — Send/Sync, scoped threads, channels, Arc<Mutex<T>>, atomics and memory orderings, rayon, and what fearless does not mean.
  • Creation: Saved book The Rust Programming Language ("the Book") — the official Rust book — the canonical, free introduction whose ownership, lifetimes, smart-pointer and concurrency chapters are the spine of this concept group.
  • Creation: Saved book The Rustonomicon — the official book of unsafe Rust — where the ownership guarantees actually come from, and the rules unsafe code must uphold.
  • Update: Deep dive Rust — # Related now hands its core-model bullets off to the new ownership, memory & concurrency group.
  • Update: Cross-linked the new group both ways with Java memory & GC, Deep dive Go, and Concurrency and Parallelism.
  • Creation: Added concept API documentation — the contract-artifact formats (OpenAPI, AsyncAPI, protobuf, GraphQL SDL) and the generate-doc-from-code vs generate-code-from-doc trade.
  • Creation: Added concept API documentation in Java — the doc flavors mapped onto Spring, Quarkus and Micronaut: springdoc, SmallRye/Micronaut OpenAPI, Springwolf, OpenAPI Generator.
  • Creation: Added concept API documentation in Go — the doc flavors mapped onto net/http/chi, Gin, Echo and Fiber: oapi-codegen, swag, huma/fuego, buf, grpc-gateway.
  • Creation: Added concept API documentation in Rust — the doc flavors mapped onto Axum, Actix Web and Rocket: utoipa and kin, tonic-build, async-graphql SDL export.
  • Update: Cross-linked the wave both ways from API design, the three protocol maps (Java, Go, Rust), the REST and messaging deep dives per language, and the three framework landscapes (Java, Go, Rust).
  • Update: Diagrammed Hexagonal architecture — the pattern as a flowchart: driving adapters → ports → hexagon → driven ports → driven adapters, dependencies pointing inward.
  • Update: Diagrammed the reference layout — the module dependency graph from the dependency-rules table, forbidden infrastructure→domain-core edge marked.
  • Update: Diagrammed the domain layer — both port directions living in domain-api, core implementing one side and consuming the other.
  • Update: Diagrammed the application layer — deployment units with pair-only-where-the-contract-is-real, cron units as single modules.
  • Update: Diagrammed the Go derivation — nested internal/ visibility boundaries with the compiler-blocked import shown.
  • Update: Diagrammed the Rust derivation — the workspace crate graph with the Arc dyn-port wiring seam at the binary crates.
  • Update: Diagrammed GC principles & algorithms — tri-color marking as a state diagram, with the lost-object mutation and both barrier families.
  • Update: Diagrammed Distributed consensus — Raft's follower/candidate/leader roles and their transitions.
  • Update: Diagrammed Relational databases from Java — the JPA entity lifecycle, LazyInitializationException marked on the detached state.
  • Update: Diagrammed OpenJDK & the JEP process — the JEP lifecycle including retarget/drop until ramp-down.
  • Update: Diagrammed the Java memory model — happens-before edges chaining across the Publisher example's two threads.
  • Update: Diagrammed Ownership & borrowing — a value's states: moves, shared vs exclusive borrows, NLL returns, drop.
  • Update: Diagrammed TLS/HTTPS & certificates — the handshake as a sequence diagram plus the chain of trust (two diagrams).
  • Update: Diagrammed WebSockets & bidirectional protocols — the upgrade handshake and the pub/sub fan-out topology (two diagrams).
  • Update: Diagrammed Kubernetes & containers — the reconciliation loop as a cycle plus Deployment→ReplicaSet→Pod containment (two diagrams).
  • Update: Diagrammed CI/CD & delivery engineering — build-once-promote and expand→migrate→contract (two diagrams).
  • Update: Diagrammed Maven — the lifecycle phase chain with plugin-goal bindings.
  • Update: Diagrammed Browser internals — the rendering pipeline with property re-entry points, and the event loop (two diagrams).
  • Update: Diagrammed Git internals — the object model as an ER diagram plus the worktree/index/repository triangle (two diagrams).
  • Update: Diagrammed rustc — the compilation pipeline from parse to object code with per-phase costs.
  • Update: Diagrammed GraalVM — the Native Image build pipeline with the build-time vs run-time split.
  • Update: Diagrammed Agents, RAG & tool use — the RAG pipeline and the agent loop (two diagrams).
  • Update: Diagrammed How a computer works — the fetch/decode/execute/writeback cycle and the memory-hierarchy latency ladder (two diagrams).

2026-08-08

2026-08-03

2026-07-31

  • Creation: Saved Hardening Linux — Linux system hardening guide for securing self-hosted infrastructure and container hosts.

2026-07-28

2026-07-26

2026-07-21

2026-07-20

  • Migration: Converted GitHub Maintainer Security Settings to OKF frontmatter.
  • Migration: Converted Google Cloud Platform — Knowledge Catalog OKF to OKF frontmatter; noted its adoption as this bundle's format.
  • Migration: Converted graphify to OKF frontmatter.
  • Migration: Converted How Boris Uses Claude Code (Part 17) to OKF frontmatter.
  • Migration: Converted Incus OS — cluster sans shell to OKF frontmatter.
  • Migration: Converted Karpathy Gist — 442a6bf to OKF frontmatter.
  • Migration: Converted rtk to OKF frontmatter. The whole bundle is now OKF v0.1 conformant.
  • Initialization: Adopted the Open Knowledge Format (OKF) v0.1 for this bundle — operating manual established in AGENTS.md, okf_version declared in the root index.