pi benchmark on ldc and dmd

[Andrew Wiley]

On Tue, Aug 2, 2011 at 7:08 AM, Adam D. Ruppe <destructionator at gmail.com>wrote:

> > LDC builds in under a half hour, even on my underpowered ARM SoC,
> > so I don't see how you could be having trouble there.
>
> Building dmd from the zip took 37 *seconds* for me just now, after
> running a make clean (this is on Linux).
>
> gdc and ldc have their advantages, but they have disadvantages too.
> I think the people saying "abandon dmd" don't know the other side
> of the story.
>
>
> Basically, I think the more compilers we have for D the better.
> gdc is good. ldc is good. And so is dmd. We shouldn't abandon
> any of them.
>

For the record, I'm fine with the current arrangement and just playing
devil's advocate here:

So far, you've outlined that GDC takes a while to build and the build
processes for GDC and LDC are inconvenient as the only disadvantages they
have.
LDC took about 3 minutes on a Linux VM on my laptop, and since it has proper
incremental build support through CMake, I don't really see that qualifying
as a disadvantage. The only people that really need to regularly build
compilers are the folks that work on them, and that's why we have
incremental builds.
Now, DMD does have speed on its side. It doesn't have debugging support (you
have to jump through hoops on Windows and Linux is just a joke), binary and
object file compatibility (even GDC has more going for it on Windows than
DMD does), platform compatibility (outside x86 and x86_64), name recognition
(I'm a college student, and people look at me funny when I mention Digital
Mars), shared library support, and acceptance in the Linux world.
The reason I use GDC for pretty much all my development is that it has all
those things, and the reason I think it's worth playing devil's advocate and
really considering the current situation is that GDC and LDC get all this
for free by wiring up the DMD frontend to a different backend. The current
state of affairs is certainly maintainable, but I think it's worth some
thought as to whether it would be better in the long run if we started
officially supporting a more accepted backend.
My example would be Go, which got all sorts of notice when gccgo became
important enough to get into the GCC codebase.

I'm not saying DMD is terrible because it isn't. I'm just saying that there
are a lot of benefits to be had by developing a more mature compiler on top
of GCC or LLVM, and that we should consider whether that's a goal we should
be working more towards.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20110802/41df669b/attachment.html>