That's true, but there wasn't a lot of second-round design benefit here.
It was pretty much the same specs sent to both people. The Java
programmer continued to try to fix the crashing bugs, which were really
a design issue and not anything to do with scoping.
We used a contractor for both, and both were loosely managed, so there
wasn't a lot of design experience that carried over either.
Worse, when the D project was near complete (it did start after the Java
server)... we discovered a few bugs in the Java implementation that we
needed to replicate, because development of client components was
already underway using it. So, the D programmer had to reverse engineer
bugs (departures from the scope document) in the Java version.
Yes, second round does help, but it was not nearly so clean cut in this
case. I don't have any question that the project would've gone worse if
we had just hired another Java programmer for it to start over.
-[Unknown]
Brad Roberts wrote:
Don't discount the major advantage of being a second round design and
implementation as well. I'm sure you learned a lot in the first iteration that
fed directly into not making the same set of mistakes again.
Not that D isn't the better language, but there's so many variables in
situations like this that you really can't draw significant conclusions from
them.
All that said.. yay for going with D and having success with it, for whatever
the reasons. :)
Later,
Brad
Unknown W. Brackets wrote:
For another real world example, we had a server daemon written in Java
and it took forever, had huge problems, cost us quite a bit, etc. etc.
We decided to have the same server rewritten in D, and it took
significantly less time, works correctly according to spec, doesn't
crash/hang half as often (the Java server would die in a way that made
it appear to still be up, made us crazy), and more.
Sure, maybe this is a reflection of the programmer who worked on it -
but in the end, D was by far the better route for us.
-[Unknown]
bearophile wrote:
Walter Bright:
D aims to reduce project costs by reducing training time and
shortening development time.<
I agree that this is very important. Helping the programmer avoid bugs
and helping her to follow good design practices are among the most
important qualities of a programming language, because in practical
programming often most time (= money) is spent debugging programs and
updating them.
But you are comparing D with C++, because programming in D1 is faster
and often simpler than doing the same in C++.
But today most people use languages like Java, Python, C#, that often
shorten developing time even more than D1.
D1 is almost a system language, so it's not easy to compete with the
productivity of application languages designed to put the programmer
first and the CPU second.
And D2 is not an easy&simple language, you need a good amount of time
to learn/teach it, more than Java for example.
Bye,
bearophile
