Haven’t been able to spend too much time on it lately, but the code is now down to 6,470 errors.
One thing I have been able to do a bit of lately is read a few more programming books. I’ll have to post a few comments on them one I finish what I’m reading now.
Down to 6,976 today.
Down to 7006 errors today. That’s all.
After a handful of changes, the number of errors is down to 7,173. That’s less than half of what we had during the last report.
Most of the fixes were ‘invalid argument’ fixes (function calls for ref ClassName, but called without the ‘ref’).
Ever-so-slight progress this weekend – only 77 squished, making the total 14,810.
The errors count is now down to 14,887. The more time I spend with C# the more I develop a pure loathing for raw C. Programming with C is like trying to chop down a tree with a spatula. Sure, you could probably manage to get your way through the tree, but it’s going to be a long, messy, painful task.
ReSharper’s main feature is automatic code analysis. When you open a code file, it will scan for and higlight errors in your code and show an error count and error locations on the sidebar. It also goes a step further than the compiler by highlighting warnings and making suggestions for improving code.
ReSharper is smart enough to warn about places where a NullReferenceException could occur and overrides intellisense with its own, more thorough version. It gives more parameter information, shows more class info, and takes intellisense to the next level in general.
Visual Studio’s refactoring options are a neat addition, but not overwhelmingly useful. ReSharper extends them quite a bit to add a lot more functionality. I never really made much use of ReSharper’s refactorings since I prefer to change things by hand.
ReSharper has quite a few features that I couldn’t imagine ever using, such as code generation, code templates, and build script editing.
Although it add a lot of features and functionality to Visual Studio, in a project of any significant size (such as the 116k-line Basternae codebase) it causes a drastic slowdown, rendering my development machine nearly unusable at times, especially when code analysis is grinding away on a large code file. It’s true that the codebase I’m working on isn’t optimal (huge classes, bloated files, plenty of errors, etc), but that’s why I’m working on it in the first place — to fix all of that.
It’s an ambitious tool, but perhaps it’s trying to do too much. Maybe future versions will be faster, but right now it doesn’t add enough value to the development process to justify the $149 price tag.
If JetBrains removed everything but the code analysis functions for a “lite” version that sold for $49 I’d buy it in a heartbeat, but as it is now ReSharper doesn’t speed up my development process more than it slows it down. I’ll look at the 4.0 version when it comes out, but 3.0 isn’t for me.
Just a few minor fixes for today. The error count is now down to 15,785.
This may only be a temporary solution until I find a better way, but for now we just number skills and spells in the constructor based on a reference count (static int _numSpells), essentially like this:
Spell()
{
SpellNumber = _numSpells;
++_numSpells;
}
This insures that nobody will get a duplicate and is a simple way to do things. More importantly it was quick to implement and didn’t break anything.
We’re now down to 16,156 errors.
Small change in numbers: We’re now at 17,270 errors.
One of the problems I have to solve is to find a clean way to create global references to specific spells and skills without them actually being globals (which are ugly and disgusting and a horrible thing to put in code).
For example, in C, we used something like skill_bash which was just an integer referring to the skill number for bash. At runtime, when all the skills were initialized, the value of skill_bash would be set. It didn’t really matter what order skills were created in, because skill_bash would always point to the bash skill, whether it be number 35 or 350. The problem with this method is that is uses a global variable. It’s something that can be done in C#, but what, really, is the point of having a value containing the bash skill if you someday decide to take the bash skill out of the game. Then you have a bunch of useless code lying around doing nothing.
Not that bash will be removed from the game — this is something more likely to be an issue with spells.
I’ll have to look into reflection, delegates, etc. to see if there is some sort of common-sense way to handle this. I also have to keep in mind that someday I may want to convert the skill and spell tables to files that load at runtime and can be tweaked and adjusted without recompiling the entire codebase.
Since skills are so heavily involved in the game engine, it will be nearly impossible to decouple them completely.
The error count is now down below 20,000. Quite a bit, in fact. We’re now at 17,719. This puts us at about 4500 for the day.
A large portion of the vanquished errors were just array initialization fixes — converting from C-style to C#-style, which is quite different. I can’t give a definite date, but I suspect this phase of the conversion/rewrite will finish in mid-August.
One thing commonly seen in C and C++ code is use of the NOT operator to check whether a struct or class pointer is set to NULL. For instance:
class value = NULL;
if( !value )
{
printf( “value is null” );
}
In C# code this results in an error because the compiler has no idea what “NOT” means on a class. To be able to use this syntax in C# you have to override the ! operator, which is something I’ve never had occasion to do, AND that there are no easy-to-find code examples of. Luckily it’s just like overloading any operator in C#:
public static bool operator !( ClassType ct )
{
if( ct == null )
return true;
return false;
}
It works and it saves me the trouble of changing around 700 lines of code. We’re now down to 20,392 errors.
I mentioned in an earlier post that Visual Studio 2005 was gradually becoming more responsive as the error count decreased.
On my system, which is a Pentium D 2.66 GHz with 1GB of RAM, it starts becoming usable again at about 22,000 errors (we’re at 22,267 now). That’s where the “type-a-character-and-wait” transitions into using the application in realtime.
One thing to keep in mind is that I have a trial installation of ReSharper (which I’ll post about once I’ve had more chance to evaluate), which slows things down considerably due to constant recompiling to find errors in realtime and excessive intellisense-ing above and beyond that which Visual Studio does. Without Resharper I think I would have noticed responsiveness a bit earlier, but for now I have to say that 22,000 errors should be considered the upper limit of usability in a system like mine.
With more RAM it would probably be a bit better, and at this point it probably makes sense to upgrade to 2GB (RAM’s gone down quite a bit recently, probably due to Vista finally starting to sell). I’ll have to add that to my grocery list.
Soooo… here’s my list of excuses:
1. I started a new job Monday (writing home automation software used to control lights, stereos, alarm systems, etc.)
2. I got married over the weekend.
3. I’m just plain tired right now.
So, not much progress in the past few days. The bug count is sitting at 22,677 right now. At that rate it would take about 396 days to finish. It won’t take that long.
We’re down to 22,906 errors now. The errors are getting a little harder to smash, but we’re crushing them into tiny little bits nonetheless.
One of the things I had to do to eliminate a few thousand bugs as part of this C++ to C# conversion is replace the text transmission functions.
Nevermind how they work internally, the important thing for the sake of the current conversion is that they look completely different.
The old functions looked something like:
send_to_char( “Words.\n\r”, ch );
While the new functions are supposed to look like:
ch.SendText( “Words.” );
With around 4000 or so calls to that function, it would be a dauntingly huge project to retype every reference to send_to_char. Because it’s a bit more complicated than a simple word replace, we would be hosed if not for Visual Studio 2005’s regular expression search and replace.
If you Google regular expression search-and-replace, most likely you’ll come up with a lot of people complaining about it. Ignore them — those people are whiny idiots. It is easily one of the most useful things ever added to Visual Studio and it takes about 10-15 minutes to get the hang of.
To make the above change, all I had to do was do a search for:
send_to_char[(] {:q}, {:i} [)];
And replace it with:
\2.SendText( \1 );
As a basic explanation:
1. Anything in [] brackets means “any of these characters”. I had to bracket the parenthesis to keep the parser from evaluating them as an expression.
2. Anything in {} brackets means that it’s assigned an “expression tag”. It’s the equivalent of the scripting language act of assigning it to %0, %1, etc and they’re numbered in the order they are found.
3. :q means match a “quoted expression”.
4. :i means match a C++/C# identifier (i.e. a variable name).
5. \1 means “insert the first tagged expression”. \2 inserts the second, etc.
This is enough to get the basic idea going, and it works like a charm, provided the functions are spaced EXACTLY as indicated. If you have something like (notice spaces):
send_to_char(“Something” , ch );
It will not work. In any codebase that has had more than one person’s fingers in it, you’ll have inconsistent spacing. Some people will put spaces before/after every variable, some won’t, and some will be mixed. That’s why we have to set it to ignore spaces anywhere they will be a concern. We do this by inserting [ ]* which means “match anywhere from 0 to infinity spaces”. The search expression now looks like:
send_to_char[(][ ]*{:q},[ ]*{:i}[ ]*[)];
And now that I’ve figured out how to use regular expressions, all of the references to the Diku send_to_char function have been replaced with our shiny new code.
The error count is now down to 24,414.
Now we’re down to 30,975. Nothing interesting is happening, but we’re making progress.
Most of these errors are related to one of four things:
1) References to functions moved into classes have to be changed.
2) Pointer-based functions and comparisons that need to be rewritten to be reference-based.
3) Public vs. private data.
4) Different handling of arrays in C#.
The majority are #2, with a large quantity of each of the others. When you have 30,000+ bugs to fix, everyone gets their share.
The compiler tells me:
“You have just passed the halfway point in the journey toward your next codebase.”
Errors are now quite a bit less thant the halfway mark (which would be 37,571).
We now have 35, 542 errors to resolve. We’re making pretty good progress so far.
We’re down to 39,610 errors now. Even though that’s a stunningly huge amount, it’s still progress.
My brain’s starting to hurt, I should probably work on a different project for a few days.
We’re down to 44,773 errors. That’s 12,486 fixed for today.
Visual Studio 2005 has become noticeably more responsive. It’s still a little slow and clunky, but each error corrected is a slight speed increase.