"The State of the Language: An Interview with Bjarne Stroustrup", it contains several interesting things: http://www.devx.com/SpecialReports/Article/38813/1954?pf=true


In this page talks about rvalue references: http://www.devx.com/SpecialReports/Article/38813/0/page/3


This page is about GC:
http://www.devx.com/SpecialReports/Article/38813/0/page/4
I vaguely like what he says, he seems rather balanced, unlike most of the people I have heard about this topic. He explains the problems related to having an optional GC too.


Here explains some things regarding C++ as coming from C: http://www.devx.com/SpecialReports/Article/38813/0/page/5

>The C syntax is horrendous, the conversion rules chaotic,<

>Even Java, which was supposedly designed from scratch according to first principles, chose the ugly and illogical C syntax to appeal to C and C++ programmers—and Java doesn't even have the excuse of compatibility.<

I think that it can be better for D to drop/change few other features of C, to improve its syntax, and make the programs less buggy/safer. Integral conversion rules can be improved, as the switch syntax, and integral overflow errors at runtime introduced. And all (or most) situations where C code is undefined/unspecified D can become defined or produce compilation errors. Such things may sound less important than improvements in multiprocessing, but I think they are the base to built the other things on.

From what I have seen, D is largely inspired by Java too. Java fixes several problems of C++, so in several things it's an improvement over C++ (but Java isn't a system language, so its purposes are partially different), but today Java is surely not state of the art anymore, so I believe D has to take a good look at more modern languages too, like C# 3.5/4, Scala and even Python 3.0 and Fortress (Python 3.0 uses lazy computations a lot. Haskell too is modern, and its type system is a marvel, but it may be too much different from C-like/Algol-like languages to be of much use for D). I think that copying too much Java and ignoring the last C# and Scala is a mistake, because in the last 10 years languages have found ways to improve over Java :-)

(I think Walter may even use some days to improve his Python3 pythonic skills, and learn C#3.5 / Scala in few weeks, hopefully to have some other modern ideas regarding the future of D :-] ). I don't know how much functional programming Walter knows, if he knows little of it then it may be useful to learn some (from Haskell) just to know how to design the future functional sides of D.

Regarding the funcional-style programming, this page (at the "Whole-Program Static Analysis and Optimizing Compilation" part) written by the autor of the Stalin Compiler shows that some of the current problems in optimizing D closures are already well known by the functional programming crowd, so it may be wise to learn some of their (complex) solutions, before trying to invent new ones:
ftp://ftp.ecn.purdue.edu/qobi/research-statement.pdf
Learning and understanding some of those things may be quite difficult for a single person, so some help may be asked to some people in the "Lambda the ultimate" crowd, they may give some very good suggestions regarding efficient implementations of some of the functional bits of future D.

Bye,
bearophile

bearophile Wrote:

> "The State of the Language: An Interview with Bjarne Stroustrup", it contains several interesting things: http://www.devx.com/SpecialReports/Article/38813/1954?pf=true
> 
> 
> In this page talks about rvalue references: http://www.devx.com/SpecialReports/Article/38813/0/page/3
> 
> 
> This page is about GC:
> http://www.devx.com/SpecialReports/Article/38813/0/page/4
> I vaguely like what he says, he seems rather balanced, unlike most of the people I have heard about this topic. He explains the problems related to having an optional GC too.
> 
> 
> Here explains some things regarding C++ as coming from C: http://www.devx.com/SpecialReports/Article/38813/0/page/5
> 
> >The C syntax is horrendous, the conversion rules chaotic,<
> 
> >Even Java, which was supposedly designed from scratch according to first principles, chose the ugly and illogical C syntax to appeal to C and C++ programmers—and Java doesn't even have the excuse of compatibility.<
> 
> I think that it can be better for D to drop/change few other features of C, to improve its syntax, and make the programs less buggy/safer. Integral conversion rules can be improved, as the switch syntax, and integral overflow errors at runtime introduced. And all (or most) situations where C code is undefined/unspecified D can become defined or produce compilation errors. Such things may sound less important than improvements in multiprocessing, but I think they are the base to built the other things on.
> 
> From what I have seen, D is largely inspired by Java too. Java fixes several problems of C++, so in several things it's an improvement over C++ (but Java isn't a system language, so its purposes are partially different), but today Java is surely not state of the art anymore, so I believe D has to take a good look at more modern languages too, like C# 3.5/4, Scala and even Python 3.0 and Fortress (Python 3.0 uses lazy computations a lot. Haskell too is modern, and its type system is a marvel, but it may be too much different from C-like/Algol-like languages to be of much use for D). I think that copying too much Java and ignoring the last C# and Scala is a mistake, because in the last 10 years languages have found ways to improve over Java :-)
> 
> (I think Walter may even use some days to improve his Python3 pythonic skills, and learn C#3.5 / Scala in few weeks, hopefully to have some other modern ideas regarding the future of D :-] ). I don't know how much functional programming Walter knows, if he knows little of it then it may be useful to learn some (from Haskell) just to know how to design the future functional sides of D.
> 
> Regarding the funcional-style programming, this page (at the "Whole-Program Static Analysis and Optimizing Compilation" part) written by the autor of the Stalin Compiler shows that some of the current problems in optimizing D closures are already well known by the functional programming crowd, so it may be wise to learn some of their (complex) solutions, before trying to invent new ones:
> ftp://ftp.ecn.purdue.edu/qobi/research-statement.pdf
> Learning and understanding some of those things may be quite difficult for a single person, so some help may be asked to some people in the "Lambda the ultimate" crowd, they may give some very good suggestions regarding efficient implementations of some of the functional bits of future D.
> 
> Bye,
> bearophile


Interesting stuff.  In the section on 'concepts', he makes a statement  about wanting to move C++ to a place where it needs less cleverness to  use -- something that sounds a lot like what Walter has talked about here.

Kevin