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/CONFIG_DRIVEN_DEVELOPMENT.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
CONFIG_DRIVEN_DEVELOPMENT.md · 5.6 KB · 236 lines

Config-Driven Development (CDD)

The Final Evolution of Software Development

The Journey Back to the Future

1990s Insight: "Non-programmers should build applications"

  • Vignette StoryServer: $200K visual builder
  • Symphony, BroadVision: Point-and-click development
  • They had the right idea, wrong implementation

2000s Detour: "Real programmers write code"

  • Rejected visual builders as "not real development"
  • Built frameworks requiring 50,000 lines
  • Made everything harder to prove we were "serious"

2020s Circle Complete: "Everyone using no-code again"

  • Webflow, Framer, Notion, Airtable
  • We came full circle but pretended it was new

2025 Revelation: "It was always just config"

The Evolution of Development Paradigms

1. Code-Driven Development (1950-2000)

for (int i = 0; i < users_count; i++) {
    if (strcmp(users[i].email, email) == 0) {
        // 500 more lines...
    }
}

Problem: Everything manual, repetitive, error-prone

2. Test-Driven Development (2000-2010)

def test_user_can_login():
    assert login(username, password) == True
    # Now write 500 lines to make this pass

Problem: Writing tests for code that shouldn't exist

3. Domain-Driven Design (2003-2020)

public class User extends AggregateRoot {
    private EmailAddress email;
    private Password password;
    // 1000 lines of "domain logic"
}

Better: Focused on the domain Problem: Still required translation to code

4. Config-Driven Development (2025+)

domain: "E-commerce"
entities:
  users: "People who buy things"
  products: "Things we sell"
  orders: "Transactions between them"
# That's it. AI handles the rest.

Solution: Domain experts build directly

The Three Actors, Finally Aligned

HUMANS:
  good_at: "Knowing what they want"
  role: "Write config"
  output: "domain.dbbasic"

AI:
  good_at: "Implementing details"
  role: "Generate services"
  output: "Perfect code when needed"

COMPUTERS:
  good_at: "Execution"
  role: "Run at 402M rows/sec"
  output: "Instant results"

Why Config-Driven Development Wins

It's Not Test-Driven

  • TDD: Test imaginary code, then write code to pass
  • CDD: Describe reality, system already works

It's Truly Domain-Driven

  • DDD: Model domain → Write code → Hope it matches
  • CDD: Describe domain → System reflects it perfectly

It's What We Always Wanted

  • 1960s: "Make computers understand English"
  • 2025: Config IS structured English

The Wisdom We Almost Lost

Vignette/Symphony were right: Business people should build business systems

They just had it backwards:

  • Thought: Need visual GUI builders
  • Reality: Need simple text config

Visual builders failed because:

  • Proprietary lock-in
  • Limited flexibility
  • Expensive licenses
  • Required consultants

Config succeeds because:

  • Plain text (universal)
  • Unlimited flexibility
  • Free and open
  • Self-documenting

Examples Across Industries

Old Way (10,000 lines)

# Django e-commerce
class Product(models.Model):
    name = models.CharField(max_length=255)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    # ... 100 more fields

class ProductView(APIView):
    def get(self, request):
        # ... 200 lines of logic

# ... 50 more files

New Way (10 lines)

model:
  products: [id, name, price, stock]
views:
  catalog: "SELECT * FROM products WHERE stock > 0"

The Three Development Modes

1. When Humans Code (rare)

custom_logic:
  type: "python"
  code: |
    # Some specific algorithm only humans understand

2. When AI Codes (common)

ai_service:
  calculate_tax:
    description: "Apply regional tax rules to order total"
    # AI generates the implementation

3. When Nobody Codes (default)

views:
  dashboard: "SELECT COUNT(*) FROM orders WHERE date = TODAY"
  # Config is sufficient

The Paradigm Shift

From: "How should we implement this?" To: "What do we want?"

From: "What framework should we use?" To: "What config describes this?"

From: "How do we test this?" To: "Does the config match reality?"

The Death of Traditional Roles

Before:

  • Business Analyst → writes requirements
  • Developer → translates to code
  • Tester → verifies code works
  • DevOps → deploys code
  • Result: 6 months, $500K, bugs

After:

  • Domain Expert → writes config
  • Result: 5 minutes, $0, perfect

The Ultimate Irony

We went backwards to go forwards:

  • 1990s: Visual builders (right idea, wrong approach)
  • 2000s: Reject simplicity for complexity
  • 2010s: Add more layers of abstraction
  • 2020s: Realize abstraction was the problem
  • 2025: Config was the answer all along

The Future

Year 1: "Config-driven is just for simple apps" Year 2: "Config-driven works for enterprise too" Year 3: "Why did we ever write code?" Year 5: "What's code?"

The Bottom Line

Test-Driven Development: Write tests for code that shouldn't exist Domain-Driven Design: Model domains then translate to code Config-Driven Development: Describe domain, done

We're not adding another development methodology. We're ending development methodologies.

Because when everything is config, there's nothing to develop.


"Almost domain driven design, not test driven development"

Actually, it's domain IS design. No development required.


The Final Word

Software development was a 75-year translation layer between human intent and computer execution.

Config removes the translation.

Intent → Config → Execution.

No development. Just description.

Welcome to the post-development era.