06-Jan-2013 14:37, Benjamin Thaut пишет:
Am 05.01.2013 05:24, schrieb ixid:
On Monday, 31 December 2012 at 14:40:48 UTC, Benjamin Thaut wrote:
Am 31.12.2012 15:02, schrieb DypthroposTheImposter:
Do you find that D without GC is more effective than C++? Seems like
you would be stuck using structs which seems somewhat limiting, even
compared to C++...
UE4 has similar reloading capabilities(using DLLs), though they use
C++ and rely more on the ability to serialize everything
Why should I be stuck with structs? Its the exact same as in C++. I
did build my own new and delete operators (as templates). It's not
that hard and works pretty well, only the syntax is not ideal in some
cases. I can use everything you can use with D+GC. Sometimes you have
to be carefull with implict allocations (e.g. closures, array
literals) but I have a leak detector that points me to these directly
and usually its easy to free these manually.
And I'm quite a bit more productive then in C++. Module constructors
with a defined order instead of random static initalizers,
code generation isnstead of huge amounts of boilerplate code and many
other features are the cause of this.
Kind Regards
Benjamin Thaut
Is D moving away from your sort of use? Games and bioinformatics
would seem to be the areas the language should be trying to get
people to start using it in. The features you're using seem very
much like they should be a part and mode of using the language.
I wouldn't say its moving away from it. Some recent changes to druntime
have made it significantly less leaking. But on the other hand a API
design like toString() which pretty much does leak in almost all cases
don't exactly help a GC free D. In Summary it feels to me that GC free D
is not important to the community or the active contributors.
Regarding toString there is a better signature that avoids useless
allocations:
void toString(scope void delegate(const (char)[]) sink);
It takes a delegate to output string representation directly to the
destination via 'sink' delegate (that may e.g. write chars to file).
Plus the 'scope' part of declaration avoids allocating the said delegate
on the heap.
I'd even say that string toString(); is an artifact of the past, instead
to!string should be used (if allocating a string is fine).
I also see D's biggest chances in becoming popular in the performance
critical fields of programming. Which would be systems programming,
Gaming and others. For programming fields in which a GC is applicable
people tend to use languages like C# or Java, because they are truly
safe (see the recent "ref is unsafe" discussion in the newsgroup), they
have nice productivity features like runtime code changing through the
VM and have a way better GC because the language was designed from the
beginning to support a advanced GC.
Kind Regards
Benjamin Thaut
--
Dmitry Olshansky
