Misc Tech Stuff

Hot Damn!!

Dave Redding — Mon, 12 May 2008 14:14:12 GMT

I know a WMDODN (West Michigan Day of .Net) Post is in order, but that can wait. check this out!

http://blogs.msdn.com/xna/archive/2008/05/07/announcing-xna-game-studio-3-0-community-technical-preview-ctp.aspx

Finally, we can start building games for our zunes! WOOT! I expect to create a talk on the topic very soon

Watashi no "IL Code" seksu desu

Dave Redding — Mon, 31 Mar 2008 14:52:29 GMT

So, I may not be entirely up on my un-couth Japanese sayings, but one thing is for sure, IL code, to the average developer (Read: Me) might as well be written in the same Romaji thats in the title. That is, it's hard to make heads or tails of, and since you most likely never, or only rarely look at it, you get very little opportunity to actually study it. I've been the same way for the past few years, acknowledging that IL exists, and just like that ugly friend, I don't actually acknowledge there being a relationship between "It" and I in public.

That all changed for me last Friday when my buddy Joshua Haynes dropped me a note abut my "Unloved Operators" Tech in 5 minutes post . He was interested enough in how the ?? operator stacks up against the if(x==null) else structure that, he compiled an example and then sent me the IL code, looking for my opinion.

So I was stuck. I could not admit defeat because of my ignorance of IL. So I leapt into action, quickly throwing out all the TLA's I could in an attempt to undermine my friends intelligence. He quickly blocked, pivoted and swatted away my attack. Before he could completely recover I attempted the Clinton-Dodge-the-issue move I had learned from CNN, but Joshuah quickly saw through funny analogy's and interesting tangents and held his ground firmly, so....I gave in and made a trip to the ~~oracle~~ Google. Come to find out, it can be difficult to research an answer, as compared to just pulling out of god knows where. But I think that I figured out how do answer Josh's imposing "What do you think?" question. below is the code and the IL that he sent me.

Person myself = null;
Person myFriend = new Person("Johhny", "Cash");
Person newFriend = myself ?? myFriend;
Console.WriteLine("The new Friend likes: {0}", newFriend.FullName());

if (myself != null)
   newFriend = myself;
else
   newFriend = myFriend;
Console.WriteLine("The new Friend likes: {0}", newFriend.FullName());

IL_0012: stloc.1
IL_0013: ldloc.0
IL_0014: dup
IL_0015: brtrue.s   IL_0019
IL_0017: pop
IL_0018: ldloc.1
IL_0019: stloc.2
IL_001a: ldstr      "The new Friend likes: {0}"
IL_001f: ldloc.2
IL_0020: callvirt   instance string Test.Person::FullName()
IL_0025: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
IL_002a: nop
IL_002b: ldloc.0
IL_002c: ldnull
IL_002d: ceq
IL_002f: stloc.3
IL_0030: ldloc.3
IL_0031: brtrue.s   IL_0037
IL_0033: ldloc.0
IL_0034: stloc.2
IL_0035: br.s       IL_0039
IL_0037: ldloc.1
IL_0038: stloc.2
IL_0039: ldstr      "The new Friend likes: {0}"
IL_003e: ldloc.2
IL_003f: callvirt   instance string Test.Person::FullName()
IL_0044: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
The top is the ?? test and below is if statements. What do you think?

So, starting from the top, I began to investigate what each call was.

The first thing i needed to figure out was, what was the "IL_xxx" marker? simple, line numbers, easy enough. Next up, what does this mean:

brtrue.s IL_0037

a little googling and i found that "br" means "Branch" so "brtrue" must mean "True branch from a decision" (the .s seems to indicate Short form, or something of that nature). So combine that with a line number and we have a basic go-to statement of

IF True GoTo: IL_0037

Ok, so that tackles the low hanging fruit. The next thing on the list was these

stloc.x
ldloc.x

To google for these, i had to rack my brain for a bit. I discovered that there is an OpCodes object that lives in the system.refelction.emit namespace. And surprisingly enough, it has codes that match what I'm seeing the the IL. So I quickly discovered the following entries.

Stloc_0 Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 0.

Ldloc_0 Loads the local variable at index 0 onto the evaluation stack.

Alright, so basically, both of these commands manipulate the Stack (more on "The stack vs The Heap" in another post). For now, lets just call the Stack = Fast memory but limited The Heap =Slow Memory, but massive. Think of the stack as a tower of single bricks. Each brick represents a single amount of data. When you "Pop" an item of the stack you grab the top most item and remove it (in our case, we also "Pop" from an indexed item), when you Push (again, in our situation "Load into"CEQ Compares) your putting something.

There were a few other things to check out before I could move on. For instance, what does ldnull and ceq do?

Ldnull Pushes a null reference (type O) onto the evaluation stack.

Ceq Compares two values. If they are equal, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise 0 (int32) is pushed onto the evaluation stack.

Ok, simple enough. LdNull puts a Null Reference Type onto my stack, and Ceq checks for equality. This will become important later on.

Ok, so I'm armed with some basic implements of the trade, time to start interpreting. The second section seems a bit more straight forward, so lets start there.

IL_002a: nop
                    means no-operation, do nothing, waste time, etc...
IL_002b: ldloc.0
                    Load into a local var whatever is in location 0 on the stack (object "MySelf")
IL_002c: ldnull
                    Load a reference to a value on the heap, into my stack...
IL_002d: ceq
                    Compare the last two values to each other and stuff them into the stack (if x == null)
IL_002f: stloc.3
                     Pop item at index 3 of the stack and into the local variable
IL_0030: ldloc.3
                    Load the value stored in index 3 of the stack to the local variable stack (the result of ceq)
IL_0031: brtrue.s   IL_0037
                    if that value is 1, skip to line 37
IL_0033: ldloc.0
                    Load the value stored at index 0 of variables into the stack (remember, the person "MySelf")
IL_0034: stloc.2
                    Pop the item at index 0 of the stack into the local variables (what we just loaded);
IL_0035: br.s       IL_0039
                    Branches us directly to line 39. do not pass go, do not collect $200
IL_0037: ldloc.1
                    in our else statement, Load item at index 1 into the stack (remember, make x = y if null , essentially)
IL_0038: stloc.2
                    pop off item 2 from the stack into the local variable (the actual variable getting assigned)
IL_0039: ldstr      "The new Friend likes: {0}"
                     load this string into the stack
IL_003e: ldloc.2
                     load variable 2 into the stack (the "NewFriend" object)
IL_003f: callvirt   instance string Test.Person::FullName()
                     call the following method and load it's value
IL_0044: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
                      call this method, which has full access to the stack, so were passing it, in this order, the string "The New Friend Likes:{0}" and then stack item[1] which = the return of Test.Person.FullName property.

Well, that was quite a bit. So the simple rundown is....it does exactly what our code tells it to. Interesting to note though, is were newing up an object of type "Null" and doing an object comparison between it and "Myself". This isn't bad, but it's a tad slow. You also have to load up every property and variable to see if they do actually equate. Find in most situations, but like in the previous post, if you make a comparison of Type B to Null from Type A, when Type B Has references Type A doesn't, your going to error out...because your loading values in Type B, that Type A is ignorant of....GetItGotItGood.

Ok, so we've seen what the commands do, lets take the short route examining how the ?? works in IL.

IL_0012: stloc.1
IL_0013: ldloc.0
IL_0014: dup
                    Duplicate the item on top of the stack and pushes the duplicate into the stack
IL_0015: brtrue.s   IL_0019
                    If the values are the same (if the value of the object is empty like the first register) jump to 19
IL_0017: pop
                    Else pop the first item off the stack and get rid of it
IL_0018: ldloc.1
IL_0019: stloc.2
IL_001a: ldstr      "The new Friend likes: {0}"
IL_001f: ldloc.2
IL_0020: callvirt   instance string Test.Person::FullName()
IL_0025: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)

First off, we have obviously fewer instructions. Secondly, and most important, notice that were not doing any object comparisons or loading any objects from the heap. so the breakdown after examining the two IL statements is this

If(x == Null) is like saying (If object x is the same as object Null)
and
x??y is like saying (If object x is as empty as Brittney Spears head)

So in short, ?? is faster, and easier to evaluate because were only comparing it to an empty value in the stack, not a reference type. Obviously the speed gain is minuscule, but it's still there.

Ok, so IL probably will only help you gain geek cred and debug issues that you'd rather not be debugging. But understanding IL code is worth serious geek cred, and helps you prove (or dis-prove) your theories on how your .net code works. And hey, chicks dig the serious geek ;)

Microsoft announces Open Protocol Specfication

Dave Redding — Thu, 21 Feb 2008 18:15:06 GMT

The link explains it all

http://msdn2.microsoft.com/en-us/library/cc203350.aspx

As a developer, you now have full access to the information about Open Application Programming Interfaces (APIs) and Open Protocols. All Windows client operating system API documentation is now available on this MSDN website.

Wow!!!

What I've learned from bloggin'

Dave Redding — Thu, 21 Feb 2008 14:33:44 GMT

I know, 2 whole blog posts in 1 week, i'm going nuts! Actually i'm trying to ramp up my blogging frequency, so keep an eye out for a few more tech in 5 min and other sheeeet.

If you would have asked me a little more than a year ago if i'd have a (psudo) active blogging habit, I would have laughed it off as something I "Should" do and dropped it. So I still find it a little hard to believe that i've been at this for as long as I have.

Now, while most bloggers seem to make a post in this vein targeted at non-bloggers. I'm not going to. if you don't want to blog, don't. Honestally, I'm not trying to convince anyone of anything and i'm narciscistic enough that I can truly say, I could give a shit less. It's your decision to make and I fully support anyone taking on the daunting task of blogging, I also support everyone else who doesn't.

When considering starting a blog, I had the same excuses as everyone else:

I failed English in H.S., there is no way I could carry on with some kind of constant writing that was open to public scrutiny.
I don't have time.
Does the saying "It's better to be thought a fool than open your mouth and remove all doubt" mean anything to you?

And the most pervasive argument people make to get out of blogging

4. What do I have to say that has'nt already been said before? most likely in a better way than I could ever pen!

Bearing all that in mind, I finally succumbed to my buddy Josh Holmes pressure to start a blog. It's been an interesting trip, and I'd like to take a moment to share with you all what i've learned along the way.

1.) Whatever you write on your blog is inxoriabally tied to you and your name on the internet AND the real world.

Boy, was this a hard lesson learned. Like many other people, I've grown accustomed to the annomity provided by the internet. Like schisophrinic wearing a straight jacket looking for a bathroom, I've bumbled across the web acting and speaking in ways that just are not appropriate in polite company. Which is fine, if your assuming annoyminity. But with a blog, especially a trade blog, you are not anyonomous, not even if you use a pen name. Someone will know who you are and let others know and then BAM, your Real Life name is tied to your writings. Point in case: the lambda expressions tech in 5 min offended a buddy of mine. This buddy exists in Real Life. We drink beers together, talk shit and hangout. So to find out that he was pissed at my real life persona because of something that my internet one did...that was quite a shock.

2.) People are interested in what I have to say, even if they've read about the topic 20 times already.

The one thing I've found through blogging is that, people like options. Like, what kind of car to drive, where to buy their hamburger, or where they go to drink. That urge to have "Options" tend's people to look around. Just because Jay says Vista Sucks for this reason and that, someone else may say it sucks for other reasons. Every blog post (except the ripped off from the authors site) is a unique perspective on the world around the author. So, yeah, someone out there is going to talk about WPF, but is it you?

3.) I've never learned so much about technology so fast.

There has never been a truer statement. When writing my blog, especially the tech in 5 min, i'm forced to double check my assumptions and do a little research before I post to my blog. You don't want to post mis-information, and you don't want to appear a hack, so you have to study. Also, you have to stay on top of technology if thats your blogs focus, you don't want to become stale.

4.) Having a blog gives you geek cred.

Having a blog is a highly interactive deal. It may not seem like it, but the next time your at a launch or usergroup and you mention your blog, bam, someone's going to check it out, and possibally comment. And, since your in print (sorta) you gain crediability. Not only for the content of your blog, but for having the huavos to put your name out there and voice your opinion.

So, i'm not going to say, "Get out there and blog" or something crazy like that, but what I will say is that if your making excuses to not blog, then your only letting yourself down. Blogging is strangly addicitve, a great way to network with people, a fantastic way to show people what you have to offer, an excellent opprtunity to enhance your communication skills and overall, gives you a voice on the internet.