williamcotton

Article Title: Ed tech is profitable. It is also mostly useless

https://www.economist.com/united-states/2026/01/22/ed-tech-i...

So we're getting Rickrolled?

I agree. What is missing from the discussion about DSLs are the importance of tooling such as linters, LSPs, etc, to give the LLMs further context.

For example, charts/plots are often stringly typed with regards to column names and a DSL specific to plotting could give immediate feedback to an LLM.

https://williamcotton.github.io/datafarm-studio/

https://williamcotton.github.io/algraf

https://williamcotton.github.io/pdl

https://github.com/williamcotton/algraf

https://github.com/williamcotton/pdl

Check out the /docs dir in the repos for each plan file and the language specs.

They are my 4th and 5th DSLs and I learned quite a bit along the way, most importantly how to separate a WASM runtime wired up to a Monaco editor “lsp” with the same crate for editor-services that works with the actual system binary LSP.

Why? Trial and error is a pretty important component of creativity.

I’ve had good luck with this approach:

https://github.com/williamcotton/algraf/tree/main/docs

There’s also some tests in place to make sure some things from the master spec are up to date, eg, error codes.

Funny enough, I just published this blog post yesterday:

The Discoverable Evidence of AI-Assisted Software Porting

https://williamcotton.com/articles/the-discoverable-evidence...

The plotting aspect of this seems very similar to:

https://opensource.posit.co/blog/2026-04-20_ggsql_alpha_rele...

A big part of the motivation was that something like this...

  $ which ggplot
  ggplot () {
          if [[ "$1" == "-f" ]]
          then
                  shift
                  rush run --library tidyverse "$(cat "$1")" -
          else
                  rush run --library tidyverse "$@" -
          fi
  }

  $ echo "one,two,three\n1,2,3\n4,5,6\n,7,8,9" | ggplot 'ggplot(df, aes(one, two)) + geom_col() + theme_minimal()' | imgcat

BTW, that "R on the command line" tool was inspired by:

https://datascienceatthecommandline.com

I really like to build things that build other things!

I've always liked the ggplot2 and the Grammar of Graphics approach to plotting so much so that I wrote my own DSL based on it - it is standalone, written in Rust, has WASM bindings (as you can see on the website) and more:

https://williamcotton.github.io/algraf

It pairs well with a related data translation DSL:

https://williamcotton.github.io/pdl

And you can see the two working together here:

https://williamcotton.github.io/datafarm-studio

There's LSPs for both, LSP clients for VS Code, and even language diagnostics for standalone Monaco editors in the browser.

Of note is that the same language diagnostics are exposed via the WASM as via the LSP interface allowing for the same friendly red squiggles to look and work the same in both your browser with Monaco and your editor with the LSP!

In the last few weeks I've been working on a couple of custom data transformation and chart visualization DSLs that pair well together, as you can see here:

https://williamcotton.github.io/datafarm-studio/

One of the DSLs is:

https://williamcotton.github.io/pdl/

The other is:

https://williamcotton.github.io/algraf/

Full LSP that is built into the binaries and compile to CLI and WASM. Full LSP support in the Monaco text editor npm packages that use the same static analysis crate as the VS Code LSP client.

Native GIS with GeoJSON and Shapefile support for both languages.

So really, if you want to do something you'd normally use a DSL for, you should be talking to your AI, and telling the AI to encode it into computer-speak. Binary files, libraries, programs, composeable piped applications. The AI can take what you think and turn it into a regular old computer program, just as easy as you would write a DSL. But you don't need a DSL to do this; the AI can already program.

I use LLMs to write DSLs that I write all the time! What else is an LLM doing when it is stringing together a bash pipeline than coordinating a number of DSLs? jq is what, 15 years old? I see LLMs using it all the time. Who knows, maybe there are a few more tools that have yet to be made that will further bridge the expressivity gap between human language and computers.

Legibility has a time and place, for example, global health data around pandemics.

Well what if you take on an extremely ambitious project like writing a programming language complete with DAP step debugging, a full LSP, etc, etc?

That takes a lot of quality time to just figure out the right syntax and semantics, let alone having to figure out how all of these complex pieces fit together!

However, the process was far more important than the product (again!). Not every whimsy needs to become a reality.

I mean, I get it, there's different kinds of people out there with different motivations, goals, spare time, etc.

But there's also a process of product design that I think the author is overlooking.

Lately I've been working and iterating on a number of DSLs, projects that might be a total waste of my time because they end up being poorly conceived or not very useful compared to a general purpose language!

I'm also working on a video game that is basically Magic: The Gathering meets StarCraft with Civilization style hex-grid conflict. It could be a total bust and entirely no fun to play (it's hard to tell if it's fun by itself because I enjoy working on the game while testing out the play patterns). It would suck to spend a couple of years on this if it's no good.

I very much enjoy the process of trying to figure out the best syntax and semantics for a new DSL or the process of iterating on gameplay elements when working on a game. The destination is also less important. I don't really expect anyone to use my DSLs or play my video games. I'm ultimately doing it for my own enjoyment.

Saying this, I am interested in the overall architecture and I've definitely learned from my mistakes, especially with creating DSLs. Like, having a TypeScript language server with a Rust runtime has some issues. It's kind of better to build the language server into the runtime so you're not maintaining multiple parsers, and depending on the language features, an additional pseudo-runtime in the language server.

It all makes a strong case for universal grammar, IMO.

What about through the lens of the Norvig-Chomsky debate?

One-shot converted my game from a 2D board to a 3D board along with all entities and animations. Sold!

https://github.com/williamcotton/space-trader/commit/0859c65...

Space Trader!

Imagine mixing Magic: The Gathering, StarCraft and Civilization’s hex grid combat.

There’s multiplayer but I haven’t put the server anywhere yet.

Check out the introduction here:

https://github.com/williamcotton/space-trader/blob/main/docs...

Clone the repo:

  npm install
  npm run dev

So what's the legal issue here?

How does the chardet achieve this? Explain in detail, with shortened code excerpts from the library itself if helpful to the explanation.

The prompt is explicitly requesting the source!

"Just a few weeks ago a SOTA model was shown to reproduce non-trivial amounts of licensed code[0]."

That LLM response is describing a specific project with full attribution.

What about trade secrets, breach of contract, etc, etc?

Undo:

  Ctrl + _ (Ctrl + underscore)

I agree 100%. Boring old software skills are part of what it took to "write" this DSL, complete with a fully featured LSP:

https://github.com/williamcotton/webpipe

https://github.com/williamcotton/webpipe-lsp

(lots of animated GIFs to show off the LSP and debugger!)

While I barely typed any of this myself I sure as heck read most of the generated code. But not all of it!

Of course you have to consider my blog to be "in production":

https://github.com/williamcotton/williamcotton.com/blob/main...

The reason I'm mentioning this project is because the article questions where all the AI apps are. Take a look at the git history of these projects and question if this would have been possible to accomplish in such a relatively short timeframe! Or maybe it's totally doable? I'm not sure. I knew nothing about quite a bit of the subsystems, eg, the Debug Adapter Protocol, before their implementation.

Undo (typing):

  Ctrl + _ (Ctrl + underscore)

Lines of code are meaningful when taken in aggregate and useless as a metric for an individual’s contributions.

COCOMO, which considers lines of code, is generally accepted as being accurate (enough) at estimating the value of a software system, at least as far as how courts (in the US) are concerned.

https://en.wikipedia.org/wiki/COCOMO

That’s not how we started down this path. See snark-free sibling comment from padjo.

”The current market share of custom-built homes is approximately 19% of total single-family starts”

https://www.nahb.org/blog/2025/08/custom-home-building-grows...

  Browser -> your server route -> server calls API -> server renders HTML -> htmx swaps it?

Sure it has. See the modernism as a whole.