From Ted Neward's blog comes the news that he's now the Editor-In-Chief for the new .NET community site TheServerSide.NET.  It's the .NET port of the TheServerSide, a vibrant Java community, but it's backed by companies such as Microsoft and Developmentor.  Ted's aiming to do the following with the site:

1. Create a place where the hard questions can be asked.
2. Promote J2EE/.NET interoperability.
3. Promote open source .NET projects.

Some good points already:

• An excellent sets of interviews, with transcripts, such as Don Box on Indigo, Scott Guthrie on ASP.NET and some guy from Borland. 
• A good set of articles from DevelopMentor trainers such as:
  •  Justin Ghetland on Unit Testing in .NET showing a Visual Studio Addin that still has the NUnit green and red traffic lights.  Any thoughts Jamie Cansdale?
  • Stuart Charlton on Autonomous Services dealing with SOA and the ROX holy trinity of relational, object and xml technologies.
• Pre-release chapters from the Microsoft Patterns & Practices group on Remoting and Managed Code Performance.

This looks like a great addition to the .NET community and already has some quality content.  The only downside, and this is a major one in my view, is the lack of an RSS feed - the front page only has an RDF feed that wont work in SharpReader.   What's going on there?

At last night's Extreme Tuesday Club meeting we talked about the use of Gold Cards as a way of handling problems that can arise in successful Extreme Programming teams.  The idea of Gold Cards was presented in this paper from XP Universe 2001 which came out of the original Connextra team (an early and influential London XP team).

When an XP team is functioning successfully and doing paired programming, frequent releases and working at a constant it can be difficult to find time to do individual investigation on new approaches to problems.  There are several difficulties for a successful XP team:

• It can be difficult to take time out and think about new and innovative approaches to a problem.
• Often innovative new ideas come from individuals thinking laterally rather than a team focussed on task completion.
• Sometimes pairing and the team work made it hard to highlight positive contributions of individuals, or to handle performance reviews.

The Gold Card was a way of overcoming these problems.  The index card is a core part of XP planning, used to write User Stories and drive development.  The Gold Card is simply an index card that allows a developer to spend some a day of solo time investigating a topic of their choice, ideally with some business benefits.  They used this system:

• Each developer had two Gold Cards each month, so about 10% of work time.
• During the morning stand-up meeting a developer could elect to use the Gold Card
• The developer writes on the card what they want to achieve and provides an update at the next morning's stand-up meeting as well as on the Wiki.

Part of the discussion last night was how one global financial bank allow their developers to do skunkworks style tasks on Friday afternoon.  Gold Cards provide a mechanism for time-shifting this idea.

Gold Cards helped promote a 'praise culture' within the group.  It also proved a successful motivation tool.  On top of this there were significant business benefits, such as reducing project risk, increasing development efficiency and most surprisingly, generating a business opportunity that became the company's major product.

Finally, Ian Griffiths has a blog (RSS).  For those not in the know, Ian is UK-based, a Developmentor trainer, an O'Reilly author, a co-author and friend of Chris Sells, an associate consultant with my company, Axxiant, and the guy who interviewed me for my job at Axxiant (there was a stressful interview).  Ian also writes great email.

Glad to see his great sense of humour is already shining through in his recent post:

"I used to know a lot about C++ ... not only did I buy my own copy of the C++ spec, I actually referred to it from time to time. How sad can one man get? Despite this, I continued to learn new and often surprising things about the C++ programming language on an alarmingly regular basis, right up until I discovered that I preferred C#."

 

I recently came across Fate Hani's Bile Blog on the Java Community (via Joe Walnes, an XTC attendee who's book was biled).  It's opinionated, rude, mostly negative, full of overgeneralizations and contains some foul language.  It is also sometimes informative, entertaining and funny.  Imagine a darker version of Rory who swears and has a bad attitude. 

Some topical posts that give a feel for the site's contents:

• Die petstores die.  The world has enough pet stores already.
• The codehaus of crack.  I mentioned this group in a list of things I liked (from afar) about the Java Community.  Seems that all communities have their good points and bad points.
• Mock obsession.  Mocking frameworks like JDBC isn't the way to go.
• FOAF can FOAD.   Echoing Jon Udell's thoughts that this isn't the way to go.
• ThoughtWorks: The new BodySnatchers.  "The training program at ThoughtWorks must be a modern day marvel of human engineering. It takes in as input fresh young bodies, and at the other end spits out those same bodies with their previous mental contents erased, to be replaced with one of the six possible variants of the MartinFowler template."

The Application Integration and EAI Architecture guidelines I mentioned in the last post seem to me to be an answer to Michael Earl's Plea to Microsoft Architects because they talk about problems that really matter today and how you can apply currently-shipping technologies to solve these problems.  The guidelines have contributions from a great bunch of Microsoft Architects (at least I think they qualify for this title) such as Maarten Mullender, Keith Short and Pat Helland (who have given some top presentations at TechEd and PDC recently).

Don Box has already responded to Michael by saying he'd like to see a list of top 10 MSFT bloggers who are focussing on helping people apply shipping bits to the problems that matter.  I agree, but think part of the problem is that many of these guys aren't blogging but are writing great content for MSDN Enterprise Development site (nice reorganisation) or the Patterns and Practices group.  For better or worse, blogging seems better suited to short, time-relevant information such as thinking about the design of upcoming technologies.   The problem is that blogging helps make a topic seem alive and current and creates a sense of community.  It would be nice to combine these benefits of blogging with high quality content already available.

Adding life to the Patterns and Practices content
I'd like to see some way of using blogging and the community to increase the value that comes from the Patterns and Practices and MSDN material.  Every time I go back to it I'm impressed with the content, but sometimes it seems impenetrable, and well, a little dull.  I wonder what can be done to bring it to life and get more dialogue going in the community? 

I know that the Patterns and Practices group are now doing webcasts (disclaimer: I haven't had a chance to participate yet). Perhaps there could be some more focussed community involvement or debate around the architectures or concepts?  I know that Shadowfax, the Patterns and Practices group's project to apply service oriented solutions with currently shipping technology, is available for download.  Perhaps there could be some key questions the group are looking for feedback on?

Perhaps there needs to be a pub architecture club, similar to the Extreme Tuesday Club (now open in Brisbane, Australia).  Either that or find some way to get the like of Pat Helland or Maarten Mullender to start blogging?

The ever-active Patterns and Practices group have released Guidelines for Application Integration focussing on EAI Architectures.   It provides useful coverage of all of many of the issues involved in integrating applications.

The guidelines covers the levels of application integration, such as business process, data and communications-level integration.  It defines the capabilities required at each of these levels.  It also covers security and operational considerations before finally showing how to map Microsoft Technologies to application integration capabilities.

The guide is useful because it deals with concepts from an abstract perspective rather than a technology-centric approach.  All of this is likely to be useful in a service-oriented (it's just not PC to say SOA anymore) world.  The architectural concepts and business issues identified are independent of the technical implementations such as Indigo.

Apologies for the lack of technical content of late (and in this post).  Today I finished my engagement on the project that involved a 4 hour commute, tomorrow I'm flying to Gifhorn, a small town in Germany, to spend the Christmas week with my wife and her family.  I'm hoping to have more time and energy to blog again in the New Year (before our first child is born in April)

Happy Christmas to everyone in the blogosphere.

Mary and Tom Poppendieck's have a book on Lean Software Development that's really excited me of late.  I was reading it while I was thinking about how the project I just finished on could be improved in future iterations.

Lean Software Development takes ideas from Lean Manufacturing can be applied to software development.  Their website has an excellent range of presentations and publications.  The one I first read, which I think is as good as the book, is 'The predicability paradox'.  It goes through their eight keys to lean thinking:

• Start early. Focus on establishing good communication between the group and about the problem.
• Learn constantly.  Look for end-to-end slices of functionality that you can build, test and deliver to learn more about the problem.
• Delay commitment.  Use encapsulation, loose coupling, refactoring and automated testing to make it easier to change code.
• Deliver fast. Focus on being able to deliver fast (e.g. automated build and deployment) through excellent operational discipline (source code control, build tool) in order to get quicker feedback.
• Eliminate waste.  Focus on customer value and remove wasted processes.
• Empower the team.  Avoid central control, focus on self-directed workers.
• Build integrity in.  Write the tests at the start.
• Avoid sub-optimization. Sometimes breaking a complex task into small parts leads to sub-optimum solutions.  Make sure you measure the right things and set the correct goals.

For some reason this just seemed to speak to me in ways that some of the other writing on Agile/Extreme hasn't in the past.

Here's a Public Service announcement for fellow UK bloggers. The London .NET User Group will be hosting Dave Sussman speaking on ASP.NET 2.0 'Whidbey' on January 20th at the Cafe Royal  (not the MS swimming pool room in Soho).  For those that don't know, Dave is a co-author of the Addison-Wesley .NET Series titles - 'A First Look at ASP.NET v 2.0' and a 'First Look at ADO.NET and System.Xml V2.0' (sample chapters are available at both links).

The event is free but book early as it is likely to book out.  If you're interested let Ian Cooper know at meetings@dnug.org.uk 

I'm going to be presenting on Service Oriented Architecture with WSE and Indigo in February.

Doing some performance testing on my current project showed me the evils of premature optimization and the need to test performance first before 'optimizing' the code.

A month ago when I started on the project there was no working deployed version of the application in an environment I could run tests against, so I did some code reviews and eyeballed areas of the architecture that might be slow.  The project uses BizTalk 2002 Orchestrations to process a SOAP message that is passed around as a string.  All of this manipulation was based around the XmlDocument DOM model, which had been slow and memory-hungry in previous projects, so I wrote some code to test the speed of different approaches to XML processing.  Using the XPathDocument and XPathNavigator turned out to be 70% faster. 

However, when I analysed the entire web service method only 6% of the call time was spent in these methods.  So even if we implemented the change it would only improve the overall performance of the web service call by about 4%.  This may or may not be worth it, but it highlighted to me the need to get real performance figures to test my assumptions about where the bottlenecks were in the code. As Donald Knuth says:

"We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil."

I love that Microsoft has put the PDC presentations online, and unlike the US TechEd prsentations, has left the questions in at the end.  They've been very useful in helping to sort out the Microsoft Messaging message.  Here's one more piece of the puzzle that I found at the end of Steve Swartz's excellent WSV 403 Indigo Coming Attractions presentation when he was asked 'How do you implement something like MSMQ with Indigo?'

MSMQ kind of semantics can be implemented [in Indigo] in two ways:  They can be implemented inside a channel, or out in an application serving as an intermediary.

Indigo comes with a channel called the reliable channel that implements point-to-point buffering, point-to point-queuing - so that you can be on a laptop sending messages to me.  The messages stay in a buffer. Later your app goes away, I connect, the messages get sent to me, I reply, the messages sit in a buffer, later your app comes out and drains them.

Or I can build a queue intermediary.  Indigo V1 will ship with a queue class that you can put in an intermediary sitting at an address.  You can put messages to that and you can pull messages from it.

So those are the two options depending on whether you think of a transport kind of thing - so the semantics of me talking to you - or whether it’s a real thing that sits between your and app and the user of the app, where many people may be writing to the same queue and many apps might be reading from it.

Over time - Indigo is a long plan - in Indigo v1 we will be releasing classes, so that you can build queues.  Over time we will be implementing 'queue services' - full bore services that known about clusters and the whole thing.  Parts of MSMQ wont be in v1.  The programmer part will be, but the big old configurable server side wont be.

So, the programming model is there for V1, but a replacement for the enterprise aspects of MSMQ will have to wait until the future.  This would cover the apps where I've message queue in the past (basically a private queue that one app can post to independent of another that reads the messages off), though its not (yet) the replacement to Tibco I was hoping for.