Column

Rethinking configuration for Human readability

Finding the Sweet Spot Between Human and Machine

Every software project faces the same fundamental challenge: configuration. Despite being a solved problem in theory, existing solutions force uncomfortable tradeoffs. JSON is machine-friendly but human-hostile. YAML is powerful but error-prone. INI files are simple but limited.

Column emerged from a recognition that the seemingly mundane problem of configuration represents a significant friction point in software development and deployment. I saw an opportunity to create a language that balanced human readability with machine parseability—finding the elusive middle ground between simplicity and expressiveness.

The Challenge

Creating a new configuration language required navigating several interconnected challenges:

  • Cognitive Overhead – Existing languages either required too much mental mapping (JSON’s excessive syntax) or created too much ambiguity (YAML’s whitespace rules)
  • Technical Requirements – The language needed to support modern needs like environment variables, namespaces, and different deployment environments
  • Learning Curve – Configuration should feel intuitive to both developers and non-technical stakeholders
  • Adoption Barriers – Any new language needs clear advantages to overcome the inertia of established alternatives

The central question became: How might we create a configuration language that feels natural to write, maintains rigorous structure, and addresses the practical needs of modern software development?

The Approach

I approached Column’s design with the methodical rigor of a systems architect:

1. Structural Foundation

First, I established the core structural principles:

  • Two-space indentation for hierarchy
  • Simple key-value syntax for basic properties
  • Clear rules for handling whitespace and special characters
  • Automatic normalization of inconsistent formatting

This created an immediate visual clarity while preventing the common whitespace errors that plague YAML.

2. Type System

Rather than relying on error-prone type inference, I designed:

  • Intuitive defaults for common types (strings, numbers, booleans)
  • Optional type annotations for explicit type checking
  • Clear multiline string handling with purpose-specific variants
  • First-class support for lists and nested objects

The type system balanced implicit simplicity with explicit power—allowing both quick configurations and rigorous type safety.

3. Environmental Awareness

Modern applications run across multiple environments, so I incorporated:

  • Built-in environment variable substitution
  • Environment-specific configuration files
  • Default value fallbacks
  • Clear resolution rules for conflicts

This environmental awareness addressed real-world deployment needs without complicating the basic syntax.

4. Organizational Features

To support complex applications, I designed:

  • Namespaces for splitting configuration across files
  • Sections for multiple configurations within single files
  • Clear resolution rules when merging configurations
  • Standardized error reporting for troubleshooting

These features enabled Column to scale from simple projects to complex systems while maintaining its readability.

The Solution

Column emerged as a comprehensive configuration language with several distinctive features:

Intuitive Syntax

The language used familiar patterns while avoiding common pitfalls:

# Basic structure
server:
  host: api.example.com
  port: 8080
  timeout: 30s

# Lists with simple syntax
allowed_origins:
  - https://example.com
  - https://admin.example.com

Rich Type Support

Column supported diverse data needs without complexity:

# Automatic type inference
user_count: 42
is_active: true
api_key: $_API_KEY || default_key

# Optional type annotations
created_at: {DATE} 2023-05-20
request_timeout: {DURATION} 30s

Multiline Handling

Different multiline formats addressed specific use cases:

# Preserved formatting for code
sql_query: |
  SELECT *
  FROM users
  WHERE active = true

# Folded text for paragraphs
description: <
  This product helps developers
  create configuration files
  with minimal friction.

Practical Extensibility

Column scaled through namespaces and sections:

# Namespace declaration
@- database
connection_string: $_DB_URL
pool_size: 10

# Section declaration
@/ development
debug: true
log_level: verbose

@/ production
debug: false
log_level: error

What made Column special isn’t any single feature, but the thoughtful balance between simplicity and capability—making the common cases easy while keeping complex cases possible.

Key Insights

This playground project reinforced several principles that inform my approach to entrepreneurial design:

  1. Find friction in the mundane – Innovation opportunities often hide in everyday problems that people have simply accepted

  2. Balance is a feature – The most valuable solutions often find the middle ground between competing concerns, rather than optimizing for one dimension

  3. System design requires empathy – Creating effective languages and interfaces requires deep understanding of both technical and human factors

  4. Details matter at scale – Small design decisions compound dramatically when systems are used thousands of times daily

Column demonstrates my ability to identify opportunities in overlooked spaces and create elegant solutions that balance technical rigor with human usability—a skill set essential for entrepreneurs building foundational technologies.