New Features Always Come With Bugs

[Nicolas J.]

Falk-Florian Henrich Wrote:

> Am Thu, 12 Apr 2007 23:03:49 +0800 schrieb Davidl:
> 
> > There is nothing in the world can be free of bug while offer you new
> > features.
> 
> True, but that's not at all the point of the discussion.
> 
> > So I think in some degree walter & DMD go in the right way.
> > 
> > And complains won't get better result, why not fix it by yourself? Most
> > unfixed
> > bugs are frontend related. And frontend source is open. And I don't
> 
> Yeah, right. I put several days into reading the D 1.011 frontend code, 
> spend another couple of days fixing some bugs only to download 1.012 
> which contains some sort of modifications that break my bug fixes, 
> because the original compiler author is not aware of them. I think this 
> problem stops many people who would like to help with D (myself included).
> 
> Right now, the only way to contribute to the D frontend is to do a fork 
> and work on that.
> 
> Falk

Well, you can't blame Walter for not guessing that you discovered and fixed bugs in the compiler. He is not omniscient.

But I second the idea that two branches are necessary. Because the idea behind a STABLE branch is to have LESS bugs for each new version, not more. You could have submitted your bug fixes to this branch.

As has already been said, which serious company could reasonably bet on a language which is always unstable ?
There is one point where one wants to be able to trust the tool of the trade. Even if this tool has acknowledged limitations, one learns to know them and how to deal with them. The good thing with a STABLE branch is, it offers a chance to see bug fixes without any risk of broken code.

Because the language evolves constantly, it is not possible for library writers to keep up.
The bad thing is, different libraries may take advantage of different features of the language because they were written for different versions of the compiler. This means that libraries are not guaranteed to be compatible with each other.

In order to insure compatibility between libraries, they must all be written for a defined set of features, i.e for a single version of the compiler (or for bug fix versions of this compiler). This would be the role of the STABLE branch.

Every year or so, the DEV branch becomes the STABLE branch, and all the library writers can update their code for the new stable compiler, taking advantage of its new features. And the application writer can then confidently use all these libraries, knowing that they are compatible.

This is more or less how all major languages evolve. Why would D be any different ?