A gentle critque..
Ben Cooley
Ben_member at pathlink.com
Sun May 14 17:16:16 PDT 2006
There are a few major problems with D that still prevent it from being practical
for use in the real world.
I'll just list them and note their importance. Anything witha
- Inability to access C/C++ include files... Importance: SHOW-STOPPER
--------------------------------------------
C++ can do this, D can not.
The size, scale, and prevalence of C and C++ libraries and code make writing
wrappers for all of these libraries impractical. That D can not just easily
include C and C++ headers "as is" gives it a serious and I would suggest fatal
disadvantage vs. C++.
C++ out of the box could include C header files, meaning that even today I have
access to the largest possible body of third party libraries and code. Binary
compatibility with C only is just not good enough.
Incompatibility with C++ ABI... Importance: SHOW-STOPPER
--------------------------------------------
Even if you could include C++ headers, you could not interface with C++ classes.
C has abi compatibility with C++, and C++ has ABI compatibility with C. C and
C++ have more or less abi compatibility with most other systems (including COM,
CORBA). D intends to be used for system programming, but is icompatible with
the most prevalent existing ABI.
Inability to make D code work with C/C++ Importance: SHOW-STOPPER
---------------------------------------------
Likewise, if you write D code, your code exists only in the very small world of
D, and will not be useful to the world outside of the D programming community.
This makes any library or system you might create only marginally useful, and is
a strong disincentive for anybody to actually write code in D for general public
consumption.
No support for meta-programming or Macros Importance: SHOW-STOPPER
---------------------------------------------
Say what you will about the unclean use of macros in C and C++, they are
critical for a large set of important functionality that C and C++ programmers
take for granted. There are many ways to provide hygenic macro replacesments,
true meta programming, or generative programming. D offers none of these, and
no way to replace the functionality lost using macros.
Correct me if I am wrong on this point, but the meta-programming offered by
macro code injection is just not easily replaced by mixins, templates or other
language features.
Provides no additional support for safe programming vs. C/C++ Importance: HIGH
---------------------------------------------
C# and Java trade incompatibility and the inability to easily integrate with
C/C++ for the additional productivity and security. D trades incompatibility
for.. incompatibility. Programming in D is just as unsafe as programming in C
and C++, without the support of Microsoft and other 3rd parties to provide huge
quantities of high level libraries and a powerful integrated environment. D is
unsafe by design, just as C and C++ were, but the difference is that this is
2006, and not the 70's, 80's, or 90's.
The choice one is left with is to either program in a safe language and accept
the overhead of the JIT, or use C/C++ with it's large existing base of tools and
code other things in C# or Java. One wonders why this is so, since C# has
unsafe capabilities.. and CSecured offers safe C programming capabilities. How
long should we have to wait for a safe systems level language.. till microsoft
releases their Singularity project and their Bartok compiler?
------------
The first two issues make much of the remaining critique irrelevant. Once you
have a singel showstopper, additional issues don't really make any difference.
However I'll list them anyway.
- Inability to integrate with visual studio. No good IDE.. Importance... HIGH
- No stable standard. Importance... MEDIUM
- Difficult to control what is garbage collected and what is not. Garbage
collection performance. Garbage collection violates C++'s "zero overhead" rule
where any performance overhead is at the programmers explicit discression.
Importance... MEDIUM
- Not open source. Importance... HIGH
- Very small library base. Importance... HIGH
----------------------------------------------------------
A modest suggestion, were I to try to introduce a new language which I intended
to be not only clean and simple, but "popular" and widely used as well would be
to squarely address the first three issues above.
C++ provided a translator. The original versions of C++ were able to output C
code which would compile on any ordinary C compiler. Likewise, the idea that C
headers could simply be directly included in a C++ language file, and "it just
worked" allows any C code to be used in a C++ program.. a feature that all C++
programmers use today.
Finally, C and C++ code code be easily mixed within a single project, another
feature of C++ that is used today. Since C++ can consume any C header, and in
most cases C can understand the ABI of C++ with the extern "C" {} wrapper, it's
possible to go in both directions.
All this being said, I would really like to see a language like D succeed,
because I need the features it has. But I can't abandon my C and C++ libraries,
and I am not about to commit to coding wrappers for them, nor forgoing using my
current programming environment and debugging tools. When I adopted C++ 20
years ago, I didn't need to do this. C++ integrated well with my tools and
existing libs (the exception being the debugger of course). But overall it was
a good citizen in the overall world of C/C++ code.. it played nicely. The same
can not be said of D, C#, or Java, and D doesn't have the other benefits of C#
or Java.
Until D addresses these issues, it will be nothing more than a niche language
offering syntactic cleanliness and interesting features to a few faithful, but
largely ignored by the rest of the programming world.
More information about the Digitalmars-d
mailing list