Why the @ in @safe? & UDAs

[Jonathan M Davis]

On Monday, November 11, 2013 00:39:04 Rob T wrote:
> On Sunday, 10 November 2013 at 23:08:11 UTC, Nick wrote:
> > The alternative is to slowly build up a menagerie of quirks
> > that put us on the same path as C++.
> 
> It seems that a buildup of quirks is underway as is evidenced by
> this discussion. The other solution is to at some point place a
> freeze on D2 with bug support only and move on to D3 with at
> least the worse of the known baggage removed. There are of course
> disadvantages and dangers with doing that, but it is an option.
> 
> Ultimately if we try and keep everyone happy, at some point no
> one will be happy, so I think it's worth trying to find good
> solutions to enable the language to evolve in ways that can leave
> baggage from the past behind.

I think that it's naive to think that any serious language will avoid building 
up quirks and rough corners over time. You never get a language completely 
right (assuming that's even possible), and you only have so long after you 
create it to tweak stuff before it has to be more or less set in stone for it 
to be useable in the real world. Some stuff can be tweaked over time even after 
you're "stable," but you have to be very careful about it in order to minimize 
if not outright eliminate breakage. And the longer that a language is around, 
the more unwieldy it's going to get. Either it doesn't innovate at all and 
avoids building up more quirks, or it innovates and ends up with quirks as it 
adds and adjusts stuff after the fact.

Eventually, the baggage from those quirks will be big enough that if you want 
to get rid of them, you'll be forced to either create a new language or to 
create a new version of the language which breaks backwards compatiibiity, 
which tends to be little different from just creating a new language. I really 
don't think that there's any way around that. D doesn't have all of the 
baggage of C and C++, because it's a new language which breaks compatibility 
with them, but it's building up its own quirks and mistakes and will continue 
to do so. We should do our best to minimize that, but I really don't think 
that there's any way avoid it completely.

Languages _need_ to be more or less set in stone in order to be useable in the 
real world, and if you set them in stone, then you're going to end up with 
quirks and baggage when you add onto them later. That's just the way it is, 
and I think that anyone who thinks that D can avoid the same fate as C++ in 
that regard is being naive. Some day, there will be a D++, or a D3, or an E, 
or whatever for the same reason that we created D instead of continuing to use 
C++ and for the same reason that the python developers created python 3. But 
that's a _long_ way off. First, we have to make D2 work, and part of that means 
living with at least some of the mistakes that we've made and quirks that the 
language has acquired. And honestly, many of those are tradeoffs that I don't 
think that anyone has a good solution for at this point anyway. So, even if 
someone went and created D3 right now, I don't think that it would be 
appreciably better than D2 (in some regards maybe, but not enough to be worth 
the split that that would cause to the code and to the community).

- Jonathan M Davis