David Mohundro

2011 in Review

2012-01-08

Now that the year of the Mayans is upon us, I wanted to take some time to look back over 2011. And don’t worry, I’ll do my best to not mention the Mayans and 2012 anymore this year. I won’t guarantee it won’t come up again because I think it is funny, but I’ll try.

A new job… sort of

Back in June of 2010, I made a major decision and moved my family to Memphis and took a new job. Little did I know that my employer would change in just over a year. My prior employer, ServiceU, was acquired by the Active Network. I’m still at the same location doing mostly the same thing, but it was still unexpected. I’m excited about the change, though, and I’m excited that I’m still working for a software company.

As a part of the acquisition, we’ve also fully embraced Scrum as our development methodology. Prior to the acquisition, it wasn’t like we were doing Waterfall, but we didn’t really have a formalized process either. You might be able to call it Lean, but that would probably be stretching it as far as Lean Software Development is concerned. I’ve been reading about Scrum and Agile development for years now, but I discovered that “reading” is far different than “doing.” I thought I understood Agile – I was wrong. There is a big difference between talking about iterative releases and actually releasing iteratively. You’ll understand if you’ve ever been there.

Another interesting thing that happened this past year was I experienced my first trip to Redmond and the Microsoft Campus. It’s big. And this bad Seattle weather everyone talks about? Lies – it was sunny and in the 70s the entire time we were there. One of the results of the trip was that our company was featured in a Microsoft Case Study about SQL Server 2012. Over the last year, I’ve learned far more about uptime and availability than I ever thought I would. It’s been quite the learning experience to actually get to help build systems (and maintain them effectively) while keeping the uptime numbers we’re looking for.

From a speaking and community perspective, I barely did anything… publicly. However, we really started a push to have Dev Lunches at work as a means of continual improvement. Basically, once a month, one of the devs would volunteer to present a topic to the team over lunch. The atmosphere is great for presenting because everyone is peers and friends already, and you’re pretty much guaranteed to have in-depth discussions. I’d really recommend something similar as a training opportunity. And it also fits into the self-organizing side of agile.

On the home front

Earlier last year, my family increased from two to three with the addition of my daughter Daila. Needless to say, I’ve been getting my hands dirty. Literally. She’s gone from sleeping most of the time (except at night) to babbling, rolling over, standing with help, laughing at just about everything, and more. She’s not responding to baby signs just yet, but I’m pretty sure she understands what we’re saying now.

This year?

I expect that we’ll have our first iOS application released soon. Chances are good that it won’t mean much to you if you’re not familiar with our service, but it is still exciting for us.

I also recently cancelled my cable finally and am fully embracing streaming. It probably isn’t even worth mentioning that part, but it’s a big deal to me. I’m giddy over how much I’ll be saving a month.

Other than that, well, who knows. Stay tuned.

//BUILD/ Windows Conference

2011-10-14

So, a few weeks ago I was able to attend the BUILD Windows conference in Anaheim. I’m guessing you heard something about it. The last time Microsoft held a conference at the convention center in Anaheim was when it announced Windows 95 - this conference was an attempt to show that Windows was going to revolutionize things again. I’ve got a lot of thoughts that I want to talk about, so I’ll probably have to break this into multiple posts.

The conference itself…

Because I have lots to talk about, I am going to go into more detail about various topics. This post is just going to be a general conference overview about some of the various sessions I attended. I’m planning on digging into more detail about more specifics like what I think about the Win8 tablet and more. If you’re interested in watching any of the sessions, the full list is at the buildwindows.com site.

So, the conference…

Preconference…? Nerd Dinner!!!

If you attended the conference or at least visited the BUILD site, you likely saw that there was a preconference slot on the calendar. So, my group all got flights for Sunday so that we would be there for the preconference sessions… which were all canceled. So, we just walked around Anaheim all day Monday. It was a little annoying given that it would have cost a lot of money to change travel plans and all that, but it turned out alright. We spent most of the day coding and discussing future development options. We had planned on attempting to build a Windows Phone 7 application, but it took forever to actually get the Windows Phone 7 SDK installed. Oh well. We did end up walking around the area and into Downtown Disney and, later that night, a group of people all went to the Cheesecake factory for a nerddinner. You’ll note that while only 2 people RSVP’d on the site, at least 15-20 people showed up!

Keynotes galore…

So, the conference actually began on Tuesday. Because the entire event was shrouded in secrecy (even though everyone knew that there would be Win8 tablets being handed out). To give you an idea of the amount of secrecy, the session lists pretty much just said “Sessions: 8 to 5” for the entire week. There was no session planning until after the first keynote. And even then, the entire first day was just one keynote after another. Even on Wednesday, the morning was full of keynotes! Thankfully, the keynotes were pretty good… far better than the keynotes that I saw at TechEd a few years back.

So, the Windows 8 tablet reveal. I’ll admit, it at least demos really well. I don’t think it is stretching anything to say that people were excited. There were a few people who currently have iPads that were showing a lot of interest in the Windows 8 tablet. Something interesting for me was that, at least for the first day, the attendees were not the primary audience. The BUILD conference keynotes for day 1 really served as marketing for consumers and tech enthusiasts. My take is that this is Microsoft trying to take back some of the consumer appeal that Apple has been able to win over the last few years.

I’ll put up a separate post about my actual hands-on experience with the tablets that they’ve gave the attendees, but from the perspective of just watching the keynotes, I was impressed. The promise of being able to dock your tablet, use it as a real PC and then take it with you as a tablet is quite nice.

Jensen Harris did give a keynote presentation on the traits of a great Metro style application that was good. My take on the presentation is that it was more of a demo on how to actually use Windows 8 from a usability perspective. I believe that is where the term “Charms” showed up, which is just an awful name in my opinion. I’m all for getting away from the really technical names for things (think Control Panel, System Tray, etc.), but Charms? How many Lucky Charms jokes are we going to hear? Also, I do have some concerns about the usability of parts of Windows 8. For example, the app bar can only be shown if you swipe from the top or bottom. If you’re aware of the functionality, then it makes sense I guess, but if you were to just walk up to one of these devices in a store, would you know to do that? At least with all of the iDevices out there, the primary functionality for applications is almost all visible. Sure, there are often gestures like holding down on icons to move or delete applications, but this isn’t a common action for users. In Metro Internet Explorer, browsing is a common action, but you have to pull up the app bar to type in a new address. I’m planning on a separate post for Windows 8, so I better stop :–)

The other two presentations of the day were Platform for Metro style apps and Tools for building Metro style apps. I enjoyed both of these sessions quite a bit, because they got a little more technical. We were seeing a lot of this for the first time, so it was nice to begin to get an idea of what building applications for this platform was going to be like.

We actually didn’t get to pick up our tablets until the end of the day, so every session after the morning keynote made some mention of them standing between us and our tablets. Oh, and viva la COM I guess. I’ll talk more about that in a little bit.

Sessions… and some more keynotes…

Wednesday morning was all keynote presentations again, though it was more of a stream of shorter presentations. We got to see Visual Studio 11, ScottGu finally came on stage and we saw a lot more about the developer side of Windows 8. It was more appropriate for developers than the first day was. I thought that Steve Ballmer’s closing words went over well – he even gave an homage to his famous “Developers, developers, developers” thing from a few years back.

With the morning keynote over, the afternoon finally began the traditional sessions. In the interest of actually getting my post uploaded, I’ve decided to only share my thoughts on the really interesting sessions that I attended. Obviously check out the full session list online, because there were a ton of WinRT sessions that will be valuable to you if you’re interested in building Metro applications.

Windows Server 8
- This was a good session because it was really sort of a good overview of everything coming in Server 8. There were parts on Hyper-V enhancements, new PowerShell features and more. It wasn’t a groundbreaking session by any means, but given that I do spend quite a bit of time working on Server 2008, I figured it would be good to learn more. Feel free to skip this one if you only deal with client-side applications, though.
Future directions for C# and Visual Basic
- Ander’s presentation was likely one of my favorite of the entire week. Obviously, he spent a lot of time talking about the new async features in C# – that wasn’t particularly exciting, because we’ve at least seen that with preview builds for a while now. In fact, Eric Lippert did a great series on the new async features that began almost a year ago. The really exciting announcement from my perspective was Roslyn, otherwise known as “Compiler as a Service” for C#. There has been talk about having the C# compiler as a service forever so it is nice to finally have this. The Visual Studio support for it seemed great. At the time of this writing, it doesn’t appear that the Roslyn CTP has released yet, but I imagine it will soon. I did want to point out that the Mono team got the C# Compiler as a Service working first!
What’s new in .NET Framework 4.5
- As a .NET developer, this talk was obviously of interest to me. The 4.5 version the .NET Framework will be an inplace upgrade, which means it will be an upgrade to the current CLR version as opposed to a side-by-side release like .NET 4.0 is to .NET 2.0. So, thus far, still 3 major versions of the CLR (1.1, 2.0 and 4.0 – remember that 3.0 and 3.5 just run on top of 2.0… yay for confusing version numbers). If you’re doing any development in .NET, you’ll probably be interested in this session.
Windows Runtime internals: understanding “Hello World”
- The WinRT internals session is the only one that possibly rivaled Ander’s session in my mind. It is also the session that showed that COM is still alive and well! Okay, maybe not COM, but some iteration of COM. I would say that Metro apps are closer to COM than .NET is. This session digs into the hosting model for Metro apps, the registry lookup that occurs for WinRT types, and more. I’m sure there are some developers out there that are quite annoyed that COM is still alive and well, but the thing is, this stuff has always been there. Welcome to Windows. .NET is built on COM. .NET objects all have a GUID… just like COM objects. I’m actually a big fan of how the WinRT types are exposed as .NET metadata (winmd files). You can actually open them in ILDASM. Miguel de Icaza has a really good post that goes into WinRT as well that I’d recommend you check out.. If you’re interested in getting even more deep into how WinRT works, though, check out Ian Griffiths' posts on WinRT (see Real Native WinRT Development and Native WinRT Inheritance).

Thoughts on the tablet or Windows 8?

So, enough about the conference, though… how’s the tablet? It’s hard to say. The most important thing to remember about Windows 8 is that it is a developer preview – NOT a beta. Betas are occasionally buggy. Developer previews are… more than occasionally buggy. I let my wife try out the tablet and she was so annoyed that she stopped using it. My favorite application so far is OneNote, simply because I’m finally getting to try a stylus and see how the Ink support is… and that has nothing at all to do with Windows 8. It’s almost too early to say. There aren’t any really substantial applications yet. I think Microsoft really needs to build some real applications in Metro before most people will be sold.

I’m planning another post at some point to talk about Windows 8 and Metro in more detail, but I’m still trying to gather my thoughts together. Have you had a chance to use Windows 8 yet? Any thoughts?

WCF and service-side Timeouts

2011-08-19

Ah, timeouts. At my previous job, I wrote quite a bit of code that dealt with threading. When dealing with threads, asynchronous operations, and performant UIs, you can’t always rely on callbacks to get you the results of some asynchronous operation. Sometimes you also have to throw in some waits, particularly if the UI gets to a point before the callback has happened. Whenever I did have to write any code to wait for something (usually off an AutoResetEvent or a ManualResetEvent), I never wanted to actually specify a timeout. What would my application do if it timed out? Would I retry again? Would I just show the user an error? Instead of dealing with that question, I just made the wait last for the default… which in most cases is INFINITE.

I guess circumstances change. Today, most of my code is from the web. Not only that, but a lot of the code that I’m writing has dependencies on external services (SOAP, REST, etc.). The default timeout for ASP.NET requests is 110 seconds (or 90 seconds in .NET 1.0 and 1.1). That is an eternity when you’re talking about a user browsing a web page. What if your web page is calling a WCF service that is calling a web service? You might trust your service, but do you trust the web service you’re calling?

What happens when service calls go CRAZY

Let’s up the stakes here – WCF services default to allowing only 10 concurrent calls at a time. See, maxConcurrentSessions. Here’s the details from MSDN:

A positive integer that specifies the maximum number of concurrent connections to a single service. The service will accept connections in excess of the limit, but only the channels below the limit are active (messages are read from the channel). Setting this value to 0 is equivalent to setting it to Int32.MaxValue. The default is 10.

I’ll point that default of 10 out again. The fact that it is that low is to help protect against DoS attacks – this is a good thing. However, it means that the service can only work on 10 incoming calls at a time. What this means practically speaking is that performance issues have the potential to pile up quickly. If one request starts eating resources, it can slow the others down – it may not be long before you’ve filled up those 10 concurrent sessions.

Let’s assume that the horrible service in question is written with an infinite loop. Sort of like this:



public class TestServiceImpl : ITestService
{
    public TestResult TestIt(TestArgs args)
    {
        var stopwatch = new Stopwatch();
        stopwatch.Start();

        // this is a contrived example, but it shows that WCF never stops this thread
        while (true)
        {
            Console.WriteLine("{0}> I'm running forever...", stopwatch.Elapsed);
        }

        return new TestResult {Result = "Args were " + args.Args};
    }
}

Will WCF do anything to help you out? Not really, at least from the service side. You can configure the receiveTimeout, sendTimeout, closeTimeout, and the openTimeout but these won’t really buy you anything other than timing out the client. The service just keeps on going and going and going… and your user has given up and closed the browser.

What is strange to me is that WCF doesn’t timeout requests while ASP.NET does. At least ASP.NET will try to prevent that one bad request from eating resources forever. I actually asked about this on Stackoverflow because I was baffled. We even opened a case with Microsoft because we were running into problems with this and we didn’t have any visibility into where our hang was. For all we knew, it was an external service that wasn’t returning. It was really a vicious hang cycle from which there was no return. Well, that was overly dramatic, but you get the point.

The solution… maybe?

One of my colleagues decided to take it upon himself to solve this. He ended up writing his very own timeout monitor… or what we affectionately refer to as “the Thread Killer.”

The code works by spawning a single monitor thread that has an internal collection of threads for each of the executing service calls. Each thread is stored along with a ticket which keeps track of the timeout. Any time there are any threads being monitored, a timer is ticking (currently every 250 milliseconds) and will abort any threads that have run for longer than they should be. During the thread abort, the actual ThreadAbortException is caught and is reset, so that a true TimeoutException can be thrown instead.

Usage looks like this:

Run.For(10.Seconds(), () => DoSomeStuff());

Basically, you pass in how long it should run (we’ve made it a little more readable with some extension methods), and a delegate. When we’re working with WCF, though, we don’t want this in our code – this is an infrastructure concern.

WCF has the IOperationInvoker interface that is used to invoke service operations. It works in conjunction with an IOperationBehavior, which can be used to decorate service operations on the service contracts.

So, the invoke method of our custom IOperationInvoker looks like this:

public object Invoke(object instance, object[] inputs, out object[] outputs)
{
    object[] inputOutputs = null;
    object returnValue = null;
    Run.For(_timeout, 
        () =>
        {
            returnValue = _decoratedInvoker.Invoke(instance, inputs, out inputOutputs);
        });
    outputs = inputOutputs;
    return returnValue;
}

If we were to hook up our custom behavior directly to a service contract, it would look like this:

[ServiceContract]
public interface IAmAnAwesomeServiceContract
{
    [OperationContract]
    [OperationTimeoutBehavior(60)]
    OpResults GoFindSomeAwesomeStuff(OpArgs args);
}

However, we would rather it happen for all of our services, so we implemented a custom ServiceHost and we add our custom behavior in the OnOpening method.

protected override void OnOpening()
{
    foreach (var op in Description.Endpoints
        .SelectMany(ep => ep.Contract.Operations)
        .Where(op => !op.Behaviors.Contains(typeof (OperationTimeoutBehavior))))
    {
        op.Behaviors.Add(new OperationTimeoutBehavior());
    }
    base.OnOpening();
}

The above details could be used to hook in just about any behaviors around WCF invocation, including pre and post call.

So, how does it work?

Well, with all of that work, you’d think it would fix our problems, right? It did, indirectly – it turns out that most of the cases that we were interested in timing out were external service calls. It also turns out that aborting threads doesn’t actually do anything when you’re dealing with external service calls.

Some thread abort history – when you call the Abort method of some thread instance, you’re not just killing the thread in question. What .NET is doing for you behind the scenes is that it is injecting some IL that will throw the ThreadAbortException on the thread in question. If your code is waiting on unmanaged execution (networking calls, SQL calls, etc all go unmanaged at some point), your thread abort may never be thrown.

The solution in this case is to set the timeouts at each level – if you’re working with a SQL call, make sure that the CommandTimeout is being set. If you’re working with a web service, there is a Timeout property that can be set there.

By ensuring that all of our SQL calls and service calls had appropriate timeouts on them, we caught 99% of the problem areas.

Then… what about thread abort?

By the time we had properly coded timeouts around our problem areas, we had already coded our thread abort solution. I didn’t mention how that went for the first deployment… it went pretty badly actually. It turns out that you can thread abort the dispatcher thread for WCF and, while the service stays up, it will stop responding to requests. Our only recourse was to kill the worker process serving the requests.

Thread aborts are dangerous. You are playing with fire.

On the other hand, using them along with our error logging helped point us to the performance problems in the first place. We might still have been dealing with performance problems had we not started down the thread abort path. The thread abort solution would have helped us catch our horrible infinite loop example above… though thankfully we don’t have any code like that!

Wrapping up

I’ve been trying to think of other things that we could have done to have prevented this issue.

One potential solution might have been logging (WCF provides extensive tracing support). I’m not convinced this would have helped us though, because the errors we were actually seeing were relatively sporadic. We didn’t know anything strange was happening until we started seeing system errors. To effectively have seen this, we would have had to add system wide logging across the board – we didn’t have visibility into the problem in order to inform us about where the problem even was! We’ll likely add better logging (see Ayende’s post) but it will take time. Another thing about logging is that it can be very difficult to know what kind of logging is needed before issues occur. In hindsight, well sure we’d have loved to have logged service entry and exit points along with times along with the parameters that were involved when the slowdown occurred!

I’ve thought about whether or not the usage of asynchronous service calls would have helped also. I think it might have prevented as many system hangs (particularly if I/O Completion Ports are being used for waiting for responses instead of thread pool threads), but it wouldn’t have done anything to inform us of the actual problems.

In sharing this post, I want to point out the things we learned:

WCF doesn’t time services out – at all (certainly not with TCP or named pipe bindings)
It isn’t all that hard to decorate all service calls
Thread abort is dangerous
Thread abort is really dangerous
Thread abort doesn’t always abort
Most components that might run for a long time provide timeout facilities of their own

Hope this helps.

Introducing Daila Joy!

2011-06-24

The Mohundro family has some big news… our first child was just born a couple of weeks ago! Both mother and daughter are doing great!

The past couple of weeks have just been a series of events to help us “learn how to be parents.” We read quite a few books during the pregnancy (particularly my wife), but nothing can really prepare you for when the baby gets here. (don’t get me wrong, definitely try to prepare and learn, though – we’re more prepared than we would’ve been!)

Here’s a photo that I took of her a few days ago:

Highlights thus far:

Experiencing my first “is that poop or chocolate” moment (it was chocolate)
Learning how to dress a baby whose arms and legs DO NOT STOP MOVING
Holding my daughter for the first time
Having her turn to my voice within minutes of being born!

Fun with binary!

2011-05-31

I know what you’re thinking… “did he just say ‘binary data’? Like, 1’s and 0’s?” Well, yes, yes I did. If you’re like me, the last time you actively had to do anything with straight binary data was in college when you were learning how to convert between binary to hex to decimal and back again. I would imagine that most of us run into hex somewhat frequently, but that we don’t actually have to deal with binary data as often.

Some Background

On one of my recent projects, I had to write an API that interfaced with some hardware, which was something relatively new to me. Most of my work in the past has been either standard client-side GUI applications or web applications. I have yet to have written any applications that talk over a serial port. Even with this new project, I didn’t have to talk over ports because the hardware had a relatively nice .NET SDK for it. The primary flaw with the SDK was that it still had quite a few methods that only returned byte arrays. The documentation for those byte arrays was specified in a table of bits… in other words, if the second bit in the fourth byte is on, then one feature is accessible… you get the idea. In many cases, I had to parse out these bits to determine what the hardware was actually returning me.

I can’t show you any of the code that I used in this project, but I can provide a similar example. You know TCP, right? One of the network protocols that we use every day without even thinking? Here’s an image from Wikipedia that shows the structure for the TCP header (via Wikipedia):

For fun, let’s assume that that we’ve been provided the below data and we’d like to parse this into a structure that looks more like the table the TCP spec has.

First, in hex:

0000   de 39 00 50 d5 99 75 e4 02 50 89 dc 50 18 01 01  .9.P..u..P..P...
0010   cc 87 00 00                                      ....

Then, in binary:

0000   11011110 00111001 00000000 01010000 11010101 10011001 01110101 11100100   .9.P..u.
0008   00000010 01010000 10001001 11011100 01010000 00011000 00000001 00000001   .P..P...
0010   11001100 10000111 00000000 00000000                                       ....

(for those who are curious, I got this data from Wireshark)

Of course, I wasn’t provided my bytes in such a pretty format… byte arrays are going to look a lot more like this:

0xde, 0x39, 0x00, 0x50, 0xd5, 0x99, 0x75, 0xe4, 0x02, 0x50, 0x89, 0xdc, 
0x50, 0x18, 0x01, 0x01, 0xcc, 0x87, 0x00, 0x00

The Naive (and horribly non-performant) Way

My first step was to see the structure of what I was getting passed. I’m not like those guys in movies – I don’t dream in binary and I sure don’t see structure in ones and zeros. So, I wanted to get the data into a tabular format. To do so, my first stop was Powershell.

Given the above byte array, all it took was the below snippet of Powershell (note that I used the 0x prefix with the hex values… there isn’t any binary literal notation):

$bytes = [byte[]](0xde, 0x39, 0x00, 0x50, 0xd5, 0x99, 0x75, 0xe4, 0x02,
                  0x50, 0x89, 0xdc, 0x50, 0x18, 0x01, 0x01, 0xcc, 0x87, 
                  0x00, 0x00)

Now that we’ve got a byte array, we can start to play around with it. I created the following script that I named Get-ByteTable.ps1:

param (
  [Parameter(ValueFromPipeline=$true)]
  [byte]
  $bytes,

  [int]
  $rowLength = 8
)

begin {
  $offset = 0
  $bitIndex = 0
  $byteTable = ''

  Set-Variable -name LENGTH_OF_BYTE_IN_BINARY -value 8 -option constant

  function To-Binary {
    param (
      [Parameter(ValueFromPipeline=$true)]
      [int]$num
    )
    [Convert]::ToString($num, 2)
  }

  function outputByteRow {
    if ($byteTable.Length -lt $rowLength) {
      $byteTable = $byteTable.PadLeft($rowLength, '0')
    }

    $hexValue = "0x{0:X$($rowLength / 4)}" -f $([Convert]::ToInt64($byteTable, 2))

    $bitIndex = 0
    $table = New-Object PSObject

    $table |
      Add-Member NoteProperty 'Offset' ($offset - $rowLength) -pass |
      Add-Member NoteProperty 'Hex' $hexValue

    for (; $bitIndex -lt $rowLength; $bitIndex++) {
      $table |
        Add-Member NoteProperty "$bitIndex" $byteTable.Substring($bitIndex, 1)
    }

    $table
  }
}

process {
  if ($byteTable.Length -ge $rowLength) {
    outputByteRow
    $byteTable = ''
  }

  $byteTable = $byteTable + ($bytes | To-Binary).PadLeft(8, '0')

  $offset += $LENGTH_OF_BYTE_IN_BINARY
}

end {}

Basically, the usage is just $bytes | Get-ByteTable.ps1. Now, the issue then is output formatting… that just dumps the list of PSObjects out and the default format is Format-List. So, let’s try, $bytes | Get-ByteTable.ps1 | Format-Table -AutoSize -Property *. The AutoSize flag informs Powershell to use as little space as possible and the Property * flag tells Powershell to output all properties as columns… if you don’t do this, Powershell will only output some of the columns. The script also has a parameter if you want to specify the row length. If you’d rather work with the data in something like Excel, you could pipe the output to Export-Csv.

Check out the below sample output:

> $bytes | Get-ByteTable.ps1 -rowlength 32 | Format-Table -AutoSize -Property *

Offset Hex        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
------ ---        - - - - - - - - - - -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
     0 0xDE390050 1 1 0 1 1 1 1 0 0 0 1  1  1  0  0  1  0  0  0  0  0  0  0  0  0  1  0  1  0  0  0  0
    32 0xD59975E4 1 1 0 1 0 1 0 1 1 0 0  1  1  0  0  1  0  1  1  1  0  1  0  1  1  1  1  0  0  1  0  0
    64 0x025089DC 0 0 0 0 0 0 1 0 0 1 0  1  0  0  0  0  1  0  0  0  1  0  0  1  1  1  0  1  1  1  0  0
    96 0x50180101 0 1 0 1 0 0 0 0 0 0 0  1  1  0  0  0  0  0  0  0  0  0  0  1  0  0  0  0  0  0  0  1

We can use this table to line up our values with what we saw from the TCP header protocol. For example, bits 0-15 make up our source port. In the table above, those bits come out to be 1101111000111001… or 56889 in decimal. This lines up with what we can see in Wireshark, so our script works as expected.

The Better (and more Programmatic) Way

Okay, so that Powershell script was fun. But seriously, it was not the right way to deal with binary data. We took bits (i.e. 0’s and 1’s) and converted them to hex… but hex as a string. And then we parsed it. Not only was it non-performant, but it was also an explosion of data.

A better way to parse binary data is the System.Collections.BitArray class. It takes in a byte array and presents that byte array as an array of booleans… true is to 1 as false is to 0. Pretty easy.

Now, the BitArray class doesn’t ship with any means of working with the data in a tabular format. It isn’t a big hurdle, but it was something that I wanted to be able to do because the specification I was dealing with showed the bits in a tabular structure, too. Actually treating the one array in a tabular way is easy (i.e. rowLength * rowIndex + columnIndex = actualIndex) and is best served via extension methods as shown below:

// Note that I've set a constant BYTE_LENGTH below, which effectively
// serves as the row length... it would be easy enough to specify a 
// different row length via another parameter.
internal static class Extensions
{
  private const int BYTE_LENGTH = 8;

  public static IEnumerable<bool> GetRowBits(this BitArray bits, int row)
  {
    var startIndex = BYTE_LENGTH * row;
    var endIndex = startIndex + BYTE_LENGTH;
    for (var i = startIndex; i < endIndex; i++)
    {
      yield return bits[i];
    }
  }

  public static void Set(this BitArray bits, int rowIndex, int columnIndex, bool value)
  {
    var startIndex = BYTE_LENGTH * rowIndex;
    bits.Set(startIndex + columnIndex, value);
  }
}

Usage then would be:

// assume bytes is an already populated byte array.
var bits = new BitArray(bytes);

// to get the bit at 0,4
var bit = bits.GetRowBits(0).ElementAt(4);

// to set the bit at 5,4 ON
bits.Set(5, 4, true);

I’m not particularly happy with the method names and I haven’t come up with a great way to specify the row length… as it stands now, my extensions are using the row length of 8 (BYTE_LENGTH). I would guess the best way to handle it would be to wrap the BitArray class instead of actually using extension methods.

Who Knew Calc Could Do That?!?

The final thing I wanted to share is some calc.exe awesomeness. First, ensure that you’re running calc.exe in “Programmer” mode.

Next, let’s start in Dec (decimal) mode and type in 255. Of course, you can change between decimal, hex, octal or binary and see the resultant numbers. This didn’t surprise me. However, notice the the section beneath the number display, where it shows the binary for your number.

Try clicking one of the bits. It’s awesome.

It flips the bit for you! I had no idea calc could do that! One of the things I really like about some of the “programmer” features of calc is that you can now visually see what happens when you right or left shift bits (Lsh and Rsh respectively). Turns out it is a really good tool for visually observing bit operations. Not only that, but it is also good at helping explain things like “Two’s complement”.

A custom switch statement in C#

2011-01-10

I don’t usually do blog requests, but then again, I don’t usually get blog requests. I’ve got a few friends that I email back and forth with regarding technology, programming languages or whatever else piques our interests.

This particular time, my friend was complaining about the switch statement in C# versus VB.NET.

It’s true, actually. VB’s Select statement is more powerful than the switch statement in C#. In VB.NET, you can do things like:

Select Case num
  Case 1 to 10
    'do something
  Case 11 to 20
    'do another thing
  Case Else
    'do the default
End Select

Whereas, this isn’t possible in C# with the switch statement. However, that doesn’t really bother me much.

Besides, I initially responded with the whole “prefer polymorphism over conditionals” thing anyway. You know.

We went back and forth a little bit and he mentioned that he’d rather see a switch statement that accepted lambdas or delegates to choose the action to take. This reminded me of switch statements in both Ruby and PowerShell.

In Ruby, you’ve got the case statement:

case some_var
  when nil
    # executes if some_var is null
  when String
    # executes if some_var is a string
  when 42
    # executes if some_var equals 42
  when /regex/
    # executes if some_var matches the regex
  when 1..10
    # executes when some_var is between 1 and 10
  else
    # the catch all
end

As you can see, the case statement in Ruby is very powerful.

PowerShell’s switch statement can take arguments (i.e. -wildcard, -regex, etc.) to let it match on different things. Like so:

switch -regex ($a) { 
    "[a-d]" {"$a matches the first group."} 
    "[e-g]" {"$a matches the second group."} 
    "[h-k]" {"$a matches the third group."} 
    default {"$a didn't match any of the cases."}
}

So, when looking at all of these other switch statements, C#’s version does look sort of weak. But hey, we’re programmers. Surely we can solve this ourselves, right?

The first step I took was to write out the code I was interested in. My friend had sent an initial snippet that included a non-existent keyword called “swatch” that did allow for much more powerful checks – primarily by delegating off to lambdas. His proof of concept snippet looked like this:

// this is *pseudocode* - it won't compile!
swatch (myObject)
{
  case myObj => return myObj == null:
    Console.Writeline("the object is null");
    break;
  case myObj => return myObj.property1 == 3:
    Console.Writeline("the object's property1 value is three");
    break;
  case myObj => return myObj.myCollection.Contains(4):
    Console.Writeline("the object's collection contains the 4 value");
    break;
}

So, I’ve got something to start with. How can I tweak this into valid C#? I began with writing the code that I wanted first. In other words, I’m designing the API of the class from the outside, not from the inside. This is one of the best benefits of writing tests first – you get to build the API as a consumer of the class first.

Here’s what I initially came up with:

var accts = new List<Account>
                {
                  new Account 
                  {
                    Name = "Amazon", 
                    IsPreferred = true, 
                    Moolah = 123456789.01m
                  },
                  new Account 
                  {
                    Name = "Bob's Store", 
                    IsPreferred = false, 
                    Moolah = 15.78m
                  }
                };

var swatch = new Switcher<Account>();

foreach (var acct in accts)
{
  swatch.Switch(acct,
    swatch.Case(x => x == null,
      x => Console.WriteLine("the object is null")),

    swatch.Case(x => x.Moolah > 10000.00m,
      x => Console.WriteLine("Whoa, these guys (" + x.Name + ") got some money")),

    swatch.Default(
      x => Console.WriteLine("wha?!?"))
  );
}

The above syntax can work. We just need to implement the Switcher<T> class.

Here it is, in its entirety:

class Switcher<T>
{
  public Decision Case(Predicate<T> condition, Action<T> branch)
  {
    return new Decision {Condition = condition, Branch = branch};
  }

  public Decision Default(Action<T> branch)
  {
    return new Decision {Condition = x => true, Branch = branch};
  }

  public void Switch(T instance, params Decision[] cases)
  {
    foreach (var @case in cases)
    {
      if (@case.Condition(instance))
      {
        @case.Branch(instance);
        break;
      }
    }
  }

  public class Decision
  {
    public Predicate<T> Condition { get; set; }
    public Action<T> Branch { get; set; }
  }
}

The code isn’t complete – it doesn’t do any checks to ensure that only one Default case is passed in. It also doesn’t do anything to ensure that the Default case is the last one to be checked. We can leave that as an exercise to the reader perhaps. Other types of case methods could be added such as TypeOf that evaluates the action if the instance is of the type specified (i.e. swatch.TypeOf<Foo>()). It would also be pretty easy to add in a RegEx case method, too (i.e. swatch.RegEx("[a-z]")).

After responding to the email, I considered that it would also be possible to implement this in a fluent interface style of API. It might be interesting to try that, too.

Chrome OS Cr-48 Review

2010-12-30

Surely you’ve heard of the Chrome OS by now? If not, well, Chrome OS is a new operating system from Google that “provides a fast, simple, and more secure computing experience for people who spend most of their time on the web.” (from the Chromium OS project page)

The big news around Chrome OS lately is that Google is running a pilot program where volunteers can sign up in the program to receive a notebook from Google that is running Chrome OS. Basically, it’s a beta test for Chrome OS that includes a laptop.

Of course, I signed up.

What’s in the box?

I didn’t expect to hear anything out of it, but hey, I like playing around with technology. One morning, after my wife had already left for work, I walked into the dining room and, lo and behold, a box was sitting on the table. It was clearly something that had been shipped to us, but that’s all I knew. I hadn’t ordered anything recently so I gave her a call – she didn’t know what it was either, except that it had been sitting on our front door step.

So what did I do? I opened it of course. Here’s what I found in the box:

I knew it was either a Cr-48 laptop or a small, hamster-powered spaceship. Considering that I had already read reviews from others who had received the laptop, I knew it wasn’t the hamster-powered spaceship.

Opening it and using it

I ended up taking the whole box with me to work that day because I knew all of my co-workers would be interested in seeing it. When I got there, I took out and got it hooked up.

Out of the box, it’s a pretty standard black notebook. It’s pretty small and light, at least compared to my 15 inch laptop, which I like.

As you can see, there aren’t any logos on top or anything. The laptop has an interesting finish – it almost feels like soft plastic or something. I don’t know how to describe it.

Upon opening it, it starts immediately – yeah, no pressing a button, just instant on. I like that aspect – especially considering it starts quickly. It might be annoying if it turned on immediately but that meant a 60 second boot. Instead, you see the Chrome OS logo and, very soon after, the welcome screen.

Set up involves logging in with your Google ID and getting your picture taken by the built-in webcam – pretty easy. If you’ve got any Chrome syncing set up, your Chrome extensions, bookmarks and whatever else is set up to be synced will be pulled in.

It found our wireless at work without any problems so I was online quickly. As an aside, the pilot laptops come with a free 100 MB plan with Verizon if a wireless access point isn’t available.

The browsing experience is pretty much just like using the Chrome browser. The biggest difference is you can’t switch to a different application. You’ve got Chrome… full-screen. That’s it. You can have multiple Chrome windows open, sure, but it feels more like separate tab groups to me.

OS related settings can all be found under the wrench toolbar button – which is almost identical to what the Chrome browser has. In fact, I see two differences: 1) “About Google Chrome” is called “About Chrome OS” instead and 2) “Exit” is “Sign out”. That’s it.

The actual settings in Chrome OS open up in a separate tab and include a few more settings than the browser does, but mostly they’re related to the operating system (things like time zone and account settings).

So, do I like it?

Well… yes. And no. I mean, it depends.

I completely respect Google for taking the steps they are here. A laptop that can only browse the internet – I mean, a few years ago, I would never have dreamed of dropping Outlook in favor of a webmail based email. But I use Gmail now and I find that I miss features of it in Outlook. So yeah, things are moving to the web. But can I do everything there? I personally can’t, but the steps that Google is taking will make it more of a reality faster than anything else I can think of.

So, what do I like?

Browsing on it is fine. My preferred browser is Chrome when I’m on my other computers so I like it on Chrome OS, too. Basically everything you like about Chrome you’ll like in Chrome OS. If you can’t stand browsing in Chrome, chances are good you won’t like browsing in Chrome OS.
I like the form factor – the notebook is small. It’d be awesome to travel with this notebook.
The suspend and resume actions are flawless and ridiculously fast. I’m not running on any SSDs so I can’t compare, but it wakes up faster than any of my other devices.

What do I dislike?

The trackpad. I can’t stand the trackpad. It seems like they tried to make the trackpad like the trackpads that come on MacBooks. MacBook trackpads are awesome. This one feels cheap. When I’m typing, I consistently brush up against and make the mouse jump. It does support tap to click, which lets me avoid the click. It does have gestures to support scrolling – again, like the MacBooks. So, two-finger swipes make it scroll up or down. It all sounds great in theory except that it isn’t very precise. At one point, it scrolls slowly and then, all of sudden, I’m at the bottom of the page. I don’t know, maybe I’m just not used to trackpads, but I’ve heard from others that they feel that the trackpad isn’t very good.
The keyboard. Okay, the keyboard isn’t terrible. I typed a longish email last night and it worked well for the most part. I just hate the “1” key on the keyboard. It gets stuck. Stuck to the point where I have to lift my hands off the keyboard to put some weight behind it before it presses with an audible click. It completely messes up my rhythm while typing.
The speed. Browsing is fine, but the hardware isn’t the fastest in the world. It’s clear that it can’t always keep up with the data being pulled in on the screen.

What’s just plain strange?

I find it strange that some settings are global to the operating system. For example, tap to click on the trackpad. Say I like tap to click but my wife doesn’t. We’d have to change it each time one of us got on. Maybe that’s standard, but it does seem a little odd.
If the notebook hasn’t been turned on in a while, the entire screen gets a lot of lines across the top – sort of like old tube TVs do. I actually thought I got a bad notebook at first, but it always clears up after a few seconds.

Overall

Overall, I like it. The majority of my complaints are based on the hardware. I honestly hope that a lot of this is because it is commodity hardware that is being used for the actual test driving. I wouldn’t want to pay for some of this hardware. I’m hopeful these things will get worked out before they go on sale.

This can’t replace my other computers. I know they have some cloud editors for code, but those aren’t going to cut it for me. I’ll at least need a CloudVim first :) I was planning on taking the notebook with me over the holidays, but I needed to be able to VPN in to work, so I had to leave it at home – my wife wouldn’t let me take two laptops! I also miss my command line (whether it is PowerShell, bash or zsh, I don’t care – I just want some kind of command line).

Now, interestingly enough, you can get to a command prompt, but you’ve got to put the notebook into “Developer Mode”. If you follow that link, you’ll find that this involves removing the battery, peeling back some protective tape, and flipping a magic switch. Once you’ve done this, you can get into a “chrosh” shell – it isn’t bash, its chrosh. I haven’t done this myself yet, but I’m planning on it at some point.

A few people online have been able to get Ubuntu on their notebooks as well, but I certainly haven’t tried that yet. We’ll get developer mode working first, eh?

Chris Benard received one of the notebooks earlier in the month and he’s got a good post with his first impressions of the Cr-48, too. Oddly, Chris mentions that he couldn’t get a Google Apps account to log in; however, my Google Apps account works great with the Chrome OS.

The new blog is live!

2010-12-23

So, my blog looks different now… and it isn’t just a new theme. It’s new blog engine, new web host, new look and feel, new everything!

The back story…

So, I started my blog back in January of 2006. At the time, dasBlog was one of the most prevalent .NET blog engines around on .NET. So, I decided to roll my blog on dasBlog. I chose a recommended web host that had great pricing and also supported ASP.NET. All was great. At the time, I was posting every single thought that came to mind which resulted in a good 20 to 30 posts every month. Slowly, though, over the years, I started to find my blogging groove.

Fast forward to this year. dasBlog doesn’t hold the high place it once had as top .NET blogging engine. Worse still, my web host had seriously gone down the tubes. Lee Holmes posted that his uptime was averaging 60%. If you’re not familiar with uptime percentages, that means that my visitors had a 60% chance for my site to be up.

The last straw for me was seeing a link to the Google cache for my site mentioned on a response to an MSDN forum question because it was down. It was time to move.

The new platform!

The short version: the new blog is running on toto, a Ruby-powered blogging engine. I’m hosting it on Heroku.

The longer version: lately (err, the last couple of years), I’ve become much more interested in learning and writing Ruby code. I had already written two fairly small sites in Ruby (one in Sinatra and one in Rails) and both were hosted on Heroku. The process for those sites had been great. The deployment story was amazing – it was literally git push heroku master. You couldn’t get any better as far as I was concerned.

So, I knew I was interested in moving platforms; however, there were some problems with this. First off, I had to convert my posts. Second, I wanted 301 redirects in place. Third, I needed a theme.

Converting my posts

Thankfully, dasBlog stores its posts in a fairly straightforward way – there is an XML file for each day that can contain one or more posts. On the other hand, toto stores its posts as straight text files formatted as Markdown (if you’ve used StackOverflow, you’ve used Markdown – it’s what they use for their questions and answers).

So, how best to convert? I ended up writing a smallish Ruby script to convert that made use of Nokogiri to parse the XML. The main script turned out to be just under 60 lines. Writing the script turned out to be the best thing I could do, because it let me re-run the conversion process. I could add small tweaks to try to strip out invalid HTML and try out my changes. Since I had everything in source control, I could just run a diff against the converted posts to see if everything still looked good.

Redirecting old URLs

Redirecting my old URLs to the new URL format turned out to be easy for 80% of my posts and time consuming for the rest. I used a Ruby gem called rack-rewrite.

The below code snippet accounted for the easy 80%.

r301 %r{/blog/
  (\d{4})/  # year
  (\d{2})/  # month
  (\d{2})/  # day
  (\w+?)    # slug
  \.aspx$}x, lambda { |match, rack_env|

  helper = RedirectHelper.new

  year, month, day, slug = match[1], match[2], match[3], helper.convert_legacy_slug(match[4])
  "/blog/#{year}/#{month}/#{day}/#{slug}/"
}

I just used a fairly simple regex to parse the old format out and move it over to the new format. I did end up building a RedirectHelper class that contained most of the logic for handling the remaining 20%. Overall, though, it seems to be working well, though I’m sure I probably missed a few posts. If you are browsing around and run into any 404s, feel free to let me know.

The new theme

My starting point for the blog theme was the dorothy toto theme. It provided a nice HTML5 basic structure that I was able to build upon. Since it was already using HTML5, I decided to stick with that. Chances are, the site looks like junk on Internet Explorer 6 and 7. It honestly doesn’t look great on IE 8 even, though the IE 9 beta renders it just fine.

The fun things for me in the conversion were getting to use the Google WebFont API – that’s how the cool fonts are getting loaded in. Everything else was just some minor CSS changes.

I did elect to use Disqus for my comments, because Toto doesn’t provide a commenting solution out of the box. This actually has a couple of ramifications for me. First, I lost all of my old comments. That wasn’t a huge deal, because I never really had a boatload of them. Second, it’s an external service that I’m not in control of. Mostly, this doesn’t bother, but I do think some of my former coworkers back in the Fort Smith area might not be able to comment because I think Disqus is blocked by their firewall. At least it was when I was still working there.

Wrapping this post up

So, anyway, there you go, my new blog. Actually, I’d like your input now. I want to post the code for the blog up on my GitHub account, but I have some questions about the best way to do this. First off, I don’t want my blog content duplicated. It isn’t a huge deal, but I don’t want Google returning search results to the GitHub hosted markdown files over my posts. It probably won’t, because there won’t be returned as the main HTML like it would be when served from my blog, but it is still a concern I’ve got.

And I guess that’s it actually. Try out the comments if you want. Let me know if you like the look or if you notice any broken links or broken functionality.

DevLink 2010 Recap

2010-08-23

This year, I was fortunate enough to attend DevLink for the fourth year in a row. I’m pretty sure 90% of my Conferences posts are recapping prior trips to DevLink. Well, here goes number four, though I’ll try to keep it more succinct than last year.

Sessions

The first session I attended was on Test Driven Development with T-SQL by Philip Japiske. If you just did a double take at that last sentence, then you know how I felt when I first saw it on the session list. I had never heard Philip speak before, but I was honestly worried that a session on TDD with T-SQL would be a trainwreck. I’m happy to say that it was not, in fact, a trainwreck – it was actually a really good session. Philip showed us T.S.T. (the T-SQL Test Tool) which is basically a set of stored procedures that provide the basic assertion libraries you’d expect to see in a unit testing framework. The real gems were assertion calls like Assert.TableEquals. It can still use some work, but if you’ve got any sort of T-SQL sitting around, wrapping some of that in tests could be very useful.

Another session I really enjoyed was on HTML5 with Todd Anglin. Most of the noise regarding HTML5 that I’ve seen has revolved around mobile development, the canvas tag and how it will replace Flash/Silverlight/etc. Todd did a great job of showing us the other parts of HTML5. I had no idea that there were new input tags that were coming (are here? sort of?) like tel, email, etc. Really, that’s all it takes for mobile browsers like Safari to give the different input types (i.e. if an input element with type email gets focus, you’ll get the email input display on the iPhone).

Jim Wooley did a great job showing off the Reactive Framework (Rx). We spoke a little bit last year when I attempted an Open Space session on Event Driven Architecture and he had pointed out Rx then, but I never really had a chance to dig in since then. Honestly, once people really start grokking Rx and applying it in their frameworks, I’ll think we’ll start seeing some big jumps in the way we write code, particularly on the client side. I’m still trying to think of good applications of it on the server side, though Chris Patterson did mention that MassTransit was looking into adding IObservable capabilities…

There was a session on Caliburn by Bryan Hunter on the first day, but the room was packed so I wasn’t able to hear it. I did get to make it to his part 2 talk on the last day, though, and I really enjoyed it. I still love the way Caliburn uses iterators (with yield) to implement coroutines. If you’d like to get a good feel for Caliburn and what it provides, check out Rob Eisenberg’s MiX session.

The last session I attended on Saturday was on IronRuby and Rails with Shay Friedman. I have already been doing some Rails work on the side, so I was familiar with most of it, but I still wanted to support IronRuby, especially considering Jimmy Schementi’s post regarding IronRuby’s future went up the day before Shay’s session. (side note, lest you think IronRuby is dead, it is having almost daily commits to it and it has the potential to flourish even more in the community’s hands)

Open Spaces

I sat in on a open spaces session led up by Alex Robson on RabbitMQ. RabbitMQ is a “highly reliable enterprise messaging system” that is written in Erlang. Think MassTransit or nServiceBus in the .NET community. It was interesting to hear how other messaging frameworks are structured and to also talk about how messaging and event driven architecture change the way applications are built. It was a very fun discussion.

After my relative success last year leading an open spaces discussion on event driven architecture, I decided to talk about something else I’m passionate about: VIM. I entitled the session, “VIM and other Ye Olde Text Editors” (tongue firmly in cheek). I hoped my poor attempt at title humor would draw people to my session. If by people, I can count 2 individuals, then I can say that, yes, it did draw people to my session :–). Brian Sullivan and Mark Haskamp both swung by and we had a good time talking about Vim and Emacs both. My hope in coordinating the session was in sharing the awesomeness of Vim and getting ideas from other Vim users on how they customize and use Vim to the fullest. I didn’t get a lot of tips in that regard, but I did get to show a few people the very well known String Calculator Kata in Python, which should instead be titled String Calculator in Python in Vim. It’s as much of a kata on Vim as it is on Python.

Brandon Satrom kicked off a talk on “What’s good in MVC, what’s missing in MVC.” I really enjoyed this session – there was a lot of push to improve what we’ve got with MVC. We realized that the finished list (which probably could have continued) leaned heavily on the ways to improve MVC, but I commented that I think this is because we’re really enjoying using it and we want it to succeed and move forward.

I sat in on another of Alex Robson’s open space sessions on NoSQL on Saturday. We talked a lot about CouchDB and Cassandra, neither of which I know a lot about. I’ve read up on Mongo quite a bit more, but I’m finding that the document database (and other NoSQL variants of databases) very intriguing. I’m planning on using one of them for some of my Rails projects at some point.

In closing

All in all, I had a great time at the conference. I really enjoyed getting to see a lot of friends, particularly some of those from the Fort Smith area. I used to get to see most of those guys at least at every FSDNUG meeting, but since moving to Memphis, it had been a couple of months since I had seen them.

Here’s to another DevLink next year!

New stuff

2010-06-29

First off, apologies for not posting anything in 2 (wait, has it been 3?!?) months – that’s the longest I’ve ever gone without posting anything. Second, apologies for talking about not posting. That’s a no no. Third, apologies for apologizing for… oh, right.

So, what have I been up to.

Long story.

Well, my wife and I are now residents in the Memphis area. Obviously a big change. I had been living and working in Fort Smith, AR for the past 7 years. I’d even been at the same company that whole period. We had always talked about whether or not we would stay there or move and all that, but if you had asked me at the beginning of the year if I thought we’d end up moving, I probably would’ve said no. Well, guess I would’ve been wrong!

I took a job with ServiceU Corporation and I’m just finishing up my first week with them. Other than the obvious location change, the job is also quite a bit different from what I’ve been used to. First off, it’s a much smaller company. Second, technology adoption is pretty serious here. Third and likely most important for me, it’s a software company. You know, the end product we provide is software. Well, okay, technically it’s a service. But you know, that service is fulfilled by software. It’s pretty much summed up by Jeff Atwood’s 2007 article entitled, “remember, this stuff is supposed to be fun.” That’s the main reason.

So, what will I be doing? Well, for one, I’ll get to work with ASP.NET MVC 2. I’ve been playing around with it, but I haven’t really worked with web stuff extensively since classic ASP. I’ve delved into Rails a little on my own, but nothing major. It will be interesting to compare what I’ve learned with Rails to ASP.NET MVC. I’m really excited! I’m also planning on getting the rest of my team interested in PowerShell. So don’t worry, the PowerShell posts will continue!

On the DNUG side of things, I’m obviously no longer the FSDNUG president. Jeremy Sloan is the new president and he’s got lots of other great guys helping him out. Over here, I’m planning on getting active with Memphis DNUG. I’m hoping to get to see some of the FSDNUG guys at DevLink. That was a hint, by the way.

On the personal side of things, I hate not seeing all of my Fort Smith area friends as often as we were able to before. Thankfully, Fort Smith and Memphis aren’t that far away from each other. I imagine we’ll be on I-40 quite a bit more than we have in the past.