On the 17th of October I presented a talk at SMU to a group of computer science students.

Here’s my abstract:

This presentation will show how fundamental computer science concepts such as data structures, recursion, object orientation, and runtime analysis are not only useful beyond the classroom today but also essential skills for tomorrow’s software engineers. I’ll begin by demonstrating real world code where these fundamental concepts come into play. I’ll then show how a robust understanding of fundamentals can mean the difference between an elegant solution and a hack. I’ll conclude by discussing how tomorrow’s reality of many cores, functional languages, massive scalability, and the coming cloud revolution necessitate a solid computer science foundation.

The value of a college education to a career in software engineering has always been questioned. The venerable Robert Martin recently tweeted:

“It doesn’t take a college degree to be a programmer.  Programming is a trade that can be learned through apprenticeship and mentoring.” – Robert Martin

Bob is being narrow; Programming is a broad concept.  Designing compilers, operating systems, embedded systems, circuits and DSLs does require a foundation of computer science. While you can succeed in object oriented business programming without a college degree, you will appreciate knowledge of fundamentals when you step outside this comfort zone.  Yes, you can succeed in today’s 4GL languages without a degree ,but you will be at a disadvantage each time the industry shifts.

Joel Spolsky offers the following on the subject of fundamentals:

“I want my ER doctor to understand anatomy, even if all she has to do is put the computerized defibrillator nodes on my chest and push the big red button, and I want programmers to know programming down to the CPU level, even if Ruby on Rails does read your mind and build a complete Web 2.0 social collaborative networking site for you with three clicks of the mouse.” – Joel Spolsky

I couldn’t agree more.

I had the pleasure of presenting the expanded version of my “Connect with your Kinect” presentation at both the C# Special Interest Group and the Ft Worth .NET User Group this month.   I’ve really been enjoying both speaking on Kinect and developing with the peripheral.  I promised code and slides so here they are!

The code can be pulled from BitBucket here. Slides are available here

I also just learned I get to do this one more time at SMU. The SMU Computer Science Department has invited me to give the talk again on Oct 27th to students.  The talk is open to everyone so if you are interested in attending look here for more information later this month.

I’ve been meaning to tackle this for awhile. GDI+ Architect is a designer I created for GDI+ code under the DBA name (The Modern Renaissance Group (Mrgsoft). It lets you draw objects on a canvas and generate SVG or GDI+ source code. I had moved it a while back from .NET 1.1 to 2.0, but there was a proprietary icon set which prevented me from releasing the source.  I decided to just remove the icons and keep my ugly ones I created in instead.

My reason for open sourcing it is want to make sure if anyone had legacy code from the .NET 1.1 time frame that used this product, they could still get at it. While I don’t expect a lot of new development on this project, if you need help with it please contact me. It’s also interesting code you ever need to do anything with snapping, drawing, text wrapping, or anything of that sort regardless of your target platform. Even though this code is geared toward .NET GDI+, the concepts are universal. Warning though – it’s in VB.NET instead of C# as this was once my primary language.

It’s rough to look at your own code from 8 years ago. It’s missing clear separations of concerns. It’s got some “mammoth methods” that need to be torn apart and refactored. It’s littered with somewhat useless comments because I thought code wasn’t “done” until it was commented ad nauseam. Also since it’s from the 1.1 timeframe there is no use of generics, Linq, etc. In fact checking it into BitBucket today was the first time it ever saw a source control repository! My how things change.

All that aside, it shipped, was fairly bug free, and made me a decent return on investment and received positive feedback from customers.

If you are interested, you can get the source from BitBucket.

Since the ALT.NET movement a couple years ago, Microsoft developers have, to varying degrees, embraced open source technology.  Many of us can’t imagine planning a project or designing an architecture without leveraging at least some open source tools.  What surprised me is where the source for these tools live.

Here’s the skinny:

A couple note on my data. 

First, there are excellent open source project from Microsoft including Unity, MEF, the Silverlight toolkit, and more hosted on CodePlex, but I have excluded these since they are not community open source projects.

Second, some of these projects are not on created on the .NET stack but I believe they are still relevant to .NET developers so I have included them. Other projects I have left off because they are not relevant to developers, rather consumers.

Finally, this is my subjective list of projects. I’m sure I forgot some.

Based on this data, it’s GitHub by a landslide.  The truth is almost every important C# based open source project lives there.  And amazingly, Git is only sort of supported on Windows using Cygwin. What’s going on?

It turns out that GitHub has turned open source collaboration into a social experience.  Contributors can gain status and recognition for participating in GitHub.  Projects rank against each other in a fun, competitive manner.  It’s easy to search projects by language and to collaborate.  In other words, GitHub really is “cool”.

GitHub also revolves around Git which is distributed version control.  For SVN or TFS users, this is a completely new and liberating experience.  I recently worked on an SVN project where certain folders were only committable by one individual, effectively stopping collaboration.  Nothing like this happens with a Git based project.  You are encouraged to fork and you can always commit against your own repository, 

If you haven’t used Git, there are some good resource to help you get started.  I think the best is Rob Conery’s series on TekPub called Mastering Git.  It’s not free, but it’s really good and it shows using Git from windows.

Last May my friend Shawn Weisfeld recorded a quality presentation by David O’Hara presenting at the North Dallas .NET User Group on Git.  You can see that presentation here.

For me, I think Mercurial is the better distributed version control system for Windows users.  It doesn’t require Cygwin and there is a nice Tortoise and command line client.  You can also play nice with GitHub using this plugin.

My data set below.

Generics were a great addition to .NET but sometimes their behavior can be unexpected.  Check out these somewhat unintuitive bits.

Static Constructors

Consider the following class with a static constructor:

        public class GenericDemo<T>
    {
        static GenericDemo()
        {
                Console.WriteLine("static (shared) constructor");
        }

        public void SayHello()
        {
            Console.WriteLine("Hello!");
        }

    }

Given the following usage of the type, how many times is the shared constructor called?

            1:  public static void Main()

            2:   {

            3: 
        

            4:   GenericDemo<string> instance1 = new GenericDemo<string>();

            5: 
        

            6:   GenericDemo<string> instance2 = new GenericDemo<string>();

            7: 
        

            8:   GenericDemo<int> instance3 = new GenericDemo<int>();

            9: 
        

           10:   GenericDemo<float> instance5;

           11: 
        

           12:   GenericDemo<double>.SayHello();

           13: 
        

           14:   }

The answer is 3 which makes sense if you think about it.

This gets at the heart of what generics really are.  Static constructors are only called once (single threaded assumed) per type when first instantiated or when invoking a static method.  So lines 4, 8, and 12 exclusively manipulate new types for the first time and trigger the call.

Overloading

Consider the following declaration.

        public class GenericDemo2<T>
    {

        public void SayHello(T myinput)
        {
            Console.WriteLine("generic overload invoked");
        }

        public void SayHello(string myinput)
        {
            Console.WriteLine("string overload invoked");
        }

    }

Will it compile? It surprised me that this is indeed valid and does not throw a runtime error if T is a string.  If called when T is a string, it calls the non generic method every time.  Interestingly VB does not allow this to compile because its implementation varies slightly.

How about this which uses generic methods:

        public class Example3
{
    public void SayHello(string toSay)
    {
        Console.WriteLine(toSay);
    }

    public void SayHello<T>(string toSay)
    {
        Console.WriteLine(toSay);
    }
}

It looks like there would be a conflict and the compiler would reject the overload.  But it does compile!  The T is a true parameter and gives it a different signature!