Confession of an Option Strict Convert
Back when I first got going with .NET, one of the first programs I wrote was actually a program I had written in VB6, then converted over to .NET (not using any wizard, it was a total re-design).
The program is a complicated genetic algorithm that does pattern matching. The number of generations is so high that the total runtime to reach an endpoint for all tests I performed with that original version took a minimum of three days, and some took a fourth day.
A couple days back, I decided to add a feature to the program, and as I was working on it, I realized that I was not getting warnings or errors when I should have. When I looked at the project settings I found out that I had not had Option Strict On for the project. Therefore, I turned it on, and took about an hour fixing the errors that arose. All but about two of them were really trivial cases of explicitly converting things that had previously been handled implicitly. The other two were bugs that I had never encountered, but which could have caused trouble at times (in fact, the program did cause unhandled errors once every week, or so, which was too rare and random to even attempt debugging).
Having made that change, I decided to re-run the program on the same data sets that I used the first time around. Since the time to completion changes each time, no single comparison is necessarily meaningful, unless the difference in runtime was HUGE Since the change I had made added a few minor steps, but added them at the innermost loop, so that they happened ALWAYS and OFTEN, I felt that the change would be a minor increase in time taken.
Now, the first run is nearing completion, and it will finish after only two days. Considering that ALL previous runs took AT LEAST three days, this is MUCH faster than any earlier run, even with the increased operations of the new feature (and running it for a few hours in a slower mode).
Therefore, it appears that Option Strict On does not just find some bugs, it can have a highly significant affect on the runtime of a code-intensive program. All of this speed increase appears to be due solely to explicitly directing casts instead of allowing them to be implicitly handled.
Use Option Strict at ALL times.
Re: Confession of an Option Strict Convert
Good post and good advice. :thumb:
Re: Confession of an Option Strict Convert
Option Explicit and Option Strict should not be optional. There is always a way to convert, cast or reflect to get it working correctly.
Re: Confession of an Option Strict Convert
It is somewhat disappointing that Microsoft chose to have Option Strict Off by default. How many people have been developing for months or longer before they even know it exists? By then they are in bad habits and have lots of code to fix if they want to turn it On. I was in that very position myself. Having it On by default with the option to turn it Off would have been preferable, but I guess they figured that people who didn't know it existed would then be complaining that it was too hard to understand how to cast and convert all the time. I guess it's just a part of how VB is easier to use but easier to write bad code in too.
Re: Confession of an Option Strict Convert
Quote:
Originally Posted by jmcilhinney
It is somewhat disappointing that Microsoft chose to have Option Strict Off by default. How many people have been developing for months or longer before they even know it exists? By then they are in bad habits and have lots of code to fix if they want to turn it On. I was in that very position myself. Having it On by default with the option to turn it Off would have been preferable, but I guess they figured that people who didn't know it existed would then be complaining that it was too hard to understand how to cast and convert all the time. I guess it's just a part of how VB is easier to use but easier to write bad code in too.
I totally agree!
Back in VB6, Option Explicit was not the default (or was it VB5?). That was bad back then. Option Strict should be the default for .NET. I was hesitant to move there at first, because it seemed like more work. It isn't much more work, and it produces better, cleaner, safer code. Now I can see the performance benefit as well. I knew there would be some, but I didn't think it would be so great that even with the added work in the inner loop, my speed increased dramatically.
It's good to see an improvement in action, so I figured I ought to share in the hopes that somebody will be converted to using Option Strict just because of the performance consideration.
