Concept 625 nodes

Pattern of persisting state as an immutable, append-only sequence of domain events.

Approach to modeling software around the business domain using a ubiquitous language.

Command Query Responsibility Segregation: separating write and read models at service level.

Collaborative workshop technique for modeling domains using sticky-note events.

Decentralized social networking protocol underlying Bluesky.

Rails ORM pattern of keeping current state in database rows without history.

Passing collaborators into an object from outside rather than constructing them internally.

DDD boundary within which a model has a single, unambiguous meaning.

Ruby's actor-model abstraction for parallel execution without shared mutable state.

Persistence-agnostic functional pattern with decide, evolve and react pure functions.

Append-only, read-only persistence of immutable domain events.

Relationship-based access control modeling permissions as a graph of tuples.

Coverage technique that mutates code and checks whether tests catch the change.

Draft web standard letting a third party serve a cryptographically signed copy of a page.

Service as an action expressed by class or singleton methods, without instance state.

DDD object serving as the consistency and public-contract entry point of an object tree.

Autonomous or semi-autonomous LLM-powered program that uses tools via function calling.

User-data bootstrap mechanism for configuring freshly provisioned cloud VMs.

Degree of interdependence between software elements; a design attribute with multiple levels.

Single-deployment monolith with clear internal module boundaries and high cohesion.

Multi-tenant data isolation where every row carries a tenant_id.

Long-running coordinator that compensates for failures across distributed/external systems.

Discipline for improving design by validating every implementation step through tests.

Development methodology deriving constraints and process from universally-accepted truths (axioms).

Stages a compiler/interpreter uses: lex, parse, semantic analysis, optimization, execution/codegen.

Deep-learning neural networks with general-purpose language understanding and generation.

JSON-RPC-based protocol for exposing tools to LLMs.

Inject relevant proprietary knowledge into the prompt so the LLM answers with current, specific data.

Rails pattern of encapsulating a use case as a callable object; debated naming and semantics.

Model of system behavior as states and permitted transitions.

Tagging each database record with a target region before physically separating tables.

System architecture in which components react to published domain events.

Modeling technique that describes business processes as sequenced frames of commands, events and views.

Instrument code with generic events, independent of log/trace/metric output sink.

Caching rendered view fragments keyed by model to skip re-rendering.

Rails architectural layer encapsulating atomic creation, edit, and deletion operations.

Classic ORM query-per-row performance anti-pattern.

Miniature Rails application mountable inside a host Rails app.

Periodic snapshot of aggregate state to bound replay cost in event sourcing.

Bellware's OOD doctrine: objects must be operational the moment they are instantiated.

Bi-directional protocol for persistent client-server communication.

Commit so small it cannot be meaningfully broken up further.

Registry dispatching commands to exactly one registered handler.

Closed set of five atomic commit-level change types: remove, fix, refactor, change, add.

Database structures that speed lookups when used deliberately.

Anti-pattern: splitting a monolithic data model across HTTP without changing access patterns.

EDN Query Language — data-structure-based query notation for graph APIs.

PostgreSQL query-plan inspection and execution profiling.

Ruby hook interface letting fibers transparently defer blocking IO.

Mathematical languages defined by an alphabet and a grammar of production rules.

MRI Ruby's lock preventing true parallel execution of Ruby threads.

Anti-pattern: a single class that knows and does too much, tightly coupling a system.

Splitting data across multiple databases sharing the same schema.

Mobile app combining web technologies (HTML/CSS/JS) with native APIs.

Debugging methodology using the scientific method: observe, hypothesize, experiment, publish.

Unique client-generated token that lets a receiver detect and ignore duplicate create requests.

Running a mutation testing tool only on subjects touched in the current change.

Legal contract between insured and insurer defining coverage, premiums and deductibles.

MongoDB + Express + React + Node.js JavaScript web stack.

Ruby practice of modifying existing classes/methods at runtime from outside their source.

Bundling a Rails engine's CSS/JS at gem build time and serving via Rack::Static.

Two-track workflow pattern where failures jump to an error track.

Event-driven component that performs side effects, often interacting with external systems.

Event-subscribed, persisted projection serving a specific UI or report.

Callback invoked when a SQLite connection can't acquire the write lock; replaces busy_timeout.

Design practice of building systems as layers with strictly downward dependencies.

Emitting logs as key/value attributes instead of plain strings.

Plain class including TestBench::Fixture that behaves as a composable test object.

Open HTTP-based protocol for resumable file uploads.

PostgreSQL tables that skip the write-ahead log for speed.

Runtime that executes intermediate code instead of running directly on hardware.

Portable binary instruction format letting non-JS languages run in the browser.

Design philosophy letting component APIs expand or contract in expressiveness.

Computation model in which actors react to messages, spawn actors, and mutate only their own state.

Event Modeling building block: a robot that reacts to events by dispatching commands across modules.

Business Process Model and Notation for modeling business processes as events and flows.

Mental model classifying every contribution as a dart against ecosystem/automation/contribution thresholds.

Replacing sensitive data with realistic non-real substitutes that preserve shape and relationships.

Experimental HTML template-tag API for streaming/replacing named DOM fragments.

Logging to_formatted_h representations of business domain objects.

Running multi-step workflows whose state survives crashes, restarts and long waits.

Test double implemented as a real class with controllable behavior replacing a collaborator.

Denial, anger, bargaining, depression, acceptance — response to any loss.

Property that an operation produces the same result when applied multiple times.

Technique splitting Active Record's connection pool into separate read and write pools against one SQLite file.

Specification for consistent JSON HTTP APIs.

Using JSON Schema to enforce attribute shapes on analytics/observability events.

Vision + skills + motivation + resources + action plan needed for smooth change.

Architectural layer wrapping interactions with external systems.

Meta-tool protocol letting an LLM discover and call other tools on demand.

Database optimized for storing and retrieving commands and events.

Plain object implementing a type's interface with no-op/stub behavior to remove conditionals.

Standardized attribute-naming conventions for telemetry across vendors.

Organizational commitment to a page-load ceiling used to defend against feature bloat.

Coordinator of long-running business processes across events and aggregates.

Component that projects events into a specific read-model representation.

Splitting Active Record models into write-side decision objects and read-side display objects.

Ruby feature for scoped, lexically activated monkey patches.

Experimental Sorbet feature declaring that a module must be included by a given ancestor class.

Using include, extend, prepend and super to customize Ruby objects.

Multi-tenancy using a separate database schema per tenant.

Enterprise architectural style composing systems from networked, contract-defined services.

Sidekiq feature grouping related jobs and running a callback when all complete.

Forcing LLMs to emit valid JSON/YAML via schema-prompting or server-side enforcement.

Mathematical model of computation with an infinite tape, head, and state transitions.

DDD term for a shared vocabulary between domain experts and developers.

ViewComponent feature exposing named content holes filled by callers (render_one / render_many).

SQL functions that compute values across a set of rows related to the current row.

Computation whose result depends on when or how many times it runs.

Distinguishing framework/input-level logic from true domain rules.

Level of quality enforced by tests, linters, type checks and CI on top of the base language.

Gapless deployment strategy running old and new versions in parallel.

Packaging a Ruby gem inside a Docker build to avoid host-environment contamination.

Compact instruction-set intermediate representation executed by a virtual machine.

Function whose output depends only on its inputs, regardless of when or how many times it runs.

Dependency-arrow diagram of layers used to diagnose architectural smells.

Optional sub-resource used via JS to detect whether SXG prefetching succeeded.

Storing table data column-by-column instead of row-by-row for analytical speed.

Entry-point component that receives a command and decides which event(s) to write.

Bertrand Meyer's principle that methods either change state or return data, never both.

The three kinds of messages objects can exchange, mirroring linguistic sentence types.

HTTP-level compression scheme using a previously downloaded resource as a diff dictionary.

Zeller's 1882 trick of shifting the year start to March so February sits at the end.

Identifiers meaningful without surrounding scope, enabled by namespacing.

Principle of following well-established conventions instead of bespoke solutions.

Google's user-centric performance signals (LCP, FID/INP, CLS) influencing SERP rank.

Pattern of co-locating component styles with JavaScript code.

Eric Evans' iterative model-exploration cycle driven by scenarios.

Designed-in null-object substitute with telemetry, used instead of mocks/stubs/spies.

Systems that span multiple process boundaries and must handle concurrency and idempotence.

Language- and framework-agnostic model imitating the problem domain.

Eric Evans' DDD construct for stateless operations representing significant domain processes.

Ruby dispatch style based on whether an object responds to a method.

Query events by attributes to form virtual streams per decision, instead of one fixed stream.

Baseline contribution quality enforced automatically by the base language and standard library.

Folding an event stream from empty state into a single entity representation.

Pragmatic style mixing CRUD with selected event-sourced aggregates and read models.

Async message types: past-tense events (facts) and imperative commands (intent).

npm package compromised via social-engineering backdoor that stole Bitcoins.

Rails convention of concentrating business logic in ActiveRecord models with lean controllers.

Read-check-write fallback for creation without idempotency-key support.

Automaton with finite states used to recognize regular languages.

Concern-based form object with delegators pretending to be the underlying model.

Single polymorphic association linking a Geneva Drive workflow to any domain record.

Google's opaque cache (web-pkg-c.com) that stores and serves Signed Exchange packages.

Decorator Ruby class in Hanami View wrapping exposed values with presentation methods.

Hanami View Ruby object that computes the locals needed by a partial.

HTTP-level compression using a pre-shared dictionary of common tokens.

Small-in-bytes image with huge pixel dimensions, used to crash processors.

SQLite transaction mode that acquires the write lock at BEGIN instead of deferring it.

Migrate in small reversible steps rather than a big-bang cutover.

Time-limited, non-binding estimate of insurance cost that becomes a policy on purchase.

Linux asynchronous I/O interface based on submission and completion ring buffers.

AT Protocol JSON Schema defining a record collection's shape.

Determining file type from a signature of bytes at the start of the file.

DHH's term for a well-structured single-deployment Rails application.

Practice of coaching less experienced developers to grow individuals and community.

Keep each layer's API surface as small as the abstraction allows.

Container format (MPEG-4 Part 14) wrapping video, audio, and metadata.

io_uring pattern: submit once, receive many completions.

Software pattern where a single application instance serves multiple clients with isolated data.

Clojure keywords carrying a namespace, making identifiers globally unambiguous.

Weighted decision graph of layered neurons mapping inputs to outputs via local computations.

Generating processed file derivatives when a URL is first requested.

Concurrency control using a version parameter to detect and reject stale updates.

Uploaded files that are never attached to any record.

Secret site-wide value added to passwords and stored outside the database.

AT Protocol server holding user accounts and record repositories.

Data that can identify a specific individual and must be protected.

Java business class with no framework or library imports.

Web apps delivering native-like, offline-capable experiences via standard web platform features.

io_uring feature letting the kernel pull read buffers from an application-supplied buffer ring.

Messaging pattern where publishers and subscribers interact only through named categories.

State-driven UI paradigm where the view is a pure function of observable state.

Storing long-lived refresh tokens in HttpOnly, Secure, SameSite cookies rather than JS storage.

Pathom graph node declaring input-to-output attribute mapping plus a fetch function.

Architectural style for HTTP APIs centered on resources and representations.

Routing architecture that walks executable code paths at request time instead of a parsed route table.

DBMS mechanism restricting row visibility per user or session.

Extract model scopes into a concern to separate query shortcuts from domain logic.

Enabling MFA only for users flagged as violating account-sharing rules.

A service has no GET API, no external dependencies, and is oblivious to other system parts.

On-chain program of functions and storage whose state changes only via its functions.

XML-based RPC protocol foundational to Service-Oriented Architecture.

Rack mechanism to take over the raw socket behind a request.

Tokens that tell the LLM runner to halt generation.

Incremental migration pattern where a new system gradually replaces pieces of an old one.

Use stubs to replace external collaborators; avoid mocks that couple tests to internal structure.

Prefetching CSS/JS/fonts/images alongside the HTML via hashed entries in the Link header.

Replace a table by copying wanted rows into an empty clone and renaming.

UI approach presenting small process-aware forms instead of a giant edit-everything form.

Standards committee defining the ECMAScript language specification.

Using Time.current/Time.now as a hidden source of non-determinism in tests.

Passing a shared trace ID through every service call to correlate logs across services.

Trailblazer 2.1 BPMN-style process with multiple end events and nesting.

Neural network architecture underlying modern large language models.

Inline mini-charts rendered using Unicode block characters instead of a UI library.

ML-generated numeric vectors that cluster data by semantic meaning.

Remote desktop protocol providing access to a graphical session.

Store incoming webhooks as events in the event store before processing them asynchronously.

SQLite journal mode allowing concurrent reads alongside a single writer.

Fat line between layers such that consumers never need to look underneath.

Tree representation of source code produced by syntactical analysis.

Google's 2015 simplified-HTML framework for prefetching mobile pages from Google servers.

Rails Active Record feature auto-creating nested models from a nested params hash.

Rails-provided monkey patches adding utility methods to core classes.

Rails per-request Singleton for request-scoped state like current tenant.

Anti-pattern: a single class mixing entity, handler, and projection responsibilities.

Per-aggregate sequence number on events, in addition to a global identifier/order.

A mutation is 'alive' if tests still pass, 'dead' if a test fails.

Plain Ruby object that multiplies a product's score by a coefficient based on one local question.

AT Protocol materialized-view server producing user-facing data.

Reliability recipe: combine at-least-once delivery with idempotent receivers to achieve exactly-once effect.

Self-contained piece of software that broadcasts signals and reacts to broadcasts, not a microservice.

Fibers that yield automatically on blocking I/O, like Go/Crystal.

Anti-pattern of using many boolean fields to encode object state, causing combinatorial explosion.

Dynamic-array IO.select pattern to avoid spin-lock in bidirectional proxies.

Expose a component's configuration as DSL methods on a yielded builder object.

Prefer build/build_stubbed over create to avoid unnecessary DB hits in tests.

Reactive rule mapping domain events onto commands on other domains to coordinate them.

Single consolidated log line per request carrying all relevant attributes.

Content-addressed archive format for exporting AT Protocol repositories.

Ruby's === operator used for type membership, case/when, and pattern matching.

Pattern where popular tools are kept mentally taxing to hold their audience captive.

Model of people's motivation through an organizational change over time.

Don't remove a rule before fully understanding why it exists.

Classification of formal languages into regular, context-free, context-sensitive, and recursively enumerable.

Anything computable can be computed by a Turing machine or equivalent formalism.

Running CI jobs across combinations of parameters like language/framework versions.

Pairing a primitive initializer with class-level factory methods for convenience and operational wiring.

Metaphor for cultures that are hard outside/soft inside vs soft outside/hard inside.

Intuitive judgement for how many layers a team actually needs.

View-layer form object dispatching intention-revealing commands from user input.

A message expressing intent — a generalized name for a web form or controller input.

Explicit up-front agreement between collaborators on how they will communicate.

Frontend-architecture view that complexity should grow organically rather than start at the SPA end.

Algorithm to calculate the date of Easter; etymological root of 'computer'.

Compile-time evaluation of constant expressions.

Substituting known constant values into later expressions at compile time.

The bar above which merging a change actually helps the company.

Systems mirror the communication structure of the organization that builds them.

Index that includes extra columns via INCLUDE for index-only scans.

Web standard for defining reusable HTML elements with JavaScript classes.

Information at rest — meaningful without a computer, with multiple future interpretations.

Multi-tenancy using a separate database per tenant.

Anti-pattern where the shape of existing data dictates application design.

Rich Hickey's practice of separating things unintentionally coupled together.

Default every web request to a read connection and switch to the write connection only for writes.

Phased deprecation of legacy behavior with explicit warnings before removal.

ActiveSupport module that keeps a hash of every class and its subclasses.

Graph of nodes where edges have direction and no cycles exist; workflow foundation.

'Every piece of knowledge must have a single, unambiguous, authoritative representation.'

Linux kernel technology for safely running programs that observe kernel events.

Elixir operator chaining expressions as successive function arguments.

UI pattern: record bad input as an event and show tailored read-model views per audience.

Anti-pattern: entities that accept command messages, interpret them, and return events.

Attack that discovers which accounts exist by observing form responses or timing.

Linux scalable I/O event notification mechanism.

A mutation whose behavior is semantically indistinguishable from the original.

Using time estimates to surface resource needs without discussing emotions.

Extract, Transform, Load — classic pipeline for moving and reshaping data.

Registry broadcasting events to multiple registered handlers.

Recording state-change events so tests and operators can assert on what actually happened.

Evolving persisted events by migrating to newer versions on read.

Distinction between known/handled errors and novel ones, for alerting purposes.

Retry strategy where wait between attempts grows exponentially.

Test-slowness anti-pattern where factories build a whole object graph per example.

List of common misconceptions programmers hold about how LLMs work.

Faraday middleware logging URL, duration, and attributes of every outbound API call.

Ruby execution context that can be suspended and resumed, used for cooperative concurrency.

Rails facility that redacts configured attributes (PII) from payloads.

Two-stage recommender: filter a product pool, then score survivors with weighted amplifiers.

Prefer Rails fixtures to FactoryBot for speed, cross-references, and dev-DB reuse.

Rails habit of dumping all models into a single app/models folder.

API design where 1:1 relationships are expressed as sibling attributes, not joins.

Object that wraps UI input and validations, separate from models and services.

Ruby gem manifest file declaring metadata, files and dependencies.

Pattern of running your own CI worker connected to GitHub Actions.

Minitest helpers asserting maximum database queries per GraphQL operation.

1582 papal reform patching the Julian leap rule with divisible-by-100/400 exceptions.

Widely-supported video codec with profile-based feature sets.

Using pen and paper to boost creativity, memory, and motivation.

Ports-and-adapters architecture that keeps the domain pure.

US healthcare data privacy and security compliance regime.

US insurance policy type covering a renter's belongings, liability and temporary living costs.

Which HTTP verbs are idempotent and under what assumptions.

Distinction between response-driven HTTP Turbo Streams and Rails-specific WebSocket broadcasts.

Combining classic keyword lookup with vector/embedding search for retrieval.

Workday structured into repeating offline, online, and off-topic phases.

Feeling unqualified despite sufficient skill; confused with lacking skills.

Fundraising mechanism by issuing a new token on a blockchain.

Risk-assessment process determining whether to offer coverage and at what price.

HTML attributes enabling native hover/long-press popovers without JavaScript.

Refactoring: extract a meaningfully-named boolean variable to clarify intent.

HTML button command/commandfor attributes that trigger element actions without JS glue.

Tricking an LLM into doing or saying unintended things.

Calendar reform introduced by Julius Caesar in 45 BC with a 4-year leap rule.

Formal system for expressing computation; equivalent in power to Turing machines.

Core Web Vital measuring when a page's largest visible content element renders.

Postgres SQL feature correlating a subquery with the outer row.

Pattern where LLMs 'call tools' by emitting structured invocations caught via stop tokens.

Anti-pattern of putting conditionals, loops, or production helpers inside test code.

Persisting each user login as a database record identified via cookies.

Callaghan's take on the three observability data types.

Compiler optimization expanding loops to exploit SIMD instructions.

Race condition where concurrent writes overwrite each other's changes.

Mutant syntax specifying which subjects the engine should target.

Linking commands and their resulting events to reconstruct full workflow traces.

Seed new event streams with a dedicated 'migration' event to backfill state.

Defining a monolith as a single data model cramming many unrelated domains together.

Bluesky's fleet of 10 federation-test PDSs named after mushrooms.

Transformation applied to a subject to produce a mutation.

Grouping Rails models and controllers into folders by entity dependencies or bounded context.

Bleeding-edge branch-free algorithm for epoch-to-date conversion.

Aggregate root containing other aggregates to manage complexity.

One tenant's usage pattern exhausting shared resources and degrading others.

Communication style with explicit rules for separating intentions, feelings, needs, and requests.

Attribute that lazily initializes to a default (often a null object) when still nil.

Built-in Ruby mechanism to snapshot all live objects to a JSON-lines file.

Treat observability as a first-class developer concern, not something delegated to ops.

Ivan Nemytchenko's visual ontology representing OOP constructs as cartoon dudes.

Anti-pattern: hiding projections, writers or other dependencies the handler should control.

Anti-pattern: passing a bag of request params through controllers, services and models.

Index covering only rows matching a WHERE clause.

Rails ActionView partials are far slower than direct view rendering due to file lookup and compilation.

Mathematical modeling formalism for concurrent/distributed systems.

Central registry mapping did:plc identifiers to DID documents.

Extracted business rules testable without the aggregate.

Aggregate split into one class per state, each exposing only valid transitions.

HTML link hints telling browsers to fetch DNS/resources in advance.

Calling a Ruby Proc with === — enabling procs in case/when.

Blockchain consensus mechanism requiring validators to lock tokens as stake.

Testing by declaring invariants and generating random inputs to find counter-examples.

Designing application protocols by reasoning about every failure point, not the happy path.

Finite-state machine with a stack; recognizes context-free languages.

Ship unfinished code to master hidden behind a feature flag instead of long-lived PRs.

Time a request waits in a queue (load balancer, Puma, worker) before handling.

Quantitative RAG evaluation combining faithfulness, context relevance, and answer relevance.

Rails routing internal that undef_methods all URL/path helpers on every reload.

Question-driven test strategy prioritizing controller tests, then services/mutators, over unit/acceptance extremes.

LLMs that emit hidden chain-of-thought tokens before the user-visible answer.

Rate, Errors, Duration — core service-health metrics.

Reform 3 step-based parsing built on Trailblazer activities that users can extend.

Add a region-denoting parent folder to file paths so whole folders can be migrated at once.

Facilitation pattern of repeatedly splitting attendees into subgroups and merging their findings.

Yippee's named slicing of a repository-pattern-inspired model layer.

Serving multiple output formats from a single controller action via respond_to.

Communicating concerns to business as risks plus proposed solutions.

Explaining a problem step-by-step (to an inanimate duck) to surface the solution.

Ruby's GC frees objects but does not return freed heap pages to the OS.

undef_method scales super-linearly and spends half its time clearing the method cache.

Queue holding ready-to-run fibers, mediating cooperative scheduling.

Random per-password value stored with the hash to prevent rainbow-table attacks.

Collect data and define indicators before rolling out a risky feature.

Ruby's :: operator for resolving constants, classes and modules.

Process of finding the tests corresponding to a subject under mutation.

Ill-defined industry title conflating skill, role, tenure, and company marketing.

Cloud execution model based on events and functions without managing servers.

Fowler's architectural layer defining application boundary and available operations.

Partitioning data/requests across nodes by a deterministic hash to scale writes.

Letter-swap search that occasionally accepts worse scores, cooling acceptance over time.

Philosophy of deploying a whole web app to one server with a persistent file system.

A unit of software should have one purpose and therefore one reason to change.

Declarative JSON API telling browsers to prefetch or prerender links.

Shared AT Protocol lexicon agreed on by multiple blogging platforms.

Serving pre-rendered, pre-gzipped HTML directly from nginx without touching Rails.

tea mechanism: staking tokens against a library to back a claim and earn rewards.

Geneva Drive DB row representing one attempt to run a specific workflow step.

Callaghan's five-step SOS cycle for adding observability to fix specific bugs.

Design rule that an aggregate's event stream is the authoritative state, not the DB table.

Rails controller-level whitelisting of permitted request parameters.

The thing Mutant mutates — currently a Ruby instance or class method.

Experience-based knowledge that cannot be fully expressed in words.

Sorbet runtime helper that rebinds `self` to a given type inside a block/method.

Testing strategy model — many unit tests, some integration, few end-to-end.

Diagram of parallel actions across workers used to spot possible race conditions.

Using response-time differences to determine whether accounts exist.

Assign region buckets starting from the Authority root and walking associations down.

Ruby core API for subscribing to runtime execution events.

Callable orchestrator object delegating to scoped steps with a result.

Application-wide Trailblazer process modeled visually with suspend/resume events.

PgBouncer mode that assigns connections per transaction rather than per session.

Tools compiling one source language to another (typically to JavaScript).

Sorbet escape hatch disabling type checks for a single expression.

Layer components into generic UI ones and object-aware domain ones that compose them.

Small immutable type that represents a domain primitive with meaning.

Database that indexes vector embeddings for similarity search.

Unit of work in Event Modeling: write, read, or automation slice bounded by events.

Anti-pattern: shaping events to carry UI/view fields rather than raw facts.

In-memory representation of the UI derived from application state.

Unified OpenTelemetry primitive with high cardinality and dimensionality, subsuming logs/traces/metrics.

Ruby 2.5 method yielding self to a block — Ruby's 'pipe' analog.

Chroma-subsampled pixel format universally supported by browsers.

Overuse of opaque acronyms/abbreviations makes team communication hostile to newcomers.

Users reusing paid credentials with others, hurting subscription revenue.

Rails pattern for serializing/deserializing Ruby objects in unsupported DB types.

Rails feature for encrypting attributes at rest in the database.

Ruby parse-time concatenation of adjacent string literals separated by whitespace.

Count of inbound calls into a unit of software from other units.

RSpec option letting a slow example record all assertion failures instead of stopping at the first.

Component that shapes event streams into read models / materialized views.

Measure of algorithm cost in space (memory) and time (steps).

Translation barrier isolating a bounded context from another context's model.

Storage model where records are only appended in order, never modified or deleted.

Two-layer split separating Rails-bound plumbing from a pure Ruby domain layer.

Business context, project context, and quality attributes that frame any design evaluation.

Paradigm separating cross-cutting concerns via 'before/after' advice on events in code.

Ability to trace each recommendation back to the parameters and signals that produced it.

Two-step form pattern: paste requirements as text, LLM analyzes and pre-fills the form for user review.

Verifying who a user claims to be.

Determining what actions or resources a user is allowed to access.

Serializing large objects into background jobs can make them slower than inline execution.

Metasyntax for describing context-free grammars of programming languages.

Country where launching an ICO is legal, per the Ethereum lightning talk.

Hundreds of GB is small for Postgres; don't prematurely reach for Elasticsearch.

I/O model where reads/writes wait for the OS buffer to be ready.

Cloudflare feature blocking bot-like requests; must be disabled for curl-based debugging.

Modern-CPU optimization that speculatively executes instructions past a branch.

Developer-experience trick giving each git branch its own SQLite database file.

Notebook-driven BFS through code dependencies to fully remove legacy code.

Auditing front-end dependencies and payload to keep bundles small.

Using cron to brute-force rebuild caches ahead of user requests.

Native C code bundled with Ruby gems to accelerate or wrap system libraries.

Human-readable record of notable changes between releases.

Vocabulary distinguishing automated checks (tests) from manual checks (reviews) and their flags.

Resilience pattern that stops calls to a failing downstream service to avoid cascading failure.

The automated, known space around a developer that business change disrupts.

Stream containing all commands addressed to a particular entity instance.

Use the originating command's UUID inside event metadata to deduplicate events.

SQL WITH-clause for naming an inner query; available in Postgres ≥ 8.4.

Rails config hook to attach per-request attributes to every log line.

HTTP requests inside open DB transactions starve the connection pool while the external call is in flight.

Sharing a pooled Redis connection between Sidekiq and the host application.

Using the LLM analysis phase to prepare state for subsequent screens, amortizing cost across features.

Process that continuously reads messages from a category, dispatches them to handlers, and writes new messages.

Strategic map of a domain's bounded contexts and their relationships.

Using nested descriptive prose in tests as technical writing that validates design.

Complexity you add to a system but only deal with a small subset of at any time.

The part of the domain that gives a business competitive advantage.

Per-crawler per-day request budget that bounds how many pages a site gets indexed.

Moore's model of the gap between early adopters and the early majority in tech adoption.

Some cultures won't tell you they don't understand — plan communication accordingly.

Single mutable snapshot of system state, contrasted with an event log.

Building domain-specific matchers and helpers so specs read as intent, not boilerplate.

Define scalar and aggregate SQL functions in Ruby callable from SQLite queries.

Sense-making framework classifying problems as obvious, complicated, complex, or chaotic.

Evolving immutable event schemas over time via optional fields, versions, and binary formats.

Obfuscation variant that preserves the shape of real data with non-real substitutes.

Replacing sensitive values with reversible tokens resolvable only by authorized parties.

Describe the desired schema; framework synthesises safe migration steps.

Using Rails default_scope to preview what per-region data will look like.

Modes of execution: at-most-once, at-least-once, exactly-once.

Event subscriber that builds query-optimized views from domain events.

ActiveRecord bulk-deletion methods with very different performance and consistency trade-offs.

Distinction between writing code and solving business problems.

Using the Rails console and production data carefully to diagnose real issues.

Permanent cryptographic identifier for AT Protocol accounts.

Uploading files directly from the browser to a cloud storage service.

Design metric plotting afferent/efferent coupling against generality/specialization.

DNS returning region-specific IPs based on the requester's origin.

Modelling each domain as a pure function mapping input commands to output events.

Collaborative DDD modeling technique using pictographic domain stories.

Count of outbound calls from a unit of software into other units.

Process: identify affected people, interview them, surface common theme, vision, minimal iterations.

Performance countermeasures for event-stream replay: versioned entity cache and periodic snapshots.

Architectural pattern for games separating data (components) from behavior (systems) on entities.

Explicit list of model events that invalidate a cached GraphQL field.

Policy for handling failures in one event subscriber without breaking others.

Property where distributed state converges over time rather than instantly.

Artificial controller-vs-background-job split that makes one domain workflow look like two.

Concurrency control parameter on event-store writes used to detect and reject races.

Interactively inspecting and modifying a running program via a live console.

System in which the output affects the input for the next iteration.

Raise in dev/test but silently fall back with reported error in production for unknown values.

Swap ActiveRecord each for find_each to paginate large result sets into memory batches.

Questioning technique that drills to the real reason behind a statement.

Stacked visualization of sampled call-stack frames showing where time is spent.

Cloud execution model running individual functions on demand.

Blaming others' failures on character but our own on circumstances.

AI that generates text, audio, video, and other content.

The aspiration — and fragility — of making distributed offices feel genuinely unified.

graphql-ruby feature exposing the requested query tree to resolvers.

Schema-level limit on nesting depth of incoming GraphQL queries.

Combining multiple GraphQL queries into one HTTP request and executing them concurrently.

Per-query maximum execution time enforced at the GraphQL schema level.

LLM outputs that are fluent but factually wrong or fabricated.

Two ways AT Protocol proves a domain handle belongs to an account.

Language primitive for projecting a map to a subset of keys.

Ruby method converting a hash into a proc equivalent to hash[key].

A long-standing company-wide issue multiple teams have failed to fix.

Cultural spectrum on power distance — flat structures vs deferential hierarchy.

Keyed hash construction usable to preprocess passwords with a secret pepper.

Server proactively pushing resources before the client requests them.

Conditional HTTP requests that return 304 Not Modified to skip re-rendering.

With enough users, every observable behavior of an API becomes part of its contract.

Three properties Ivan Nemytchenko proposes for an ideal software system.

Requirement that projectors and reactors produce the same outcome on repeat events.

API design where form operations are class methods returning fresh immutable objects.

Relying on query scopes to enforce access rather than explicit checks.

British English phrases whose literal meaning masks a very different intent.

Cultural spectrum contrasting focus on the individual with focus on the group.

Scope of risks protected by an insurance policy, with limits and exclusions.

Amount the insured pays out of pocket before insurance kicks in.

Recurring amount paid for insurance coverage; feeds the claims pool.

Module-based wrapper exposing only specified methods as a Ruby 'interface'.

Trade-offs between working with native speakers and working with non-native lingua-franca English.

Internal 'want to' motivation vs external incentives like money or Prestige.

Design practice of making illegitimate object states unrepresentable through types.

Ruby wrapper over the POSIX select system call.

Separate app, infrastructure, and schema deployments through a framework-managed queue.

Communication technique of starting with 'I' to express feelings without blame.

Remote procedure call protocol that encodes calls as JSON messages.

BSD/macOS scalable event notification mechanism analogous to epoll.

Conflict-resolution strategy keeping only the most recent write to a field.

Barbara Liskov's rule: objects sharing an interface are interchangeable regardless of behavior.

Front-end development technique auto-refreshing the browser on file change while preserving state.

Numeric units LLMs emit one-at-a-time when generating text.

Put data fetching next to data usage inside views when per-query cost is negligible.

Two-way HTTP gateway forwarding Logux events between Logux server and backend.

Ordering events via server/client time-shift and a per-client incrementing counter.

CPU cache / memory access is slow relative to computation on modern hardware.

Community efforts to make referencing Ruby methods ergonomic.

Converts a Method object into a Proc bound to its receiver.

1887 experiment measuring Earth's speed relative to luminiferous ether; found no difference.

Personal mind map aggregating event-sourcing patterns, use cases, and sources.

In knowledge work, any obstruction to human understanding counts as a mistake.

Stub or mock external services so the app can be developed and tested without them.

Anti-pattern where entity-relationship modelling grows into an everything-relates-to-everything graph.

Test-suite properties required for mutation testing to work in practice.

How Postgres and MySQL implement multi-version concurrency control differently.

Rails patterns that break MVC by creating circular dependencies between layers.

With SQLite, many small simple queries outperform fewer complex joined queries.

Use named route helpers and i18n for all strings even in single-language apps.

Deeply nested GraphQL queries hiding expensive or circular data fetches.

Chat etiquette: skip 'hi, how are you?' and state your request directly.

Socket I/O that returns immediately with EAGAIN/EWOULDBLOCK instead of blocking.

Implicit block parameters _1, _2, _3… in Ruby.

Design approach treating the network as optional and intermittently available.

Architectural style placing the pure domain at the center and infrastructure on outer rings.

March-2020 spike in interest in online whiteboards triggered by the lockdown.

Running processing synchronously/asynchronously when a file is attached.

Third-party service delivering bank-account data to financial apps, typically via webhooks.

SOLID principle: software entities should be open for extension, closed for modification.

UI pattern that immediately reflects success, assuming most requests will succeed.

Shipping type signatures that support users without forcing them.

Ruby 4.0 VM instruction letting the JIT optimize standard object construction.

Target of keeping first-page render under one second, including mobile 3G.

Only a small set of filter combinations is actually used; index those hot paths.

Splitting an application into smaller isolated parts (the older name for microservices).

Attack combining plain-hash pre-images with a bcrypt layer to break wrapped hashes.

JVM GC configurations trading throughput for zero pause times.

Service-level agreement defining acceptable performance targets for features/pages.

Proposed JavaScript operator for chaining function calls as successive arguments.

Classic warning that optimizing too early wastes effort on the wrong code.

Google's middle-ground speculation mode that stops prerendering at the first script tag.

Ruby method returning a curried proc that partially applies arguments.

Pure fold over an event stream producing current or derived state.

Applying modern calendar rules backwards in time for convenience.

Andrei's name for so-called 'prompt engineering' — unreliable, non-scientific prompt tweaking.

1960s workflow where code was mailed through typists and operators for a days-long feedback loop.

Scoring candidate decryptions by summing frequencies of their four-letter substrings.

Google user-centric performance model with a 100ms UI response budget.

Critique that Rails makes replacing or disabling core components very hard.

Configuration pattern preventing duplicate event subscriptions across Rails reloads.

Observation that most systems have far more reads than writes (or vice versa).

Web apps delivering updates instantly without client polling.

Reform 2 hooks that decide how to turn an incoming nested fragment into a form/model.

Any change leaving the system in a worse state, not just a production bug.

Training step where models are tuned to produce outputs humans prefer.

Uniqueness validation in event-sourced systems via a reservation event on the shared key.

A REST resource is accessed only through different representations.

Uploads split into chunks so interruptions don't restart from zero.

Anti-pattern of adopting fashionable tech stacks to build a career rather than solve a problem.

Wrap non-final Sidekiq errors so monitoring only logs them once retries are exhausted.

Rails 1.11 (2006) feature letting the server return JavaScript to manipulate the DOM.

Bell-curve model of how technology moves through a population (innovators → laggards).

Representing SQL queries as composable Ruby hashes built from constants, hashes, arrays, and primitives.

Trade-off between runtime type checking and static type checking in Ruby.

Nested fragment caches where outer caches reuse valid inner caches.

Long-running coordinator of multiple aggregates to achieve a business goal.

Schemaless stores are a poor transactional DB but good for logging/monitoring/telemetry.

Phlex feature where a view renders only a subset of its output (e.g. one Turbo Frame).

Recording production traffic and replaying it against a new module to validate behaviour.

Hooks invoked around Sidekiq's client-push and server-execute flows.

Rails pattern of storing multiple subclasses in one table via a type column.

Running a separate application instance per client.

UI pattern: don't wait for async processing when real-time feedback isn't required.

Einstein's theory deducing length contraction and time dilation from two simple assumptions.

Specs are tests written for humans; tests are written for the computer.

Compile all of an app's Ruby to VM instructions stored in one SQLite file, shipped as the deployment.

SQLite per-column collation for case-insensitive comparisons.

Diagnosing opaque foreign-key violations via PRAGMA foreign_key_check.

SQLite allows many concurrent readers but only one writer at a time.

UI pattern: hide async background work behind a plausible static confirmation screen.

Framing software design as obedience to universal structural laws (coupling, cohesion, transparency).

Testing paradigm that separates stubbing from verification into distinct phases.

Classical cipher mapping each plaintext letter to a fixed replacement.

Ruby method converting a symbol into a proc that invokes that method on its argument.

TCP congestion-control mechanism where bandwidth ramps up from ~14KB.

tea role that validates new package releases by staking tokens on review outcomes.

Encapsulation principle: instruct objects to act rather than query their state.

Principles that outlive the conditions that created them.

Separate data only, separate apps fully, or hybrid with shared middle.

Spend 10–30 minutes scouting where an optimization hour would yield the biggest win.

Front-end build optimization eliminating unused module code from bundles.

Running Ruby threads in parallel on all CPU cores via the JVM, with shared mutable state.

Joel Drapper's abstract definition of a type as a description of a set of objects.

Generic business domain (pricing, shipping, inventory…) repeated across almost every project.

Logux event rolling back an optimistic change when the server reports an error.

Registering with a unique email per site to detect which site leaked your data.

Causal-ordering mechanism for events across distributed systems.

Scale SQLite workloads by running on a bigger single machine.

Linux mechanism for dedicating PCI devices (e.g. GPUs) to VM guests.

Declarative browser API for animated DOM/page transitions with minimal code.

1970s text terminal whose protocol is still emulated in modern terminal apps.

Browser request timeline used to diagnose web-performance bottlenecks.

Technical prefixes and suffixes in class names that drain domain meaning.

Open web video container format, historically needed alongside MP4.

Two-way messaging pathway between a webview's JavaScript and native code.

Software expands to consume available hardware performance faster than hardware improves.

A graph of steps that depend on each other's completion or failure, with persisted state.

Running remote modeling as repeated small cycles rather than a 1-3 day offline marathon.

Famous xkcd comic depicting modern infrastructure balanced on one unpaid maintainer.

Deploying an app without dropping WebSocket connections.

Build setup combining esbuild, npm and similar tooling to bundle front-end JavaScript.