SerpentOS departs from Dlang (page 2)

The announcement post from Ikey included as its only explicit mention of something bad about D itself that DIP1000 was incomplete.

My mention of reference counting as a way to allow for a complete story for DIP1000 matched this goal that also matched what other people wanted here.

Not everyone has the same priorities, especially when it comes to comparing a minor feature that is almost in the language already, to a major feature that will take years to complete.

Lets be clear on something, I want sum types. I need sum types for value type exceptions which are waiting on only sum types. I do not believe that Walter's DIP is complete enough to be a "good" design to further this goal.

Disparaging me because I placed a higher priority on something critical to my 110k+ LOC code base performance wise, does not aid in your goal of the addition of a major feature which pretty much everyone wants at some level.

September 20

Re: SerpentOS departs from Dlang

Posted by Greggor
in reply to ryuukk_

Permalink

Greggor

Posted in reply to ryuukk_

Permalink

On Friday, 15 September 2023 at 21:49:17 UTC, ryuukk_ wrote:

On Friday, 15 September 2023 at 17:39:41 UTC, M.M. wrote:

In February there were some exciting news on the usage of dlang within serpent-os linux distribution, quite a large open source project of Ikey Doherty and the team around him.

Unfortunately, the project decided to leave dlang behind, and to embrace golang and rust instead... in part due to some hiccups in dlang and due to contributors pushing for more mainstream languages:

https://serpentos.com/blog/2023/09/06/oxidised-moss/

Pity that it did not succeed. It would be a great showcase for the marvelous dlang.

That's unfortunate..

Ikey seems to still want to use D, so the main driving factor is the contributors, i wonder what are the exact reasons, pseudo memory safety can't be the only reason

To be honest, I wouldn't blame contributors for looking at more mainstream languages, who still want to do their switch cases this way:

switch (it)
{
    case MySuperLongEnum.MySuperLongValueA:
       result = do_something_a();
    break;
    case MySuperLongEnum.MySuperLongValueB:
       result = do_something_b();
    break;
    case MySuperLongEnum.MySuperLongValueC:
       result = do_something_c();
    break;
}

When other languages have it cleaner:

result = switch (it)
{
    .MySuperLongValueA: do_something_a();
    .MySuperLongValueB: do_something_b();
    .MySuperLongValueC: do_something_c();
}

Improving ergonomics won't necessarily attract people, probably not, but i'm pretty sure that'll make contributors of existing projects not request to change language because the ergonomics are so poor

Even C# understand that and made the appropriate changes across their language and even improve their compiler to avoid the urge to switch to Go (NativeAOT), even Java made appropriate language changes in hope to stay relevant, why only D should be frozen? Acting like the world depend on D

D has many benefits, but some areas need lot of love, this reminds me of this dude in an online chat, he said the reason why he stick to Rust was because of Rust's enum.. not because of memory safety

Hopefully more wake up calls like this one will resonate with the D foundation

I do not think the lack of a little bit of syntax sugar is what is hurting D.
Also with is your friend.

auto result = (){with(MySuperLongEnum) final switch(it){
    case MySuperLongValueA: return do_something_a();
    case MySuperLongValueB: return do_something_b();
    case MySuperLongValueC: return do_something_c();
}}();

full version that will compile, if you want to play with this.

@safe:
enum MySuperLongEnum{
    MySuperLongValueA,
    MySuperLongValueB,
    MySuperLongValueC,
}
int do_something_a(){ return 1; }
int do_something_b(){ return 42; }
int do_something_c(){ return 99; }

void main(){
    auto it = MySuperLongEnum.MySuperLongValueB;
    auto result = (){with(MySuperLongEnum) final switch(it){
        case MySuperLongValueA: return do_something_a();
        case MySuperLongValueB: return do_something_b();
        case MySuperLongValueC: return do_something_c();
    }}();
    import std.stdio;
    writeln("result: ", result);
}

Forums