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).

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.

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.

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.)

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.

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.