So this thread is designed to bring some balance, between being negative about D, and being positive about D.

To participate, you must (should, since I cannot 'enforce' this) post two things:

(1) What I like most about D:

(2) What I dislike most about D:

Please keep it simple and short, ideally one item for each would ideal.

passive-aggressive types.. stay away...go somewhere else please!

if you're eager to respond to someones post, please take a moment to consider whether that is in the spirit of this thread.

I'll start:

(1) What I like most about D:
    D is a multi-paradigm programming langauge, and enables what I like most, which is flexibilty towards experimenting with different approaches during the design phase of a solution to a problem.

(2) What I dislike most about D:
    There is no option to declare an invariant of a class type that the compiler will enforce, during compile time, from code surrounding that class (in the same module) - including unit-test code. But easily solved with something like 'scope private', if it were available in the language.

On Sunday, 12 June 2022 at 01:48:43 UTC, forkit wrote:
> (1) What I like most about D:
>
> (2) What I dislike most about D:
>
> Please keep it simple and short, ideally one item for each would ideal.

My humble, not particularly informed opinions:

I like D's overall feel and it's mixture of features, in short. D's mixins, ranges, CTFE, delegates, UFCS, scope guards, unit-tests, iteration style, templates, contracts, UDAs, it's module system, it's easy interfacing with C, Objective C and C++'s OOP and it's compilation speeds are honestly the best part of the programming language. And for a language with all these features, D feels tidy, it's not merely a "C++" with more features, it feels unique in it's own right. I also like it's efforts to become safer, like the inclusion of a borrow checking system (live functions), @mustUse and the "safe specification", i think they are going to improve D overall.

The thing that i dislike most about D, on the other hand, it's D's lack of vision for the future. D doesn't have a clear roadmap with clear proposals, and the DIP process seems to me too strict. I don't know what D is going to have or eliminate next. Also, D is somewhat underpowered when it comes to it's features. D does not have structural bindings for arrays and tuples (or at the very least, a way for AliasSeq to have type inference and a possibility to skip what values of the tuple you want, maybe with a underscore like in Go; through, i can understand that it doesn't really fit in with the language), coroutines (yield, async, await, etc.), static array inference, lazy variables like in Swift (through, D allows excellent workarounds for this), named unit-tests (like in Zig; maybe with the possibility to skip them internally, again, like in Zig), generic lambdas, an "inline" attribute for functions instead of the pragma-inline idiom, support for Unicode operators, anonymous structures, records (C#-style), mixin identifiers. I also don't understand certain idioms: why is a case range statement styled like "case 1: .. case 3" and not like "case 1..3:"? It's more readable?

Thank you all in advance.

On Sunday, 12 June 2022 at 01:48:43 UTC, forkit wrote:
> So this thread is designed to bring some balance, between being negative about D, and being positive about D.
>
> To participate, you must (should, since I cannot 'enforce' this) post two things:
>
> (1) What I like most about D:

CTFE and UFCS

> (2) What I dislike most about D:

GC

On Sunday, 12 June 2022 at 01:48:43 UTC, forkit wrote:
> So this thread is designed to bring some balance, between being negative about D, and being positive about D.
>
> To participate, you must (should, since I cannot 'enforce' this) post two things:
>
> (1) What I like most about D:

Arrays, way better than C or C++. Then GC, UFCS and CTFE + template meta-programming.

> (2) What I dislike most about D:

Lack of proper IDE plugins, with proper auto-completion and integration (Ok, when you have lots of time and willpower). Over focus on C/C++ people with all betterC/ImportC, when the basic tooling is still lacking (IDE integration).

Best regards,
Alexandru.

(1) What I like most about D:

    - fast compile speed
    - great metaprogramming
    - C like syntax
    - great knowledgeable community
    - walter, he knows his stuff, and don't like to bloat things
    - importc, when it'll be completed!

(2) What I dislike most about D:

    - GC
    - core language features that end up being library in std. (sumtype/tuple)
    - runtime/std being too dependent
    - everything in a module will be compiled, even if not used, it makes it hard to write multi platform code in a single module, i am forced to split things in DUB project, wich SUCKS
    - lack of proper language server with semantic analysis, this one is becoming annoying..
    - reserved keywords (init, debug, equals), this one really hurts me a lot (not being able to choose API with names: init/deinit)
    - incomplete/class-based Allocators
    - betterC broke, mostly with static float array

On Sunday, 12 June 2022 at 13:39:37 UTC, ryuukk_ wrote:
>     - everything in a module will be compiled, even if not used, it makes it hard to write multi platform code in a single module

this is what version and static if are for......

Pros:
- clean syntax
- ctfe
- ufcs
- metaprogramming
- native code
- module system
- default initialization of variables
- slices/arrays
- GC

Cons:
- lack of first class types (would enable using types with ctfe, get rid of templates as a separate metaprogramming language):
- half implemented features
- ad hock addition of features without proper vision of unwanted interactions
- unwillingness to properly fix the language and introduce breaking changes
- while metaprogramming is great, it still lacks some functionality i'd like to have (for example a trait that gets me aliases to all variables a function accesses that are from outside it's scope)
- no pattern matching
- no tuples / destructuring assignment
- autodecoding!!!

On Sun, Jun 12, 2022 at 01:48:43AM +0000, forkit via Digitalmars-d wrote:
> So this thread is designed to bring some balance, between being negative about D, and being positive about D.
> 
> To participate, you must (should, since I cannot 'enforce' this) post
> two things:
> 
> (1) What I like most about D:

- Sane template syntax.
- CTFE.
- static if.
- Compile-time introspection.
- UDAs.
- DbI.
- Built-in unittest blocks.
- GC.
- Delegates.
- UFCS + ranges.
- foreach (i; x..y)
- Compile speed (for small programs).


> (2) What I dislike most about D:

- Ruining my appetite to use any other language. ;-)
- Silly int promotion rules:
   - `ubyte b; b = -b;` issues a compile error.
   - bool autopromotes into int, causing unintended overload matching.
   - char implicitly converts to int, causing unintended overload
     matching.
- Arbitrary limitation of lambdas and delegates to single-context.
- Inscrutable error messages when there's a typo in a nested lambda deep
  inside a UFCS chain.
- Certain Phobos modules trigger ridiculously large template
  instantiations, slowing down compile-times by several seconds at
  least.
- Excessive compiler memory usage, esp. for template-heavy code.


T

-- 
Having a smoking section in a restaurant is like having a peeing section in a swimming pool. -- Edward Burr