What language, or language feature, do you wish made it to the mainstream? [closed]

Question

Some languages in the past have been influential without ever reaching wide adoption. For example, many languages owe much to the design of Algol 68, even though few compilers were ever written for it. The Dylan language was killed by Apple but had a clean and interesting design.

What other programming languages had cool ideas but-- for whatever reasons-- didn't make it to the mainstream? Is there an interesting language feature that you wish your main language had? Is there a feature ahead of its time that we'll soon see used?

Answer 1

Common Lisp, or something equivalent.

The killer feature is the macro system, which essentially allows arbitrarily extending the language (I've seen different object-oriented systems added to Lisp with macros). Other useful things are the multi-paradigm nature, the extensive built-in arithmetic (including arbitrary-sized integers, rational numbers, and a general treatment of complex numbers), strong run-time types with optional compile-time types, and an easy-to-use OO system with multimethods.

Answer 2

String Aggregator for SQL

i.e., a simple standard process, like avg() or nvl(), that takes a column of values and appends them to each other, given a string separator.

E.g. Given

select name_col 
from my_table;

returns:

Ringo
John
Paul
George

, then

select substring(stragg(', '||name_col), 3) 
from my_table;

should return:

Ringo, John, Paul, George

Answer 3

D still has a chance to make it into the mainstream, though it's not there yet. Two key features that go together and for some purposes can be treated as one feature are:

1. String mixins. This is basically like a compile-time eval. Compile time strings can be compiled as normal code in whatever scope they're mixed into.

2. Compile time function evaluation. This allows said code to be generated at compile time, so that it can be mixed into any scope necessary.

Combine these with regular template metaprogramming and the result is some pretty powerful and transparent (to the API user) code generation.

Answer 4

Object-Orientation

Seriously. The mainstream languages have absolutely abysmal implementations of OO. Sometimes one wonders whether the designers of those languages have ever actually heard of Simula or Smalltalk.

Answer 5

Well, Felix hasn't made it into the mainstream and has cool features. There are certainly interesting features I wish my main language had, the most important one is well principled polyadic programming. {oh, my main language is Felix, because I'm the designer and compiler implementor .. :} Joerg will love the OO implementation, since it is perfect (there isn't any OO in Felix :)

I'm not sure what string mixins are, nor exactly what would be expected by compile time function evaluation: Felix has a user programmable grammar, the action code for the grammar productions are written in Scheme (does that count? for one or both of those features?)

Answer 6

I think multi-method dispatch is very cool. At first it might sound like simple overloading, but the decision is deferred to runtime. Multi-method dispatch is part of CLOS and Dylan.

And the generalization of it, predicate dispatch, is even better. The JPred language showed that it can be added to a Java-like language. My guess is it might take a decade or two before predicate dispatch reaches the mainstream.

Answer 7

Does "the debugger" count as a language feature?

I don't care how fancy concepts a language expresses or what cool features it has, if debugging it amounts to essentially leaving print statements all over the place, it's garbage.

Answer 8

• proper closures
• continuations
• the ability to make variables lexical or dynamic (in terms of scoping)
• prototype based oo
• real macros

With the exception of prototype based oo I doubt any of these will make their way into languages they aren't already in because:

• it makes the language implementation much more complex, slower and the perceived trade-off isn't worth it
• the implementor/designer doesn't like it
• the implementor/designer feels it's not worth the extra work

Answer 9

Build in immutability support for all fist class members , especially more robust than C++ const correctness

Answer 10

Lambda expressions. They are incredibly useful, but have not gained a lot of momentum yet. Java has (limited) suport for them in the form of anonymous classes. not really true lambda, but close and still useful. C uses function pointers, which are awkward. The ability to pass a piece of code around to use where needed is a boon to programming, as Lisp and other functional languages demonstrate.

Answer 11

Design-by-contract, done right. MS almost got it right when they did Spec#, but they threw it all away with the poor implementation in VS2010 / .NET 4.

Also, parallelism, though some of the stuff they've done there in .NET 4 is interesting.

Edit: Also, Aspect Oriented Programming I'm fed up of having to splatter logging calls everywhere. It'd be nice to be able to have this done for me - say, a logging call at the start of every set accessor.

Answer 12

Scala.

I have mentioned a lot of reasons under this thread.

Answer 13

I would like to throw my hat in the ring for REXX.

It's easy to learn, fun to write, is incredibly flexible (including Object Orientation), and ports to just about every environment you can think of -- with OS extensions available for many of them.

Its no less relevant than PERL, in my opinion. And, it stands head-and-shoulders with some of the big-boys of development, in terms of reliability and performance.

It's an interpreted language, so it may not be the best choice for a full application, but as a scripting language and for smaller apps, I've always enjoyed it.

I think REXX would be a terrific language for teaching the fundamentals of computer programming, as well.

Answer 14

immutable state

Answer 15

Mixin Inheritance

It works in C++ and DataFlex...and almost nowhere else. Very useful in certain contexts.

Answer 16

Nested functions.

Answer 17

Non-nullable reference types

Why? Because the purpose of type systems is to "prove" the correctness of our programs by limiting the values a variable can take to some meaningful ones.

But they fail to do so, as there is a hidden extra value in our reference types without knowing - one, that is in most cases not meaningful: null

Non-nullable reference types by default would give us meaningful types again, thereby reduce run-time errors that now can be caught at compile-time, and force the programmer to be explicit if null is actually a desired, valid state too.

Answer 18

Why is it that 2/3 of the responses here seem to be things that lisp had in 1962 but everything else is only adding now?

Answer 19

From APL: Better array and matrix manipulation tools, like those that were considered basic functions within APL. These functions simplify all kinds of coding problems found in the fields of vision, voice recognition, terrain traversal, etc.

There are a lot of other built-in functions from APL that I miss using in C, but the array processing functions are missed most.

---

From LabVIEW: Built-in or easily implemented libraries for a profusion of HW devices, SW APIs, and interface protocols. It's elementary to construct a system that, once working with one device, can be upgraded to work with dozens of similar devices by just installing additional VIs--no additional manipulation of the 'code' is required.