D is pretty cool, perhaps someday I can use it instead of C++ and have cool shit like fast build times, modules, no more bloody headers, sane templates, CTFE, UFCS etc

 But can the D GC ever be made:

1. precise
2. able to scale to large-ish data set(2gig+)
3. No long stalls(anything over a couple millisecond(<3))

Q. Curious, would it be compacting?

 If not then I'm stuck not using it much--

Which leaves me with structs, and lets just say D struct are not impressive--


* Oh and on a totally unrelated note, D needs Multiple return values. Lua has it, it's awesome. D doesn't want to be left out does it?

* OpCmp returning an int is fugly I r sad

* why is haskell so much shorter syntax, can D get that nice syntax plssssssssss

STAB!

On Wednesday, 3 October 2012 at 21:31:52 UTC, DypthroposTheImposter wrote:
>  But can the D GC ever be made:
>
> 1. precise
> 2. able to scale to large-ish data set(2gig+)
> 3. No long stalls(anything over a couple millisecond(<3))
>
> Q. Curious, would it be compacting?

I believe all these things are being worked on, or at least planned.


> Which leaves me with structs, and lets just say D struct are not impressive--

Why?


> * Oh and on a totally unrelated note, D needs Multiple return values. Lua has it, it's awesome. D doesn't want to be left out does it?

It doesn't need them, but it might be nice. In the meantime you can use out params.


> * OpCmp returning an int is fugly I r sad

Maybe, but it does make things easier to implement.


> * why is haskell so much shorter syntax, can D get that nice syntax plssssssssss

Using C-family syntax makes D feel more at home to C/C++/Java/C# programmers. A lot of people are scared off by Haskell's syntax because it is so unusual.

On Wed, 03 Oct 2012 23:26:05 +0200, DypthroposTheImposter wrote:

> D is pretty cool, perhaps someday I can use it instead of C++ and have cool shit like fast build times, modules, no more bloody headers, sane templates, CTFE, UFCS etc
> 
>   But can the D GC ever be made:
> 
> 1. precise 2. able to scale to large-ish data set(2gig+)
> 3. No long stalls(anything over a couple millisecond(<3))
> 
> Q. Curious, would it be compacting?
> 
>   If not then I'm stuck not using it much--
> 
> Which leaves me with structs, and lets just say D struct are not impressive--
> 
> 
> * Oh and on a totally unrelated note, D needs Multiple return values. Lua has it, it's awesome. D doesn't want to be left out does it?
> 
> * OpCmp returning an int is fugly I r sad
> 
> * why is haskell so much shorter syntax, can D get that nice syntax plssssssssss
> 
> STAB!

Can you write a GC which meets your criteria?  If so, D can get one as soon as you write and contribute it.

Justin

 Did that hook thing to let peoples write custom GC ever make it in?

On Wednesday, 3 October 2012 at 21:31:52 UTC, DypthroposTheImposter wrote:
>
> * Oh and on a totally unrelated note, D needs Multiple return values. Lua has it, it's awesome. D doesn't want to be left out does it?

If it's for composability's sake that you *need* multiple return types, wouldn't returning a tuple in D be just as good (tuples automatically expand if needed).

On 03-10-2012 23:26, DypthroposTheImposter wrote:
>    D is pretty cool, perhaps someday I can use it instead of C++ and
> have cool shit like fast build times, modules, no more bloody headers,
> sane templates, CTFE, UFCS etc
>
>   But can the D GC ever be made:
>
> 1. precise

Yes. Work is being done.

> 2. able to scale to large-ish data set(2gig+)

Parallel marking is perfectly possible even with a conservative GC. I've been meaning to look into this.

> 3. No long stalls(anything over a couple millisecond(<3))

A (non-real time) GC can't really make guarantees about pause times. While having a real time GC might be nice, it'd take an incredible amount of engineering effort.

>
> Q. Curious, would it be compacting?

In theory, it is possible to do this for some heap objects, but I suspect that it would do more harm than good in a systems language.

>
>   If not then I'm stuck not using it much--
>
> Which leaves me with structs, and lets just say D struct are not
> impressive--

?

>
>
> * Oh and on a totally unrelated note, D needs Multiple return values.
> Lua has it, it's awesome. D doesn't want to be left out does it?

Use tuples. Multiple return values (as far as ABI goes) are impractical because every major compiler back end (GCC, LLVM, ...) would have to be adjusted for every architecture.

>
> * OpCmp returning an int is fugly I r sad

It's a sensible design decision. What would be the alternative?

>
> * why is haskell so much shorter syntax, can D get that nice syntax
> plssssssssss

D is a C-family language.

>
> STAB!
>

-- 
Alex Rønne Petersen
alex@lycus.org
http://lycus.org

On 10/3/2012 2:26 PM, DypthroposTheImposter wrote:
> But can the D GC ever be made:
>
> 1. precise
> 2. able to scale to large-ish data set(2gig+)
> 3. No long stalls(anything over a couple millisecond(<3))

There is nothing in the language that prevents this, it's a matter of doing the implementation effort. Recently, the compiler started using a library-defined hook for doing precise GC. That hook currently does nothing, but it enables development of a better GC without needing compiler modifications.


> Q. Curious, would it be compacting?
>
> If not then I'm stuck not using it much--

Compacting requires making objects movable, and yes, D's semantics allow for movable objects. Interestingly, some of the latest ideas in GC seem to be moving away from compacting.



> * Oh and on a totally unrelated note, D needs Multiple return values.
> Lua has it, it's awesome. D doesn't want to be left out does it?

You can do that now with Tuples.


> * OpCmp returning an int is fugly I r sad

How else would you return a 3 state value?


> * why is haskell so much shorter syntax, can D get that nice syntax
> plssssssssss

Haskell's syntax is quite a bit shorter, but I find it difficult to mentally read, though I'm sure with practice I could get used to it.

D's syntax is deliberately designed to be a { } language, and to be comfortable for people who are used to { } languages.

On Wednesday, 3 October 2012 at 23:38:57 UTC, Alex Rønne
Petersen wrote:

>> 1. precise
> Yes. Work is being done.

BTW, where can I learn about the current progress with GC? Is
this work concentrated in one project or are there several
parallel works on improving GC? Is anyone already working on
making memory allocation and GC more multicore friendly?

On 2012-10-04 00:01, DypthroposTheImposter wrote:
>   Did that hook thing to let peoples write custom GC ever make it in?

Yes, it's pluggable at link time. Here's an example of a stub implementation:

http://www.dsource.org/projects/tango/browser/trunk/tango/core/rt/gc/stub

It's for Tango but the runtimes are basically the same.

-- 
/Jacob Carlborg

On 2012-10-04 01:33, Alex Rønne Petersen wrote:

> Use tuples. Multiple return values (as far as ABI goes) are impractical
> because every major compiler back end (GCC, LLVM, ...) would have to be
> adjusted for every architecture.

Why can't it just be syntax sugar for returning a struct?

-- 
/Jacob Carlborg