Only want to say

[ddcovery]

This last year I started a new project and (as people that reads 
this forum knows) I decided not to use D as primary language:  I 
really was not enough experienced and I required a fast way to 
launch my prototypes (some difficulties like debugging or 
inspecting variables or strange linux erros with hunt/vibe.d 
frameworks stopped me)...

I decided not to use either Go or Rust:

* Go is pure imperative/structured language and a hell in terms 
of modular structuring of your project.  It is not suitable for a 
"functional" orientation... and my pure imperative way of 
thinking was abandoned decades ago:  I want to write map/reduce 
expressions instead for/if loops when possible.

* Rust is a straitjacket with the ownership management:  may be 
it is great way of avoiding erros, but codding flexibility is 
very limited

I wanted to return to a strong typed/native compiled language, 
but Go/Rust were not comparable in terms of productivity (and 
expressiveness) with Scala+Play or Java+Spring Boot or 
Node+typescript...

Finally, I decided to use D as a day-by-day scripting/common 
tasks language (for acquire experience) and I only want to say 
one thing:

D rocks

* The modularity of my scripting tasks is simple: I can organize 
my code in folders/modules an run scripts directly: no paths, no 
projects... only code and run.
* The in/out/body (and scope) mechanism/syntax is awesome (I 
really love it)
* The function first parameter possibilities calling ways removes 
the need of "extension" methods and it is something I really 
appreciate.
* The standard library is really useful.
* The way memory is managed transparently is awesome:  I'm not 
afraid of pointers and manually managed memory ... but being able 
to forget about it in your project is a dream.
* The functional syntax is really flexible (I will love a more 
integrated functional way of working in all std library, but I 
understand that it is out of D scope... D is not a functional 
language but a language with good support for functional 
programming).
* Templates instead Generics power/flexibility is awesome (each 
time I write format!"..."(...) I feel a positive emotion 
difficult to describe).

May be, I will appreciate to work with "asynchronicity" naturally 
as part of the language itself,  but it is not mandatory for me 
and I will cover my needs using vibe.d in the next months.  May 
be I will appreciate not opening brackets on new line (I have 
some vision difficulties... and this "standard" forces me to 
scroll a lot in the code because I use a big font size)

In summary:  D is a productive great language and I'm sure I will 
increase it's use next months.

I just wanted to share a bit of the positive feelings that D has 
given me over the last few months and wish the team that 
continues to work day by day despite the difficulties my sincere 
thanks and best wishes.