DMD needs branches

[Clay Smith]

Walter Bright wrote:
> Chris Miller wrote:
>> I know, I know, report bugs. This doesn't cut it. Reporting bugs is 
>> hard as hell and time consuming. I need time to report bugs. Now I 
>> have to either restrict use to specific compiler versions, which 
>> people don't always know about and report their issues back to me, 
>> until I remind them they need to downgrade their compiler (which isn't 
>> always an option if they need bug fixes), or I have to rush to fix my 
>> code to workaround such issues and report bugs. If there was a stable 
>> branch, I could get the code working with the unstable branch at a 
>> reasonable pace.
> 
> Please let me know which issues are breaking your code. I'll be sure 
> they get in the test suite so they'll never break again.

What we're trying to say, I think, is that we simply need two compiler 
branches.

D 1.x Compiler + Documentation Branch w/ bug fixes only

D 2.x Compiler + Documentation Branch w/ features & bug fix

The problem is that folks need a compiler that is consistent and stable, 
and constantly adding new features to the compiler inherently undermines 
its stability. We could report bugs, but why report bugs when this 
fundamental issue can be solved by a simple change of compiler 
development? Some of us have little time on our hands to develop in D, 
but when developing, would rather spend our time coding D then going on 
bug report brigades which are seemingly entirely avoidable.

For example: even though DMD v1.0 doesn't use the 'ref' keyword, using 
the -v1 switch still allows you to use the 'ref' keyword and it works as 
expected. These types of problems, I imagine, must be more difficult to 
handle only having one compiler branch. With two compiler branches, 
these problems will never crop up in the first place.

I know two compiler branches might be more difficult to maintain and 
will probably consume 2x more development time on your part, but I 
imagine some us of just need a stable branch no matter the cost, where 
they can guarantee new bugs aren't added from new features that they 
don't even use. IMO, D seems in a constant process of keyword and 
feature assimilation, and D might even be benefited by simply slowing 
down the pace a little.

While I know you treat this simply as a technical issue, it is a 
psychological issue as well.

1) Big company will never adopt a language which can not /guarantee/ 
stability. ( or, nonprofessional coder only has time to code , not bug fix )

2) From the outside, having a compiler constantly add new features + 
keywords almost guarantee's the compiler won't be stable, and certainly 
looks like an extremely unstable language from the outside, and 
therefore an unstable compiler.

~ Clay