D and Nim

[anonymous via Digitalmars-d]

On Sunday, 4 January 2015 at 21:46:09 UTC, Ary Borenszweig wrote:
> On 1/4/15 3:10 PM, Jonathan wrote:
>> Hey folks,
>>
>> I've been recently checking out Nim/rod and feel like it takes 
>> a lot of
>> inspiration from D (I think the creator was in the D community 
>> too as
>> some point). How do you think it compares? What areas does D, 
>> in
>> principle, makes it a better choice? To give you my 
>> background, I like
>> creating games (mostly using SDL bindings) using new 
>> languages, aiming
>> for the most efficient yet concise way to write the engine and 
>> game logic.
>>
>> FYI, this is NOT a language war thread. I'm just curious about 
>> what
>> separates them from a principle level.
>
> In my opinion Nim is superior than D in every aspect (and I say 
> this as my personal opinion, not to trigger a language war).

You do want a language war because your spewing too much
bullshit. I dabbled in both d and nim/rod. All interesting in nim
is whats taken from d.

> There are examples of D code in these two repos:
>
> https://github.com/logicchains/LPATHBench
> https://github.com/kostya/benchmarks
>
> Take a look at for example the first one in D and Nim:
>
> https://github.com/logicchains/LPATHBench/blob/master/d.d
> https://github.com/logicchains/LPATHBench/blob/master/nim.nim
>
> According to the writeup:
>
> https://github.com/logicchains/LPATHBench/blob/master/writeup.md
>
> Nim is faster than D. And it does so with much less code.

Bullshit. dmd is easy to beat. also json parsing? library issue.

> Then look at kostya/benchmarks: D is always behind Nim (except 
> matuml, where they are similar, but all statically compiled 
> languages are similar in that one). And Nim's code is always 
> shorter and cleaner. (and before you reply to this with "but if 
> you add pure nothrow @safe @abracadabra", continue reading)

Bullshit. Main differences are nim has significant whitespace.
Code looks shorter because theres less {}. Second difference is
nim has code at top level. Great for short benchmarks but aweful
in large code.

> There was a time I liked D. But now to make the code fast you 
> have to annotate things with pure nothrow @safe to make sure 
> the compiler generates fast code. This leads to code that's 
> uglier and harder to understand.

Bullshit. That stuff makes d more modular than nim.

> Another point is that Nimrod has CTFE but does so with a 
> virtual machine, so I'm sure it's faster than D in that aspect.

How does that make the language superior? Bullshit again.

> Then, Nim is written in Nim.

How does that make the language superior? Bullshit again.

> Having the compiler be written in itself is a good way to 
> immediately have the developers of the language get the feeling 
> of the language, find bugs and improve it.

ddmd

> Nim has 363 issues accoring to 
> https://github.com/Araq/Nim/issues . D has 2444 according to 
> https://issues.dlang.org/buglist.cgi?component=DMD&limit=0&order=bug_status%2Cpriority%2Cassigned_to%2Cbug_id&product=D&query_format=advanced&resolution=---

Bullshit. Thats nimrod is less popular than dmd. Jesus i cant
believe you can smoke that.

> . Also, because the compiler is written in itself, everything 
> is garbage collected, so there are no worried when doing CTFE 
> (D's CTFE consumes a lot of memory, I read in this newsgroup). 
> Nim compiles itself in between 2.5 and 5 seconds.

How does that make the language superior? Bullshit again.

> Also, I get the feeling that D has too many features and not 
> all of them work in harmony with the rest of them. So people 
> always find small bugs and others suggest workarounds and 
> eventually people learn to program in a WDD way 
> (Workaround-development-driven).

Also, I get the feeling your bullshitting through your ears.

> Back to LPATHBench, I find things like 
> minimallyInitializedArray and uninitializedArray, which are 
> great for optimizing things, but it's sad that one has to use 
> these special functions instead of regular ones (idiomatic 
> code) to achieve better performance. Also, "uninitialized" 
> sounds unsafe... And then you must compile your code with 
> -noboundscheck to get more performance, but that's so unsafe...

Bullshit.

> But then, both D and Nim have things which I dislike: too many 
> built-in things. Static arrays, arrays, sequences, etc. Can't 
> these be just implemented in D/Nim? Why the need for special 
> built-in types with special operations?
>
> Anyway, just my opinion :-)

Just a load of bullshit.