What programming languages and language features are under 10?

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.

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

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.