What I like about D:

- Being a systems programing language with GC
- Type system
- Metaprogramming capabilities
- UFCS
- OOP approach
- COM support


What I dislike about D:

- @system by default
- templates as workaround for attribute soup
- metaprogramming with strings instead of AST
- the way features get added and fail to be implemented end to end

On Sunday, 12 June 2022 at 01:48:43 UTC, forkit wrote:
> (1) What I like most about D:

Suitable for prototyping to production. You can add annotations and cleanliness as you go, which respects how software is created.


> (2) What I dislike most about D:

The D forums is attractive to a peculiar sort of people that want to boss people around and tell volunteers what to do.

On Monday, 13 June 2022 at 18:59:26 UTC, Guillaume Piolat wrote:
> 
> ...
> The D forums is attractive to a peculiar sort of people that want to boss people around and tell volunteers what to do.

this is NOT in the spirit of this thread.

On Tuesday, 14 June 2022 at 01:20:33 UTC, forkit wrote:
> On Monday, 13 June 2022 at 18:59:26 UTC, Guillaume Piolat wrote:
>> 
>> ...
>> The D forums is attractive to a peculiar sort of people that want to boss people around and tell volunteers what to do.
>
> this is NOT in the spirit of this thread.

You asked what people disliked most about D.
This is what I dislike most about D.

Let's sum up.

An anonymous user opening a thread that will likely deride into a flamewar, (after 100 pages of "why D is unpopular"), stating that lack of "strict private" is somehow the biggest flaw of D, and that everything need to stop and cater to their own perceived need is the definition of passive agressive - or should I say, trolling - at its finest.

On Tuesday, 14 June 2022 at 11:16:21 UTC, Guillaume Piolat wrote:
> On Tuesday, 14 June 2022 at 01:20:33 UTC, forkit wrote:
>> On Monday, 13 June 2022 at 18:59:26 UTC, Guillaume Piolat wrote:
>>> 
>>> ...
>>> The D forums is attractive to a peculiar sort of people that want to boss people around and tell volunteers what to do.
>>
>> this is NOT in the spirit of this thread.
>
> You asked what people disliked most about D.
> This is what I dislike most about D.
>
> Let's sum up.
>
> An anonymous user opening a thread that will likely deride into a flamewar, (after 100 pages of "why D is unpopular"), stating that lack of "strict private" is somehow the biggest flaw of D, and that everything need to stop and cater to their own perceived need is the definition of passive agressive - or should I say, trolling - at its finest.

I think you've just demonstrated 'trolling at its finest'.

Of course, this was to be expected.

The thread is about what people like most and dislike most about D (the programming language).

It's not about what people they like or don't like.

Please... find another thread for your trolling.

On Tuesday, 14 June 2022 at 11:20:03 UTC, forkit wrote:
>
> Please... find another thread for your trolling.

Just stating the obvious here.

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:
>
> (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.

1) Templates, CTFE, memory management. It's easy to write good and performant native code. It has really cool unique features. The code feels safe while being flexible. Boilerplate is practically non-existent for concepts (but bad for individual methods due to attribute soup). As a language, it feels very nice.

2)
- The "focus" seems to be so theoretical rather than writing code that most companies actually produce. The forums are a bunch of smart people arguing about theoretical improvements that don't really feel like they have a ton of practical value outside language theory.

- Tooling / infrastructure / cloud support. Imagine the effort required to use D if you're a SASS company writing cloud-native code. I had a recent project where I was writing an in-memory database and wanted low level data structures that would be deployed as a Lambda in AWS. D should be a great fit. Then I looked into actually using AWS with D, and wrote it in C# instead.

- The attributes are a complete nightmare; const gets in the way of everything, writing template methods becomes extremely difficult because of having to deal with both const/immutable and non-const/immutable/etc functions, and the benefit feels very low. All of these attributes sound nice in theory, but I just don't feel they're remotely worth the sheer amount of issues they cause.

- "Intellisense" functionality -- unfortunately I don't think these can ever be reliable enough in D due to UFCS, templates, and mixins. I love those features, but I'm not sure how you write a _reliable_ code completion / refactoring engine for D. I personally don't tend to use refactoring features unless I'm confident that the code could be analyzed 100% for things like references, and I just think that's extremely difficult to achieve with D.

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:
>
> (2) What I dislike most about D:

Like:
 Optional memory management, ability to use examples for SDL/OpenGL/etc that were written for C (m/l seamless C integration), compile time features, arrays and associative arrays are very natural unlike in other languages. I actually REALLY like immutable transitivity and stuff like that being options. When I write D code, it's almost always very clean. It feels like C programming, but it's a better C by a long shot.

Dislike:
 Sometimes people paste code on the forum and I can't understand what it does. Then some people respond with a bunch of acronyms I don't know what they are so I still don't know.
 My previous projects never compile when I come back
 Immutable transitivity is required so sometimes I just want to write some code and all of the sudden I'm having to figure out what all these extra requirements are.