Fadstack

The substrate language. Kernels, compilers, embedded — still the lingua franca when you need the metal.

Process model, pipes, and files-as-interfaces. Linux and macOS still speak this dialect every day.

Declarative data that outlived every ORM fashion cycle. Postgres and friends keep winning by being boring.

The network stack that won. Every "revolutionary" protocol still rides these packets.

The production OS. Cloud VMs, containers, phones, routers — the penguin ate the datacenter.

Batch processing lingua franca of mainframes. Despised in conferences; irreplaceable in unemployment and banking ledgers.

Pipes, globs, and glue. The programming language that never needed a framework conference.

Systems performance with object machinery. Ugly, powerful, and still the default where latency pays rent.

Formula Translation for scientists who needed numbers before "software engineering" was a job title. Still runs the weather, the bomb labs, and half of HPC.

The metal under every abstraction. You do not write it for CRUD; you write it when cycles, size, or boot ROM matter.

Dependency graphs as a file. Still the bootstrap build tool when everything else is too clever to trust.

Beginners All-purpose Symbolic Instruction Code — home computers, line numbers, and the first mass programming literacy wave.

Parentheses, macros, and AI winters. The language academics admire and enterprises politely ignore — until a dialect sneaks into their editor.

Teaching language with structured discipline. Mutated into Delphi and Object Pascal; faded as a mainstream career stack.

Write once, run everywhere — then enterprise forever. Still the backbone of serious backend estates.

Microsoft's managed stack grew up — cross-platform, open source, and still dominant in enterprise Windows shops.

Customize the ERP until upgrades are impossible. The enterprise tax that keeps consultants in villas.

$ ABAP extensions and bespoke modules that made every upgrade a multi-year program. Millions spent aligning ERP to process instead of process to ERP.

JVM language with functional teeth. Spark and Kafka culture kept it relevant long after the Twitter hype cooled.

Let it crash, supervision trees, and nine-nines uptime. The telecom substrate that outlived every "modern" backend pitch.

Drag-and-drop business logic that powered SMB back offices worldwide. Microsoft killed it; the apps refused to die.

EJB-heavy stacks taught a generation that XML config was architecture. Spring and lighter runtimes absorbed the survivors.

Spec first, code later. Agile didn't kill planning — it killed pretending the Gantt chart was reality.

RAD Windows client development before .NET. Still runs vertical-market apps whose source lives on a burned CD.

Everything is an object, the IDE is the world, and the web stole the ideas while HR never posted the job.

Pure functional, lazy by default, and the language that makes conference talks deep and hiring pipelines empty.

Language-agnostic distributed objects. Complexity scaled faster than value for most shops.

$ Enterprises spent years on IDL, ORBs, and vendor lock-in for distributed objects that SOAP and REST later made look quaint — after the invoices cleared.

When every wiring decision lived in 4,000-line XML files. Configuration became a second programming language nobody wanted.

Diagrams as deliverables. Useful as a sketch tool; catastrophic when treated as source of truth.

From scripting glue to the default language of data and AI. Readability as a growth strategy.

Resources over RPC theater. Won the API wars by being boring enough to debug with curl.

The application protocol of the internet. HTTP/2 and HTTP/3 are evolutions, not replacements.

Distributed version control that ate the industry. Merge pain remains; centralized SVN does not.

Batteries-included Python web. Still the adult choice when you want an admin, auth, and ORM that behave.

Model-view-controller as the default web shape. Still how most server-rendered apps think.

Java's practical operating system for apps. DI and Boot made enterprise Java shippable again.

Linux, Apache, MySQL, PHP — the cheap, fast path to a website. Mutated into countless managed stacks.

Dismissed by snobs, powering WordPress and half the web. Ugly pragmatism beats elegant irrelevance.

Convention over configuration. Taught a decade of frameworks how to ship MVPs — and how to hit scaling walls.

Small Python core, extensions for everything else. The pragmatic counterweight to Django's batteries.

Partial page updates without full reloads. Became the mental model for every modern front-end framework.

Individuals and interactions — then SAFe slideware. The manifesto stuck; the ceremony industrial complex is the fad layer.

Opinionated CSS that made every site look like a startup for a while. Still the fastest path to a decent admin UI.

The duct tape of the early web and sysadmin era. Regex culture in a language that read like line noise.

Minimal Ruby routing for apps that did not need all of Rails. DSL elegance in a few hundred lines.

DOM peace treaty for a fractured browser world. Mission accomplished — then frameworks ate its job.

Tag-based rapid web apps in CFML. Government and agency sites that outlived every contractor who knew the syntax.

Enterprise web services with ceremony. Interoperability theater with XML envelopes.

$ Banks and governments sunk fortunes into WS-Security, WSDL toolchains, and vendor stacks — then quietly rebuilt on REST/JSON while still paying maintenance on the old bus.

Reuse via shared services — in theory. In practice: central buses and political ownership fights.

$ ESBs, governance boards, and "service portfolios" burned seven-figure programs. Many orgs got distributed monoliths with worse latency and a permanent integration team.

Minimal structure for early client MVC. Taught the browser to think in models before React rewrote the rules.

Observable view models for declarative UI. MVVM before the term became enterprise cosplay.

Write Java, compile to JavaScript. Enterprise AJAX before anyone admitted they hated JavaScript.

Enterprise desktop UI in the browser — grids, trees, and megabytes of widget chrome.

Message bus in the middle of everything. SOA's plumbing invoice with vendor licensing.

$ Middleware vendors sold central buses that became single points of failure and political bottlenecks. Integration teams grew; end-to-end latency did too.

Animations, games, and video in a plugin the web learned to hate. Steve Jobs wrote the obituary; HTML5 dug the grave.

.NET in the browser via plugin. Netflix used it; the web moved on anyway.

$ Enterprises built internal dashboards and streaming pilots on Silverlight just as HTML5 and iOS said no to plugins. Migration projects burned budgets Flash already warned them about.

Ship the environment with the code. The packaging unit of modern compute.

Design for the small screen first. Became table stakes, not a differentiator.

One deployable with clear boundaries. The unfashionable default that keeps shipping while microservices argue about ownership.

Container orchestration that became the cloud's OS. Overkill for many; unavoidable for many others.

In-memory data processing that made Hadoop feel overnight. Still the batch/stream workhorse under many lakehouses.

Durable log as nervous system. Event-driven architecture with real operational teeth.

Fast structures in memory with persistence options. Cache, queue, session store — pick your footgun.

Components and unidirectional data. Won the front-end by being good enough and having a gravitational ecosystem.

Small language spec, fast compiles, great concurrency story. Cloud infra's favorite hammer.

Declarative infra with state files everyone learns to fear. The closest thing to versioned datacenters.

Apple's successor to Objective-C. The price of admission to serious iOS and macOS development.

Java without the boilerplate ceremony. Google's Android pick and Spring's polite nod kept it climbing.

The bundler that taught JavaScript developers what suffering means. Still under legacy apps; Vite owns greenfield.

YAML over SSH that sysadmins could actually read. The config-management winner by approachability.

Document DB that became a punchline, then a grown-up product. Survived by getting serious about transactions and ops.

Full-text search and log analytics at scale. Powerful, hungry, and everywhere in observability stacks.

Progressive framework with a friendlier learning curve. Steady share without the cult volume.

Compile away the framework. Less runtime theater, more shipped HTML — including this site.

Thin routing layer on Node that became the default API sketchpad. Middleware culture in a single file.

Binary RPC with contracts. Fast internal glue that should never face the public internet without a gateway.

BEAM reliability with modern syntax. Phoenix and LiveView keep the torch for pragmatic functional web.

Hermetic builds for monorepos that hurt until they save you. Google brainworm or serious reproducibility — pick one.

Real-time Elixir on the BEAM with HTML-over-the-wire before it was cool. Small but fiercely loyal community.

Wide-column store built for Netflix-scale write throughput. Resume-driven clusters optional.

Property graph database that finally made graph queries a product. Niche that pays when the graph is the domain.

Independent deployability as religion. Correct for some; ruinous cargo-cult for most.

$ Teams split 4-person products into 40 services, then hired SREs to babysit the mesh. Many later consolidated — after years of distributed tracing invoices and on-call trauma. See case studies on premature microservices and big-bang cutovers for named failure modes.

Client-side apps as the only architecture. Great for apps; absurd for brochures.

$ Marketing sites and docs portals shipped multi-megabyte JS bundles for content that wanted HTML. SEO and performance teams spent years unwinding "modern" defaults.

Hide SQL until N+1 queries own your night. Good ORMs survived; "never write SQL" didn't.

Plugin palace CI that defined pipeline culture — and Groovy nightmares. Still running somewhere in your org.

Convention-over-configuration SPA framework. LinkedIn and Discourse kept the faith; everyone else went React.

Mobile UI kit on Cordova then Capacitor. Still ships hybrid apps for teams that prioritize one codebase over polish.

git push deploy and twelve-factor bliss. The PaaS that taught a generation what deploy should feel like — then priced them out.

$ Free-tier sunsetting and Salesforce neglect sent hobbyists and startups shopping mid-project. Dyno pricing that made sense at demo scale became a line item at traction.

Agile at enterprise scale with certifications and train metaphors. Process theater with a subscription model.

$ Certified release trains, PI planning offsites, and agile coaches billing seven figures to wrap waterfall in sticky notes. Velocity went up on slides; cycle time often did not.

Schema-optional databases sold as a lifestyle. Right tool for some jobs; default for none.

$ Startups ditched Postgres for document stores "because scale," then rebuilt relational integrity in application code — and paid twice when joins came back as a product requirement.

Datacenter kernel before Kubernetes won the orchestration war. Twitter survived on it; most did not need it.

MapReduce as lifestyle. The elephant in rooms that needed a spreadsheet.

$ Enterprises stood up Hadoop clusters for gigabytes of data that fit on one Postgres instance. Hadoop admins, ZooKeeper nightmares, and ETL rewrites burned millions before Spark and cloud warehouses retired the elephant.

Two-way binding magic that became a migration tax. Angular 2+ was a rewrite; the 1.x apps lingered for years.

Full-stack JS with live data sync before anyone agreed on modules. Magic demo, fragile production.

C# for iOS and Android before Flutter and React Native won the cross-platform narrative.

Google's web components push before the platform was ready. Shadow DOM slides; React won the component war.

HTML in a native WebView with camera plugins. The first cross-platform mobile bet before React Native ate lunch.

$ Teams shipped WebView shells as "native apps," then paid twice for performance fixes, plugin rot, and App Store rejections when users noticed the jank.

Document store with replication and offline sync as the headline. MongoDB took the NoSQL spotlight.

Ruby DSL infrastructure as code with cookbooks and a community site. Ansible ate the simpler path.

Declarative config management with a heavy enterprise sales motion. Still haunts datacenters that virtualized early.

Command/query separation as default architecture. Right for high-scale event domains; absurd for to-do lists.

$ Teams split read and write models for CRUD apps that never needed separate projections. Double the schemas, double the bugs, double the on-call surface — for a blog admin.

Store every state change as an eternal log. Audit gold for some domains; operational nightmare as a default.

$ Immutable event logs for domains that needed UPDATE statements. Replay debugging sounded elegant until production needed GDPR deletes and schema migrations on millions of events.

Sidecar proxies for every microservice. Netflix problems with startup headcount.

$ Istio sidecars on three-service startups burned SRE headcount on mTLS ceremonies nobody could debug. Many teams ripped mesh out before the observability dashboard paid rent.

The first JavaScript task runner that made config files a lifestyle. Gulp and webpack ate its lunch.

Streaming build pipelines with code-over-config aesthetics. Briefly cool; webpack became the sun.

Front-end package manager before npm figured out flat dependency trees. jQuery plugins as a service.

Dynamo-inspired KV store from Basho. Bet on eventual consistency; lost to operational simplicity elsewhere.

BaaS before Firebase owned the category. Open-sourced on the way out; trust never recovered.

$ Facebook shut down Parse with a year's notice, forcing thousands of mobile backends into emergency migrations or self-hosted forks.

JS with a typechecker that conquered the ecosystem. The rare fad that became the floor.

The only language that runs in every browser. Accidental monopoly turned deliberate platform.

JS on the server. Unified the stack and created a package ecosystem that is both miracle and hazard.

Memory safety without GC pauses. Climbing from systems niches into cloud infra and WASM.

React with routing, SSR, and deployment opinions. The default answer when someone says "we need a web app."

Utility classes in markup upset purists and accelerated shipping. Design systems without meeting paralysis.

Python APIs with types and OpenAPI for free. The default backend for ML demos that became the default for a lot else.

Angular-style structure for Node backends. Enterprise comfort food with decorators and modules.

ESM-native dev server that made webpack feel instantaneously obsolete for new projects.

Functions as the unit of deploy. Brilliant for spikes and glue; awkward as a whole product architecture.

Pre-render + CDN + APIs. The brand cooled; the pattern (static where possible) stuck.

HTML as the engine of application state — a deliberate counter to SPA maximalism.

Batteries-included SPA platform for teams that want opinions and CLI scaffolding.

Chromium in a trench coat. Slack, VS Code, and RAM usage everywhere you look.

Paint your own pixels on iOS and Android from one codebase. Google's bet against native UI fragmentation.

React components on native views. Share logic with web until platform differences ruin your sprint.

Auth, realtime DB, and hosting as a product. Prototype paradise; vendor lock purgatory at scale.

Portable bytecode beyond the browser. Slow burn with real teeth in edge and plugin runtimes.

Web standards–first React framework with nested routes and forms. Merged into React Router; the ideas survived the brand.

Google's language that found purpose as Flutter's syntax. Rare case where the UI framework rescued the language.

Clients ask for exactly what they need — and sometimes invent a second backend team to make that safe.

Drag-and-drop apps for the enterprise backlog. Useful for internal tools; fantasy as a full replacement for engineering.

C without the footguns — in theory. A systems language beloved in blog posts and absent from most job boards.

Node reimagined with TypeScript native and permissions. Correct instincts; wrong moment against npm gravity.

Fine-grained reactivity without a virtual DOM. The framework perf nerds cite when explaining why React rerenders hurt.

Resumability and zero-JS-first marketing. Correct diagnosis of hydration pain; crowded prescription aisle.

Decentralize data ownership like microservices for warehouses. Real org problem; often a logo refresh for the same broken pipelines.

$ Consultancies sold domain ownership and federated governance while teams still could not agree on a customer ID. Slideware outpaced catalog tooling by years.

Replace the working system instead of strangling it. A perennial money pit with new branding each decade.

$ "We'll freeze features and rewrite in the hot language." Multi-year projects shipped late, incomplete, or not at all — while competitors iterated on the ugly system that made money.

Erlang semantics with friendly syntax on the BEAM. The language your functional meetup loves and your employer has never heard of.

Distributed consensus for problems that needed a database and an audit log.

$ Enterprises funded "innovation labs" to put loyalty points and supply-chain spreadsheets on ledgers. Most pilots ended as slide decks; the gas fees and audits did not.

Wallet popups as UX. A subculture with real tech under a mountain of token incentives.

Autocomplete that actually understands the file. Changing how code is written faster than how it's reviewed.

Regression tests for nondeterministic models. The unglamorous infrastructure that separates demos from products.

Embeddings back in the database you already run. The quiet winner of the vector DB gold rush.

All-in-one JS runtime that actually feels fast. Winning scripts and side projects while production waits for edge cases.

Retrieval-augmented generation as the answer to every knowledge problem. Often right; often Postgres with pgvector would suffice.

$ Teams stood up vector pipelines, chunking strategies, and rerankers before asking if fine-tuning or a SQL query would answer the question. Retrieval infra became the product.

The shakeout from seventeen LLM wrappers to three vendors and one observability bill. Hype cycle entering boring procurement.

Tracing, cost caps, and prompt versioning for production LLM features. Datadog for tokens.

Craft the magic string until the model behaves. Job title of 2023; table-stakes skill of 2026.

Run the model on your laptop or rack. Privacy, cost control, and the refusal to send every token to a vendor.

Standard ways for models to talk to tools and data — MCP-class protocols instead of one-off plugin snowflakes.

Chains, agents, and prompt wrappers shipping weekly. The durable pieces will be boring: evals, retrieval, and product UX.

Specialized stores for embeddings. Many workloads are folding back into Postgres extensions — after the vendor tour.

Chains, tools, memory, and agents as a framework — LangChain-class glue sold as architecture.

$ Teams adopted chain/agent frameworks before they had a single reliable tool call. Abstraction layers multiplied while prompt quality stayed flat.

When in doubt, fine-tune. Often the expensive answer to a retrieval or eval problem.

$ Fine-tune jobs and GPU bills for problems that prompt + retrieval would have solved. Model zoos became the new snowflake servers.

If it is text, vectorize it. Semantic search cosplay for problems that needed a better filter.

$ Embedding pipelines for tickets, PDFs, Slack, and the cafeteria menu — then nobody measured retrieval quality. Vector bills and reindex jobs became the product.

Big-bang rewrite, now with a chatbot. Same failure mode; prettier slides.

$ Exec decks promised autonomous migrations "by next quarter." Teams that skipped tests, ownership, and incremental strangler patterns bought expensive demos and fragile diffs.

LangGraph, CrewAI, AutoGPT cosplay — agents delegating to agents for tasks one function call could do.

$ Autonomous agent swarms burned API budgets on coordination loops that a single prompt and a cron job would have handled. Debugging "which agent lied" became the new on-call sport.

Accept AI output on feel, skip the diff, hope tests exist. Fast demos; fragile ownership.

$ Ship-to-prod without reading the diff became a flex until incidents revealed nobody knew which prompt wrote the auth middleware. Review debt arrived in one weekend demo.

Give the model a goal and a credit card. Viral in 2023; quietly shelved when the loop never stopped spending.

$ Open-ended agent loops burned API credits chasing goals nobody specified well enough to finish. Demo videos outpaced production deployments by orders of magnitude.

LLM evals as slideware — metrics that look scientific and never gate a deploy.

$ Dashboards of vibe-check scores that never blocked a release. Green charts for leadership; prod still hallucinated.