On the panel discussion at Dconf day 3

[Jonathan M Davis]

On Thursday, September 7, 2023 12:31:10 PM MDT ryuukk_ via Digitalmars-d 
wrote:
> > Ideas for new features for D have been deferred for the time
> > being
>
> This is the saddest thing ever, i've been waiting for tagged
> union / tuple since forever

Well, waiting for any particular feature could always mean waiting forever,
since some stuff is never going to make it into D regardless, though of
course, it's hard to know ahead of time which features will eventually make
it in and which won't.

> IVY = bureaucracy + religion, recipe for disaster, and we are
> already seeing the effects: the language is now in a deep freeze
> state

Not really. All that really seems to have come out of IVY is that Walter and
and company have re-examined the role of the D foundation, what their
personal goals are with regards to D, and what the goal of the foundation
should be. No bureucracy was actually added as part of any of it. At most,
some time was arguably lost with the time that they spent in IVY meetings to
go over their goals and where they want to go with D, but if what came out
of those meetings helped focus them (as it sounds like happened), it could
be that the overall result will be less time wasted over time. Either way,
there was no bureaucracy added to how the D foundation or the D development
process actually functions.

Basically, Walter and company re-examined where they wanted D to go and what
they could best do to achieve that, and they were getting a lot of feedback
that too much existing code was being broken, and not enough bugs were
getting fixed. So, they're temporarily focusing on fixing stuff over adding
new stuff, and they're working on coming up with a cleaner way to add new
features to the language over time without breaking existing code. That does
mean that we're not getting new features for the moment, but it doesn't mean
that things will stay that way, and depending on how well they do with
better enabling adding new features without breaking code, we might actually
see more new features in the future than we would have otherwise.

They're still trying to figure out the details, but it sounds like they're
going to attempt to make it so that major changes to the language will be
versioned off in some fashion (what they're calling additions) while letting
older code compile with the same semantics that it had before. So, newer
code will use a newer version of the language while still being able to work
with older code that hasn't been updated. How well they're going to pull
that off is an open question, but if they do a good job with it, it should
make it easier to make larger changes, because they won't be breaking older
code at the same time, whereas right now, they have to be very worried about
breaking existing code with every change that they make. So, the fact that
they're re-examining their approach to making breaking changes to the
language could actually result in us getting new features faster over time
even if it means that there has temporarily been a freeze on new features in
the meantime.

- Jonathan M Davis