My opinion? They have their place. However, it’s because of the abuse of Exceptions that you sometimes feel dirty for using them. I tend to agree with those that believe in exceptions for exceptional cases, as lame and / or straightforward as that sounds.

Why do I say this? Sometimes you see Exceptions used for ordinary, average program flow control.


try
{
this.SomeImportantSoundingFunctionThatShouldNotFail(someParam, someLocal, -1);
}
catch (System.Data.SqlException)
{
return true;
}
catch
{
return false;
}
return true;


I actually saw this in a very real codebase! Yes, including two unnamed exceptions. (Side note: Don’t do that either.) Apparently, it’s okay to fail in the SQL query, but if there was to be some sort of Windows exception (NotEnoughMemory?) would be an actual failure. This code, to me, says that the entire Database is unnecessary or we assume we know exactly what the SqlException. In the end, I investigated an SQL procedure and it was a constraint violation that wasn’t truly a failure, but this function was ugly none the less. Furthermore, what happens when the SqlException changes because we can’t even connect to the database?

Looking at this, you might not think the code is THAT bad. Consider it, though. We sweep an exception under the rug, designed a system to silently fail half the time, and ignore the unnamed exception because we think we know exactly what it is. This is a bad assumption with an unnecessary amount of overhead.

This is a pretty simple example and some might argue with the language I have used here. Let me clarify. Exceptions should not be used in everyday code flow as a fifty-fifty chance. Exceptions should be thrown when the caller gives you egregiously bad data. Exceptions are okay if you get some unrecoverable error you need to bubble upwards. Exceptions are a part of the language and they have their place. That place is not multiple times a frame every update loop.

What if I told you this was in some TreeView related code? What if I told you this code was called thousands of times in a second in response to a mouse click? Exceptions have performance and memory implications if used two thousand times in a row in a single frame. There’s no way around that one. You could balloon loading from a minute to five. (Another side note: That’s not hypothetical. That’s anecdotal.) Be careful about how you use exceptions! Please don’t use exceptions for flow control, especially deep in a stack that gets called often.

After a short coffee and pastry break, we reconvened to hear about the latest server upgrade and how it can be utilized to the fullest as well as a testimonial from National Instruments on the why and how of Perforce. I heard a few cool things and had a few good ideas. The event, however, seemed aimed at executives and administrators. I think I was one of three or four developers.

The real value, for me, came afterwards during the demos and networking. This is where I realized that Commons could be everything that we wanted, got some made-to-order macaroni and cheese, and enjoyed some conversation. I was able to talk to some folks from other companies and get some stellar advice. Use an ssd for your Perforce server and it will be crazy fast. Don’t bloat your metadata with horrible automatic check-ins. Go to Burning Man and get crazy. You know, all kinds of great advice.

My advice? Go for the swag. Stick around at the end for the networking.

It is called Debtscape. It helps you escape your debt. (A port manteau of debt and escape, of course.) You enter your debts and you can use one of two debt snowball methods to calculate how long until you pay off your debts. Plus, it tells you what order to pay off your debts. Here is a screenshot in which you would never be able to tell that I did my own art.

Let me break down what is in this photo and what I learned. First of all, here we have a Panorama view. A Panorama is the current Windows Phone hotness in which you can put multiple tabs on a single page and navigate through them by swiping left and right. You’ll notice that you can see a sliver of the next tab on the right side, and this is to make it intuitive that you are able to swipe from right to left to discover it. You create Panorama Items like so:

<!--Panorama control-->
<controls:Panorama Title="DebtScape">
<controls:Panorama.Background>
<ImageBrush ImageSource="../DebtScapeBackground.png"/>
</controls:Panorama.Background>
<!--Panorama item one-->
<controls:PanoramaItem x:Name="Debts" Header="Debts">
</controls:PanoramaItem>
</controls:Panorama>

You can see that I use the Header attribute in the PanoramaItem. This gives me a default header at the top labeling the tab of the PanoramaItem. DebtScape uses three tabs: Debts, Add Debt, and Settings. This is the Debts PanoramaItem and it contains a DataBound ListBox. This is achieved simply and elegantly through the xaml. Instead of putting any code in the .cs file, I have created a template that transforms a DebtItem from a data structure into a view with a progress bar and fancy markup. It happens in the xaml like so:

<ListBox Name="DebtListBox" Margin="0,0,0,0" DataContext="{Binding}" ItemsSource="{Binding Items}" VerticalAlignment="Top">
                        <ListBox.ItemTemplate>
                            <DataTemplate>
                                <StackPanel Margin="0,0,0,0" Width="432" Height="198">
                                    <TextBlock Text="{Binding Name}" TextWrapping="Wrap" Style="{StaticResource PhoneTextExtraLargeStyle}"/>
                                    <Rectangle Height="26" Margin="-20,0,0,0" Width="390" Stroke="Black">
                                        <Rectangle.Fill>
                                            <LinearGradientBrush StartPoint="0,0" EndPoint="1,1">
                                                <LinearGradientBrush.GradientStops>
                                                    <GradientStop Color="Red" Offset="0.0"></GradientStop>
                                                    <GradientStop Color="Red" Offset="{Binding PercentPaid}"></GradientStop>
                                                    <GradientStop Color="Transparent" Offset="1.0"></GradientStop>
                                                </LinearGradientBrush.GradientStops>
                                            </LinearGradientBrush>
                                        </Rectangle.Fill>
                                    </Rectangle>
                                    <TextBlock Text="{Binding PrettyDebtString}" Margin="0,-29,0,0" TextWrapping="Wrap" Style="{StaticResource PhoneTextNormalStyle}" Padding="20,1,0,0" />
                                    <TextBlock Text="{Binding MinimumPayment, StringFormat='{}{0:C} Per Month' }" TextWrapping="Wrap" Style="{StaticResource PhoneTextNormalStyle}" />
                                    <TextBlock Text="{Binding APR, StringFormat='{}{0}%' }" HorizontalAlignment="Right" Margin="0,-27,35,0" TextWrapping="Wrap" Style="{StaticResource PhoneTextNormalStyle}" />
                                    <TextBlock Text="{Binding MonthsRemaining, StringFormat='{}{0} Months Remaining' }" TextWrapping="Wrap" Style="{StaticResource PhoneTextNormalStyle}" />
                                    <Button Content="Pay" Name="payButton" Width="130" Height="70" HorizontalAlignment="Left" Click="payButton_Click" />
                                    <Button Content="Edit" Name="editButton" Width="130" Height="70" Margin="0,-70,19,0" HorizontalAlignment="Center" Click="editButton_Click" />
                                    <Button Content="Delete" Name="deleteButton" Width="130" Height="70" Margin="0,-70,20,0" HorizontalAlignment="Right" Click="deleteButton_Click" />
                                </StackPanel>
                            </DataTemplate>
                        </ListBox.ItemTemplate>
                    </ListBox>

Do you see the fanciness of Binding? Oh yes! We simply set the ListBox’s DataContext property to an IEnumerable; and it works like a charm. Actually, we could set it to a IEnumerable of anything as long as it contains the public Properties that are mentioned in the Bindings. This is both a blessing and a curse as it is a simple to do as it is to screw up. Speaking of making sure input is valid; queue an awesome segue way into the Add Debt Panorama Item!

The Add Debt PanoramaItem is a tab that lets the user add new debts. I require the fields to be filled out and the fields that are numbers must be numbers. Here is how you can do that!

<TextBox x:Name="minimumPaymentTextBox" Text="{Binding MinimumPayment, Mode=TwoWay}" InputScope="Number" />

I have ensured the data is entered appropriately by constraining the input. This actually pops up a keyboard that only contains a number and a period. On the back end, I have bound this to a float property. Should the data be mucked with outside the application somehow they will get a big, fat goose egg. (That’s a 0.)

Okay, this seems to be running a little long. Stay tuned for the next episode where I’ll delve into the Settings and how to use IsolatedStorage to store files and other objects.

Wrong. For some reason they offer the Performance Tools from the Team Suite as a free download online. Check it out! How nice, Microsoft! The only draw back is that you will be doing this through the command line. (Even then, for some that is a pro and not a con.) My program is a command line utility, so it did not really change my method, but it is something to note as a draw back for the less command line literate. So I looked for a tutorial to get me on my way and I found everything I ever needed. Sort of. A little bit.

I spent way too much time staring at a blue screen. It was horrendous to behold. All I was trying to do is profile my C# application to gather some metrics for something I already know. The computer needed a memory upgrade. Before you even begin, see if you need this patch: http://blogs.msdn.com/b/chrissc/archive/2009/02/24/patch-released-to-fix-sampling-on-intel-core-i7-processors.aspx. Otherwise you will blue screen constantly and think you are doing something wrong. Trust me, it is a huge waste of time if you have an i7 processor and don’t download this patch.

To get us started, here is the article of reference I used: http://msdn.microsoft.com/en-us/library/aa985628.aspx. This was probably the best source of information. I will be duplicating some of the information here in walking through how to profile a C# application.

Let’s begin. Build your binaries in Release! Building in Debug is a waste of time as it does not perform quite the same. Add the location of the VSPerf tools to your PATH. Again, build Release and then fire up the command line. For me, this was located in “C:\Program Files (x86)\Microsoft Visual Studio 9.0\Team Tools” and if you have Visual Studio 2008, that’s where it should be for you. Translate to the proper Visual Studio install and OS for your machine.

Now you have a choice to make: Sampling or Instrumentation. If sampling, you just need to turn sampling on globally with the following command:

VSPerfCLREnv /sampleon

If you are using instrumentation, you will have to do slightly more. Turn on instrumentation globally:

VSPerfCLREnv /traceon

For all of the dll and exe files that you will be profiling, (hint: do this for dependencies) you will need to run the following commands to allow instrumentation.

VSInstr ProgramOrDll.exe


Now you’re ready to collect some data. I hope you have a simple, repeatable test planned. This is critical to identifying performance issues, especially if you plan on fixing them. Always have a repeatable test and run it multiple times to ensure you get correct data. Run your program from the command line with Performance Monitor by using the following command:

VsPerfCmd /start:sample /output:Report.vsp /launch:YourProgram.exe


When you’re done with sampling, you must turn it off with the following command. (Instrumentation will end when your program ends.)

VSPerfCmd /shutdown


Now you’ve got a beautiful vsp sitting on your hard-drive! This is the raw performance data. Now you need to change it into a consumable format because of our lowly Visual Studio version. Team Edition opens these bad boys. We are going to use more primitive tools. Microsoft, and I, recommend creating a folder at this point to help stay organized. Run this command to create a bunch of csv files:

VSPerfReport PeopleTraxReport.vsp /output:path\filename /summary:all

Now, don’t forget to restore your environment!

VSPerfCLREnv /sampleoff


These csv files are all different types of profiling information. You can tell what they are by the extension. There are functions, threads, modules, etc; My recommendations? If you’re looking for hotspots, use the _functions file. Application Exclusive Time is a great column to sort. If you’re trying to find a dead-lock or places of I/O wait try the _threads file. Otherwise, enjoy!

Now, what I found wasn’t exactly reflection, more like run time type checking, but it was certainly a useful tool to accomplish what I needed to do. What’s that magic?

[SomeClass class];

That’s right, there is actually an object called Class. Every single object implicitly has a member of type Class, the isa pointer, which you can get with the “class” message. This member tells you to what type your object points. You may have noticed this while debugging in XCode. Every time you mouse over a variable you get that lovely isa pointer. You probably thought it was obvious and totally annoying if you came from Visual Studio. Class is a strong type of which you can declare instances, pass to functions, and anything else you can do with a class. You can use this for numerous things, the most obvious among them being run-time type checking. Is my BaseVehicle object ACTUALLY a Car or is it a Plane? Grab that class and compare like so:

Class realClass = [someVehiclePointer class];
if ([realClass isKindOfClass:[Car class]])
{
// Do something specific to Cars.
}

Maybe, you want to know more than whether you’re a Car. You have a Sedan or a SportsCar class derived from Car and you even have Civic, Camry, Charger, and Lamborghini classes derived from those types. Maybe you only want SportsCar derived classes.

if ([realClass isSubclassOfClass:[SportsCar class]])
{
// Get ready for the races!
}

Now, what if you wanted to test for exact matches only? What if you wanted to put your foot down and make sure that there is no inheritance masquerading, and that your object MUST be a Lamborghini in order to respond to the OpenButterflyDoors message. There is a message for that as well!

if ([realClass isMemberOfClass:[Lamborghini class]])
{
[someVehiclePointer OpenButterflyDoors];
}

Finally, another trick you can do with Class, is use an instance of Class as a type. (Huh?) Meaning whatever you can do by typing the actual class name, it is possible to do with an instance of Class. (Well, except forward declaration, I think.) For example, if I had a VehicleFactory, I could implement a method in the following way:

- (Vehicle*) createGameObjectOfClass:(Class)type Error:(NSError**)error
{
Vehicle* result = nil;
if ([type isSubclassOfClass:[Vehicle class]])
{
result = [[type alloc] init];
[m_objects addObject:result];
}
return result;
}

Hello, Factory! Hello, decoupling! Hello, Class! But wait, there’s more! Is it necessary to check if you subclass something? Maybe my factory follows a different contract. By convention, people usually think that you need to be of a certain subclass to have any given collection of functions. Not true. You don’t have to derive from a Car in order to accelerate and decelerate. In fact, a Person does the same thing. If I only care about subclassing because I don’t want to add objects that can’t respond to that message there is a more accurate check!

if ([vehicle respondsToSelector:@selector(accelerate)])
{
// Make the thing go vroom!
}

At this point, you may be looking at all of this and thinking it is a bit of black magic. It must have a harsh performance penalty. It seems you would be disappointed. You see, Objective-C sends messages using a similar methodology all the time. You check the isa pointer on a class to see whether or not a selector (method, message) is handled by the class. If it is not, you check the parent class, rinse, repeat. Theoretically, you incur the same cost as calling a function (sending a message.) The only gotcha there is that over time, messages that are commonly called get put into a cache and don’t incur the walking of the inheritance chain. (See link.) If you want faster performance than that… well, you could turn to these articles and start implementing your own obj_msgSend function. Personally, I prefer readability. I prefer clarity and reduced maintenance costs. I prefer simply sending messages by using the bracket notation and the simple isKindOfClass message.

Thoughts? Comments? Clever uses for the isa pointer? Drop a comment!

See you, Space Cowboy.

It’s a whole new year, baby. Welcome to my fancy, new blog. I decided to move hosts to WP Engine, a dedicated WordPress host who will serve my pages 4.7x faster. (Yes, that’s a real, measured metric.) As a part of the move, I have decided to do some major house-keeping. I am going to edit the heck out of the previous content I had and re-post it eventually along with plenty of fresh stuff.

So welcome. If I could pretend this was a website from the earlier 90′s for a moment:

There are exciting things to come. We just launched Star Wars: The Old Republic. I have news I cannot share, yet. I just got a new toy and I want to get programming. Join me, won’t you? Until next time…

See you, Space Cowboy.