On Thu, Sep 24, 2020 at 07:58:23AM +0000, glis-glis via Digitalmars-d wrote: [...]
> For me, the key features I like about D are:
[...]
> * Pseudo-gradual typing: Usually, I start defining my functions as returning auto and template every parameter. Once the function is finished and passes the unit-tests, I start thinking about types

That's a very interesting way to approach it!  I might adopt this approach for my future prototyping experiments!


T

-- 
If lightning were to ever strike an orchestra, it'd always hit the conductor first.

On Monday, 21 September 2020 at 18:36:20 UTC, data pulverizer wrote:
> On Monday, 21 September 2020 at 11:04:43 UTC, Imperatorn wrote:
>> [...]
>
> From my experience:
>
> # Rust
>
> [...]

I would also add that Julia is very memory hungry and in some cases outdoes Java in this regard. I have hard time understanding why Julia gets so much praise on HN despite such glaring performance flaws... The only thing I can imagine why ppl wave performance arguments off is great and growing Julia's ecosystem.

On Wednesday, 23 September 2020 at 00:35:56 UTC, Walter Bright wrote:
> On 9/21/2020 4:04 AM, Imperatorn wrote:
>> Top reasons to use D instead of for example Rust, Julia, Go etc :)
>
> The top reason for me is plasticity. The combination of D's features make it much easier to refactor and redesign code to improve it. With C, the initial design tends to stick because it's so difficult to redesign it.

Yes! I truly think D is in a sweet spot of low/high multi-paradigm programming while aslo having great performance. To be honest I've looked at other languages, a lot. But what I find is that I actually come back to D after a while. Because, well, it's actually great :)

On Saturday, 26 September 2020 at 07:32:20 UTC, tastyminerals wrote:
> I would also add that Julia is very memory hungry and in some cases outdoes Java in this regard. I have hard time understanding why Julia gets so much praise on HN despite such glaring performance flaws... The only thing I can imagine why ppl wave performance arguments off is great and growing Julia's ecosystem.

Yes, Julia is unreasonable memory hungry. I had to disable it for inputs above 5000 functions in

https://github.com/nordlow/compiler-benchmark

For details on the superiority of D's compilation speed see

https://github.com/nordlow/compiler-benchmark#conclusions-from-sample-run-shown-below

On Saturday, 26 September 2020 at 17:34:44 UTC, Per Nordlöw wrote:
> On Saturday, 26 September 2020 at 07:32:20 UTC, tastyminerals wrote:
>> I would also add that Julia is very memory hungry and in some cases outdoes Java in this regard. I have hard time understanding why Julia gets so much praise on HN despite such glaring performance flaws... The only thing I can imagine why ppl wave performance arguments off is great and growing Julia's ecosystem.
>
> Yes, Julia is unreasonable memory hungry. I had to disable it for inputs above 5000 functions in
>
> https://github.com/nordlow/compiler-benchmark
>
> For details on the superiority of D's compilation speed see
>
> https://github.com/nordlow/compiler-benchmark#conclusions-from-sample-run-shown-below

Just want to confirm: it's the Julia *compiler* itself that is memory hungry, not the generated app that is memory hungry?

On Monday, 21 September 2020 at 17:20:41 UTC, Steven Schveighoffer wrote:
> On 9/21/20 7:04 AM, Imperatorn wrote:
>> Top reasons to use D instead of for example Rust, Julia, Go etc :)
>
> My list, in no particular order:
>
> 1. Metaprogramming
> 2. Using Metaprogramming to generate code
> 3. Using CTFE to generate Metaprogramming to generate code.
>
> -Steve

No 3 is really meta ❤️🐣

On Saturday, 26 September 2020 at 18:19:28 UTC, mw wrote:
> Just want to confirm: it's the Julia *compiler* itself that is memory hungry, not the generated app that is memory hungry?

Yes

On Monday, 21 September 2020 at 11:04:43 UTC, Imperatorn wrote:
> Top reasons to use D instead of for example Rust, Julia, Go etc :)

As quick as possible speed (no room below) which matters for a few domains, and very high productivity - so the end result often end up providing value.

There are of course a few newer native languages now, but there is a disturbing trend.

They seems to increasingly rehash old ideas that did NOT work: forcing TABs on people (or a particular style), doing away with exceptions, having AST macros, lifetimes annotations, segmented stack, lack of GC... all these things do not kill a language but in the large they do not work and it's strange to try the experiment again.
To me it's worrying that the new native language don't learn from the past.