Am 22.07.2012 00:16, schrieb Nick Sabalausky:
On Sat, 21 Jul 2012 23:14:12 +0200
"Stuart"<stu...@gmx.com> wrote:
Let me just add, I really *like* the terse syntax of D. Lambdas,
uniform function call syntax, and so on.
Yea. I used Java in college and ever since then I've been a fan of
non-verbose systax - ie syntax that's the *opposite* of Java ;)
Actually that verbose sintax is quite helpful when dealing with gigantic
code bases in big corporation projects like where I work.
The type of "programmer clogs" we have in our projects are so low skill,
that I have bad dreams what they could do in more powerfull languages.
Already C# is highly advanced for some of them!
What I hate in Java is the abuse of annotations to avoid introducing new
keyworks, like @overload. This recalls me of a software project where
the DSL in use, got so many annotations that it become unmanageable.
Garbage-collection I can live without. Closures, properties and
events I really miss when they're not available. But header files
were the single worst thing to ever befall coders.
I agree, a proper module system was one of the first, biggest things
that drew me to D - It was one of the handful of things Java actually
got *right* compared to C++ (another big one being reference semantics
for classes). When I use C++, a proper module system is one of the
biggest things I miss.
Aside from the issues you mention, there's another big benefit to
killing off the #include system and switching to D: Type names and other
identifiers aren't cluttered up with the noise of a make-shift module
system. (Yea, there's namespaces, but not everyone seems to use them.
I assume there's probably good reasons for that...besides easier
integration with D ;) )
Legacy code. As some compilers took several years to fully support the
standard. This was one of the things that got my interest in Java back
in 1996.
Finally a C++ like language, where I could make use of modern C++
features, without getting the source code full of #ifdef.
For example, I'm using the IwGame C++ library
( http://www.drmop.com/index.php/iwgame-engine/ ) and fucking *EVERY*
type name is prefixed with "CIwGame...". And anything from the
underlying Marmalade starts with "CIw..." so basic vectors are
named convoluted shit like "CIwFVec2". Of course, this is on top of the
fact that until C++11 becomes more widespread there isn't a damn bit of
type inference anywhere, so those horrific full names have to be used
EVERYWHERE. With a proper module system like D's, there'd be no
problem with names like "ImageActor" and "FVec2" instead of
"CIwGameImageActor" and "CIwFVec2", because conflicts could be easily
detected and dealt with.
And of course the other real obvious benefit of killing #include: None
of that separate cpp/h file bullshit.
C++ is living in the 70's. It should have a mascot wearing a leisure
suit.
Very true.
I never understood why C++ could not have a module system. It would
still be possible to compile C code anyway. In fact, in Turbo Pascal you
get both, a preprocessor with includes and modules(units).
The sad thing is that most languages designed in the early 80's all had
proper modules.
--
Paulo
