I find it that when languages are considered the same as commercial software, there is always a constant need to add new features to justify new releases.

Can there be or are there languages where version 1.0 is the final version? Of course bug fixes are exempt from this, but the feature set always remains the same?

This way every feature in the language fits together nicely and not seem like they are bolted on after the fact with obsolete features still around because of backwards compatibility.

I assume some academic languages are like this? But are there commercially successful languages that follows this idea? The accompanying library is also free to get new features too, but the language always remains constant.

One example I can give is, one of my favourite languages C#, which I use pretty often, more and more features are being added every release. To take advantages of these, I have to drop actual tasks in hand, and spend considerable time learning these instead of being able to pick up trivial concepts and combine those myself to solve more complex problems with ease.

So I guess I am looking for a minimalist approach where everything is consistent, makes sense, and is as orthogonal as possible.

  • 8
    A field of work of most developers is to solve problems in an effective way. Effectiveness requires learning new things, constantly. New language features, new frameworks, new tools are developed to be more effective. By learning them, you're actually focusing on your work. Dec 26, 2012 at 14:20
  • 4
    Well not everyone who programs is necessarily a full-time programmer. It's just another tool for many other professions.
    – Joan Venge
    Dec 26, 2012 at 14:24
  • 5
    Then, again, nobody forces you to learn anything. If C# 1.0 solves your requirements, don't waste your time learning something you don't need. Dec 26, 2012 at 14:27
  • 11
    I think the question is legitimate: why should we apply the KISS and YAGNI principles to software artefacts but not to programming languages? When a language has enough core features, further development is (IMHO) mainly due to marketing (competition with other languages that forces companies to stuff languages with features to keep their customers).
    – Giorgio
    Dec 26, 2012 at 17:35
  • 2
    @MainMa: "Effectiveness requires learning new things, constantly.": A complex programming language, packed with too many feature can decrease effectiveness instead of increasing it. E.g. in a team it can lead to different developers using different subsets of the language, making code reviews, bug fixing, and maintenance less efficient.
    – Giorgio
    Dec 26, 2012 at 18:34

9 Answers 9


Lisp, Smalltalk. Coincidentally, those are also the best languages in the whole bunch.

Both Lisp and Smalltalk are languages which are built around strong unifying metaphor. Lisp's metaphor is "everything is a list; this list represents both data and code (as functions)". Smalltalk's metaphor is "everything is an object; the only way to invoke a behaviour is to pass a message to an object". These metaphors allows the languages to be stable, minimal and powerful. The rest is in the library.

Things that are called "control structures" in all non-minimal (I wanted to write "bloated") languages, are parts of the library here (as an example: cond function in lisp; ifTrue:/ifFalse: family of messages in Smalltalk both implement a conditional, where other languages have if keyword).

It can be seen that Lisp / Smalltalk are nearly minimal embodiments of their paradigm and nothing more (Lisp: functional programming; Smalltalk: object-oriented programming).

  • 4
    Good Lisp implementations can compete with C, good Smalltalk implementations can compete with C++. Heck, Oracle's HotSopt JVM, the fastest VM on the planet, is a Smalltalk VM, it doesn't even use static type information for its optimizations. Dec 26, 2012 at 14:08
  • 1
    @JoanVenge: stackoverflow.com/questions/1007250/…
    – herby
    Dec 26, 2012 at 14:29
  • 9
    This answer is too small to be constructive. Lacks detail or supporting evidence. Dec 26, 2012 at 17:04
  • 2
    -1 Lisp? LISP? Seriously? After the LISP Wars of the 1970s, the repeated attempts a LISP Unity, and finally Common Lisp? No, even LISP didn't make it to "done" at 1.0. Dec 26, 2012 at 22:19
  • 1
    I think you pointed out a very important idea: that a language should be built around one (or a few) strong, unifying metaphor(s), i.e. a programming language should offer you a way to organize your thoughts. I think the complexity of some languages is partially due to the lack of such a metaphor: these languages keep growing by incorporating new features because they do not have an underlying unifying view.
    – Giorgio
    Dec 26, 2012 at 22:19

TeX, the typesetting system, has been very stable since version 3.

Since version 3, TeX has used an idiosyncratic version numbering system, where updates have been indicated by adding an extra digit at the end of the decimal, so that the version number asymptotically approaches π. This is a reflection of the fact that TeX is now very stable, and only minor updates are anticipated. The current version of TeX is 3.1415926; it was last updated in March 2008. The design was frozen after version 3.0, and no new feature or fundamental change will be added, so all newer versions will contain only bug fixes. Even though Donald Knuth himself has suggested a few areas in which TeX could have been improved, he indicated that he firmly believes that having an unchanged system that will produce the same output now and in the future is more important than introducing new features. For this reason, he has stated that the "absolutely final change (to be made after my death)" will be to change the version number to π, at which point all remaining bugs will become features.

I won't claim that it fulfills your "So I guess I am looking for a minimalist approach where everything is consistent, makes sense, and is as orthogonal as possible." statement, but it meets most of your other criteria.


Others have already said Lisp so I must bring up Forth. It is very easy to implement and the rules of the language are simple to follow.

It is a stack-based language with a dictionary of "words." You can easily extend the language using some inherit features.

A VERY terse example of turtle graphics:

\ 8.8 fixed point sine table lookup
-2 var n F9F2 , E9DD , CEBD , AA95 , 7F67 , 4E34 , 1A c,
: s abs 3C mod dup 1D > if 3C swap - then dup E > if
  -1 1E rot - else 1 swap then n + c@ 1+ * ;

0 var x 0 var y 0 var a
0 var q 0 var w 
: c 9380 C80 0 fill ; \ clear screen
: k >r 50 + 8 << r> ! ;
: m dup q @ * x +! w @ * y +! ; \ move n-pixels (without drawing)
: g y k x k ; \ go to x,y coord
: h dup a ! dup s w ! 2D + s q ! ; \ heading
: f >r q @ x @ y @ w @ r 0 do >r r + >r over + \ forward n-pixels
  dup 8 >> r 8 >> plot r> r> loop o y ! x ! o r> o ;
: e key 0 vmode cls ; \ end
: b 1 vmode 1 pen c 0 0 g 0 h ; \ begin
: t a @ + h ; \ turn n-degrees

Then running it with : squiral -50 50 g 20 0 do 100 f 21 t loop ; gives you:


Credit to this Microsoft employee's blog.

  • 1
    How did this get upvoted again? Forth might be a good candidate, but the example given isn't much better than executable line noise; a prime example of why PLT's obsession with terseness is counter to what professionals actually need.
    – Telastyn
    Dec 27, 2012 at 17:12
  • 4
    @Telastyn That wasn't his question. Dec 27, 2012 at 18:15

C and Fortran are languages that spring to mind. They are very stable and their syntax is easily contained in one's mind. Other than writing bad code yourself, there are very few suprises when using these languages. But I wouldn't hold them up as great languages for rapid application development.

I prefer the rapid advancement of languages with features that once I spend a little time on them, make my job considerably easier and the code less complex while maintaining expressiveness.

  • 1
    I agree with the minimalistic design of C. Even if the language was updated during the years, the basic design and programming model of the language is still recognizable (other languages undergo a revolution every 5 to 10 years). Of course, C is not a general-purpose language as it used to be, because it has been replaced by other languages in specific application domains (desktop applications, web applications, and so on).
    – Giorgio
    Dec 26, 2012 at 18:42
  • @Giorgio: Not all. The minimal ones (like ones I mentioned) don't. There was no change in Smalltalk syntax since its inception except one, brought in by Squeak: the curly-braced computed arrays. Library is also very stable at the core (Behavior and Collection hierarchies). It seems to me that C is lot less stable with all those C89, C99 and whatnot.
    – herby
    Dec 26, 2012 at 21:16
  • 1
    @herby: You are probably right that other languages like Smalltalk are more stable than C. Yet, the basic programming model of C is the same as it was, say, 20 years ago. Other languages have undergone deep changes. So, again, I do not claim that C is the most stable language around, yet, IMO it is much more stable than many other mainstream languages.
    – Giorgio
    Dec 26, 2012 at 21:24

Although Lisp was mentioned, The most minimalistic language I know is scheme. I had a hard time understanding it in university courses where I had to. But it changed my way of thinking about programming, and It is very minimal. As minimal as its whole syntax are Parentheses () and spaces.

The only change in the language was the decision to convert the primitives like +, define (and some others) to built-ins. Meaning they are available on launch, but can be re-defined during run-time.


I think Python's a reasonable candidate for a language with minimalism as one of its design goals. It's based around a relatively small number of core concepts, and version 3 attempted to, amongst other things, simplify the language a bit by removing some features.

(Granted, that's not the same as a feature set that stayed the same from version 1, but I think that's a fairly arbitrary way to evaluate languages, given that language authors can call it version 1 whenever they want.)

  • Dec 2012 answer date gives you a free pass, because since then we have the monstrosity known as Python 3, which rivals C++ in wanting to add a garbage pile of cruft, while actually removing simplicity. It's now one of the most extraneous addon-infested languages in computing. May 6, 2019 at 15:19

Tcl, which was design to be minimalist in the first place

From there about page http://www.tcl.tk/about/features.html, one of the features is that it is very easy to learn and where casual programmers or even non programmers can use it.

  • 3
    This sounds accurate to me, but single line answers with no supporting information or details are too low quality to be helpful to anyone. Please add some good detail (and not just a link with no summary of it) and you'll get an up vote from me Dec 26, 2012 at 17:04
  • ok, will do though due to the question being closed don't know how much effort its worth
    – Egryan
    Dec 26, 2012 at 17:22
  • 1
    With luck it will be re-opened from votes. It's a good question. I might post on Meta to try and get it re-opened if it's not re-opened soon by the community. Dec 26, 2012 at 17:40
  • I agree and I plan to add more to the post once I get off work, I am not having any quick luck with finding the relevant links
    – Egryan
    Dec 26, 2012 at 17:43
  • Search google for "A Case Study on TCL Language", "Tcl: An embeddable Command Language" and tcl.tk/about/history.html - they give some key points. However, I'm not sure they back up the OP's desire - it appears that TCL has been extended from its original 1.0 (see wiki.tcl.tk/1721 )
    – user40980
    Dec 26, 2012 at 17:55

There are few languages that have remained relatively unchanged since their inception outside of the esoteric one off languages which are unlikely to be what is desired (I would hate to try to write something meaningful in Befunge (though it has also been modified since its original 1.0 release)).

The languages that are most likely to fill the desire of not having to learn anything new are languages that specialize in 'glue' between other programs. Languages such as jcl, bash, and the like. Simple scripting languages may also fall into this - awk being one of the leaders.

Once one leaves this realm, development happens. Either the language or the frameworks. In some situations it is 'difficult' to code for the language without getting some of some framework that is reving quickly.

Many languages have some degree of backwards compatibility. One can still write Java 1.4 today, though it probably isn't recommended - the frameworks people write for it are changing faster than the language. One can still find f77 and f90 compilers out there for a language spec that hasn't changed in 20 or 40 years. C, Objective C, C++ can still be coded to older specifications of the language - one doesn’t need to keep updating one's code because a new spec was released or a new framework is out there.

Some languages have a rather long unchanged history because the language itself is sufficiently powerful to do whatever one wants it to. Lisp is the prime candidate in this area. Forth also falls into the "it hasn't changed much" realm.

Going to more traditional scripting languages look at TCL, Perl and Python. Avoid things that are currently in the 'fad' realm that are experiencing a burst of popularity for some reason or another (ruby and javascript, I'm looking at you). TCL has changed over the years, though one of its goals is to try to maintain a consistency of design. Modern Perl and Python both have some consistency of design, though admittedly new features can feel bolted on (though one doesn't need to use them).


I think "minimalist" design approach would be exemplified by Tcl. As an example, you can use the {catch} command with {return -code n} values to implement any control structure your imagination can conceive, Perl had to wait a decade to (officially) get {switch} -- (not that Perl ever needed it). Also you will see that Dodekalogue http://wiki.tcl.tk/10259 covers the grammar of Tcl completely -- the rest, whatever programming paradigm you want to work with, can be expressed in this grammar.

  • this merely repeats point made and explained in an answer posted two years ago
    – gnat
    May 21, 2014 at 9:30
  • Referring to the original post I guess I can only say orthogonality = history (the family of C languages) and recent cross-language assimilation; I have seen across the OS langs an approach among all languages to generalized MVC web frameworks, coroutines, &c. Outside of that trend I can note the remarkable addition of closures to C11 and the upcoming Java lambda (which both mirror development in the OS "scripting" langs).
    – user132043
    May 21, 2014 at 10:20

Not the answer you're looking for? Browse other questions tagged or ask your own question.