What programming languages and language features are under 10?

Question

It seems there are many 'new' languages around but in reality it seems like most of the popular, non experimental, ones are already in their teens and the truely mainstream are older than most junior programmers. Now I just remembered this obvious fact when I realized even the 'hip' Ruby language is 15 this month (February 1994). While stuff like Haskell, that's in everyones 'to learn' list is even older than that.

Thinking about it the only really new language, in common use, I could think of that's under 10 is C#. But even C# doesn't really have any new features to it, although it has picked up some of the best features of it's predecessors.

So I'm wondering what new languages, and their corresponding new features/ideas are under 10 right now? Anything that's likely to be big 10 years from now? Any new language features to look forward to? Or are we done already???

---

Apparently there is nothing really new that isn't a hybrid or refinement. Maybe LOLCODE because it's designed to be absurd above all else, but even stuff like Brainf*ck and WhiteSpace are basically ancient stack based assembly languages.

Have we reached the encyclopedic era of programming languages?

Answer 1

The D programming language is just under 10 years old. Its unique features include transitive const (everything reachable from a const object is also const), compile time function evaluation, and the ability to annotate functions as pure and have them statically checked by the compiler for side effects visible outside the function. Also included is a template system that puts C++ templates, Java/C# generics, etc. to shame:

1. Variadic templates that "just work" for unlimited numbers of arguments.
2. Strings, floating point numbers, and function aliases can be template parameters.
3. The static if statement, similar to what exists on paper in C++0x, is actually implemented and works.
4. String and template mixins, which allow the injection of arbitrary parametrized boilerplate code into any place in your source, and for arbitrary compile time code generation. In the extreme case, this has been used by Don Clugston to build a matrix math library that actually parsed code given as string literals at compile time and generated optimal inline assembly code for these operations, before the compiler's code generation stage.
5. Structs can be represented as tuples, allowing iteration over their fields. This allows for some interesting generic programming with structs.
6. Ridiculously powerful compile-time reflection/introspection. I once wrote a function template that could deep copy any struct as long as no runtime polymorphic class objects (which compile time reflection simply can't work on) were involved. This was done using only compile time reflection. No runtime type information was used.

Answer 2

I'd say C# latest additions like LINQ, extension methods, lambda expressions and the rest are relatively new. If they are not big right now, they will be.

ASP.NET MVC though it is not a language feature is going to be big (I am almost sure), though I know many will never accept it.

Answer 3

How about F# :). There are also tons of new languages in development by solo developers. Like scala, jruby, groovy, boo etc.

For a language to catch on it really needs big support from a big company, so we will be stuck with what we got for a while. Although Sun and MS are investing heavily in making their platforms (JVM, CLR) more open to these languages. The defaults will be Java and C# for now, but only time can tell.

Answer 4

The Scala programming language is under 10 years old (I believe it was originally released in 2001) and could be claimed to be the first:

• Real-world scalable language (e.g. from scripts and implicits to actors and modules). I'm saying real-world because some will claim others, starting with Lisp, were first here, but I believe Scala's Java compatibility, object-oriented features, type system etc. make it different
• Real-world fusion of functional and object-oriented programming (e.g. having higher-order functions, but also state and static typing). I'm saying real-world again because while e.g. Oz is older, I believe Scala's compatibility and pragmatism make a difference

Answer 5

very much looking forward to Boo.

Boo is an object oriented, statically typed programming language in active development since 2003, which seeks to make use of the Common Language Infrastructure's support for Unicode, internationalization and web applications, while using a Python-inspired syntax[1] and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and First-class functions.

Answer 6

OMeta is less than 2 years old and is a language for creating other languages. In my opinion, it's more expressive than languages like Microsoft's upcoming MGrammar.

The coolest idea it has is that you can create languages in an object-oriented fashion (e.g. you could create a mashup language of Ruby and C# grammars).

It's also nice that the syntax looks almost identical to BNF and thus quite readable.

I wrote more about it here.

Answer 7

Languages evolve. You don't necessarily need a new language to get a new language feature. As an example, Haskell is not a new language, but it does have many "new" features, including STM.

Answer 8

Wikipedia has a nice timeline about the 1st appearance of programming languages - it shows that there are several languages that cam into like in the years 2000+ though I believe these are not widely used languages (yet?).

Answer 9

None, that I've seen.

Sure, there are "new" languages popping up all the time. But I used the scare-quotes because all the examples usually offered are:

• repackaging (into another language) ideas that have been in Computing Science and Mathematics for decades, or
• languages/techniques which are older than that, but only recently "discovered" by the "mainstream" world.

For concrete examples:

• Lambda calculus goes back to Mathematics and logic in the 1930s,
• functional programming goes back to LISP in the late 1950s,
• John Backus discussed FP in his 1977 Turing Award lecture (pdf),
• John Hughes' paper Why Functional Programming Matters was written in 1984,
• comprehensions go back to set theory in the 1870s and SETL in the 1960s,
• parser combinators were promoted by Phil Wadler in the mid 1980s and go back to combinatory logic in the 1920s,
• and so on.

The work of promoting, popularizing, applying, and refining these (and many other) important ideas is worthwhile. But that doesn't make those uses truly innovative.

Of course, I will be delighted if anyone can provide an example of a truly original concept in programming that didn't exist ten years ago.

Answer 10

I don't think the recent innovation has been inventing new features. It's been making old ideas available (and practical) in mainstream settings. Lambda expressions are a great example of this - old as the hills, but the vast majority of developers won't have encountered them before C# 3 and VB9.

Similarly, two features may have existed independently before, but never in the same language. I wouldn't like to start claiming which combinations are new, but it's worth considering.

Is the nature of .NET generics "new" by the way? I don't know enough computing history to say, but there are clear differences between it and either Java generics (with type erasure) or C++ templates (where the specialization is really a compile-time business as far as I can tell, requiring the source for the template).

Answer 11

Lot of "new" language target one or the other well-in-place VM, namely JVM or CLR. It allows to concentrate on design of syntax and "philosophy" more than on implementation (leveraging existing optimized VM, GC, libraries, etc.).

Interestingly, some languages target both platforms, like the Fan Programming Language.

Other languages just translate themselves to another language (usually C), thus relying on some portable or local optimized compiler to do a good job.

I found haXe interesting because it targets several languages/VM: JavaScript, Flash, NekoVM or even PHP.

As others said, it is hard to find really new concepts, today. Partly because a lot have been explored already, partly because lot of programmers are lazy and confused if a new language doesn't use a familiar syntax (I saw lot of complaints of people in the Lua mailing list, requesting the use of { and } instead of do/end -- see also complaints against JavaFX not being Java...), let alone a new concept!

Answer 12

Ok, we know Code Contracts since Eiffel - so that's 20+ years, and Code Analysis for years and years, but I have never seen such a complete combination of Code Contracts, Code Analysis and Unit Testing as in c# 4.0 and Pex. Maybe I'm wrong and ignorant about other languages and products that did offer that level of functionality years ago - but I surely would call that degree of help towards "bugfree" software a feature. So, is it new?

Answer 13

The AgentSpeak(L) language for programming intelligent agents. It is based on Prolog (which is very old) but there is some very specific features, and it's brand new.

You can check a fully interpreter called Jason.

Answer 14

I think the phrasing of the question suggests that there is no innovation, but in fact all that gets revealed in the discussion here is that innovations take decades to make it into the mainstream.

If you'd asked this question about 20 years ago when OO was one of the 'big new things' with C++ and Smalltalk and whatnot, people could just respond that that was just Simula (1967) repackaged. But in 1970, I don't think anyone would have considered objects to be 'a big innovation' rather they would have just been 'an interesting syntactic nicety' in that Simula language. Over time, OO evolved, people recognized how OO is natural for modeling/structing systems, design patterns were found, ... and now today a great many languages just take OO 'for granted'. But it's hard to find any moment in time where people would say 'OO was a great new innovation' because when it was new, no one appreciated its scope of influence on the software engineering field, and by the time its reach was apparent, it was no longer new.

20 years from now maybe all the new/popular languages will have a feature like 'type classes' from today's Haskell (it is a killer feature), but it's already 'too old' by this question's criteria to be an innovation, even though it may be 'the next big thing'.

So yes, I bet there are new things under the sun, probably hundreds, but they're all off in tiny experimental languages and we won't appreciate the novelty until decades later when the best of today's ideas are refined/proven and make their way into the mainstream.

Answer 15

The E language made light-weight promise pipelining accessible. This ought to be a crucial idea for the upcoming multi-core revolution, as it makes it possible to write code that's easily parallelized, has low-cost dependencies between communicating sub-processes, and sidesteps all the standard problems with managing locks and avoiding deadlock. The main ideas in E have been ported to a variety of other languages. E is part of a long (though somewhat obscure) line of object capability languages, which has some very important contributions to make in software robustness and security. E is just about 10 years old now.

Answer 16

The Blue Programming Language shows great potential. Think "Python but easier to use and extend".

No, I am not saying Blue is better than Python, I'm just saying its brewing, easy to use and (already, after only a couple of years) quite stable. Its been growing on me for about a year :)

Answer 17

Powershell as a language is under 10, of course not the language features.