I’ve been meaning to post this for a while, but I’m finally making myself do it now… I’ll be giving a presentation on “Creating Your Own Enterprise Application Framework” at Tech Ed in Boston, on Friday, June 16 at 9:00 AM in Grand Ballroom A. My talk is based on experiences in my 2–1⁄2 years in patterns & practices and how I believe we most successfully build our libraries and frameworks.

Here are the slides from today’s webcast. Thanks who all tuned in. There will be a slight delay in posting the code from the webcast, as I seem to have accidentally deleted it in the process of getting it ready to be uploaded. I was trying to get rid of all the bin and obj directories, and I did. I also got rid of all the source code  I’ll try to recreate it tonight and post it tomorrow.

I will be doing a web cast Thursday, 11AM PDT, on Enterprise Library Extensibility. The real subject is creating your own design time experience for your application blocks, but that is the title that they gave it. You can sign up here. — bab  

Hi, All, This entry should have something in it for everybody, since I have a bunch of little things to say. Friday is my last day at patterns & practices. I want to thank everyone there who has put up with me for 2–1⁄2 years. The experiences I’ve had there and the friends I’ve made there will last me the rest of my life. And hopefully I’ve left something of myself behind that will help them in their future endeavors.

A couple of weeks ago, someone posted a question on the Enterprise Library GDN workspace, asking about how they could configure the Exception Handling block without using an external configuration file. I wrote a bit of code to do that, and I wanted to share it with everyone else. Here is my solution. This first part is a very small change I made to ExceptionPolicy to allow it to accept an ExceptionPolicyFactory through an additional HandledException method.

I’ve put together the package of sample code I used during my webcast today and made it available here. If you happen to see this post before the webcast (11:00 AM PST), feel free to download the code for yourself and follow along during the live presentation. — bab  

I just received the link for my webcast on Thursday. You can find out more about it in my previous post, and you can sign up here. Hope to have you all there! — bab  

This Thursday, Tom Hollander and I will be presenting a web cast on building your own application block using Enterprise Library January 2006. The talk will discuss how to take a piece of functionality that you have built and plug it into the configuration system, so that it can be constructed using our provider-based factories. The topics will include: Building the simplest Application Block possible Attaching configuration to the block Allowing for variability through custom providers Creating your own configuration objects for your providers And if time allows, I’ll be discussing how to create and attach instrumentation to your new application block.

One of the biggest areas of change between this new version of Enterprise Library and the original version, shipped a year ago, is our configuration system. The original configuration system, written (and rewritten 3x) by Scott Densmore, worked tremendously well, but was custom-written just for Enterprise Library. In our newer version, we’ve adopted a more reusable framework on which to base our configuration system. This framework, called Object Builder, is a reusable, configurable dependency injection and object creation pipeline written as part of the CAB project by Peter Provost and Brad Wilson, with lots of goals donated by Ed Jezierski.

Sorry I didn’t get this link out in time for folks to tune in live, but I spaced on it  Anyhow, Peter Provost, Brad Wilson, Darrell Snow, and I did a webcast about a week ago talking about lessons learned during our projects (EnterpriseLibrary and CAB). We ran both of these projects using similar Agile methods, had great results in both, and talked about what went well and what we wanted to improve on for next time.

Someone recently sent me some email after looking through my old Enterprise Library January, 2005 Caching block code, and asked to say a few words about the design of the exception safety of that block. This was one of the flaws in the original implementation of the Caching block that this newer implementation replaced. It had some thread safety issues, and it did not function well in the face of exceptions.

patterns & practices is proud to release to the web Enterprise Library for .NET Framework 2.0: November 2005 CTP (that’s a mouthful!). This version of the library has been recoded to take advantage of the  new .NET Framework 2.0 features, including database providers, better support for logging and tracing, and the new System.Configuration subsystem. Blocks included in this release are: Caching Data Logging Exception Handling Security Security Caching

One of the best gigs I’ve had in my whole life has been working with the great people at Microsoft’s patterns & practices group. These people are responsible for solving interesting problems in interesting new ways, and sharing their code and learnings with you, fellow Microsoft developers. At this point, they’re looking to hire another developer to join their team. I warn you — the bar is high. They interview many and accept only the best.

On Monday, June 26th, I had the pleasure of addressing the St. Louis .Net User Group. I had been invited to speak about Enterprise Library, as several people had been asking questions in the group about how to get started using it and were looking for an overview. I had already given a talk on Enterprise Library to the C# and VB.Net SIGs of this group, so it was only natural that they might call on me to give the talk at the main meeting at well.

Note to self: WMI and LUA don’t play together nicely. I’ve been researching a bug that many of you Enterprise Library users may have encountered. According to our instructions, you have to run installutil against all EL assemblies, to allow them to load up their performance counters, event log sources, and WMI schema. If you do this as an admin, things work beautifully. If you run your EL-based app with less than admin privileges, interesting things happen with WMI, but that has been covered on other blogs.

What in the world do these three topics have in common??? I would have thought nothing until yesterday. But then I learned better… The Principle of Least Surprise Do me a favor, really quickly. Google “Principle of Least Surprise”. Back already? Good. It sure seems like there are a lot of folks out there who are pretty hot on using software that does what they expect it to do. And doing something unexpected, like making Ctrl-Q quit your program instead of ending macro recording, makes some folks pretty angry.

Don’t know if any of you have ever had this happen to you or not, but it paniced me a bit when it happened to me. I opened up perfmon, and instead of nice names of counters and categories, I had nothing but numbers in their place. The last thing I wanted to do was to have to rebuild my VPC, so I really wanted a way to fix this.

If you could design your own war room for a software team, what would be in it? I’m talking about the kind of stuff that a company can provide, not the soft stuff like candy, etc. Here are my choices: A shared, isolated space Teams need a shared space to work, but they need to be isolated from everything else. All folks involved with the project need to be welcome in the war room, but no one not on the project should be in there.

Enterprise Library V2 is starting up, and we’re having problems getting traction. Scott Densmore, Mani, and I are the only holdovers from the original project, and we’ve picked up a new tester, Gokul (I know I spelled this wrong — sorry!) and two new developers, Brad Wilson and Fernando Simonazzi. In short, we’re basically starting over from a team point of view. And I get the sense that we’ve been thrashing the past couple of weeks, because we’re still trying to understand all kinds of different things.

I was just reading an article in Fast Company. The theme of this issue was “Design”, and the first article in there was about designing workspaces for knowledge workers. The article was written from the point of view of the author as she was writing the article, in a shared work area, with all kinds of interruptions going on around her. Every now and then in the text, she’d add an aside about how someone just came up to her to ask a question, or she’d mention that she overheard some conversation going on a few desks over.

My group at MS is considering changing over to using the new unit testing stuff built into the newest version of Visual Studio, so I decided to give it a try. I’ll be keeping a diary of how things go today, and hopefully I’ll learn something interesting. The first thing I’ve learned is that I can’t wait for the ReSharper EAP  I need the navigation and refactoring tools I get with that.

One of the biggest secrets of Enterprise Library is that we shipped it with 1800 NUnit unit tests. These tests reflect our best efforts to write this code in an agile, Test-Driven style. Sometimes we were more successful than others, but the fact remains, we did a damn good job of writing tests for our code. What do the unit tests do for me? As a developer, these unit tests are a great resource.

The second part of our continuing conversation with Ron Jacobs about our time in the Delta Lounge. Scott, Peter, and I get further into team dynamics, pair programming, things that went right, and things that went wrong. Tons of fun to create, hopefully as much fun to listen to! — bab

Ron Jacobs has up Part 1 of a 2–part podcast series that Peter Provost, Scott Densmore, and I did about our working environment during Enterprise Library V1 development. I consider the fact that we were all put into the same room to be the critical success factory in letting us get Enterprise Library out the door in the time that we did, with the quality it has. Our conversations in the 2–part series roam through how and why we used the Delta Lounge, who was in there, why it was important that devs, architects, and test were all in there at the same time, how our choices in music help draw us together as a team, and more.

Cheesy title, but it caught your eye, eh? The real point of this article is to describe a TDD experience I had the other day (Friday), and how it changed my life (OK, a bit over the top, but hey,  it kept you reading…) Here is the scene. I’m working with Peter Provost and Jim Newkirk, building a Continuous Integration system to be used internally in patterns & practices. Peter and I have been the devs on it, and Jim provided the customer’s point of view.

Peter Provost, Scott Densmore, and I were talking about some additions to our project coding guidelines, and I proposed a new one that we wanted to get some feedback on from the community. According to the Dispose pattern, you’re supposed to create classes that look like this: public class BuildProcess : IDisposable { ~BuildProcess() { Dispose(false); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (disposing) { } } } Now the issue here is what should happen if your class is disposable and the finalizer gets called?

Sometimes you accomplish nothing but you learn everything. That’s what happened to me yesterday in the Triangle Lounge. Quick background — I’m working on the Enterprise Library project in the Microsoft patterns & practices group. We’ve been working on consolidating many of the current MS Application Blocks into a single, coherent offering. We all sit in one room, called the Triangle Lounge, including the 3 remaining developers and the 3 testers.

Shortly after I posted the original entry on this, I figured out a much more simple way than using version numbers, etc. Item item = null; bool lockWasSuccessful = false; while(true) {     lock(hashtable) {         item = hashtable[key];         lockWasSuccessful = Monitor.TryEntry(item);     }     if(lockWasSuccessful == false) {         Thread.Sleep(0);         continue;     } // If we reach here, the item was successfully locked     try { // Application code goes here

I’m storing information in a hashtable. The information is keyed off a string, and the key is volatile — items can be removed, added, replaced, etc., from the hash table. The problem that I’m studying is how to manipulate this information in a thread-safe way without locking the entire hash table all the time and killing performance. Solution number 1 was to lock the entire hash table during each operation on the data in the hash table.

I’ve been working on a project along with about 10 other people in a really small conference room at Microsoft in a room we’ve dubbed The Triangle Lounge. This room could comfortably fit about 5 people, but we’ve been cramming 8-10 in there every day. Why do we do it? Because we find that we are much more productive as a team if all sit in the same place.

One thing I haven’t mentioned about myself yet is that I’m part of the Microsoft Enterprise Library team. I’ve been working on this project since its first day, back in February, and MS has finally taken the wraps off the project. This has freed us up to start talking about it, and talking I intend to do! You can see the blogs of the other Enterprise Library team members at the far left of my blogs.

As promised in the previous blog entry, here is the code I used to implement the Active Object pattern on a .Net project I’ve been working on. Here’s the setup for the pattern again. I was working on rewriting some caching functionality on this project, and I had some housekeeping operations that had to happen in the background. This meant that I had to have multiple threads operating at the same time, but I had several choices as to how to do this.

What’s In a Name It’s 1995, and the GoF book had just been published. For those of you who do not know what the GoF book is, it is the original Design Patterns book, written by Ralph Johnson, Erich Gamma, John Vlissides, and Richard Helm. At that point in time, very few developers had ever heard of patterns as reusable problem solutions. I was fortunate to be hooked in with some very smart people, so I was pushed towards reading this book, and it has served me well to this day.

Over the years, I’ve gotten a lot of requests for non-trivial examples of code entirely written using TDD and Simple Design. I can finally give you that example. This code is for the Offline Application Block, part of Microsoft’s Smart Client initiative. Basically, it implements a framework that will allow client code to operate in much the same way, whether it is connected to the internet or not. It was written over a period of about 12 weeks, and was done entirely test first.