NoVA Code Camp


I had a good time at the Northern Virginia Code Camp. Had the chance to meet some people I only really know via Twitter and got to catch up with others. I’m glad they let me present – my “I’ve Sprung a Leak” WinDbg 101 talk had a good sized crowd that had good questions and feedback. I know I learned a few things along the way.

The Software Craftsmanship panel discussion for the Community Megaphone podcast was also interesting. I’ve never had the opportunity to do something like that before. I hope my passion for the subject came through without a lot of “jerkiness”. Sometimes I get a little carried away… Smile I’m glad Andrew and Dane invited me.

NOVACC was actually a bit nostalgic for me – I attended my first code camp ever at the first NOVACC. They are always so well run – taught me a lot for when we got around to doing them in Pittsburgh. In fact, I took some notes for things we can steal to improve our camp. Thanks to Hal Hayes and the volunteers for putting on such a great event.

Fellow Pittsburgher Hemant Singh was also presenting, and I caught his session. He explained WPF styling. I wanted to finally see Dane’s session on Entity Framework (just to see how the other half lives), but by the time I realized he was doing it it was half over. There were other talks I wanted to see but couldn’t due to scheduling conflicts.

Lots of good conversations and discussions with other attendees. I found out Brian Lanham from Roanoke is a fellow Penn Stater and is actually working on getting a user group off the ground in Altoona. I’m definitely going to have to find a chance to present there.


Follow-up Info for “I’ve Sprung a Leak”


I promised those attending my talk at NoVA Code Camp 2010.2 that I’d post links to the resources I’ve found for using WinDbg, especially the SOS commands. Here you go!


My “Getting Started” blog post:

SOS Debugging Extension:

Brock Reeve’s sample code (what I used in the demo):

Tess Ferrandez’s blog (lots of good stuff):

Other interesting links:

What Software Craftsmanship Means to Me


Why do we in software dev ask permission to improve tooling or improve the code? Does your landscape firm ask permission to sharpen blades? – Troy Tuttle via twitter

I know its very much an in vogue thing these days to call one’s self a software craftsman, but I’ve been doing it for a while now. Not because I’m an arrogant snob (although I’m sure that many see me that way Smile). No, instead, because to me, craftsmanship represents what has been missing from our industry.

We like to pretend we’re engineers. In fact, my employer thinks I’m a Technical Lead Software Engineer. I’ve resisted this title all of my career. There is no formality, no cohesive body of knowledge, none of the other trappings of engineering in software development. I don’t think we’ll get there anytime soon, either. We’ve been building software for a bit over a half a century. In the Western World, engineers have been building bridges and marvelous structures since the Romans, the Greeks, even back to the Egyptians. Thousands of years ago. Even on Internet time, we have a lot of catching up to do.

I’m not a programmer, either. That’s extremely limiting. I do more than just sling out some code. I’ve liked the title Developer. I think it represents what we do. We do whatever it takes to develop good software. Whether that’s writing code, drawing diagrams on the whiteboard, discussing the best ORM in the hallway, executing a test plan – that’s what we do.

To me, the Software Craftsmanship movement is the next phase in that evolution. Its about refusing to compromise our principles without a full discussion of the consequences. Sure, I’ll crank out that feature in half the time I told you it would take. But when we come back to add to it next release, it will take that time you cut from my budget just to get it to the starting point. And that can be fine.

That’s where craftsmanship has been taken too far. At the end of the day, we’re paid to ship software. If the code underneath that shiny UI is total crap, but the application does what it needs to, we’re successful. There’s nothing wrong with that. As long as its acknowledged that the necessary structure to take that application to the next level is not there. The problem is, someone will say that we only just need to add this one feature, and then we can take the time to fix the plumbing.

But someday never comes. Or it comes years later, when its clear to everyone that the current architecture is holding us back. Only then somebody decides we need to fix things. And so we undertake a re-write. Which takes longer than anyone ever budgets, because the requirements are never well specified – its always, just make it do what it did before. And add these 5 features while you’re at it.

Maybe the first version is based on a solid architecture. The code is well written and even obeys all of our coding standards. Its been peer reviewed or maybe even pair programmed. But you don’t have any automated tests: no unit tests (or maybe a paltry 10-30% coverage), no feature/functional/acceptance tests, no automated UI tests. So as you move along, you make changes that ultimately break some existing functionality, and nobody discovers it. Until “integration testing”, which is another failure condition. Or worse, there never was even a manual test case to cover the regression and the defect isn’t found until you are in the field, or the web site has gone live. There are a myriad of ways to cut corners on software…

Software Craftsmanship means standing up for solid software. It means only allowing shortcuts to be taken when the stakeholders understand the consequences. Taking on technical debt only with the full understanding that you are doing so. Its important to not stand in the way of shipping software with debt as long as it’s a conscious business decision. It could make or break the company. But remember that unless the company is prepared to pay the extra costs associated with that debt down the road, that could also break the company.

Hansel and Gretel Architecture


Expanding on a random tweet of mine…

Ever since we gained the ability to run multiple applications/system simultaneously, either on one machine or across machines, we’ve had the need to share data between applications. The general ledger system needs payroll data. The order processing system needs inventory data. The customer web site needs pricing data. And so it goes.

Over the decades various schemes and theories have been developed for solving this problem. Some of them were good long ago when no better solution was possible. Some of them are still good in limited scenarios. Some are the current state of the art. And as time goes on, I have no doubt someone will devise some method we haven’t considered or dreamed of yet.

One of the earlier techniques used was to have multiple applications use the same database. This allowed them to all see the same data, which made it possible for the general ledger system to get at the payroll data, and so forth. It saved costs, too, in the era where a server capable of hosting a database was expensive and difficult to maintain and administer. When only a few dozen people in a couple of accounting focused (or other similar domain) departments needed to access the data. In short, it was a really good idea from a technical and business perspective.

But then machines got faster and cheaper. More and more people needed to have direct access to data. And we created more and more applications for different groups. Some of these groups had different ideas what the different “entities” in the business domain meant. To some people, an order is a request to pull some item from inventory. To others it’s a request to generate a bill. Still others find it is historical information that can be used to determine future demand for marketing plans.

And then we figured out that if we needed the accounting folks to invoice a customer for an order, we could just put a InvoiceCustomer flag on the order table and set it to some value representing true. So we set it to “T” and hoped that they would then change it to something else when they generated the invoice. We never documented that we expected it to be “F”, we just assumed they would know.

Eventually, someone decided that we added a lot of flags. Maybe we should find a way to make it easier so we didn’t have to bother the DBAs with a new state every few weeks. So we created a new field. We called it “OrderState”. Now we decided that an order that needed to be invoiced would have a value of “NI” (for needs to be invoiced) in the “OrderState” field. But we can’t get rid of the InvoiceCustomer flag, because we’re not sure if any other application is using it.

Before long, there is a massive trail of poorly documented and specified fields. Nobody has a clear picture of why (or even if) they are required. The usage is across a bunch of applications and reports, perhaps even some applications that aren’t even being developed anymore. You don’t dare touch any of items on this trail. They are like the breadcrumbs from an old folk tale – for various reasons they disappear or degrade over time until they no longer are able to show you the way home.

No matter what the data elements, no matter how tightly you control the database, no matter how well you document it, some of these breadcrumbs will materialize. The best way to combat this problem is to have a separate data store for every application/service. That way, you can know for sure how the application makes use of the data, and be sure that no one else is using the data differently. Don’t even allow another application to have read access. Require other systems to interface with the data via your application/service using messaging, pub/sub, or web services.