Re: Have we reached the asymptotic plateau of innovation in programming language design?

On 3/17/2012 12:31 PM, Rock Brentwood wrote:
> On Mar 7, 5:52 am, Rui Maciel<rui.mac...@gmail.com> wrote:
>> Quotes:
>> - But the truth of the matter is that ever since I finished my Ph.D. in the
>> late 90s, and especially since I joined the ranks of Academia, I have been
>> having a hard time convincing myself that research in PLs is a worthy
>> endeavor.
>> So, what are your views on this subject?
>>
>> Rui Maciel
>> [Personally, I'd say there's been precious little new in programming
>> languages since Simula gave us OOP in the late 1960s. In your responses,
>> please remember this is comp.compilers, not comp.semicolon-placement.flame.
>> -John]
>
> The answer is simple: whenever and wherever you hear such a question
> posed, no matter what the context or situation, no matter what the
> issue, it is *always* a clear-cut red flag that you are on the cusp of
> a major paradigm shift and that the older paradigm (and the older
> generation along with it) has simply run its course. Equally clearly
> is that during such times, when you start to see things as having been
> exhausted, you're also dating yourself and are identifying yourself in
> terms of which side of the paradigm boundary you reside on.


<snip, lots of hand-waving...>




> [I've been saying we've run out of language ideas for 20 years.
> Pretty slow cusp, if you ask me. And if there's a paradigm
> shift, to what? - John]


I agree.


The problem isn't that there aren't "ideas" (as-in, alternative
possibilities for how things could be), but that there are relatively
few "good ideas" (as-in, would offer a notable advantage over existing
practice), and even fewer are "new" (most major ideas have been floating
around for decades or longer).


Many ideas people often go on endlessly about being the "next big thing"
("Pure Functional Programming" being a big offender here), are hardly
new ideas, and I suspect that there are some notable reasons for their
relatively limited mainstream adoption (and "different" need not be
"better", and can very often be "notably worse").


granted, for example, elements of "impure FP" could be better supported
or utilized in mainstream languages (say, via closures, tail-call
optimization, and syntax for implicit return). this is already happening
some, but I don't expect state or variable assignment to be going away
anytime soon.




concurrency could be a little better, but it is a similar issue. but,
again, the process will likely be more one of gradual incremental
improvements, rather than people "jumping ship" to some entirely new
"paradigm".


an example:
in my language I have "sync" and "async" keywords;
"sync" allows forcing things to be done synchronously (if previously
using async);
"async" allows certain things to be done asynchronously (potentially in
parallel, but if/when something is done is undefined).


both, in my case, are built partly on the VM using "green threads", and
internally by the VM using a CPS based structure.


likewise, "continuations" exist in the implementation, sort of, but are
not available in the language, and have some annoying technical
limitations (they are exit-only and don't work across calls through C land).


however, the default case (and the main way I actually use the
language), is to use good old procedural control flow. even then, these
new features are used in addition to, rather than in place of, other
more traditional mechanisms (as well as them requiring explicit
declaration).


(taken further, a language could have keywords to allow for constraints
and lazy evaluation...).




one could argue, "well, people did 'jump ship' to OOP".


however, it can be noted:
earlier on, OO was hacked on top of C (inspired by Simula, etc...),
forming C++;
Java came some time later, and borrowed a fair amount from C++;
C# came along later, and borrowed mostly from C++ and Java;
all this took place over nearly 20 years (C++ to C#, or 34 years if one
counts Simula);
much "OOP" is not really "OOP", more just procedural code with classes.




so, as I see it, little is new, but there is still a lot of old stuff
that has yet to really be put to use.


maybe new ideas will trickle in, eventually, and "new" languages may in
a number of years start to look dated.


will things look drastically different? probably not.
change is continual, but typically gradual.

Return to the comp.compilers page.
Search the comp.compilers archives again.