Walter Bright:
> I wish it were possible to have a language with just a small set of 
> features that can do everything. C++'s problem is it can approximately 
> do everything but with a boatload of gotcha's, like a const system that 
> almost works but doesn't deliver. Java threw out too much.

Today lot of people think that the (close) future of programming is in 
languages that run on a VM, like Clojure (a kind of Lisp for the JavaVM fitter 
for multi-core programming). (While I think the far future is in things like 
OMeta and the like).

Java was a way to simplify C++, because in lot of applications most of the code 
doesn't need the level of detail (for example regarding memory allocation) that 
C and C++ require. Today I don't see many desktop applications written in Java, 
the Java applets are vanished (replaced by JavaScript and Flash), but Java is 
more to write applications, while today lot of high performance things or 
kernels are often in C still (often with lot of ugly things added to make it 
use the vector capabilities of modern CPUs). They have also recently released a 
kind of standard CUDA (OpenCL) that will probably lead to some change in the 
way high-performance code is written.

D isn't much a system language (I don't see people writing Linux with it, 
despite a couple attempts of writing a kernel with it), it looks more like an 
application language designed for people that like more modern things, a 
language cleaner and simpler to use than C++, but want to keep the old-style 
memory management, static compilation, etc.

In the future I think D has to remove some of its features, to have less ways 
to do one thing (even removing some of the C ways, if necessary), and make some 
of its features more consistent, more flexible, with fewer "gotchas".

I don't know in what direction D has to go. Maybe OpenCL to gain more 
high-performance? Has to gain few more functional features? To have better ways 
to manage multi-cores (see F# and Clojure)? To become more like C# (and become 
more an applicative language)? To switch most of its development to the LLVM 
platform and become a little more dynamic too (the new dynamic feature of C#4)? 
Are old-school statically compiled languages a thing of the past?

Even if D will not grow to become a very widespread language, it can give a 
significant help to the history of programming anyway. There are several 
languages that have a large legacy (es. Simula) despite they haven't had much 
diffusion. D can explore and invent ideas that later can be stolen and adopted 
by very common languages (for example new C# may be copying few things from D 
too).

One thing I like of Walter is that (beside being very good in programming), 
despite being old-school in several things (D2 is currently developed, yet, 
it's already old compared to several features of Scala and Clojure, and D is 
designed like ignoring several design features that today lot of programmers 
think as a given, like some of the features of the IDEs, that change how a 
language has to be designed too!) is open to learn and to change his original 
assumptions (and desires, regarding D design too) along the way. It's a long 
way, but so interesting to follow :-)

Bye, and thank you,
bearophile

Reply via email to