QuoteOriginally posted by: outrunOk, for MC 102,.. if you change the interface of design then do you want to solve it this way* it gets a new project in the sandbox to guarantee the non breaking of 101 users.* the 101 stays parallel+1Parallel Implementations is the way John Carmack endorses.That being said, I don't think there's much of a reason to worry about backward compatibility or interface stability of the code in the sandbox -- we're still at the early prototyping stage (that's what the sandbox is for -- an unreviewed code), once we move beyond that stage, we may consider those requirements when reviewing for the acceptance into the "official" libraries, but everything seems to indicate we still have a long way to go to reach the stage when it'll make sense to worry about that and the submission process itself. EDIT: to further elaborate upon what I mean -- in the sense as delineated in the quote below, I think we're only having experimental implementations at this stage, the reference implementation is something that might (or might not) evolve in the long-run (I'm afraid that means more than a couple weeks in our case):QuoteThere are two general classes of parallel implementations I work with: The reference implementation, which is much smaller and simpler, but will be maintained continuously, and the experimental implementation, where you expect one version to "win" and consign the other implementation to source control in a couple weeks after you have some confidence that it is both fully functional and a real improvement.It is completely reasonable to violate some generally good coding rules while building an experimental implementation -- copy, paste, and find-replace rename is actually a good way to start. Code fearlessly on the copy, while the original remains fully functional and unmolested. It is often tempting to shortcut this by passing in some kind of option flag to existing code, rather than enabling a full parallel implementation. It is a grey area, but I have been tending to find the extra path complexity with the flag approach often leads to messing up both versions as you work, and you usually compromise both implementations to some degree. Some extra reading to ponder upon:
http://lcsd05.cs.tamu.edu/papers/ramey. ... er-review/