92 notes · 13 topics · 270 tags
What software is, what software engineering is, the types of software that exist, expertise areas, team roles, and where the field is heading with AI engineering and agents.
A practical guide to using Git worktrees so multiple AI agents can work in parallel on one machine, covering creation, runtime-state isolation, merging, cleanup, and a lifecycle automation script.
AI Spec-Driven Development enhances traditional Spec-Driven Development by integrating AI tools to automate and improve the specification process, increasing efficiency and reducing errors while ensuring clarity and alignment with user needs.
This blog discusses tRPC, a solution for building end-to-end type-safe APIs with TypeScript. It details the advantages and disadvantages of tRPC, as well as its integration with monorepos and introduces the tRPC Panel as a helpful tool for developers.
An overview of software architecture — what it is, why it matters, the main architectural styles, and how to document and evolve it over time.
This article explores the concept of Database Object-Relational Mappers (ORMs), outlining their benefits, drawbacks, and popular tools used in modern software development.
A practical guide to agentic coding: what it actually means to delegate work to autonomous coding agents, and how to be effective at it through strong context, spec-and-plan workflows, rigorous verification, parallel agents with git worktrees, MCP integrations, and tool-agnostic habits.
This article explores the complexities of working with dates in software engineering, covering formats, time zones, best practices, and useful libraries.
A practical overview of microservices architecture: its defining characteristics, the benefits of independent deployment and scaling, the distributed-systems trade-offs, and best practices for adopting it without falling into the distributed-monolith trap.
A practical guide to working with Docker: defining images with Dockerfiles, orchestrating multi-service apps with Docker Compose, hosting images in registries, scaling containers horizontally, and the everyday commands for managing containers.
A practical guide to Continuous Integration and Continuous Delivery/Deployment, covering what these practices mean, why they matter, the stages of a typical pipeline, and how to adopt them incrementally.
Linters are static analysis tools that catch errors, enforce consistent style, and improve collaboration. This article explains what they are, why they matter, the most common options, and how to integrate them into your workflow.
An in-depth look at Command-Query Responsibility Segregation: what it is, how the write and read sides differ, how to synchronize them, its relationship with event sourcing, and when the pattern is worth its added complexity.
An overview of agentic infrastructure — why autonomous software agents break assumptions built for human users, and the identity, rate-limiting, observability, and API design primitives needed to support them.
A practical technical guide covering what EDA is, its benefits and drawbacks, when to use it, and how to implement it on AWS.
An in-depth look at monorepo and polyrepo strategies in software engineering — the trade-offs each makes, when to use which, the tooling that makes them scale, and how to migrate between them.
An overview of single-tenant and multi-tenant architectures, comparing their isolation, cost, and operational trade-offs, with guidance on choosing between them and common data isolation strategies.
An overview of load balancers in software architecture, covering Layer 4 vs. Layer 7, common balancing algorithms, health checks and failover, and deployment patterns.
A deep dive into hexagonal (ports and adapters) architecture: what problem it solves, how driving and driven ports work, a full worked example in TypeScript, and guidance on testing and trade-offs.
An explanation of session-based authentication: how the login flow works, where sessions are stored, the security considerations around session cookies, and how the approach compares to token-based auth.
An introduction to token-based authentication: how the login-and-token flow works, what JWTs carry, the role of access and refresh tokens, key security trade-offs, and when to use the pattern.
A practical guide to Test-Driven Development — the Red-Green-Refactor loop, why it's really about design, common pitfalls, and how to apply TDD effectively when working with coding agents.
An overview of soft deletes versus hard deletes in databases, covering how each works, their trade-offs around recovery, compliance, constraints, and performance, and guidance on when to use each.
An introduction to blockchain technology covering its core mechanics, real-world use cases, how smart contracts work, the main development frameworks, deployment pipelines, contract versioning and upgradeability, and best practices for building safely.
An introduction to passwordless authentication — what it is, the common approaches (magic links, OTP, and passkeys), and how to implement email magic links and WebAuthn passkeys.
An exhaustive guide to iOS app deployment covering environment separation, TestFlight internal and external testing, when to send builds through Beta and App Store review, version and build number management, and the release train model for predictable shipping.
An overview of prompt injection in LLMs and agentic systems: how direct and indirect injection work, why tool-using agents raise the stakes, and the layered defenses and best practices for containing the risk in modern software.
An overview of why code review matters, practical best practices for authors and reviewers, how to use AI agents as a first-pass reviewer while keeping human judgment in the loop, and how review fits into a workflow of branches, environments, and pull requests.
A practical guide to Git integration strategies — merge commits, squash-and-merge, and rebase — covering when to use each, how branch and environment topology should drive the choice, and how to revert changes safely.
A deep dive into the transactional outbox and inbox patterns for reliably publishing and consuming events in event-driven systems, covering the dual-write problem, relay strategies, idempotent consumers, and operational concerns with SQL and TypeScript examples.
An overview of over-the-air (OTA) updates in mobile development: what they are, why teams use them, and how they work on iOS, Android, and React Native.
A conceptual and practical guide to browser local storage: what it is, how it compares to session storage and cookies, the JavaScript API, cross-tab syncing, and real-world use cases like theme preferences, form drafts, and caching.
An introduction to how cookies work in web browsers, their key attributes and security flags, and a practical JavaScript example that persists a user's theme preference.
A practical, in-depth guide to using LocalStack to emulate AWS services on your own machine — covering setup, pointing the SDK and CLI at the local endpoint, writing fast integration tests, running real infrastructure-as-code locally, and knowing the emulator's limits.
An overview of the mechanisms used to distinguish humans from bots in web applications — from traditional CAPTCHAs to behavioral scoring, cryptographic attestation, proof-of-work, and possession-based verification — with the trade-offs of each.
An introduction to Git, the distributed version control system: how it stores snapshots, the three states of your files, branching and merging, working with remotes, and a practical everyday workflow.
An introduction to A/B testing for software engineers, covering experiment design, implementation patterns, result interpretation, and when not to use it.
A practical guide to optimistic updates in React — what they are, when to use them, and how to implement them with useState, the useOptimistic hook, and React Query, including edge cases and trade-offs.
An extensive guide to Kubernetes covering why it exists, its architecture, core workload objects, configuration and storage, scaling and resilience, and practical cluster operations.
An overview of the React Compiler: what it does, how it automatically memoizes components at build time, how to adopt it incrementally, and the trade-offs to keep in mind.
An extensive practical guide to Terraform covering core concepts, the standard workflow, variables, modules, remote state management, and production best practices, with annotated HCL and CLI examples throughout.
An introduction to harness engineering: the discipline of building the orchestration, verification, and control systems that let AI agents do reliable work, and why it now matters more than the model itself.
An in-depth guide to Infrastructure as a Service: what it is, the shared responsibility model, its core building blocks, how it compares to PaaS and SaaS, and the benefits, trade-offs, and decision criteria for adopting it.
An extensive guide to service workers in web development, covering their lifecycle, registration, caching strategies, and background features using JavaScript and TypeScript.
An overview of Service Level Agreements: what they are, their core components, how they relate to SLOs and SLIs, how availability is measured, and best practices for writing meaningful, enforceable agreements.
A practical guide to software environments: the common types, how to provision them as code, managing environment variables and secrets, mapping git branches to environments, and how CI/CD automates promotion between them.
A practical tour of the ways systems delete data — hard deletes, soft deletes, and audit/event logs — including their trade-offs, foreign key and uniqueness gotchas, GDPR-style right-to-erasure concerns, and how to choose between them.
An introduction to React's Context API — how it works, the create/provide/consume pattern, a practical note-editor example, and guidance on performance pitfalls and when to reach for something else.
An overview of the core resilience patterns used to build fault-tolerant distributed systems, including timeouts, retries with backoff, circuit breakers, bulkheads, and graceful degradation.
A practical guide to automated testing with Vitest in TypeScript and JavaScript projects, covering setup, writing tests, mocking, coverage, and CI integration.
A practical guide to database concurrency: transactions and isolation levels, the anomalies they prevent, pessimistic vs. optimistic locking, deadlock handling, and best practices for correctness under load.
An introduction to Biome, the fast Rust-based toolchain that unifies formatting and linting for JavaScript and TypeScript projects, covering its features, configuration, and adoption trade-offs.
An introduction to React hooks covering useState, useEffect, useContext, useMemo, useCallback, and custom hooks, with practical code examples and best practices.
An explanation of the blue-green deployment strategy: how running two identical environments and flipping traffic between them achieves zero-downtime releases, plus database and rollback considerations.
A practical overview of Redis covering its in-memory data structures, persistence options, and the range of deployment models from standalone instances to Sentinel, Cluster, and managed cloud services.
An overview of canary deployments — how they gradually shift traffic to a new release — compared with blue-green deployments across blast radius, rollback speed, cost, and complexity.
A practical guide to keeping database migrations backward-compatible during rolling, blue-green, and canary deployments, centered on the expand-and-contract pattern, safe change types, and non-blocking backfills.
A deep dive into database indexes: how B-tree and specialized index types work, composite and covering indexes, the write and storage costs they impose, and a practical strategy for choosing them.
An explanation of the best-effort design principle in software engineering — trading strong guarantees for latency, availability, and scale — illustrated with AWS services like S3, SQS, and CloudWatch, plus guidance on designing your own best-effort APIs.
An introduction to SQL injection: how it works, a concrete login-bypass example, and how to prevent it with parameterized queries and defense-in-depth practices.
An introduction to PgBouncer, the lightweight PostgreSQL connection pooler: why connection pooling matters, its three pooling modes, basic configuration, and production operating tips.
A practical guide to HIPAA compliance for software engineers, covering what the law requires, the technical safeguards that affect codebases, and how to embed compliance into the development lifecycle.
An overview of Distributed Denial of Service attacks: how botnets and amplification make them work, the main categories of attack, and the layered mitigation strategies used to defend against them.
An introduction to the VIPER architecture pattern for building modular, testable client applications, covering its five components, how the layers communicate, and the trade-offs involved.
An explanation of Server-Side Rendering: what it is, why it improves performance and SEO, how to do it with raw React, and how Next.js makes it practical with server components, streaming, and Suspense.
An in-depth guide to microfrontends: what they are, why teams adopt them, the main composition strategies, and how to build them with Next.js on Vercel's path-based microfrontends platform.
An in-depth introduction to large language models: how the Transformer architecture works, how models are trained and aligned, their capabilities and failure modes, and practical guidance for prompting and building with them.
A practical guide to React's composition patterns — children, named slots, compound components, and render props — with code examples and guidance on when to use each.
An explanation of the provider pattern in React.js — combining the Context API with a wrapper component and custom hook — illustrated with theme and auth examples, plus notes on performance and when to use it.
A practical, end-to-end guide to deploying Expo apps with the modern EAS toolchain — configuring build profiles, managing credentials, building and submitting to the stores, shipping OTA updates, and automating it all with GitHub Actions.
A practical guide to webhooks: what they are, why they beat polling, and how to receive, verify, and reliably process events with code examples.
An in-depth guide to WebSockets — how the handshake and framing work, when to use them over polling or SSE, and a complete live collaborative cursor board example in Node.js, including reconnection, heartbeats, and scaling with a pub/sub backplane.
A practical overview of Retrieval-Augmented Generation (RAG): how its retrieval and generation stages fit together, why it improves accuracy and freshness over standalone models, where it's applied, and the engineering trade-offs it introduces.
An introduction to smoke testing: a fast, broad verification that a build is stable enough for deeper testing, why it saves time, what to include, and how it fits in a CI pipeline.
A practical guide to Cross-Origin Resource Sharing: what it is, how the browser preflight handshake works, the key CORS headers, and how to configure it correctly in Next.js.
An in-depth guide to SOC 2 for software teams: what the framework is, the five Trust Services Criteria, Type I vs Type II reports, how the audit works, and a step-by-step plan for achieving and maintaining compliance.
This article discusses the deployment of applications using Kamal, covering its pros, cons, setup instructions, and integration with load balancers and CI/CD.
An explanation of the back-office and front-office concepts, how they differ in audience, permissions, and UX, and how a single shared backend can serve both surfaces without requiring separate servers.
An overview of the circuit breaker resilience pattern: what problem it solves, its closed/open/half-open state machine, a minimal implementation, and how it combines with fallbacks, timeouts, and bulkheads.
A deep dive into agent-native architecture: designing systems that expose composable capabilities so agents can operate with the same power as humans, rather than bolting automation onto feature-based software.
An in-depth look at Incremental Static Regeneration in Next.js: how stale-while-revalidate caching works, time-based versus on-demand revalidation, error handling, and when to choose ISR over fully static or dynamic rendering.
An in-depth guide to database migrations covering the core mechanics of versioned schema change, zero-downtime techniques for relational databases like expand-and-contract, and lazy versus eager strategies for non-relational stores.
An in-depth guide to database transactions, covering the ACID properties, isolation levels and their anomalies, concurrency control mechanisms like locking and MVCC, practical usage patterns, and the challenges of distributed transactions.
An in-depth engineering guide to the event sourcing pattern: how it works, its core building blocks, projections and CQRS, the hard operational trade-offs, and when to apply it.
An introduction to regression testing: what it is, why it protects the value of shipped software, how to run it in CI with sensible test selection, and how to keep the suite healthy over time.
An overview of sanity testing: a narrow, focused check that verifies a specific change or bug fix works, when to use it, and how it differs from smoke testing.
A practical guide to Amazon S3 covering buckets, key/file structure, security best practices, using the AWS SDK v3, generating presigned URLs for direct client uploads, and configuring CORS.
An introduction to Model Context Protocol servers: what they are, their core primitives (tools, resources, prompts), how they communicate over JSON-RPC, and practical advice for building and operating them.
An introduction to Zustand, the minimal React state management library, covering store creation, selector-based subscriptions, middleware, and when to use it.
An introduction to cron jobs in software engineering: how to read cron expressions, schedule tasks at the OS and application level, and design reliable, idempotent jobs with coding examples.
A practical guide to mastering GitHub Actions, covering core concepts, events, jobs and matrices, secrets and security, caching, reusable workflows, and best practices.
An explanation of the N+1 query problem—where fetching a list triggers one extra query per row—covering how to spot it in query logs and how to fix it with eager loading and batched queries.
