# Future Number of Programming Languages — Singularity or Infinity?

- Canonical URL: https://amund.blog/archive-future-programming-languages-singularity-or-infinity/
- Author: Amund Tveit (https://amund.blog/about/)
- Published: 2008-01-13
- Tags: Programming, Compilers, History
- Original Source: amundblog.blogspot.com (https://amundblog.blogspot.com/2008/01/future-number-of-programming-languages.html)

---

The development of programming language technology moves at a relatively moderate pace, and it seems like every new programming language tries to become *the* singular language used to solve all problems. I believe that is the wrong approach, because it makes languages big, complex, and hard to learn — complexity that shows up directly in code readability and maintainability. According to [Bruce Eckel](http://www.artima.com/weblogs/viewpost.jsp?thread=221903) and [Neal Gafter](http://gafter.blogspot.com/2008/01/is-java-dying.html), Java appears to be approaching some of those pain points.

## Domain-Specific Languages (DSLs)

I believe a better approach is creating small, highly [domain-specific programming languages](http://www.pragprog.com/titles/tpantlr/index.html) that can be mastered in a few minutes and function as specialized *tools*.

If you have ever renovated a house, you know the thrill of finding the exact specialized tool for a job: it may not always be faster than a general-purpose tool, but surprisingly often it is — frequently by orders of magnitude in user time.

There is potential for similar efficiency gains by increasingly adopting domain-specific programming languages. The usual alternatives are adding features to already large and complex languages (not viable) or piling on libraries in a large language — which works up to a point, yet rarely feels as syntactically expressive and pleasant as a purpose-built DSL.

## Domain-Specific Languages — Where and How?

Functional programming has enjoyed a revival — Google's MapReduce for large-scale parallel computing, Python and Ruby adopting Lisp-like features, and languages such as Haskell and Erlang. Future DSLs will likely borrow from functional programming, and probably even more from [declarative programming](http://en.wikipedia.org/wiki/Declarative_programming) (such as Gödel or inductive logic programming systems like Aleph).

A classic sign that a DSL fits is when you have to write hundreds of lines of boilerplate code to get something done that can be described in a single sentence. Boilerplate code is about as useful as heat from a *light* bulb, or [noise produced by a computer](https://amundblog.blogspot.com/2008/01/delicious-absent-of-computer-noise.html).

Because syntax matters, the syntax of most DSLs should resemble Python — which leads the expressivity axis (compressed source size) of the Computer Language Shootout. Representing types in Python-like syntax is a consideration, though unlikely to be a major obstacle for tight, declarative DSLs.

*How should all these domain-specific and general languages communicate?* Mainly through some kind of network or RPC interface. It is tempting to embed DSLs inside a host "carrier" (like Jython combining Python with Java access), though clean process/RPC boundaries may scale better. For runtimes, they should support both interpretation and JIT compilation on common VMs (such as the JVM), alongside stronger parser and compiler tooling (like ANTLR) to lower the cost of building DSLs rapidly.

So I believe the number of programming languages is likely to diverge from singularity.
