Fixing C's Biggest Mistake

[H. S. Teoh]

On Fri, Dec 23, 2022 at 08:55:58PM +0000, areYouSureAboutThat via Digitalmars-d wrote:
[...]
> I think you have to take Andrei at his word.
> 
> https://forum.dlang.org/post/qj18h2$8o1$1@digitalmars.com
> 
> At the same time, it's not unreasonable to wonder if there is
> something 'not stated' ;-)
> 
> But regardless, it can only be conjecture.

Well, Andrei *did* describe elsewhere how he became a target for
criticism once he took on the helm, much of which was pretty vicious.
There's only so much a person can take before the question pops up, why
am I doing this, and should I be doing something else instead?


> Presumably nothing has changed further since this announcement by
> Andrei?

As far as I know, no.


> One thing is for sure... The future of the D Programming language is
> primarly stuck with Walter.

I thought Atila was supposed to be making decisions with Walter as
well, it's not just Walter by himself.


> But I think some are overreacting a little.... let Walter add this
> thing...  I mean who cares.. really? I certainly don't.
[...]

The frustration is understandable, though. When your favorite pet peeve
with D has been sitting in bugzilla for a long time, months and years,
while every few months the leadership announce Yet Another New Project
(which doesn't affect you nor your project nor address your pet peeve,
and which in your opinion address only a niche issue), it's hard not to
feel that things just aren't going in the right direction.

Meanwhile, Walter feels like he's trapped between a rock and a hard
place. Spend time fixing bugs, and people accuse him of making no
progress and having no strategic vision; work on something he considers
strategic, and people accuse him of working on the wrong thing (in their
opinion) while bugs are languishing in bugzilla.  At some point, a
leader just has to be the bad guy to put down his foot and make a
decision, whether or not it's the popular one. And over the years I've
observed that what's popular with one segment of the D forums can be
extremely unpopular to another segment; there's really no pleasing
everybody on a lot of issues.

Having said all that, though, I think a lot of reactions on the forum
are overblown, because in its current state, D is already pretty darned
good. Sure, there are dark corners and quirks, and there are old
experimental features that are not worth pushing forward and unfinished
features that are extremely complex and will take a lot of time to bring
to completion.  But it's easy to lose sight of how far D has come when
focusing on what lies ahead.  D is plenty usable in its current state,
and I've been very pleased with it.  Even though there's obviously
plenty of room for improvement.

Another thing is that it's easy to underestimate the complexity and
amount of effort required to implement something that, at first glance,
may seem very simple.  Especially when it's your pet peeve that grates
on your nerves every time you encounter it, but which is, in the grand
scheme of things, not very high on the priority list. "Feature X is so
straightforward, just look at languages P, Q, R, that have it too! Why
can't we do it in D? Why hasn't it been done yet, it's been N years?"
But feature X may interact with feature Y which may conflict with
feature Z; just because something is simple in another language doesn't
guarantee it's simple in this language. And just because it's
theoretically easy doesn't mean the implementation will be trivial.

Add on top of this, that D, being a mainly volunteer-based project,
doesn't have the big bucks of a big corporation to pay people to do what
they normally wouldn't want to do, and things that require too much time
and effort, or that the people who have the skills to do something about
it aren't interested in it, simply don't get done.

None of this justifies the lack of progress, of course, perceived or
otherwise. But it's where things are at currently, and it's what we have
to live with.  It's not perfect, but D is already pretty darned good at
what it does.  Moving forward, what will *really* change the current
state of things is people who are willing to step up and implement stuff
themselves and contribute it to the project.  Angry posts in the forum
rarely bring about any long-lasting change (if any at all), as proven by
history.

For example, the WASM story can really improve if there's somebody, or a
couple of people, who are really invested in it, could work on making
things work, package it nicely, and present it as a solution to the
community.  I'd do it myself, but frankly, after dabbling with WASM for
a little bit earlier this year, I don't feel particularly inclined to
invest much effort into it after all: I found it to be early-adopter
technology, still raw around its edges and with some basic functionality
still missing / not working very well (e.g., GC support, passing any
data more complex than basic POD types, interfacing with the host
environment).  You still need a whole bunch of Javascript (involving a
LOT of boilerplate) just to get basic functionality running, and core
interactions with the host environment (I/O, access to the GPU, etc)
still have a lot of gaps and holes and places where you still need lots
of JS glue to make things work.  In such a state, I'm not sure how wise
it is to for the D foundation to invest much resources into WASM -- a
large part of it could go to waste as WASM rapidly changes in the coming
years.  But if somebody who really needs D on WASM could work out
something and contribute it to the community, it would make a huge
difference.  Someone who is motivated enough to keep up with the latest
changes in WASM and keep the D interface to it up-to-date.


T

-- 
Frank disagreement binds closer than feigned agreement.