History of
Domain Specific Languages

FORTRAN — The First Domain Specific Language formula translation

John Backus at IBM created FORTRAN (FORmula TRANslation) — widely considered the first high-level programming language and the first DSL. Its domain was scientific and mathematical computation. Engineers could write Y = A*X**2 + B*X + C instead of wrestling with machine instructions. IBM's management was sceptical — they expected the compiled code to be too slow. Backus bet his career on it. It was faster than hand-written assembly for most programs.

C     FORTRAN IV – Gaussian elimination (circa 1962)
      DO 10 I = 1, N
        DO 10 J = I+1, N
          RATIO = A(J,I)/A(I,I)
          DO 10 K = I, N+1
10          A(J,K) = A(J,K) - RATIO*A(I,K)

COBOL — The Business Domain data processing

Grace Hopper championed the idea that business data processing needed its own language — one readable by managers, not just mathematicians. COBOL's syntax reads like English prose: MOVE CUSTOMER-BALANCE TO INVOICE-AMOUNT. This was deliberate — Hopper believed self-documenting code was the future. Today, an estimated 95 billion lines of COBOL still run, processing an estimated $3 trillion in daily commerce through banking systems.

SIMSCRIPT — Simulation as a Domain discrete events

RAND Corporation developed SIMSCRIPT specifically for discrete-event simulation. It introduced entities, attributes, and sets — concepts that map directly onto simulation theory. This was a landmark: rather than shoehorning simulation concepts into a general language, a language was designed around those concepts. The legacy lives on in modern simulation frameworks.

SQL — The DSL That Conquered Data query language

IBM researchers Donald Chamberlin and Raymond Boyce created SEQUEL (later SQL) based on Edgar Codd's relational model. The insight was genius in its simplicity: describe what data you want, not how to retrieve it. The query optimiser handles the how. This declarative paradigm was radical — and it worked so well that SQL survived multiple "death" predictions to become the most widely used DSL in history, running on virtually every device on earth.

-- The iconic SELECT — describe the result, not the algorithm
SELECT customer_name, SUM(order_total) AS lifetime_value
FROM orders
JOIN customers USING (customer_id)
WHERE order_date >= '2020-01-01'
GROUP BY customer_name
HAVING lifetime_value > 10000
ORDER BY lifetime_value DESC;

Make — The Build Domain build automation

Stuart Feldman at Bell Labs wrote Make over a weekend after a colleague's bug was caused by forgetting to recompile a modified file. The Makefile syntax — targets, dependencies, recipes — is a simple DSL for expressing build graphs. Feldman later won the ACM Software System Award for Make. Its core idea — dependency-driven execution — remains the basis of every modern build system from Bazel to Gradle.

AWK — Text Processing as a Domain data munging

Aho, Weinberger, and Kernighan created AWK as a specialised language for scanning and processing text files. Its design philosophy was radical compression of common operations: a field separator, pattern–action pairs, and implicit iteration over records. A one-liner AWK script could replace fifty lines of C. It defined a generation of Unix-philosophy DSLs: sed, grep, and eventually Perl.

# Sum the third column of a CSV in AWK
awk -F',' '{ sum += $3 } END { print "Total:", sum }' data.csv

TeX & LaTeX — Mathematical Typesetting typesetting

Donald Knuth, dissatisfied with the typesetting quality of his The Art of Computer Programming volumes, spent nine years building TeX — a complete typesetting language. Leslie Lamport later built LaTeX as a higher-level DSL on top of TeX. LaTeX became the universal language of academic publishing in mathematics, physics, and computer science — because no general-purpose tool could express \int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2} with the precision and beauty that LaTeX could.

HTML — Hypertext as Domain markup

Tim Berners-Lee proposed HTML as a way to describe the structure of hypertext documents — not their appearance, not their behaviour, just their semantic structure. This domain-specificity was intentional and crucial. The initial spec was a DSL for documents with links. The browser handles the rest. Every webpage on earth is authored in a DSL.

CSS — Separating Style from Structure styling

Håkon Wium Lie and Bert Bos proposed CSS to solve the "style chaos" of early HTML where <font> tags cluttered every document. CSS is a pure declaration language: you describe properties and selectors, and the browser's layout engine figures out the cascade, inheritance, and rendering. The selector grammar is itself a mini-DSL — a pattern language for matching document nodes.

/* CSS Selectors — a pattern-matching DSL within a styling DSL */
article.featured > h2:first-child + p::first-line {
  font-size: 1.25em;
  font-style: italic;
  color: oklch(42% 0.15 45);
}

XML & XPath — Data and Navigation data serialisation

XML established a universal DSL for structured data exchange; XPath provided a DSL for navigating XML trees; XSLT for transforming them. Together they formed an ecosystem of DSLs-on-DSLs. While XML's verbosity later fell out of fashion, the concept — a dedicated language for tree navigation — survived in CSS selectors, jQuery, and modern JSON path expressions.

The Internal DSL Renaissance — Ruby on Rails internal DSL

David Heinemeier Hansson's Rails framework demonstrated the power of internal DSLs: Ruby's flexible syntax allowed Rails to define a routing DSL, schema DSL, and validation DSL that read like prose. has_many :through, validates :email, uniqueness: true — these read like English declarations. Martin Fowler formalised the distinction between internal and external DSLs in his influential 2010 book, partly inspired by the Rails phenomenon.

# Rails routing — an internal DSL that reads like a specification
Rails.application.routes.draw do
  resources :articles do
    member { post :publish }
    collection { get :trending }
  end
  root to: 'home#index'
end

Terraform HCL — Infrastructure as Code infrastructure

HashiCorp created HCL (HashiCorp Configuration Language) as a declarative DSL for expressing cloud infrastructure. Rather than scripting provisioning steps, engineers describe the desired state and Terraform computes the diff. This declarative, idempotent approach mirrors SQL's "describe what, not how" philosophy — applied to infrastructure. HCL is now the de-facto standard for infrastructure-as-code.

GraphQL — Queryable APIs API query

Facebook open-sourced GraphQL as a DSL for describing exactly what data a client needs from an API. Unlike REST — which over-fetches or under-fetches — GraphQL queries mirror the shape of the desired response. It includes a type system, introspection, and fragments for composition. GraphQL is now used by GitHub, Shopify, Twitter, and thousands of other services.

# GraphQL — ask for exactly what you need, nothing more
query UserProfile($id: ID!) {
  user(id: $id) {
    name
    avatar { url width height }
    recentPosts(limit: 5) {
      title
      publishedAt
      tags { name }
    }
  }
}

LLM Prompt Engineering — An Emergent DSL? emerging

As large language models became production tools, the craft of prompting emerged as an informal DSL: chain-of-thought delimiters, few-shot examples, role assignments, and structured output specifiers. Tools like DSPy, LMQL, and Guidance formalise this further — letting developers write programs that interleave natural language and code to steer LLM behaviour. Whether prompt engineering becomes a formal DSL or remains a craft is one of the defining questions of the current decade.