askrobots / dbbasic Public

Model-config web apps: describe the app in configuration instead of writing code. Built on Polars and DuckDB.

0 downloads

dbbasic/docs/THE_SHINY_OBJECT_TRAP.md
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 Add DBBasic crate engine logo and update README 0d628db 1 year, 2 months ago History
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."