Well, it's too bad. But we decided today not to finish my 13,000-line change for our nullable value methods. A bunch of time has gone by since I started this process, and for many reasons, I haven't had the time necessary to devote to completing it.
During the process of working through the different data types, and reviewing the code where the old methods were used, I found that a lot of mistakes have been made. Luckily though, in most places where mistakes have been made, the code still works just fine. Often, 2 wrongs have made a right, balancing out the mistakes because the methods are quite forgiving.
The risk with moving forward with the code changes is that we're changing so much code, and affecting so many things. If we were doing straight-forward search and replace processes, we could minimize the risk. But since I felt compelled to make sure the new methods would get used correctly, I found myself making hundreds of manual code changes. I'm sure it would be in the thousands by the time I finished. Human error now comes into play at a much greater scale. The global replacement approach was going to be safe because I used TDD to ensure that the new methods provided the same output as the old methods. But making thousands of changes to screens where we alter the implementation is just too risky.
In addition to the risk, there are some other constraints on my time right now that I can't talk about quite yet. But let's just say, I don't have a lot of time to devote to this task, and this isn't the kind of thing I'd want to try to hand off mid-stream.
The last thing that comes into play with this decision is our impending platform change. At some point in the not-to-distant future, we'll be moving DASL to .NET 3.5+. When we do that, we'll have native nullable types. We thought this was still years away, but it is looking like we might start the process sooner. I don't know that it makes much sense to update all of this code and finish implementing .NET 1.1 null handling just in time to move to a new platform that supports nullable values out of the box.
I can't say I'm not disappointed though. When I started the process, I thought that I'd be able to use TDD to create the new methods, and then use global replacements to get it into place, and end up having changed 13,000 lines of code while incurring minimal risk. Maybe next time. Thank god I had been doing all of my work in a Subversion branch. Nothing was ever committed to trunk. So we just delete the branch and forget it ever happened.