DEV Community

Cover image for I built Kobol — because code is read far more often than it is written
V G P
V G P

Posted on • Originally published at kobol-lang.org

I built Kobol — because code is read far more often than it is written

#cobol #jvm #programming #opensource

A maintenance window at 2 a.m.

A few years ago I spent a night staring at a function I had written myself, maybe eight months earlier. It was clever. It was dense. It chained four higher-order calls across two lines and folded a reducer into a ternary inside a map. When I wrote it, I felt smart. At 2 a.m., trying to fix a rounding bug in it, I felt nothing of the sort.

I rewrote it the next morning as a boring, plain loop with names that said what they meant. The bug was obvious once the code stopped showing off. It took me longer to type. It took everyone after me far less time to understand.

That night stuck with me. We spend a tiny fraction of a program's life writing it, and almost all of the rest reading it: debugging, reviewing, onboarding, patching it at 2 a.m. years later. And yet so much of our tooling optimizes for the act of writing: fewer keystrokes, denser expressions, cleverer symbols. We optimize the cheap part and pay for it in the expensive part.

Today I'm releasing Kobol, a small, opinionated language that takes the opposite bet.

Kobol (with a K) is inspired by COBOL. It is not COBOL. The Kobol language is new and independent, with its own syntax, compiler, and runtime. It isn't a COBOL dialect, isn't source-compatible with COBOL, and isn't affiliated with or endorsed by any COBOL vendor or standards body.

Going back to a very old, very good idea

Here's the question that started it: why do we write programs in syntax that doesn't read like the language we think in?

We had an answer to that once. In 1959, a committee called CODASYL set out to build a programming language that ordinary people, not just specialists, could read. The result was COBOL, and the people behind it were serious computer scientists with a genuinely radical goal for the time: make programs readable. Grace Hopper's earlier work on FLOW-MATIC had already argued that English-like commands were not a gimmick but a feature, and that idea carried straight into COBOL's design. Jean Sammet and the rest of the committee built a language where a statement like ADD 1 TO total meant exactly what it said, to a programmer and to the accountant reading over their shoulder.

I want to be clear about something, because the internet loves to dunk on COBOL: those people were right about the important part. The systems they designed have run the world's payrolls, banks, and government benefits for over sixty years. Sixty years. Most of our frameworks don't survive sixty months. That is not an accident of inertia. It's a consequence of a design that prioritized clarity and stability over cleverness. When the original designers talked about the future, they talked about programs that would outlive their authors and still be legible to whoever inherited them. They were thinking about my 2 a.m.

What they couldn't have planned for was the world the language got chained to: the mainframe, fixed-column punch-card layouts, divisions and paragraphs and ceremony that made sense in 1959 and make a 25-year-old developer bounce off the language today. The good idea got buried under the era it was born in.

So I took the idea, and left the era behind

Kobol keeps what was good — English-like, readable, says-what-it-means syntax — and drops everything that tied it to a specific decade of hardware.

Here's a complete Kobol program:

NOTE:
  Hello World in Kobol — the simplest possible program.
  Block comments read like English: NOTE: ... END-NOTE.
END-NOTE

PROGRAM HelloWorld
  VERSION "1.0"

DATA:
  greeting : TEXT = "Hello, World!"

PROCEDURE Main:
  DISPLAY greeting
  DISPLAY "Welcome to Kobol — a modern COBOL-inspired language."
  STOP RUN
END-PROCEDURE
Enter fullscreen mode Exit fullscreen mode

You can read that out loud and a non-programmer would mostly follow it. That's the whole point.

But readable doesn't have to mean toy. Here's real business logic — invoice processing with money, conditions, and error handling:

PROCEDURE ProcessOneInvoice:
  ADD 1                        TO summary.total-count
  ADD current-invoice.amount   TO summary.total-amount

  IF current-invoice.Paid:
    ADD 1 TO summary.paid-count

  ELSE IF current-invoice.Overdue:
    ADD 1 TO summary.overdue-count
    PERFORM CalculateLateFee
    ADD adjusted-amount TO summary.total-outstanding

  ELSE:
    ADD 1 TO summary.pending-count
    ADD current-invoice.amount TO summary.total-outstanding
  END-IF
END-PROCEDURE
Enter fullscreen mode Exit fullscreen mode

Notice current-invoice.Paid and .Overdue. Those aren't magic. They're named conditions declared on the record itself:

RECORD Invoice:
  invoice-id    : INTEGER
  customer-name : TEXT(100)
  amount        : MONEY(12.2)
  due-date      : DATE
  paid          : BOOLEAN
  status-code   : TEXT(1)
    CONDITION Pending WHEN status-code = "P"
    CONDITION Paid    WHEN status-code = "X"
    CONDITION Overdue WHEN status-code = "O"
Enter fullscreen mode Exit fullscreen mode

The business rule lives next to the data it describes, in words. Six months from now, nobody has to decode what status-code = "X" means scattered across the codebase. It says Paid right where you read it.

The parts that are firmly in this century

This is where Kobol stops being a nostalgia trip:

  • It runs on the JVM. No mainframe required. Kobol compiles to JVM bytecode. It runs on your laptop, in a container, in CI, on whatever boring Linux box you already have. There is no special hardware, no emulator, no licensed runtime. If you can run Java, you can run Kobol.
  • Full Java interop. You can IMPORT and call Java directly, so the entire JVM ecosystem is available. You're not on an island. 
  IMPORT java.time.LocalDate
  IMPORT java.time.format.DateTimeFormatter AS DateFmt

  PROCEDURE Main:
    CALL LocalDate.now GIVING today
    CALL DateFmt.ISO_LOCAL_DATE.format USING today GIVING report-date-str
Enter fullscreen mode Exit fullscreen mode
  • Exact decimal money, built in. MONEY(12.2) is real fixed-point decimal, not a float you cross your fingers over. Finance code shouldn't have to fight the language to add two numbers correctly.
  • Modern data work. Filtering, sorting, and taking the top N reads like a sentence: 
  COMPUTE top5 = customer-list FILTER WHERE active SORT BY balance DESCENDING TAKE 5
Enter fullscreen mode Exit fullscreen mode
  • Concurrency without the ceremony, structured error handling with TRY / ON, records, lists, pipelines. The conveniences you'd expect from a language designed now.

Who I'm hoping finds this

Honestly? The next generation.

There's a strange situation in our industry: an enormous amount of critical software is written in a style most new developers have never been taught and have been quietly told to avoid. The people who maintain it are retiring. The work isn't going anywhere.

I'm not asking anyone to go learn 1959. I'm hoping a few curious people — students, early-career devs, anyone who's ever been burned by code they couldn't read — pick up Kobol, feel how natural readable code can be, and take that instinct with them everywhere, whatever language they write in next.

And if you're coming from COBOL: existing COBOL programs don't run on Kobol as-is. They have to be refitted and rewritten. I won't pretend otherwise. But because Kobol keeps the familiar English-like, readable shape, moving from COBOL to Kobol is a far gentler journey than porting a system into a syntax that looks nothing like what your team has read for decades. The mental model carries over; that's worth a lot on a migration.

A genuine thank-you

Credit where it belongs: Grace Hopper, Jean Sammet, and the CODASYL committee decided, in 1959, that code should be something humans can read. Kobol carries that idea forward into a world they'd recognize and a runtime they'd never have imagined. The foundational insight is theirs; building a modern language on top of it is the work I'm proud to have done.

Try it

Kobol is open source and out now. Pick whichever line matches your machine. They all leave you with a working kobol command.

macOS (Apple Silicon) — Homebrew

brew tap kobol-lang/tap
brew install kobol
kobol --version
Enter fullscreen mode Exit fullscreen mode

Linux — native binary, no JVM needed

# pick your arch: linux-x86_64 or linux-aarch64
curl -fsSL https://github.com/kobol-lang/kobol/releases/latest/download/kobol-linux-x86_64.tar.gz | tar xz
sudo mv kobol /usr/local/bin/
kobol --version
Enter fullscreen mode Exit fullscreen mode

Windows — Chocolatey

choco install kobol
kobol --version
Enter fullscreen mode Exit fullscreen mode

Any machine with a JVM 21+ (Intel Macs included) — the fat JAR

# grab the latest kobolc-<version>.jar from the releases page:
#   https://github.com/kobol-lang/kobol/releases/latest
curl -fsSL -O https://github.com/kobol-lang/kobol/releases/download/v0.1.0/kobolc-0.1.0.jar
java -jar kobolc-0.1.0.jar --version
# handy alias:
alias kobol="java -jar $PWD/kobolc-0.1.0.jar"
Enter fullscreen mode Exit fullscreen mode

Docker

docker pull ghcr.io/kobol-lang/kobol:latest
docker run --rm ghcr.io/kobol-lang/kobol:latest --version
Enter fullscreen mode Exit fullscreen mode

The rest:

If you build something with it, or just have opinions, I'd love to hear them. Write code your future self can read at 2 a.m.

— the person who got tired of decoding their own cleverness

Top comments (0)