Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.
THE_SHINY_OBJECT_TRAP.md · 8.7 KB · 393 lines
The Shiny Object Trap: How We Almost Solved It Multiple Times
We Were SO CLOSE... Then Got Distracted
2004: Ruby on Rails Almost Had It
rails_2004:
what_they_got_right:
- "Convention over configuration"
- "Database is central"
- "CRUD is 90% of apps"
- "15-minute blog demo"
what_killed_it:
- "Ajax! Must add Ajax!"
- "RESTful! Must be RESTful!"
- "Asset pipeline! Webpack! Turbo!"
- "ActionCable! WebSockets!"
result:
before: "15-minute blog"
after: "15-day configuration"
ball_of_mud: "Gemfile with 200 dependencies"
2006: Django Almost Had It
django_2006:
what_they_got_right:
- "Admin interface auto-generated"
- "Models define everything"
- "Batteries included"
what_killed_it:
- "Async! Must add async!"
- "Channels! GraphQL! "
- "React frontend! Vue frontend!"
- "Microservices! APIs!"
result:
before: "Rapid development"
after: "settings.py is 500 lines"
ball_of_mud: "requirements.txt from hell"
2009: Node.js Almost Had It
node_2009:
what_they_got_right:
- "JavaScript everywhere"
- "Simple event loop"
- "NPM for everything"
what_killed_it:
- "Callbacks! Promises! Async/await!"
- "Express! Koa! Fastify! Nest!"
- "Babel! TypeScript! ESM!"
- "Webpack! Parcel! Vite! Turbopack!"
result:
before: "var http = require('http')"
after: "node_modules is 2GB"
ball_of_mud: "package.json with 1000 dependencies"
2013: React Almost Had It
react_2013:
what_they_got_right:
- "Just the view layer"
- "Components are simple"
- "One-way data flow"
what_killed_it:
- "Redux! MobX! Zustand!"
- "Hooks! Classes! Functions!"
- "Next.js! Gatsby! Remix!"
- "SSR! SSG! ISR! RSC!"
result:
before: "React.createClass()"
after: "20 build steps"
ball_of_mud: "Infinite re-renders"
The Pattern: Death by Enhancement
Stage 1: The Beautiful Beginning
new_framework:
announcement: "Look how simple!"
demo: "TODO app in 50 lines"
promise: "No more complexity"
adoption: "This changes everything!"
Stage 2: The Feature Requests
feature_creep:
month_1: "But what about authentication?"
month_2: "But what about real-time?"
month_3: "But what about mobile?"
month_4: "But what about scale?"
month_5: "But what about enterprise?"
month_6: "But what about...?"
Stage 3: The Abstraction Explosion
abstraction_hell:
original: "Direct and simple"
additions:
- "Abstract base classes"
- "Dependency injection"
- "Middleware pipeline"
- "Plugin architecture"
- "Hook system"
- "Event emitters"
- "Service locators"
result: "Nobody knows how it works anymore"
Stage 4: The Ball of Mud
final_form:
dependencies: 500+
configuration: 1000+ lines
build_time: 5 minutes
documentation: "Outdated"
stackoverflow: "Try downgrading to..."
developer_experience:
new_developer: "WTF is all this?"
senior_developer: "Just copy from last project"
original_author: "I don't recognize this anymore"
The Shiny Objects That Killed Simplicity
The Frontend Churn
frontend_chaos:
2010: "jQuery is the answer!"
2011: "Backbone is the answer!"
2012: "Angular is the answer!"
2013: "React is the answer!"
2014: "Flux is the answer!"
2015: "Redux is the answer!"
2016: "Vue is the answer!"
2017: "GraphQL is the answer!"
2018: "Hooks are the answer!"
2019: "Svelte is the answer!"
2020: "Snowpack is the answer!"
2021: "Remix is the answer!"
2022: "Bun is the answer!"
2023: "RSC is the answer!"
2024: "..."
result: "Nothing ever gets finished"
The Backend Churn
backend_chaos:
2010: "REST is the way!"
2011: "NoSQL is the way!"
2012: "Microservices are the way!"
2013: "Docker is the way!"
2014: "Kubernetes is the way!"
2015: "Serverless is the way!"
2016: "GraphQL is the way!"
2017: "Service mesh is the way!"
2018: "Event sourcing is the way!"
2019: "CQRS is the way!"
2020: "JAMstack is the way!"
2021: "Edge computing is the way!"
2022: "WebAssembly is the way!"
2023: "AI is the way!"
2024: "..."
result: "Everything is broken"
The Almost-Solutions We Abandoned
Microsoft Access (1992)
microsoft_access:
what_it_got_right:
- "Database first"
- "Forms auto-generated"
- "No code needed"
- "Regular people could use it"
why_we_abandoned_it:
- "Not web-based"
- "Not cool"
- "'Real developers' don't use Access"
irony: "It did what DBBasic does, 30 years ago"
PHP + MySQL (2000)
php_mysql:
what_it_got_right:
- "Direct database queries"
- "No build step"
- "Upload and run"
- "Powered the entire web"
why_we_abandoned_it:
- "Not 'enterprise'"
- "Not 'scalable'"
- "Not 'modern'"
irony: "Facebook still runs on PHP"
jQuery + Server (2008)
jquery_era:
what_it_got_right:
- "Simple DOM manipulation"
- "Server renders HTML"
- "No build process"
- "Everyone understood it"
why_we_abandoned_it:
- "Not 'reactive'"
- "Not 'component-based'"
- "Not 'declarative'"
irony: "It was fast and simple"
The Complexity Ratchet
Only Goes One Direction
complexity_ratchet:
law: "Complexity only increases"
why:
- Can't remove features (breaking changes)
- Can't simplify (backward compatibility)
- Can't restart (sunk cost)
- Can't say no (competitive pressure)
result:
year_1: "Simple and elegant"
year_3: "Getting complicated"
year_5: "Total mess"
year_7: "Rewrite from scratch"
The Rewrite Cycle
rewrite_cycle:
stage_1: "This codebase is unmaintainable"
stage_2: "Let's use [new framework]"
stage_3: "So clean! So simple!"
stage_4: "Just need to add..."
stage_5: "And support..."
stage_6: "This codebase is unmaintainable"
repeat: "Every 3-5 years"
Why DBBasic Breaks the Cycle
No New Framework to Chase
dbbasic_stability:
core: "Just tables and config"
cant_add:
- New paradigms (it's just data)
- New patterns (it's just queries)
- New abstractions (it's just config)
result: "Nothing to chase"
AI Prevents Feature Creep
ai_discipline:
feature_request: "We need X"
ai_response: "Here's a config for that"
no_new_code: "Config handles it"
no_new_complexity: "Pattern already exists"
no_new_dependencies: "Core engine handles it"
result: "Complexity can't grow"
Speed Eliminates Optimization Needs
speed_solves:
traditional: "It's slow, add caching"
dbbasic: "It's 402M rows/sec, done"
no_need_for:
- Caching layers
- Query optimization
- Index tuning
- Connection pooling
- Lazy loading
result: "No optimization rabbit holes"
The Lessons
We Had The Answer Multiple Times
the_answers_we_ignored:
1992: "Access had database-first right"
2000: "PHP had simplicity right"
2004: "Rails had conventions right"
2006: "Django had batteries-included right"
2008: "jQuery had direct manipulation right"
what_we_did: "Abandoned each for the next shiny thing"
The Pattern That Killed Them All
death_pattern:
1. "Simple solution appears"
2. "Everyone loves it"
3. "Edge cases emerge"
4. "Features get added"
5. "Abstractions multiply"
6. "Ball of mud forms"
7. "New simple solution appears"
8. "GOTO 1"
Why This Time Is Different
dbbasic_difference:
no_code_to_add: "Just config"
no_features_to_chase: "AI generates patterns"
no_performance_to_optimize: "Already at physical limits"
no_new_paradigm: "Data is eternal"
result: "The cycle is broken"
The Simple Truth
We kept solving the wrong problem.
We thought the problem was:
- "Not enough features"
- "Not enough abstractions"
- "Not modern enough"
- "Not flexible enough"
The actual problem was:
- Too many features
- Too many abstractions
- Too much churn
- Too much complexity
Every framework started simple. Every framework became complex. Every framework got replaced.
Until we stopped writing frameworks. And just wrote config.
"We had the solution in 1992. We just kept 'improving' it until it broke."
"Every abstraction is a confession that the previous abstraction failed."
"The shiny new thing is always the old thing with more complexity."
"We didn't need a new framework. We needed to stop making frameworks."
"Balls of mud don't form in config files. They form in code."
"The only way to win the framework game is not to play."