Windows SysInternals

Wow! Where to begin?

Windows SysInternals is a free set of command-line and Windows utilities from Microsoft. There are so many of them, and they are so varied, that it’s impossible for me to cover all of them here. So, I guess I’ll pull out a few of my favorites to talk about. But, you should really go get the entire set of the tools, as soon as possible!

(Much of the text that follows is pinched from the Microsoft site. My comments are in italics.)

File and Disk Utilities


Defragment your paging files and Registry hives! (I use this on all of my VPCs. It runs at boot time. I’m not sure whether it’s compatible with SafeBoot, though.)


Creates Win2K NTFS symbolic links. Think of it like shortcuts within your directory structure.

Networking Utilities

AD Explorer
Active Directory Explorer is an advanced Active Directory (AD) viewer and editor.

See who owns an Internet address.

Process Utilities

Process Explorer
Find out what files, registry keys and other objects processes have open, which DLLs they have loaded, and more. This uniquely powerful utility will even show you who owns each process.

Process Monitor
Monitor file system, Registry, process, thread and DLL activity in real-time.

Security Utilities

AccessChk, AccessEnum, ShareEnum

Tools for determining who has access to what. Quite handy when configuring security.

Securely overwrite your sensitive files and cleanse your free space of previously deleted files using this DoD-compliant secure delete program.

System Information Utilities

Show users logged on to a system. (Use this when you need to TS onto a shared DEV server, but there are already too many sessions.)

Miscellaneous Utilities

This fully-configurable program automatically generates desktop backgrounds that include important information about the system including IP addresses, computer name, network adapters, and more. (We use this on our servers. But, I also use it on my VPCs to remind me which one I’m in.)

This screen saver not only accurately simulates Blue Screens, but simulated reboots as well (complete with CHKDSK), and works on Windows NT 4, Windows 2000, Windows XP, Server 2003 and Windows 9x. (Geek humor.)

You’re still here? Why aren't you downloading these tools? Go! Download them now!

OOP Book Recommendations

There were two books that really helped me understand object oriented programming and design patterns.

The first was a book called Design Patterns Explained by Alan Shalloway. Alan is a local guy. He runs NetObjectives. And, he’s a frequent speaker on Lean Software Development. His book is eminently more readable than the seminal Gang of Four Design Patterns. (Though, had it existed, when I first started learning patterns, I think that the book Head First Design Patterns by Freeman and Freeman would have helped me learn even quicker.)

The second book is Robert C. Martin’s Agile Software Development. Bob is an institution in object-oriented programming circles. People are so familiar with him that his nickname is “Uncle Bob.” He wrote an article for C++ Programmers Journal for years. This book reads like a collection of those articles. The value I found in his book was that it looked at the principles underneath design patterns. These things help me write better code whether I’m using a formal pattern or not. There’s a good, short article on his blog about these principles that I highly recommend, especially if you don’t have the time to read the book:

.NET Reflector: Your personal X-Ray machine

Have you ever run across a situation where you were trying to debug some code, but you hit a wall when you ran into an object that you don’t own? Happens to me more often than I like. And, before I learned about .NET Reflector, I was stuck using debug.print statements on either side of the object call to figure out what was going on inside.

.NET Reflector changes all that. Need to see the code for an object you don’t own? Crack open any .NET assembly with reflector.exe and disassemble the code. Here the disassembly of a method from a WCF service I wrote recently:


You can even use this tool to disassemble objects in the .NET Framework!

Plus, .NET Reflector includes a Visual Studio add-in that lets you debug into this disassembled code! So, no more debug.print. Just follow the flow of execution right on into that code you don’t own. Who knows, you may even find someone else’s bug in the process of solving your own!

iPhone Developers Training Notes

It’s been a couple of weeks now since I attended the Voices That Matter: iPhone Developers Conference. That distance has given me an opportunity to get plugged back in at work – and forget everything I heard at the conference. Fortunately, I took notes.

The conference was hosted by (can you guess?) a book publisher – namely, Pearson Education. As such, they happened to know of a couple of guys who’d just written a book about development on the iPhone OS platform: Aaron Hillegass and Joe Conway of Big Nerd Ranch. Everyone at the class received first editions of the book, which hadn’t even hit the shelves yet.

The class centered around the book, which was clearly drawn from their experiences teaching classes. We’d spend a while listening to lecture, then we’d code for a while. Nothing too complex. But, I learned a whole lot. Here are some of the good bits:

The iPhone OS is a modern, event-driven operating system, not unlike Windows or OS X.

(Oo! Big surprise!)

Basically, the OS sits around waiting for events to happen. An event might be the user swiping their finger across the screen. Or, it might be system generated, like an incoming phone call. In any case, the OS spends most of its time waiting. And, when it’s not waiting, it’s executing “the event loop” which looks like this:

iOS Main Event Loop

Thank Apple for the pretty picture. The Big Nerd Ranch guys had a better, more technical drawing in their slides. Alas, they did not share their slides with us.


Everything about the iPhone OS is based on the Model-View-Controller (MVC) design pattern. There does not appear to be a way to write an iPhone OS application without using that pattern – at least not with XCode, the Apple development environment. (Think Visual Studio for Mac OS X and iPhone OS apps.)

Frankly, I find this incredibly impressive and beautifully elegant. Each application you build consists of one or more Views (screens or sub-screens); a Controller for each and every View; and one or more Model objects for storing data.

Objective-C is weird!

You know those warm and fuzzy things like “dot notation” that C programmers have been accustomed to for decades? Yeah, they changed that in Objective-C. Instead of using periods to call a method on an object, like this:


Objective-C uses a square bracket notation, like this:

[Object Method];

Furthermore, you know that old familiar way you’ve been sending parameters to methods, comma separated lists inside parenthesis? Yeah, they changed that, too. So, instead of this:

aCircle.draw(point, radius);

In Objective-C, you write this:

[aCircle drawAtPoint:point OfRadius:radius];

In other words, Objective-C forces you to name your parameters. And, they even include them in the method name. The method above is called “drawAtPoint:OfRadius:”. They even pronounce the colons! Too weird!

Note: As a side effect of including the parameters in the name of the method, Objective-C does not support method overloading, since changing the parameters changes the name of the method.

No Garbage Collection

But, not all of the old, time-honored traditions of the C language are gone. No! Memory leaks are as prevalent as ever thanks to the lack of a memory manager with garbage collection.

Actually, OS X (on which the iPhone OS is based) does have garbage collection. Apple chose to remove it due to the memory constraints on the devices (according to Aaron and Joe).

Here’s how it works. When you want to declare a variable, you first allocate memory for it on the heap, and initialize (or zero out) the memory:

myArray = [[NSMutableArray alloc] init];

This line of code calls the static “alloc” method on the NSMutableArray class in order to set aside enough memory for the array, then calls the “init” instance method on the new object to zero out the allocated memory. After the methods run, a pointer to the memory in the heap is placed on the stack in a variable called myArray.

Note: It’s quite common to see methods strung together like this.

Now, if you just allocate more and more memory without ever releasing any of it, you’ve produced a classic memory leak, ala C programs on MS-DOS in 1981. So, the good programmer will clean up after themselves, like this:

[myArray release];

Simple enough. But, easy to forget.

Alternatively, you could flag the variable as to “autorelease” at the end of the current event loop, like this:

myArray = [[[NSMutableArray alloc] init] autorelease];

It’s not quite that simple in reality. But, you get the point. (And, one veteran OS X and iPhone OS developer I spoke to at the conference recommended that until I really understand what I’m doing, I should always autorelease my variables just to be safe.)


I could keep writing for hours. The class was fantastic. I learned an incredible amount. But, I’ll wrap it up here with a couple thoughts about developing on the iPhone OS platform.

First, developing on the iPhone OS is not easy – especially if you haven’t developed on the OS X platform. Therefore, outsourcing a native application will likely be quite expensive – much more so than a typical business application. But, training internal staff would likely take too long, resulting in potential opportunity cost.

Second, the iPhone OS platform offers some particularly attractive features. But, beyond the cool factor and the general mobility of the device, corporations need to think long and hard about why they want an iPhone OS application over an HTML5 application before they invest their money.

ASP.NET MVC for the Rest of Us

If you subscribe to the MSDN Newsletter, you may have already seen this. But, I wanted to let you know about it just in case.

Microsoft has published a series of introductory presentations about ASP.NET MVC entitled “ASP.NET MVC for the Rest of Us”. I just watched the first video (of three). It gave a good overview of the similarities and differences between traditional ASP.NET WebForms and ASP.NET MVC.

If you’re doing web development, I recommend watching the videos. They’re only about 30 minutes each. And, the ground they cover is an important foundation. Even if you’re already doing ASP.NET MVC, you’ll probably gain something from these videos.

Here are the links: Part 1, Part 2, Part 3.