Applications &
Case Studies

SQL is arguably the most successful DSL ever created — and possibly the most underappreciated design achievement in computing history. It takes a fundamentally hard problem (querying an arbitrary relational database) and makes it expressible in sentences that non-programmers can learn in an afternoon.

-- Window functions: SQL at its most expressive
SELECT
  salesperson,
  region,
  quarterly_sales,
  RANK() OVER (
    PARTITION BY region
    ORDER BY quarterly_sales DESC
  ) AS regional_rank,
  quarterly_sales / SUM(quarterly_sales) OVER (
    PARTITION BY region
  ) AS share_of_region
FROM sales_data
WHERE quarter = 'Q4-2024';

CSS is a study in elegant domain specificity. Its domain is visual presentation — and within that domain, it does things that no general-purpose language can do as concisely. A single CSS declaration can restyle thousands of elements simultaneously. The cascade, specificity, and inheritance — often cited as CSS's difficulties — are actually highly sophisticated solutions to a genuinely hard problem: style inheritance in a tree.

/* Container Queries — a DSL gaining new expressiveness */
@container article (min-width: 600px) {
  .byline {
    display: flex;
    gap: 1rem;
    align-items: center;
  }
  .byline-avatar {
    width: 48px;
    aspect-ratio: 1;
    border-radius: 50%;
  }
}

/* The cascade in action */
/* Specificity: 0-1-0 */
.card { color: navy; }
/* Specificity: 0-2-0 — wins */
.card.featured { color: crimson; }
/* Specificity: 1-0-0 — always wins */
#hero { color: goldenrod; }

Regular expressions are among the most compact DSLs ever devised — a pattern like ^\+?[1-9]\d{1,14}$ expresses an entire specification (E.164 phone number format) in twenty characters. They descend directly from Stephen Kleene's 1951 mathematical notion of regular sets, formalised into the regex syntax we know through Ken Thompson's 1968 implementation in ed. They are perhaps the purest example of a DSL rooted in formal language theory.

# Named groups — regex as structured extraction
import re

pattern = re.compile(r"""
  (?P<year>\d{4})    # 4-digit year
  [-/]
  (?P<month>\d{1,2}) # 1–2 digit month
  [-/]
  (?P<day>\d{1,2})   # 1–2 digit day
""", re.VERBOSE)

m = pattern.search("Delivery: 2024-03-15")
print(m.group('year'))   # '2024'
print(m.group('month'))  # '03'

LaTeX is the DSL that conquered academic science. The domain is scientific document preparation — and within that domain, it achieves something no GUI word processor ever has: mathematically perfect typesetting. A physicist can write \hat{H}\psi = E\psi and get the Schrödinger equation rendered with typographic precision impossible in Word. Over 60% of all academic papers in mathematics, physics, and computer science are written in LaTeX.

% Maxwell's Equations — expressed in LaTeX
\begin{align}
  \nabla \cdot \vec{E}  &= \frac{\rho}{\varepsilon_0} \\
  \nabla \cdot \vec{B}  &= 0 \\
  \nabla \times \vec{E} &= -\frac{\partial\vec{B}}{\partial t} \\
  \nabla \times \vec{B} &= \mu_0\!\left(\vec{J}
    + \varepsilon_0\frac{\partial\vec{E}}{\partial t}\right)
\end{align}

Terraform's HCL is a masterclass in applying DSL thinking to infrastructure provisioning. Before Terraform, provisioning cloud resources meant imperative scripts — create this server, then configure this network, then attach this disk, handle the errors. HCL flips this: you declare the desired state, Terraform computes the diff against reality, and executes only what's needed. This mirrors SQL's declarative brilliance applied to a new domain.

# Terraform HCL — declare desired state, not steps
resource "aws_instance" "web" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = var.instance_type

  vpc_security_group_ids = [
    aws_security_group.allow_http.id
  ]

  tags = merge(local.common_tags, {
    Name = "web-${var.environment}"
  })

  lifecycle {
    create_before_destroy = true
  }
}

output "public_ip" {
  value       = aws_instance.web.public_ip
  description = "The public IP of the web server"
}

GraphQL solves a specific, painful domain problem: clients over-fetching or under-fetching data from REST APIs. Facebook engineers in 2012 were struggling to power the mobile News Feed efficiently — too many REST calls, too much wasted bandwidth. GraphQL lets clients describe the exact shape of data they need, and the server returns exactly that. Its schema is itself a DSL — the Schema Definition Language (SDL) — that both documents and enforces the API contract.

# GraphQL SDL — the schema DSL within the query DSL
type Article {
  id: ID!
  title: String!
  author: User!
  tags: [Tag!]!
  body: String!
  publishedAt: DateTime
  comments(limit: Int = 10): [Comment!]!
}

type Query {
  article(id: ID!): Article
  articles(
    filter: ArticleFilter
    orderBy: ArticleOrderBy
    first: Int
    after: String
  ): ArticleConnection!
}

# Client query mirrors the response shape exactly
query FeaturedArticle($id: ID!) {
  article(id: $id) {
    title
    author { name avatar { url } }
    tags { name slug }
    comments(limit: 3) { body author { name } }
  }
}

Gherkin (used by Cucumber, Behave, and SpecFlow) is a DSL designed for a uniquely social purpose: writing automated tests that non-technical stakeholders can read and verify. Its domain is behavioural specification. A product owner, a tester, and a developer can all meaningfully engage with a Gherkin specification — which makes it one of the few DSLs designed as much for human collaboration as for machine execution.

# Gherkin — tests that product owners can read
Feature: User Account Deposits

  Background:
    Given a user "alice@example.com" exists
    And their account balance is £0.00

  Scenario: Successful deposit
    When alice deposits £50.00
    Then her account balance should be £50.00
    And she should receive a confirmation email

  Scenario Outline: Deposit limits
    When alice attempts to deposit <amount>
    Then the result should be <outcome>

    Examples:
      | amount   | outcome  |
      | £10.00   | success  |
      | £0.00    | rejected |
      | £10001   | rejected |