The Death and Resurrection of the Two-Language Problem

A "Julia" for LLMs

Photo by Vincent van Zalinge on Unsplash

Once upon a time, there was a “Two-Language Problem” (which led to the creation of Julia; see the old texts). The problem was that while most analysis took place in high-level languages like Python or R, both were too slow, so most of the core logic of the various mathematical and statistical packages is not actually written in either language. It’s written in C (or in Fortran for many R packages).

One of the main selling points of Julia was that it avoided needing two languages by using a compiler with multiple dispatch to mimic a lot of the niceties of a dynamically-typed, flexible language while still being performant because it could act more like a compiled, statically-type language (each function is compiled once types are known, so the code generated knows the data type).

I like Julia because multiple dispatch and the language's more functional nature fit mathematics and statistics well. I was never bothered by using two languages in a project. It’s actually kind of a nice experience to write the parts of an analysis that need to be performant in Fortran, and handle the data cleaning, etc., in R.

But I admit to liking C and Fortran because they were the first two languages I learned to program in. So, I’m biased.

And yet… like when Nixon said “We’re all Keynesians now”, we’re all two-language people now. The dream of one language has been deferred. The new dual-language world is Natural Language and X, where X is one of those old programming languages that requires you to think logically and carefully about what you’re doing (lame).

Before, the distinction was between a language where you needed to think in bytes and data types and a language where you could be a little more loosey-goosey about such things. Now, the distinction is between a language where you need to think in syntax and semantics and structure, and a language where you don’t.

We won’t be able to ditch structured language entirely. Natural language is a lossy representation of computing, just as the flexible scripting languages before it were. But it loses precision that can’t be recovered by spending performance.

The lossyness of Python and Ruby hurt performance. The lossyness of Natural Language hits business logic.

I predict a language will emerge that solves the modern two-language “problem”. It’ll be a more structured version of Natural Language that adds back some information, while still partially keeping the loosey-goosey feel of “build Spotify, make no mistakes.”

What I have in mind. Imagine you’re building a web app purely with AI today. You’re going to type lots of prompts to fix various things as you debug the app, but that doesn’t really scale for an app of any real complexity. Natural Language isn’t precise enough. In most cases, it’s quicker and better to just fix the code directly once the project is closer to being done.

But let’s say you defined things a little more precisely, then maybe you could keep it in Natural Language longer, i.e., in some kind of MVC-ish language:

• My app has a Model for users. They have passwords and emails and have to log in. Users can’t access other users’ stuff unless it’s been shared with them.

  • We need endpoints for users to sign-up, log-in, log-out,…

• My app has a Model for books. Users can write books or upload them as .epubs and share them with each other. There is an in-app reader for books.

  • We need endpoints for …

• Etc

So, I’m specifying the Model and a bit about the Controller components of MVC, and letting the LLM fill in what the views and controllers look like.

This scaffolding holds a lot more information than “clone Kindle.” I can add a model for pages read and mention that I want to bill by that metric rather than fixed prices, and I think the LLMs would do a decent job.

But this doesn’t really approach a maintainable language. I think we’ll get there. Someone will come up with a language that uses this newfangled LLM thing to both keep the expressiveness of Natural Language and recover some of the precision of structured language.

Or at least that’s where I hope it goes, because I doubt the old structured languages will ever gain market share.

(Alternatively, we’ll drown in endless AI slop, where nothing is built to last, and the past severs from the future, so that we exist in a never-ending present, neither returning nor progressing, until our souls, which yearn to plant some small monument, vanish into the void…)

I bet the language will look kind of like YAML, if I had to guess.

---

Thanks for reading!

Zach

Connect at: https://linkedin.com/in/zlflynn