28

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.

Joan Venge
  • 1,950
  • 2
  • 18
  • 24
  • 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. – Arseni Mourzenko Dec 26 '12 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 '12 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. – Arseni Mourzenko Dec 26 '12 at 14:27
  • This question is not about learning new features. – Joan Venge Dec 26 '12 at 14:32
  • Ask again when software engineering actually matures. Until then, things are going to evolve as we learn what works and what doesn't. – Telastyn Dec 26 '12 at 14:33
  • 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 '12 at 17:35
  • Commercially dominant? Seems like the utility belt languages fare better commercially, which in fairness helps fight against "technology soup" to some degree as they offer opportunities to reduce the total number of languages involved in a platform / enterprise. Having said that, I am really intrigued by the Io language (http://en.wikipedia.org/wiki/Io_(programming_language)); it would never fly in the sort of environments I generally work in as it isn't mainstream enough. – Ed Hastings Dec 26 '12 at 18:11
  • 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 '12 at 18:34
  • @giorgio - because KISS/YAGNI taken to the extreme, we'd all still be writing in Assembly. That is super simple and all we need after all. I'm hoping that people agree that assembly is *too* simple and we do need more than it alone. The question then comes where to draw the line. – Telastyn Dec 26 '12 at 21:20
  • @Telastyn: I was not suggesting taking KISS/YAGNI to the extreme (otherwise Assembly would be way too complex and lambda calculus would be enough), but simply using KISS/YAGNI instead of ignoring it. Each programming language starts with a basic set of concepts. Eventually, a language has become powerful enough and adding new features decreases productivity instead of increasing it. – Giorgio Dec 26 '12 at 21:38
  • Also just because a language has a small footprint doesn't mean it has to be low-level like assembly. For example having "var" in a staticly typed language doesn't increase its complexity IMO, yet still adds value. Or having reference types to be non-nullable by default or having built-in design by contact features. Basically any collection of ideas that are put together seamlessly, that once you "understand" it, it's very easy to create complex code quickly in a clear way. – Joan Venge Dec 26 '12 at 22:16
  • The correct answer is [Logo](http://en.wikipedia.org/wiki/Logo_%28programming_language%29). Thanks for playing. `HIDETURTLE` – dietbuddha Dec 27 '12 at 09:06
  • @MainMa Sadly if C# 1.0 is all you know, good luck at a .NET interview. That said, they really need to slow down on the addition of new stuff. It's impressive they've managed to cram them all in to the same language but I don't think they're doing developers any favors. Especially when you have to work with mediocre teams where everybody is learning/regurgitating by rote rather than only using what they need regardless of what they read in some blog somewhere. – Erik Reppen Jun 26 '13 at 17:14
  • If a language doesn't change features, but implementations add to the libraries they ship with, is it any different? If the standard library doesn't change, but necessary third party libraries change, is that any different? At a guess, few if any domains have discovered all the useful abstractions. – Caleth Sep 26 '22 at 09:50
  • Backwards compatibility: Apple has a long tradition for Objective C/C++ and Swift to supply tools that do a textual translation to make code compatible with new versions. New language versions are not backward compatible themselves. – gnasher729 Sep 26 '22 at 09:58

9 Answers9

33

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

Robert Harvey
  • 198,589
  • 55
  • 464
  • 673
herby
  • 2,734
  • 1
  • 18
  • 25
  • Thanks, I need to find more info about them. From what I know they are pretty old, right? I mean if these guys really came up with these unique ideas, why didn't it catch up mainstream? I guess performance? So having an amazing language with the reasonably good performance of C# for example would be very nice. – Joan Venge Dec 26 '12 at 14:03
  • 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. – Jörg W Mittag Dec 26 '12 at 14:08
  • "Worse is better" effect, and in case of Smalltalk also some marketing mistakes (it has its heyday in 80s but it was expensive so C took over). Performance was not the main issue (and is definitely not now, when compilers are much smarter, look up Self project if you want more details on this). But Lisp is THE functional language (and its descendant Haskell performs good), and Smalltalk is THE object-oriented language (Pharo is the contemporary professional dialect, and is free, with constantly developing VM). – herby Dec 26 '12 at 14:09
  • @JörgWMittag: Isn't V8 the fastest VM? ;-) Jokes aside, I knew that Hotspot was created from Stringtalk VM which took a lot from Self, but does it reaaly not use static type information (much like Strongtalk didn't)? I assumed it uses it once it specialized to Java. – herby Dec 26 '12 at 14:13
  • When I was reading wikipedia, it says: "Lisp has changed a great deal since its early days". So it wasn't 1.0 == final version? Like it didn't have all the answers from day 1? I was thinking of a language where everything is planned in great detail, such that there are no "holes" if that makes sense. – Joan Venge Dec 26 '12 at 14:14
  • @herby: V8 is also based on the Animorphic VM (the VM powering the Strongtalk system) and was written by the same people as the Self VM, the Animorphic VM and the HotSpot JVM. – Jörg W Mittag Dec 26 '12 at 14:20
  • @JoanVenge: I can't say for Lisp in detail, but both Liso and Smalltalk have very minimal syntax (because they are built around one big metaphor, either functional or message-passing objects). Thus, the languages in fact did not change, there was no point to. Libraries did, but everything including "control structures" is part of the library in these languages, so it is hard to separate. And as for "everything planned in great detail", I don't believe that can happen. BTW Ada is such "planned" language, it originated in army. – herby Dec 26 '12 at 14:20
  • Thanks gotcha. Which flavor of Lisp would be the most updated one to be used today? Still Lisp or Common Lisp, etc? – Joan Venge Dec 26 '12 at 14:26
  • 1
    @JoanVenge: http://stackoverflow.com/questions/1007250/which-dialect-of-lisp-should-i-learn – herby Dec 26 '12 at 14:29
  • 9
    This answer is too small to be constructive. Lacks detail or supporting evidence. – Jimmy Hoffa Dec 26 '12 at 17:04
  • @JimmyHoffa: There's a lot more in the comments. But I added an edit, if you think it is needed. – herby Dec 26 '12 at 20:50
  • Removed my downvote, now that it's a useful answer. But you're going to have to define "best" or remove that comment to get an upvote. That's far too subjective. – pdr Dec 26 '12 at 21:49
  • "Both Lisp and Smalltalk are languages, which are built around strong unifying metaphor. This allows the language be stable, minimal and powerful. The rest is in the library.": Very concise and precise explanation! +1 – Giorgio Dec 26 '12 at 22:01
  • If you have the Lisp `eval` function, [you have a functional Lisp interpreter](http://www-formal.stanford.edu/jmc/history/lisp/node3.html) - and I'm pretty sure you can get mugs with the entirety of `eval` printed on them (in Lisp, of course). – Tacroy Dec 26 '12 at 22:15
  • 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. – Ross Patterson Dec 26 '12 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 '12 at 22:19
  • 1
    @Ross Patterson: But Lisp has some basic ideas and techniques that have not changed over the years. – Giorgio Dec 26 '12 at 22:22
  • @Giorgio: Exactly the essence of my question. Good explanation. It's like they don't have an identity on their own. – Joan Venge Dec 26 '12 at 22:23
  • @Giorgio Tell that to anyone who's ready McCarthy's original papers. Even the most basic aspects of Lisp syntax have changed from the original intent. About the only thing that's intact is the CONS/CAR/CDR basics. – Ross Patterson Dec 26 '12 at 22:23
  • 1
    @JoanVenge if you want to look at a LISP variant, I would suggest Clojure as a good start. There's a fabulous book about it from O'Reilly called "Programming Clojure" that goes into a lot of depth. The language sits atop the JVM, but there is also a version that sits on top of the .Net Framework. – Maurice Reeves Dec 28 '12 at 16:13
  • Actually, `cond` is typically **not** implemented as a function, and not implemented in a library, because it can't be. Instead, it's typically implemented as a **special form** -- and is evaluated using a *special* evaluation rule. TBH, I don't see much of a difference between special forms and control structures -- both are integral parts of core languages which cannot be implemented using the language. That said, I still agree with the rest of the post. –  Jan 18 '13 at 15:17
  • @MattFenwick: Ok, in fact I did not know and drew the analogy from Smalltalk `ifTrue:` which is defined in the library and can be fully redefined; but of course, it is low-level so it contains `` pragma. – herby Jan 18 '13 at 16:27
6

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.

Steven Schlansker
  • 1,616
  • 14
  • 10
6

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:

spiral

Credit to this Microsoft employee's blog.

Glorfindel
  • 3,137
  • 6
  • 25
  • 33
Austin Henley
  • 374
  • 2
  • 6
  • 25
  • 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 '12 at 17:12
  • 4
    @Telastyn That wasn't his question. – Austin Henley Dec 27 '12 at 18:15
5

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.

Peter Smith
  • 2,587
  • 19
  • 21
  • 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 '12 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 '12 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 '12 at 21:24
4

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.

Ramzi Kahil
  • 1,089
  • 1
  • 10
  • 20
3

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

Paul D. Waite
  • 1,164
  • 14
  • 18
  • 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. – Thomas Browne May 06 '19 at 15:19
2

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.

Egryan
  • 256
  • 2
  • 5
  • 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 – Jimmy Hoffa Dec 26 '12 at 17:04
  • ok, will do though due to the question being closed don't know how much effort its worth – Egryan Dec 26 '12 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. – Jimmy Hoffa Dec 26 '12 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 '12 at 17:43
  • Search google for "A Case Study on TCL Language", "Tcl: An embeddable Command Language" and http://www.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 http://wiki.tcl.tk/1721 ) –  Dec 26 '12 at 17:55
  • You are probably right on that though I have a hard time believing any actively maintained software or languages have ever stayed at a 1.0 release – Egryan Dec 26 '12 at 18:13
2

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

-1

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.

user132043
  • 1
  • this merely repeats point made and explained in [an answer](http://programmers.stackexchange.com/a/180665/31260) posted two years ago – gnat May 21 '14 at 09: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 '14 at 10:20