Tag catalogue
# The cross-cutting axis — themes shelve, tags thread.
❯ grep #1brc
❯ grep #a11y
❯ grep #accessibility
❯ grep #actix
❯ grep #actuator
❯ grep #adr
❯ grep #aes
❯ grep #agents
❯ grep #ai
❯ grep #ai-assisted
❯ grep #ai-engineering
- Agents, RAG & tool use Concept AI Engineering
- Build an agent from scratch — subject Subject AI Engineering
- Build an agent from scratch Exercise AI Engineering
- RAG over the knowledge base — subject Subject AI Engineering
- RAG over the knowledge base Exercise AI Engineering
- LLM fundamentals for engineers Concept AI Engineering
❯ grep #algorithms
❯ grep #allocators
❯ grep #analytics
❯ grep #aop
❯ grep #aot
❯ grep #api
❯ grep #api-design
- GraphQL in Go Concept Go
- Backend protocols in Go — the map Concept Go
- REST & HTTP APIs in Go Concept Go
- Backend protocols in Java — the map Concept Java
- Lifetimes — elision, 'static, variance & the craft Concept Rust
- Backend protocols in Rust — the map Concept Rust
- REST & HTTP APIs in Rust Concept Rust
❯ grep #appsec
❯ grep #architect
❯ grep #architecture
- Architecture documentation Concept Applicative Architecture
- Patterns for tools that generate configuration Concept Applicative Architecture
- Coupling & cohesion Concept Applicative Architecture
- CQRS & event sourcing Concept Applicative Architecture
- DDD Concept Applicative Architecture
- Hexagonal architecture Concept Applicative Architecture
- The four hexagonal references compared Concept Applicative Architecture
- Modulith & microservices Concept Applicative Architecture
- Team topologies & Conway's law Concept Engineering Practice
- Component architecture & state management Concept Frontend
- CSS architecture & layout Concept Frontend
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- Hexagonal architecture reference implementation — Go Concept Go
- User-side adapters & assemblies Concept Java
- Deployment & IaC — containers beside their unit, stacks in one folder Concept Java
- Domain layer — contract & implementation Concept Java
- Hexagonal architecture reference implementation — Java Concept Java
- Infrastructure layer — secondary adapters & the granularity debate Concept Java
- Module composition — the in-process service seam Concept Java
- Architect & lead — the force-multiplier track Path Paths
- Hexagonal architecture reference implementation — Rust Concept Rust
- Threat modeling Concept Security
- Microservice architecture Concept System Design
❯ grep #asdf
❯ grep #async
❯ grep #async-graphql
❯ grep #asyncapi
❯ grep #atomic-design
❯ grep #atomics
❯ grep #auth
❯ grep #authentication
❯ grep #automation
❯ grep #aws
❯ grep #axum
❯ grep #backend
❯ grep #bdd
❯ grep #benchmarking
❯ grep #benchmarks
❯ grep #binary
❯ grep #book
❯ grep #borrow-checker
❯ grep #browser
❯ grep #build
- Building TypeScript for the backend Concept Frontend
- The TypeScript build ecosystem Concept Frontend
- The bundler world Concept Frontend
- Package managers: npm, pnpm, yarn, bun Concept Frontend
- Vite deep dive Concept Frontend
- Building & releasing Go software Concept Go
- Go modules deep dive Concept Go
- Modules & the Go build ecosystem Concept Go
- go build, go run, go install Concept Go
- go mod Concept Go
- go work Concept Go
- The Go toolchain Concept Go
- The Java build ecosystem Concept Java
- Gradle deep dive Concept Java
- Maven deep dive Concept Java
- Mutation testing — PIT Concept Java
- Security testing — SCA, SAST, DAST & fuzzing on the JVM Concept Java
- The Rust build ecosystem Concept Rust
- Building & releasing Rust Concept Rust
- Cargo in depth — workspaces, features, profiles & publishing Concept Rust
- cargo — the front door Concept Rust
- The Rust toolchain Concept Rust
❯ grep #bundlers
❯ grep #bytecode
❯ grep #c4
❯ grep #caching
❯ grep #cargo
❯ grep #cargo-fuzz
❯ grep #cassandra
❯ grep #certificates
❯ grep #channels
❯ grep #ci
- Building & releasing Go software Concept Go
- govulncheck — vulnerability scanning Concept Go
- staticcheck & golangci-lint — the lint ecosystem Concept Go
- End-to-end testing — REST Assured, browsers & contracts Concept Java
- Security testing — SCA, SAST, DAST & fuzzing on the JVM Concept Java
- cargo-nextest — the test runner Concept Rust
❯ grep #ci-cd
❯ grep #cicd
❯ grep #claude-code
❯ grep #clean-code
❯ grep #cli
❯ grep #cloud
❯ grep #cloud-native
❯ grep #code-generation
❯ grep #code-review
❯ grep #codegen
❯ grep #cohesion
❯ grep #collaboration
❯ grep #communication
❯ grep #community
❯ grep #comparison
❯ grep #compatibility
❯ grep #compilation
❯ grep #compilers
❯ grep #complexity
❯ grep #components
❯ grep #composition
❯ grep #computer-architecture
❯ grep #concurrency
- Protohackers ladder — subject Subject Go
- Protohackers ladder Exercise Go
- Deep dive Go Concept Go
- WebSockets & SSE in Go Concept Go
- Execution tracer — go tool trace Concept Go
- Deep dive Java Concept Java
- jstack — thread dumps Concept Java
- The Java Memory Model — happens-before & visibility Concept Java
- Language craft — mastery in depth Path Paths
- Async runtimes — Tokio, smol & the runtime-agnostic tension Concept Rust
- Tokio mini-redis — subject Subject Rust
- Tokio mini-redis Exercise Rust
- Fearless concurrency — Send, Sync, threads, channels & atomics Concept Rust
- Ownership, memory & concurrency — the model Concept Rust
- Deep dive Rust Concept Rust
- Concurrency and Parallelism Concept System Design
- Concurrency crossroad — Devoxx slides Reference System Design
- Build your own Redis — subject Subject System Design
- Build your own Redis Exercise System Design
❯ grep #conference
❯ grep #configuration
❯ grep #consensus
❯ grep #containers
- Building & releasing Go software Concept Go
- Deployment & IaC — containers beside their unit, stacks in one folder Concept Java
- Dev containers Concept Platform
- Build your own container runtime — subject Subject Platform
- Build your own container runtime Exercise Platform
- Kubernetes the Hard Way — subject Subject Platform
- Kubernetes the Hard Way Exercise Platform
- Kubernetes & containers deep dive Concept Platform
❯ grep #context-propagation
❯ grep #contract-testing
❯ grep #contracts
❯ grep #contravariance
❯ grep #conways-law
❯ grep #correctness
❯ grep #correlation-id
❯ grep #coupling
❯ grep #covariance
❯ grep #coverage
❯ grep #cpu
❯ grep #cqrs
❯ grep #craft
- BDD Concept Applicative Architecture
- Clean code Concept Applicative Architecture
- Design patterns Concept Applicative Architecture
- Refactoring techniques Concept Applicative Architecture
- TDD Concept Applicative Architecture
- Testing strategies Concept Applicative Architecture
- Code review Concept Engineering Practice
- Software craft — design in the small Path Paths
❯ grep #crates-io
❯ grep #credentials
❯ grep #criterion
❯ grep #cross-compilation
❯ grep #cryptography
- Cryptography in Go — the stdlib way Concept Go
- Cryptography in Java — JCA/JSSE in practice Concept Java
- Security — the defensive craft Path Paths
- Cryptography in Rust — rustls, ring & RustCrypto Concept Rust
- Cryptography for engineers Concept Security
- Cryptopals — crypto challenges (sets 1–3) — subject Subject Security
- Cryptopals — crypto challenges (sets 1–3) Exercise Security
❯ grep #css
❯ grep #curriculum
❯ grep #data
❯ grep #data-engineering
❯ grep #data-structures
❯ grep #databases
- Databases and other storage systems Concept Data Storage
- Build your own database — subject Subject Data Storage
- Build your own database Exercise Data Storage
- Relational databases from Go Concept Go
- Storage access from Go — the map Concept Go
- Relational databases from Java Concept Java
- Storage access from Java — the map Concept Java
- Systems at scale — distributed systems & data Path Paths
- Relational databases from Rust — sqlx, diesel & sea-orm Concept Rust
- Storage access from Rust — the map Concept Rust
❯ grep #datetime
❯ grep #dbt
❯ grep #ddd
- CQRS & event sourcing Concept Applicative Architecture
- DDD Concept Applicative Architecture
- Event-sourced bank account — subject Subject Applicative Architecture
- Event-sourced bank account Exercise Applicative Architecture
- Hexagonal architecture Concept Applicative Architecture
- Modulith & microservices Concept Applicative Architecture
- Software craft — design in the small Path Paths
❯ grep #debugging
❯ grep #deliberate-practice
❯ grep #delivery
❯ grep #dependencies
❯ grep #deployment
❯ grep #deployment-unit
❯ grep #design
- Clean code Concept Applicative Architecture
- Coupling & cohesion Concept Applicative Architecture
- DDD Concept Applicative Architecture
- Design patterns Concept Applicative Architecture
- Birthday Greetings — hexagonal extraction — subject Subject Applicative Architecture
- Birthday Greetings — hexagonal extraction Exercise Applicative Architecture
- Hexagonal architecture Concept Applicative Architecture
- Refactoring techniques Concept Applicative Architecture
- TDD Concept Applicative Architecture
- Threat modeling Concept Security
❯ grep #design-patterns
❯ grep #design-systems
❯ grep #design-tokens
❯ grep #devcontainer
❯ grep #developer-experience
❯ grep #devops
❯ grep #devoxx
❯ grep #devsecops
❯ grep #diagnostics
❯ grep #diesel
❯ grep #distributed-systems
- Modulith & microservices Concept Applicative Architecture
- Systems at scale — distributed systems & data Path Paths
- Asynchronous and distributed system patterns Concept System Design
- Cache management Concept System Design
- Distributed consensus Concept System Design
- Implement Raft with Gossip Glomers — subject Subject System Design
- Implement Raft with Gossip Glomers Exercise System Design
- Message brokers & event streaming Concept System Design
- Microservice architecture Concept System Design
- System design fundamentals Concept System Design
❯ grep #distributed-tracing
❯ grep #distribution
❯ grep #dns
❯ grep #docker
❯ grep #docs-rs
❯ grep #documentation
- Architecture documentation Concept Applicative Architecture
- API documentation in Go Concept Go
- go doc & pkg.go.dev — documentation Concept Go
- javadoc — API documentation Concept Java
- API documentation in Java Concept Java
- API documentation in Rust Concept Rust
- rustdoc & docs.rs — documentation Concept Rust
- API documentation Concept System Design
❯ grep #domain
❯ grep #drivers
❯ grep #dynamodb
❯ grep #e2e
❯ grep #echo
❯ grep #editions
❯ grep #editor
❯ grep #editors
❯ grep #elasticsearch
❯ grep #embedded
❯ grep #embeddings
❯ grep #encoding
❯ grep #encryption
❯ grep #engineering-practice
❯ grep #ergonomics
❯ grep #error-handling
❯ grep #estimation
❯ grep #etl
❯ grep #evals
❯ grep #evaluation
❯ grep #event-loop
❯ grep #event-sourcing
❯ grep #event-streaming
❯ grep #events
❯ grep #exercise
- Build an agent from scratch — subject Subject AI Engineering
- Build an agent from scratch Exercise AI Engineering
- RAG over the knowledge base — subject Subject AI Engineering
- RAG over the knowledge base Exercise AI Engineering
- Interview-prep track — subject Subject Algorithms
- Interview-prep track Exercise Algorithms
- Birthday Greetings — hexagonal extraction — subject Subject Applicative Architecture
- Birthday Greetings — hexagonal extraction Exercise Applicative Architecture
- Event-sourced bank account — subject Subject Applicative Architecture
- Event-sourced bank account Exercise Applicative Architecture
- Gilded Rose — legacy rescue — subject Subject Applicative Architecture
- Gilded Rose — legacy rescue Exercise Applicative Architecture
- Variance workout — subject Subject Applicative Architecture
- Variance workout — LSP & ISP through the type checker Exercise Applicative Architecture
- Build your own database — subject Subject Data Storage
- Build your own database Exercise Data Storage
- End-to-end ELT pipeline — subject Subject Data Storage
- End-to-end ELT pipeline Exercise Data Storage
- Gilded Rose: a technical-debt workout — subject Subject Engineering Practice
- Gilded Rose: a technical-debt workout Exercise Engineering Practice
- Design system from scratch — subject Subject Frontend
- Design system from scratch Exercise Frontend
- RealWorld full-stack build Exercise Frontend
- Toy browser engine — subject Subject Frontend
- Toy browser engine Exercise Frontend
- DST-safe scheduler — subject Subject Fundamentals
- DST-safe scheduler Exercise Fundamentals
- UTF-8 codec + text-processing CLI — subject Subject Fundamentals
- UTF-8 codec + text-processing CLI Exercise Fundamentals
- Protohackers ladder — subject Subject Go
- Protohackers ladder Exercise Go
- One Billion Row Challenge — subject Subject Java
- One Billion Row Challenge Exercise Java
- Build your own container runtime — subject Subject Platform
- Build your own container runtime Exercise Platform
- Kubernetes the Hard Way — subject Subject Platform
- Kubernetes the Hard Way Exercise Platform
- Tokio mini-redis — subject Subject Rust
- Tokio mini-redis Exercise Rust
- Cryptopals — crypto challenges (sets 1–3) — subject Subject Security
- Cryptopals — crypto challenges (sets 1–3) Exercise Security
- Stand up your own CA + mTLS between two services — subject Subject Security
- Stand up your own CA + mTLS between two services Exercise Security
- Build a DNS resolver — subject Subject System Administration
- Build a DNS resolver Exercise System Administration
- Build your own shell — subject Subject System Administration
- Build your own shell Exercise System Administration
- Write Yourself a Git — subject Subject System Administration
- Write Yourself a Git Exercise System Administration
- Build your own Redis — subject Subject System Design
- Build your own Redis Exercise System Design
- Build a load balancer & rate limiter — subject Subject System Design
- Build a load balancer & rate limiter Exercise System Design
- Implement Raft with Gossip Glomers — subject Subject System Design
- Implement Raft with Gossip Glomers Exercise System Design
❯ grep #exercises
❯ grep #fasthttp
❯ grep #ferrocene
❯ grep #fiber
❯ grep #floating-point
❯ grep #forecasting
❯ grep #formatting
❯ grep #frameworks
- Security in Go applications — the map Concept Go
- API documentation in Go Concept Go
- Backend protocols in Go — the map Concept Go
- REST & HTTP APIs in Go Concept Go
- Echo deep dive Concept Go
- Fiber deep dive Concept Go
- Gin deep dive Concept Go
- net/http deep dive Concept Go
- Frameworks × the stdlib contracts — who honors what Concept Go
- Go web frameworks — the landscape Concept Go
- Java application frameworks — the landscape Concept Java
- Frameworks × Jakarta EE — who implements what Concept Java
- Micronaut deep dive Concept Java
- Quarkus deep dive Concept Java
- Spring deep dive Concept Java
- Security in Java applications — the map Concept Java
- API documentation in Java Concept Java
- GraphQL on the JVM Concept Java
- gRPC in Java Concept Java
- Messaging in Java — Kafka, JMS & AMQP Concept Java
- Backend protocols in Java — the map Concept Java
- REST & HTTP APIs in Java Concept Java
- WebSockets & SSE in Java Concept Java
- Storage access from Java — the map Concept Java
- Integration testing — Testcontainers & framework test support Concept Java
- API documentation in Rust Concept Rust
- Backend protocols in Rust — the map Concept Rust
- Security in Rust applications — the map Concept Rust
- Frameworks × tower/hyper — who builds on the contracts Concept Rust
- Rust web frameworks — the landscape Concept Rust
❯ grep #frontend
- Accessibility Concept Frontend
- Atomic design Concept Frontend
- Browser internals Concept Frontend
- Component architecture & state management Concept Frontend
- CSS architecture & layout Concept Frontend
- Design systems Concept Frontend
- Design system from scratch — subject Subject Frontend
- Design system from scratch Exercise Frontend
- RealWorld full-stack build Exercise Frontend
- Toy browser engine — subject Subject Frontend
- Toy browser engine Exercise Frontend
- Frontend testing Concept Frontend
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- Rendering strategies & meta-frameworks Concept Frontend
- TypeScript deep dive Concept Frontend
- Web performance Concept Frontend
- The full-stack web Path Paths
❯ grep #fullstack
❯ grep #fundamentals
- DST-safe scheduler — subject Subject Fundamentals
- DST-safe scheduler Exercise Fundamentals
- UTF-8 codec + text-processing CLI — subject Subject Fundamentals
- UTF-8 codec + text-processing CLI Exercise Fundamentals
- How a computer works — processor architecture, binary logic & arithmetic Concept Fundamentals
- Time, timezones & datetime Concept Fundamentals
- Unicode & text encoding Concept Fundamentals
- Foundations — the machine and the toolkit Path Paths
❯ grep #fuzzing
❯ grep #gatling
❯ grep #gc
- Go compilers & runtimes compared Concept Go
- jstat — GC and class-loading statistics Concept Java
- JVM implementations compared Concept Java
- Garbage collectors compared — G1, ZGC, Shenandoah & the rest Concept Java
- GC principles & algorithms Concept Java
- Java memory & garbage collection — the map Concept Java
❯ grep #gin
❯ grep #git
❯ grep #go
- The four hexagonal references compared Concept Applicative Architecture
- Go compilers & runtimes compared Concept Go
- The Go Programming Language Specification Reference Go
- TinyGo deep dive Concept Go
- Protohackers ladder — subject Subject Go
- Protohackers ladder Exercise Go
- Deep dive Go Concept Go
- How Go evolves — the proposal process & community Concept Go
- Cryptography in Go — the stdlib way Concept Go
- Security in Go applications — the map Concept Go
- OAuth2 & OIDC in Go Concept Go
- Web security in Go apps Concept Go
- Hexagonal architecture reference implementation — Go Concept Go
- Building & releasing Go software Concept Go
- Go modules deep dive Concept Go
- Modules & the Go build ecosystem Concept Go
- API documentation in Go Concept Go
- GraphQL in Go Concept Go
- gRPC in Go Concept Go
- Messaging in Go — Kafka, NATS & AMQP Concept Go
- Backend protocols in Go — the map Concept Go
- REST & HTTP APIs in Go Concept Go
- WebSockets & SSE in Go Concept Go
- Document and NoSQL stores from Go Concept Go
- Graph databases from Go Concept Go
- Redis from Go Concept Go
- Relational databases from Go Concept Go
- Storage access from Go — the map Concept Go
- Time-series stores from Go Concept Go
- End-to-end testing — API clients, browsers, contracts Concept Go
- Integration testing — httptest, testcontainers-go, real databases Concept Go
- Mutation testing — gremlins and go-mutesting Concept Go
- Performance & load testing — testing.B, benchstat, vegeta Concept Go
- Property-based testing & fuzzing — rapid and go test -fuzz Concept Go
- Security testing — govulncheck, gosec, scanning Concept Go
- Testing in Go — strategies & tooling map Concept Go
- Unit testing — the testing package, table tests, doubles Concept Go
- Delve — the Go debugger Concept Go
- Execution tracer — go tool trace Concept Go
- go build, go run, go install Concept Go
- go doc & pkg.go.dev — documentation Concept Go
- go generate Concept Go
- go mod Concept Go
- go test Concept Go
- go tool cover — coverage Concept Go
- go vet Concept Go
- go work Concept Go
- gofmt & goimports Concept Go
- gopls — the language server Concept Go
- govulncheck — vulnerability scanning Concept Go
- pprof — profiling Concept Go
- staticcheck & golangci-lint — the lint ecosystem Concept Go
- The Go toolchain Concept Go
- Echo deep dive Concept Go
- Fiber deep dive Concept Go
- Gin deep dive Concept Go
- net/http deep dive Concept Go
- Frameworks × the stdlib contracts — who honors what Concept Go
- Go web frameworks — the landscape Concept Go
- Language craft — mastery in depth Path Paths
❯ grep #gof
❯ grep #goroutines
❯ grep #gossip
❯ grep #governance
❯ grep #graalvm
❯ grep #gradle
❯ grep #graph
❯ grep #graphql
❯ grep #gremlin
❯ grep #grpc
❯ grep #hardening
❯ grep #hardware
❯ grep #hashing
❯ grep #health-checks
❯ grep #hexagonal
❯ grep #hexagonal-architecture
- Birthday Greetings — hexagonal extraction — subject Subject Applicative Architecture
- Birthday Greetings — hexagonal extraction Exercise Applicative Architecture
- Hexagonal architecture Concept Applicative Architecture
- The four hexagonal references compared Concept Applicative Architecture
- Modulith & microservices Concept Applicative Architecture
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- Hexagonal architecture reference implementation — Go Concept Go
- User-side adapters & assemblies Concept Java
- Deployment & IaC — containers beside their unit, stacks in one folder Concept Java
- Domain layer — contract & implementation Concept Java
- Hexagonal architecture reference implementation — Java Concept Java
- Infrastructure layer — secondary adapters & the granularity debate Concept Java
- Module composition — the in-process service seam Concept Java
- Hexagonal architecture reference implementation — Rust Concept Rust
❯ grep #hibernate
❯ grep #html
❯ grep #http
- net/http deep dive Concept Go
- Frameworks × the stdlib contracts — who honors what Concept Go
- Go web frameworks — the landscape Concept Go
- jwebserver — the minimal static file server Concept Java
- REST & HTTP APIs in Java Concept Java
- Actix Web deep dive Concept Rust
- Rust web frameworks — the landscape Concept Rust
- Networking fundamentals Concept System Administration
- Build a load balancer & rate limiter — subject Subject System Design
- Build a load balancer & rate limiter Exercise System Design
- WebSockets & bidirectional protocols Concept System Design
❯ grep #https
❯ grep #httptest
❯ grep #hydration
❯ grep #hyper
❯ grep #iac
❯ grep #iam
❯ grep #idempotence
❯ grep #idempotency
❯ grep #identity
❯ grep #influxdb
❯ grep #infrastructure
❯ grep #insta
❯ grep #instrumentation
❯ grep #integration
❯ grep #interface-segregation
❯ grep #interior-mutability
❯ grep #internals
- Browser internals Concept Frontend
- Toy browser engine — subject Subject Frontend
- Toy browser engine Exercise Frontend
- Deep dive Go Concept Go
- Deep dive Java Concept Java
- GC principles & algorithms Concept Java
- JVM memory anatomy — heap, stacks & metaspace Concept Java
- Java memory & garbage collection — the map Concept Java
- The Rustonomicon Book Rust
- Ownership, memory & concurrency — the model Concept Rust
- Deep dive Rust Concept Rust
- Write Yourself a Git — subject Subject System Administration
- Write Yourself a Git Exercise System Administration
- Git internals Concept System Administration
- Linux system deep dive Concept System Administration
❯ grep #interoperability
❯ grep #interview-prep
❯ grep #inverted-index
❯ grep #jakarta-ee
❯ grep #java
- The four hexagonal references compared Concept Applicative Architecture
- The Java build ecosystem Concept Java
- Gradle deep dive Concept Java
- Maven deep dive Concept Java
- One Billion Row Challenge — subject Subject Java
- One Billion Row Challenge Exercise Java
- Java application frameworks — the landscape Concept Java
- Frameworks × Jakarta EE — who implements what Concept Java
- Micronaut deep dive Concept Java
- Quarkus deep dive Concept Java
- Spring deep dive Concept Java
- User-side adapters & assemblies Concept Java
- Domain layer — contract & implementation Concept Java
- Hexagonal architecture reference implementation — Java Concept Java
- Infrastructure layer — secondary adapters & the granularity debate Concept Java
- Module composition — the in-process service seam Concept Java
- Deep dive Java Concept Java
- Cryptography in Java — JCA/JSSE in practice Concept Java
- Security in Java applications — the map Concept Java
- OAuth2 & OIDC in Java Concept Java
- Web security in Java apps Concept Java
- jar — archives & manifests Concept Java
- java — the launcher Concept Java
- javac — the Java compiler Concept Java
- javadoc — API documentation Concept Java
- javap — the class file disassembler Concept Java
- jcmd — the JVM diagnostic command hub Concept Java
- jconsole — the JMX console Concept Java
- jdb — the CLI debugger and JDWP Concept Java
- jdeps — dependency analysis Concept Java
- The JDK, the JRE & their tools Concept Java
- JDK Flight Recorder & Mission Control Concept Java
- jlink — custom runtime images Concept Java
- jmap — heap histograms and heap dumps Concept Java
- jmod — the JMOD format and tool Concept Java
- jpackage — native installers and app images Concept Java
- jps — listing JVM processes Concept Java
- jshell — the Java REPL Concept Java
- jstack — thread dumps Concept Java
- jstat — GC and class-loading statistics Concept Java
- jwebserver — the minimal static file server Concept Java
- keytool — keystores and certificates Concept Java
- GraalVM deep dive Concept Java
- JVM implementations compared Concept Java
- The Java Virtual Machine Specification (JVMS) Reference Java
- Garbage collectors compared — G1, ZGC, Shenandoah & the rest Concept Java
- GC principles & algorithms Concept Java
- The Java Memory Model — happens-before & visibility Concept Java
- JVM memory anatomy — heap, stacks & metaspace Concept Java
- Java memory & garbage collection — the map Concept Java
- OpenJDK & the JEP process — how Java evolves Concept Java
- API documentation in Java Concept Java
- GraphQL on the JVM Concept Java
- gRPC in Java Concept Java
- Messaging in Java — Kafka, JMS & AMQP Concept Java
- Backend protocols in Java — the map Concept Java
- REST & HTTP APIs in Java Concept Java
- WebSockets & SSE in Java Concept Java
- Document and NoSQL stores from Java Concept Java
- Graph databases from Java Concept Java
- Redis from Java Concept Java
- Relational databases from Java Concept Java
- Storage access from Java — the map Concept Java
- Time-series stores from Java Concept Java
- End-to-end testing — REST Assured, browsers & contracts Concept Java
- Integration testing — Testcontainers & framework test support Concept Java
- Mutation testing — PIT Concept Java
- Performance & load testing — JMH and Gatling Concept Java
- Property-based testing — jqwik Concept Java
- Security testing — SCA, SAST, DAST & fuzzing on the JVM Concept Java
- Testing in Java — strategies & tooling map Concept Java
- Unit testing — JUnit 5, Mockito, AssertJ Concept Java
- Language craft — mastery in depth Path Paths
❯ grep #javascript
❯ grep #jca
❯ grep #jdk
- jar — archives & manifests Concept Java
- java — the launcher Concept Java
- javac — the Java compiler Concept Java
- javadoc — API documentation Concept Java
- javap — the class file disassembler Concept Java
- jdeps — dependency analysis Concept Java
- The JDK, the JRE & their tools Concept Java
- jshell — the Java REPL Concept Java
❯ grep #jep
❯ grep #jit
❯ grep #jmh
❯ grep #jmm
❯ grep #jmx
❯ grep #jpa
❯ grep #jqwik
❯ grep #junit
❯ grep #jvm
- One Billion Row Challenge — subject Subject Java
- One Billion Row Challenge Exercise Java
- Deep dive Java Concept Java
- java — the launcher Concept Java
- jcmd — the JVM diagnostic command hub Concept Java
- jconsole — the JMX console Concept Java
- jdb — the CLI debugger and JDWP Concept Java
- The JDK, the JRE & their tools Concept Java
- JDK Flight Recorder & Mission Control Concept Java
- jlink — custom runtime images Concept Java
- jmap — heap histograms and heap dumps Concept Java
- jmod — the JMOD format and tool Concept Java
- jps — listing JVM processes Concept Java
- jstack — thread dumps Concept Java
- jstat — GC and class-loading statistics Concept Java
- GraalVM deep dive Concept Java
- JVM implementations compared Concept Java
- The Java Virtual Machine Specification (JVMS) Reference Java
- Garbage collectors compared — G1, ZGC, Shenandoah & the rest Concept Java
- GC principles & algorithms Concept Java
- The Java Memory Model — happens-before & visibility Concept Java
- JVM memory anatomy — heap, stacks & metaspace Concept Java
- Java memory & garbage collection — the map Concept Java
❯ grep #jwt
❯ grep #kafka
❯ grep #kubernetes
❯ grep #language
❯ grep #layout
❯ grep #leadership
❯ grep #learning
❯ grep #legacy-code
- Gilded Rose — legacy rescue — subject Subject Applicative Architecture
- Gilded Rose — legacy rescue Exercise Applicative Architecture
- Refactoring techniques Concept Applicative Architecture
- Gilded Rose: a technical-debt workout — subject Subject Engineering Practice
- Gilded Rose: a technical-debt workout Exercise Engineering Practice
❯ grep #lifetimes
❯ grep #lint
❯ grep #linting
❯ grep #linux
- Foundations — the machine and the toolkit Path Paths
- Incus OS — cluster sans shell Article Platform
- Build your own container runtime — subject Subject Platform
- Build your own container runtime Exercise Platform
- Hardening Linux Article Security
- Check which process is listening on a given port Concept System Administration
- Build your own shell — subject Subject System Administration
- Build your own shell Exercise System Administration
- Linux system deep dive Concept System Administration
- Networking fundamentals Concept System Administration
❯ grep #liskov
❯ grep #liveness
❯ grep #llm
❯ grep #load-balancing
❯ grep #loading
❯ grep #logging
❯ grep #lsp
❯ grep #macros
❯ grep #maelstrom
❯ grep #maintenance
❯ grep #master
❯ grep #maven
❯ grep #mdc
❯ grep #mechanical-sympathy
❯ grep #memory
- How a computer works — processor architecture, binary logic & arithmetic Concept Fundamentals
- jmap — heap histograms and heap dumps Concept Java
- GC principles & algorithms Concept Java
- The Java Memory Model — happens-before & visibility Concept Java
- JVM memory anatomy — heap, stacks & metaspace Concept Java
- Java memory & garbage collection — the map Concept Java
- Memory without GC — layout, smart pointers & interior mutability Concept Rust
- Ownership, memory & concurrency — the model Concept Rust
❯ grep #mentoring
❯ grep #messaging
❯ grep #meta-frameworks
❯ grep #metrics
❯ grep #micro-frontends
❯ grep #micronaut
❯ grep #microprofile
❯ grep #microservices
❯ grep #middleware
- Security in Go applications — the map Concept Go
- OAuth2 & OIDC in Go Concept Go
- Web security in Go apps Concept Go
- Echo deep dive Concept Go
- Gin deep dive Concept Go
- net/http deep dive Concept Go
- Frameworks × the stdlib contracts — who honors what Concept Go
- Correlation IDs & context propagation Concept Platform
- Security in Rust applications — the map Concept Rust
- Web security in Rust apps Concept Rust
❯ grep #miri
❯ grep #mise
❯ grep #mocking
❯ grep #mockito
❯ grep #modeling
❯ grep #modularity
❯ grep #modules
- Go modules deep dive Concept Go
- Modules & the Go build ecosystem Concept Go
- Hexagonal architecture reference implementation — Java Concept Java
- Module composition — the in-process service seam Concept Java
- jdeps — dependency analysis Concept Java
- jlink — custom runtime images Concept Java
- jmod — the JMOD format and tool Concept Java
❯ grep #modulith
- Hexagonal architecture Concept Applicative Architecture
- The four hexagonal references compared Concept Applicative Architecture
- Modulith & microservices Concept Applicative Architecture
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- Hexagonal architecture reference implementation — Go Concept Go
- User-side adapters & assemblies Concept Java
- Deployment & IaC — containers beside their unit, stacks in one folder Concept Java
- Domain layer — contract & implementation Concept Java
- Hexagonal architecture reference implementation — Java Concept Java
- Infrastructure layer — secondary adapters & the granularity debate Concept Java
- Module composition — the in-process service seam Concept Java
- Hexagonal architecture reference implementation — Rust Concept Rust
- Microservice architecture Concept System Design
❯ grep #mongodb
❯ grep #monitoring
❯ grep #msw
❯ grep #mtls
❯ grep #mutation
❯ grep #native-image
❯ grep #nats
❯ grep #neetcode
❯ grep #neo4j
❯ grep #networking
- Protohackers ladder — subject Subject Go
- Protohackers ladder Exercise Go
- Foundations — the machine and the toolkit Path Paths
- Cloud fundamentals Concept Platform
- TLS/HTTPS & certificate management Concept Security
- Check which process is listening on a given port Concept System Administration
- Build a DNS resolver — subject Subject System Administration
- Build a DNS resolver Exercise System Administration
- Networking fundamentals Concept System Administration
- Build your own Redis — subject Subject System Design
- Build your own Redis Exercise System Design
- Build a load balancer & rate limiter — subject Subject System Design
- Build a load balancer & rate limiter Exercise System Design
❯ grep #nextjs
❯ grep #node
❯ grep #nosql
❯ grep #npm
❯ grep #nvm
❯ grep #oauth
❯ grep #oauth2
❯ grep #observability
- Time-series stores from Go Concept Go
- jcmd — the JVM diagnostic command hub Concept Java
- jconsole — the JMX console Concept Java
- JDK Flight Recorder & Mission Control Concept Java
- Time-series stores from Java Concept Java
- Correlation IDs & context propagation Concept Platform
- Health checks: liveness, readiness, startup Concept Platform
- Observability & SRE practice Concept Platform
- OpenTelemetry Concept Platform
- Structured logging & MDC Concept Platform
❯ grep #oidc
❯ grep #openapi
❯ grep #openjdk
❯ grep #opentelemetry
❯ grep #opentofu
❯ grep #operating-systems
❯ grep #operations
❯ grep #orchestration
❯ grep #organization
❯ grep #otel
❯ grep #otlp
❯ grep #owasp
❯ grep #ownership
❯ grep #packages
❯ grep #packaging
- The TypeScript build ecosystem Concept Frontend
- Modules & the Go build ecosystem Concept Go
- The Java build ecosystem Concept Java
- jar — archives & manifests Concept Java
- jlink — custom runtime images Concept Java
- jmod — the JMOD format and tool Concept Java
- jpackage — native installers and app images Concept Java
- The Rust build ecosystem Concept Rust
- Cargo in depth — workspaces, features, profiles & publishing Concept Rust
❯ grep #parallelism
❯ grep #path
- AI engineering — the new tooling Path Paths
- Architect & lead — the force-multiplier track Path Paths
- Systems at scale — distributed systems & data Path Paths
- Foundations — the machine and the toolkit Path Paths
- The full-stack web Path Paths
- Language craft — mastery in depth Path Paths
- The path to excellence Path Paths
- Platform & production Path Paths
- Security — the defensive craft Path Paths
- Software craft — design in the small Path Paths
❯ grep #patterns
❯ grep #pedagogy
❯ grep #performance
- Web performance Concept Frontend
- Performance & load testing — testing.B, benchstat, vegeta Concept Go
- Execution tracer — go tool trace Concept Go
- pprof — profiling Concept Go
- Fiber deep dive Concept Go
- One Billion Row Challenge — subject Subject Java
- One Billion Row Challenge Exercise Java
- Garbage collectors compared — G1, ZGC, Shenandoah & the rest Concept Java
- Performance & load testing — JMH and Gatling Concept Java
- Test-suite scheduling & job partitioning Concept Platform
- Performance & load testing — criterion, divan & friends Concept Rust
- Profiling & debugging Rust Concept Rust
- Actix Web deep dive Concept Rust
- Linux system deep dive Concept System Administration
- Cache management Concept System Design
- Build your own Redis — subject Subject System Design
- Build your own Redis Exercise System Design
- Performance engineering Concept System Design
❯ grep #pino
❯ grep #pit
❯ grep #pki
❯ grep #planning
❯ grep #platform
- Platform & production Path Paths
- CI/CD & delivery engineering Concept Platform
- Cloud fundamentals Concept Platform
- Dev containers Concept Platform
- Developer environments Concept Platform
- Version managers — universal vs ecosystem-native Concept Platform
- Version pinning & currency Concept Platform
- Build your own container runtime — subject Subject Platform
- Build your own container runtime Exercise Platform
- Kubernetes the Hard Way — subject Subject Platform
- Kubernetes the Hard Way Exercise Platform
- Infrastructure as code Concept Platform
- Kubernetes & containers deep dive Concept Platform
- Test-suite scheduling & job partitioning Concept Platform
❯ grep #playwright
❯ grep #pnpm
❯ grep #ports
❯ grep #ports-and-adapters
❯ grep #postgres
❯ grep #probes
❯ grep #process
❯ grep #processes
❯ grep #profiling
❯ grep #prometheus
❯ grep #prompting
❯ grep #property-based
❯ grep #proposals
❯ grep #proptest
❯ grep #protobuf
❯ grep #protocols
- API documentation in Go Concept Go
- GraphQL in Go Concept Go
- gRPC in Go Concept Go
- Messaging in Go — Kafka, NATS & AMQP Concept Go
- Backend protocols in Go — the map Concept Go
- REST & HTTP APIs in Go Concept Go
- WebSockets & SSE in Go Concept Go
- jwebserver — the minimal static file server Concept Java
- API documentation in Java Concept Java
- GraphQL on the JVM Concept Java
- gRPC in Java Concept Java
- Messaging in Java — Kafka, JMS & AMQP Concept Java
- Backend protocols in Java — the map Concept Java
- REST & HTTP APIs in Java Concept Java
- WebSockets & SSE in Java Concept Java
- API documentation in Rust Concept Rust
- GraphQL in Rust Concept Rust
- gRPC in Rust — tonic & prost Concept Rust
- Messaging in Rust — Kafka, AMQP & NATS Concept Rust
- Backend protocols in Rust — the map Concept Rust
- REST & HTTP APIs in Rust Concept Rust
- WebSockets & SSE in Rust Concept Rust
❯ grep #protohackers
❯ grep #push
❯ grep #python
❯ grep #quality
- Testing strategies Concept Applicative Architecture
- Mutation testing — gremlins and go-mutesting Concept Go
- Testing in Go — strategies & tooling map Concept Go
- Mutation testing — PIT Concept Java
- Property-based testing — jqwik Concept Java
- Testing in Java — strategies & tooling map Concept Java
- Mutation testing — cargo-mutants Concept Rust
- Testing in Rust — strategies & tooling map Concept Rust
- clippy — the lint collection Concept Rust
❯ grep #quarkus
❯ grep #rabbitmq
❯ grep #raft
❯ grep #rag
❯ grep #raii
❯ grep #rate-limiting
❯ grep #react
❯ grep #reactive
❯ grep #readability
❯ grep #readiness
❯ grep #realtime
❯ grep #realworld
❯ grep #redis
❯ grep #refactoring
- Gilded Rose — legacy rescue — subject Subject Applicative Architecture
- Gilded Rose — legacy rescue Exercise Applicative Architecture
- Refactoring techniques Concept Applicative Architecture
- Gilded Rose: a technical-debt workout — subject Subject Engineering Practice
- Gilded Rose: a technical-debt workout Exercise Engineering Practice
- Technical debt Concept Engineering Practice
- Software craft — design in the small Path Paths
❯ grep #reference
❯ grep #reference-implementation
- The four hexagonal references compared Concept Applicative Architecture
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- Hexagonal architecture reference implementation — Go Concept Go
- Hexagonal architecture reference implementation — Java Concept Java
- Hexagonal architecture reference implementation — Rust Concept Rust
❯ grep #release
❯ grep #releases
❯ grep #relevance
❯ grep #reliability
❯ grep #rendering
❯ grep #repl
❯ grep #reproducibility
❯ grep #requirements
❯ grep #resilience
❯ grep #rest
❯ grep #retrieval
❯ grep #rfc
❯ grep #rocket
❯ grep #rrule
❯ grep #rstest
❯ grep #runtime
❯ grep #runtimes
❯ grep #rust
- The four hexagonal references compared Concept Applicative Architecture
- Language craft — mastery in depth Path Paths
- The Rust build ecosystem Concept Rust
- Building & releasing Rust Concept Rust
- Cargo in depth — workspaces, features, profiles & publishing Concept Rust
- Async runtimes — Tokio, smol & the runtime-agnostic tension Concept Rust
- Rust compilers & the language definition Concept Rust
- Editions — Rust's compatibility mechanism Concept Rust
- The Rust Reference & the Ferrocene FLS Reference Rust
- Tokio mini-redis — subject Subject Rust
- Tokio mini-redis Exercise Rust
- Hexagonal architecture reference implementation — Rust Concept Rust
- How Rust evolves — RFCs, teams & the release train Concept Rust
- The Rust Programming Language ("the Book") Book Rust
- The Rustonomicon Book Rust
- Fearless concurrency — Send, Sync, threads, channels & atomics Concept Rust
- Lifetimes — elision, 'static, variance & the craft Concept Rust
- Memory without GC — layout, smart pointers & interior mutability Concept Rust
- Ownership & borrowing — the rules and the fights Concept Rust
- Ownership, memory & concurrency — the model Concept Rust
- API documentation in Rust Concept Rust
- GraphQL in Rust Concept Rust
- gRPC in Rust — tonic & prost Concept Rust
- Messaging in Rust — Kafka, AMQP & NATS Concept Rust
- Backend protocols in Rust — the map Concept Rust
- REST & HTTP APIs in Rust Concept Rust
- WebSockets & SSE in Rust Concept Rust
- Deep dive Rust Concept Rust
- Cryptography in Rust — rustls, ring & RustCrypto Concept Rust
- OAuth2 & OIDC in Rust Concept Rust
- Security in Rust applications — the map Concept Rust
- Web security in Rust apps Concept Rust
- Document and NoSQL stores from Rust Concept Rust
- Graph databases from Rust Concept Rust
- Redis from Rust — redis-rs & fred Concept Rust
- Relational databases from Rust — sqlx, diesel & sea-orm Concept Rust
- Storage access from Rust — the map Concept Rust
- Time-series stores from Rust Concept Rust
- End-to-end testing — whole systems & contracts Concept Rust
- Integration testing — tests/, in-process routers & testcontainers Concept Rust
- Mutation testing — cargo-mutants Concept Rust
- Performance & load testing — criterion, divan & friends Concept Rust
- Property-based testing & fuzzing — proptest & cargo-fuzz Concept Rust
- Security testing — audit, unsafe hygiene & fuzzing Concept Rust
- Testing in Rust — strategies & tooling map Concept Rust
- Unit testing — the built-in harness, organization & doubles Concept Rust
- cargo-expand — macro expansion Concept Rust
- cargo-nextest — the test runner Concept Rust
- cargo — the front door Concept Rust
- clippy — the lint collection Concept Rust
- miri — undefined-behaviour detection Concept Rust
- Profiling & debugging Rust Concept Rust
- rust-analyzer — the language server Concept Rust
- rustc — the compiler behind cargo Concept Rust
- rustdoc & docs.rs — documentation Concept Rust
- rustfmt — formatting Concept Rust
- rustup — toolchain management & the release channels Concept Rust
- The Rust toolchain Concept Rust
- Actix Web deep dive Concept Rust
- Axum deep dive Concept Rust
- Rocket deep dive Concept Rust
- Frameworks × tower/hyper — who builds on the contracts Concept Rust
- Rust web frameworks — the landscape Concept Rust
❯ grep #rustc
❯ grep #rustls
❯ grep #rustup
❯ grep #scalability
❯ grep #scylla
❯ grep #sdkman
❯ grep #sea-orm
❯ grep #search
❯ grep #secondary-adapters
❯ grep #secrets
❯ grep #security
- Cryptography in Go — the stdlib way Concept Go
- Security in Go applications — the map Concept Go
- OAuth2 & OIDC in Go Concept Go
- Web security in Go apps Concept Go
- Building & releasing Go software Concept Go
- Property-based testing & fuzzing — rapid and go test -fuzz Concept Go
- Security testing — govulncheck, gosec, scanning Concept Go
- govulncheck — vulnerability scanning Concept Go
- Cryptography in Java — JCA/JSSE in practice Concept Java
- Security in Java applications — the map Concept Java
- OAuth2 & OIDC in Java Concept Java
- Web security in Java apps Concept Java
- keytool — keystores and certificates Concept Java
- Security testing — SCA, SAST, DAST & fuzzing on the JVM Concept Java
- Security — the defensive craft Path Paths
- Cryptography in Rust — rustls, ring & RustCrypto Concept Rust
- OAuth2 & OIDC in Rust Concept Rust
- Security in Rust applications — the map Concept Rust
- Web security in Rust apps Concept Rust
- Security testing — audit, unsafe hygiene & fuzzing Concept Rust
- AppSec fundamentals Concept Security
- GitHub Maintainer Security Settings Article Security
- Hardening Linux Article Security
- Authentication & authorization Concept Security
- Cryptography for engineers Concept Security
- Cryptopals — crypto challenges (sets 1–3) — subject Subject Security
- Cryptopals — crypto challenges (sets 1–3) Exercise Security
- Stand up your own CA + mTLS between two services — subject Subject Security
- Stand up your own CA + mTLS between two services Exercise Security
- Secrets management Concept Security
- Threat modeling Concept Security
- TLS/HTTPS & certificate management Concept Security
❯ grep #send-sync
❯ grep #serde
❯ grep #shell
❯ grep #slf4j
❯ grep #slog
❯ grep #smart-pointers
❯ grep #sockets
❯ grep #solid
❯ grep #sparql
❯ grep #specification
❯ grep #spring
- Java application frameworks — the landscape Concept Java
- Frameworks × Jakarta EE — who implements what Concept Java
- Spring deep dive Concept Java
- Security in Java applications — the map Concept Java
- OAuth2 & OIDC in Java Concept Java
- Web security in Java apps Concept Java
- Redis from Java Concept Java
- Relational databases from Java Concept Java
- Storage access from Java — the map Concept Java
❯ grep #spring-boot
❯ grep #sql
❯ grep #sqlx
❯ grep #sre
❯ grep #sse
❯ grep #ssr
❯ grep #staff-engineer
❯ grep #state-management
❯ grep #static-analysis
❯ grep #stdlib
❯ grep #storage
- Databases and other storage systems Concept Data Storage
- Build your own database — subject Subject Data Storage
- Build your own database Exercise Data Storage
- Document and NoSQL stores from Go Concept Go
- Graph databases from Go Concept Go
- Redis from Go Concept Go
- Relational databases from Go Concept Go
- Storage access from Go — the map Concept Go
- Time-series stores from Go Concept Go
- Integration testing — httptest, testcontainers-go, real databases Concept Go
- Document and NoSQL stores from Java Concept Java
- Graph databases from Java Concept Java
- Redis from Java Concept Java
- Relational databases from Java Concept Java
- Storage access from Java — the map Concept Java
- Time-series stores from Java Concept Java
- Integration testing — Testcontainers & framework test support Concept Java
- Document and NoSQL stores from Rust Concept Rust
- Graph databases from Rust Concept Rust
- Redis from Rust — redis-rs & fred Concept Rust
- Relational databases from Rust — sqlx, diesel & sea-orm Concept Rust
- Storage access from Rust — the map Concept Rust
- Time-series stores from Rust Concept Rust
❯ grep #strategy
❯ grep #streaming
❯ grep #structured-logging
❯ grep #subject
- Build an agent from scratch — subject Subject AI Engineering
- RAG over the knowledge base — subject Subject AI Engineering
- Interview-prep track — subject Subject Algorithms
- Birthday Greetings — hexagonal extraction — subject Subject Applicative Architecture
- Event-sourced bank account — subject Subject Applicative Architecture
- Gilded Rose — legacy rescue — subject Subject Applicative Architecture
- Variance workout — subject Subject Applicative Architecture
- Build your own database — subject Subject Data Storage
- End-to-end ELT pipeline — subject Subject Data Storage
- Gilded Rose: a technical-debt workout — subject Subject Engineering Practice
- Design system from scratch — subject Subject Frontend
- RealWorld full-stack build — subject Subject Frontend
- Toy browser engine — subject Subject Frontend
- DST-safe scheduler — subject Subject Fundamentals
- UTF-8 codec + text-processing CLI — subject Subject Fundamentals
- Protohackers ladder — subject Subject Go
- One Billion Row Challenge — subject Subject Java
- Build your own container runtime — subject Subject Platform
- Kubernetes the Hard Way — subject Subject Platform
- Tokio mini-redis — subject Subject Rust
- Cryptopals — crypto challenges (sets 1–3) — subject Subject Security
- Stand up your own CA + mTLS between two services — subject Subject Security
- Build a DNS resolver — subject Subject System Administration
- Build your own shell — subject Subject System Administration
- Write Yourself a Git — subject Subject System Administration
- Build your own Redis — subject Subject System Design
- Build a load balancer & rate limiter — subject Subject System Design
- Implement Raft with Gossip Glomers — subject Subject System Design
❯ grep #supply-chain
❯ grep #system-design
- Databases and other storage systems Concept Data Storage
- API design Concept System Design
- Asynchronous and distributed system patterns Concept System Design
- Cache management Concept System Design
- Concurrency and Parallelism Concept System Design
- Distributed consensus Concept System Design
- Message brokers & event streaming Concept System Design
- Microservice architecture Concept System Design
- Rate limiting & idempotency Concept System Design
- Search systems Concept System Design
- System design fundamentals Concept System Design
- WebSockets & bidirectional protocols Concept System Design
❯ grep #systems-programming
❯ grep #talk
❯ grep #tcp
❯ grep #tdd
- Birthday Greetings — hexagonal extraction — subject Subject Applicative Architecture
- Birthday Greetings — hexagonal extraction Exercise Applicative Architecture
- Event-sourced bank account — subject Subject Applicative Architecture
- Event-sourced bank account Exercise Applicative Architecture
- TDD Concept Applicative Architecture
- Software craft — design in the small Path Paths
❯ grep #team-topologies
❯ grep #tech-lead
❯ grep #technical-debt
❯ grep #terraform
❯ grep #testcontainers
❯ grep #testify
❯ grep #testing
- BDD Concept Applicative Architecture
- Gilded Rose — legacy rescue — subject Subject Applicative Architecture
- Gilded Rose — legacy rescue Exercise Applicative Architecture
- TDD Concept Applicative Architecture
- Testing strategies Concept Applicative Architecture
- RealWorld full-stack build — subject Subject Frontend
- RealWorld full-stack build Exercise Frontend
- Frontend testing Concept Frontend
- End-to-end testing — API clients, browsers, contracts Concept Go
- Integration testing — httptest, testcontainers-go, real databases Concept Go
- Mutation testing — gremlins and go-mutesting Concept Go
- Performance & load testing — testing.B, benchstat, vegeta Concept Go
- Property-based testing & fuzzing — rapid and go test -fuzz Concept Go
- Security testing — govulncheck, gosec, scanning Concept Go
- Testing in Go — strategies & tooling map Concept Go
- Unit testing — the testing package, table tests, doubles Concept Go
- go test Concept Go
- go tool cover — coverage Concept Go
- Spring deep dive Concept Java
- End-to-end testing — REST Assured, browsers & contracts Concept Java
- Integration testing — Testcontainers & framework test support Concept Java
- Mutation testing — PIT Concept Java
- Performance & load testing — JMH and Gatling Concept Java
- Property-based testing — jqwik Concept Java
- Security testing — SCA, SAST, DAST & fuzzing on the JVM Concept Java
- Testing in Java — strategies & tooling map Concept Java
- Unit testing — JUnit 5, Mockito, AssertJ Concept Java
- The full-stack web Path Paths
- Software craft — design in the small Path Paths
- Test-suite scheduling & job partitioning Concept Platform
- End-to-end testing — whole systems & contracts Concept Rust
- Integration testing — tests/, in-process routers & testcontainers Concept Rust
- Mutation testing — cargo-mutants Concept Rust
- Performance & load testing — criterion, divan & friends Concept Rust
- Property-based testing & fuzzing — proptest & cargo-fuzz Concept Rust
- Security testing — audit, unsafe hygiene & fuzzing Concept Rust
- Testing in Rust — strategies & tooling map Concept Rust
- Unit testing — the built-in harness, organization & doubles Concept Rust
- cargo-nextest — the test runner Concept Rust
❯ grep #testing-library
❯ grep #text
❯ grep #threading
❯ grep #threads
❯ grep #threat-modeling
❯ grep #time
❯ grep #time-series
❯ grep #timezones
❯ grep #tls
- Cryptography in Go — the stdlib way Concept Go
- Cryptography in Java — JCA/JSSE in practice Concept Java
- keytool — keystores and certificates Concept Java
- Security — the defensive craft Path Paths
- Cryptography in Rust — rustls, ring & RustCrypto Concept Rust
- Stand up your own CA + mTLS between two services — subject Subject Security
- Stand up your own CA + mTLS between two services Exercise Security
- TLS/HTTPS & certificate management Concept Security
- Networking fundamentals Concept System Administration
❯ grep #tokens
❯ grep #tokio
❯ grep #tonic
❯ grep #tool-use
❯ grep #toolchain
❯ grep #tooling
- Patterns for tools that generate configuration Concept Applicative Architecture
- Building TypeScript for the backend Concept Frontend
- The TypeScript build ecosystem Concept Frontend
- The bundler world Concept Frontend
- Package managers: npm, pnpm, yarn, bun Concept Frontend
- Vite deep dive Concept Frontend
- Go modules deep dive Concept Go
- Modules & the Go build ecosystem Concept Go
- Performance & load testing — testing.B, benchstat, vegeta Concept Go
- Security testing — govulncheck, gosec, scanning Concept Go
- Testing in Go — strategies & tooling map Concept Go
- Unit testing — the testing package, table tests, doubles Concept Go
- Delve — the Go debugger Concept Go
- Execution tracer — go tool trace Concept Go
- go build, go run, go install Concept Go
- go doc & pkg.go.dev — documentation Concept Go
- go generate Concept Go
- go mod Concept Go
- go test Concept Go
- go tool cover — coverage Concept Go
- go vet Concept Go
- go work Concept Go
- gofmt & goimports Concept Go
- gopls — the language server Concept Go
- govulncheck — vulnerability scanning Concept Go
- pprof — profiling Concept Go
- staticcheck & golangci-lint — the lint ecosystem Concept Go
- The Go toolchain Concept Go
- The Java build ecosystem Concept Java
- Gradle deep dive Concept Java
- Maven deep dive Concept Java
- jar — archives & manifests Concept Java
- java — the launcher Concept Java
- javac — the Java compiler Concept Java
- javadoc — API documentation Concept Java
- javap — the class file disassembler Concept Java
- jcmd — the JVM diagnostic command hub Concept Java
- jconsole — the JMX console Concept Java
- jdb — the CLI debugger and JDWP Concept Java
- jdeps — dependency analysis Concept Java
- The JDK, the JRE & their tools Concept Java
- JDK Flight Recorder & Mission Control Concept Java
- jlink — custom runtime images Concept Java
- jmap — heap histograms and heap dumps Concept Java
- jmod — the JMOD format and tool Concept Java
- jpackage — native installers and app images Concept Java
- jps — listing JVM processes Concept Java
- jshell — the Java REPL Concept Java
- jstack — thread dumps Concept Java
- jstat — GC and class-loading statistics Concept Java
- jwebserver — the minimal static file server Concept Java
- keytool — keystores and certificates Concept Java
- Testing in Java — strategies & tooling map Concept Java
- Unit testing — JUnit 5, Mockito, AssertJ Concept Java
- Dev containers Concept Platform
- Developer environments Concept Platform
- Version managers — universal vs ecosystem-native Concept Platform
- Version pinning & currency Concept Platform
- Testing in Rust — strategies & tooling map Concept Rust
- cargo-expand — macro expansion Concept Rust
- cargo-nextest — the test runner Concept Rust
- cargo — the front door Concept Rust
- clippy — the lint collection Concept Rust
- miri — undefined-behaviour detection Concept Rust
- Profiling & debugging Rust Concept Rust
- rust-analyzer — the language server Concept Rust
- rustc — the compiler behind cargo Concept Rust
- rustdoc & docs.rs — documentation Concept Rust
- rustfmt — formatting Concept Rust
- rustup — toolchain management & the release channels Concept Rust
- The Rust toolchain Concept Rust
❯ grep #tools
❯ grep #tower
❯ grep #trace-context
❯ grep #tracing
❯ grep #troubleshooting
❯ grep #tuning
❯ grep #type-systems
❯ grep #types
❯ grep #typescript
- The four hexagonal references compared Concept Applicative Architecture
- Building TypeScript for the backend Concept Frontend
- The TypeScript build ecosystem Concept Frontend
- The bundler world Concept Frontend
- Package managers: npm, pnpm, yarn, bun Concept Frontend
- Vite deep dive Concept Frontend
- Design system from scratch — subject Subject Frontend
- Design system from scratch Exercise Frontend
- Hexagonal architecture reference implementation — Frontend (web components) Concept Frontend
- TypeScript deep dive Concept Frontend
- Language craft — mastery in depth Path Paths
❯ grep #tzdb
❯ grep #udp
❯ grep #ui
❯ grep #unicode
❯ grep #unsafe
❯ grep #utc
❯ grep #utf-8
❯ grep #ux
❯ grep #validation
❯ grep #variance
❯ grep #version-control
❯ grep #vite
❯ grep #warehouse
❯ grep #wasm
❯ grep #web
- Web security in Go apps Concept Go
- Echo deep dive Concept Go
- Fiber deep dive Concept Go
- Gin deep dive Concept Go
- net/http deep dive Concept Go
- Frameworks × the stdlib contracts — who honors what Concept Go
- Go web frameworks — the landscape Concept Go
- Web security in Java apps Concept Java
- Web security in Rust apps Concept Rust
- Actix Web deep dive Concept Rust
- Axum deep dive Concept Rust
- Rocket deep dive Concept Rust
- Frameworks × tower/hyper — who builds on the contracts Concept Rust
- Rust web frameworks — the landscape Concept Rust
- AppSec fundamentals Concept Security