Coding the Architecture

Are you a software architect?

The line between software development and software architecture is a tricky one. Some people will tell you that it doesn't exist and that architecture is simply an extension of the design process undertaken by developers. Others will make out it's a massive gaping chasm that can only be crossed by lofty developers who believe you must always abstract your abstractions and not get bogged down by those pesky implementation details. As always, there's a pragmatic balance somewhere in the middle, but it does raise the interesting question of how you move from one to the other.

Software architecture: where do you start?

You may have seen this on Matt Deacon's blog already ... I'm running a session for the IASA UK chapter on the 9th of March in London.

Where do you start?

One of the hardest things about software development is being asked to come up with a design when all you're given is a set of requirements and a blank sheet of paper. Many software teams will dive straight into the code and while this can initially be very productive, the slippery slope of constant refactoring is awaiting those teams that haven't quite found a design that works. Often, a little forethought is all that's needed to get the development process heading in the right direction. So where do you start?

This session will answer this question, presenting some simple techniques for tackling software architecture while dispelling the myths about the need for complex tools and big design up front.

I'm planning the content for this session at the moment and it's going to be a mix of presentation, discussion and probably some group work to get you all drawing a few boxes and lines. We're going to cover a very very quick overview of what software architecture is all about before moving on to see what drives and influences it. Once this is done, we'll look at how to actually design software from a blank sheet of paper, focussing on some techniques to help you determine what components you need and how best to organise them. A nice side effect of the techniques we'll use to define architecture is that they can also be used to share architecture, so we'll wrap up by looking at how to document software architectures in a simple yet effective way.

You can find more information about this event and register here. I'm really looking forward to it and hope to see you there.

Designing Maintainable Systems

I'm currently involved in a project to upgrade a third party piece of software and it's apparent that when the software was originally designed, the upgrade process was not considered. This became obvious when we totaled up the time required to perform, configure and post-release test the upgrade - it came to over three days of work. This was not even taking into account any rollback times (which is fortunately simplified these days by the use of virtualisation).

The software is used heavily from Monday to Friday so we wanted to upgrade over a weekend. The vendor suggested we perform an upgrade on a parallel system and then get the users to re-enter all the data into the new system that was missed - you can imagine how well that would have gone down. This would also mean trying to post-release, regression test two systems that are live, being used and not in sync.

Software almost always needs updating/upgrading (unless it's control software for a deep space probe!) The ability and consequence of upgrading should be considered as part of the design and development process. Questions to ask include:

Can an upgrade be performed in parallel to a live, running system and how does a switchover occur?
Will a system need to be taken down for any upgrades and for how long? How does this affect your Service Level Agreements?
How easy will any upgrade be to rollback? Errors occur!
Can you upgrade parts of the systems or does everything have to be done at once?
What is the effect on any users? Will they need to log out first etc? Will they lose any work if they fail to follow your procedures?
How easy will it be to test the upgraded system to determine success? Your notice of failure shouldn't be an angry user phone call.

Some simple tools can make all the difference. Most of my work is on financial applications and I like to run regression reports between systems for important points e.g. End-of-year. However it's often very difficult to get data out of systems to perform simple comparisons!

Sensible configuration management is often missing. If I've upgraded and configured new features in my pre-production environment I really shouldn't have to repeat the process from scratch in production. Manual processes are prone to errors and ideally once I've prepared for an upgrade I should just hit a 'go' button and sit back.

In my experience very few software developers are aware of IT Service Management (ITSM/ITIL). In particular we should be aware of the Change Management, Release Management and Configuration Management roles that support staff have. If you want to read about ITSM/ITIL then the wiki page is a good place to start.

Some of the processes of ITSM may strike agile developers as being heavy-weight but this doesn't stop you developing the system in an agile manner, it just means that it can be deployed within a formal environment.

An architect should be aware of how the software fits into the organisation. So remember that your ‘users’ aren't just the end users but also the support staff who'll be maintaining your system for the next ten years!

The tension between software architects and their employers

Sergey Mikhanov has written a blog entry called Why I don't believe in software architects that, along with the follow-up comments, makes for a good read. It discusses some of the ways that software architecture is typically viewed (e.g. models rather than code) along with some thoughts about how coding should be included as a part of the role. Since this site is called "Coding the Architecture" and role of a software architect talks about how coding should play a part, I'm not going to dwell on that particular aspect. What I do like about Sergey's blog entry is that it highlights the often familiar (yet rarely discussed) tension between software architects and their employer.

What about career path then? Well, I can't give any personal advice here except for the "avoid advertised 'software architect' positions". The best company will allow you to keep writing code while expanding your area of influence wider and wider into the company products at the same time. This is what really software architecture is about.

I've been fortunate in that I've retained a large hands-on element as a part of my role and I've written code on most of the development projects that I've been involved in. I'm a firm believer that you're in control of creating your own opportunities and that the reason I've remained hands-on comes down to expressing that it's a crucial part of the role. For me it's simple ... coding is essential when designing software because I need to keep my skills up to date and understand that what I'm designing will work. Plus, it's fun and I'm not worried about admitting it.

Unfortunately many organisations seem to think that coding is the easy part of the software development process, which is why they see an opportunity to save some money and let somebody else do it. They view cutting code as low-value. Tension therefore arises because there's a disconnect between the seniority of the software architect in the organisation and the low-value associated with the coding activities.

In my experience, this doesn't happen in small organisations because everybody usually has to get involved in whatever is needed. No, it's those larger organisations where the tension is greatest. I spent some time working for a medium size consulting firm where my job grade put me squarely inline with the management and heads of business units, yet I still used to write code. In some ways it was quite an achievement to be graded as a manager and write code on a daily basis, yet it often felt very uncomfortable as other managers would try to push my name into boxes on the organisational chart.

Being in this situation is tricky and only you can get yourself out of it. A number of developers/architects have been in touch to say that they've found my Why software projects fail presentation really useful as a basis for expressing to their organisations what they would like their role to be. The role of a hands-on software architect discusses the same thing in a shorter format and both have been used as the basis for "terms of reference" for software architecture roles in organisations. Whether you're in an organisation where this is happening or you're looking to move on, be clear about how you view the role of a software architect and be prepared to stand your ground.

2009 highlights and plans for 2010 - part 4

Onwards then. The plan for 2010 is simple ... more content about pragmatic software architecture and more training. I particularly want to tackle the practical side of the software design process, including how to approach software design given a blank sheet of paper. We already have a body of material about this on the site and in the training course, but I want to consolidate it further with a very simple set of techniques to use for those "where do I start?" moments. I don't want to create an "architecture process", no, just a small collection of techniques that you can pull out of your toolbox when the time is right.

The other thing that I want to do is publish some sample software architecture documents. We have software architecture document guidelines but I've had a *lot* of requests for some concrete examples. This will go nicely hand-in-hand with the content above to form a great pack of guidance for anybody tackling software design.

Finally, Kevin and I are speaking at some events in the first few months of this year, with a view to lining some more up too.

Kevin and I will be running two sessions at QCon London 2010. The first is one-day version of our training course, while Kevin will also be talking about OSGi and industrial-strength Swing.

I'll be speaking at DevWeek 2010 in London, presenting two talks about improving software quality (automated builds in .NET and load testing).

I'm really looking to the year ahead, helping more people broaden their software development careers and build better software. If there's anything that you'd particularly like to see us cover, please feel free to get in touch.

2009 highlights and plans for 2010 - part 3

My final highlight from 2009 is that we improved our Software Architecture for Developers training course by restructuring it and adding more content. We've run this course for several hundred people now and the feedback is consistently excellent. Predominantly it's software developers that attend the course although the amount of existing software architecture experience varies wildly; from people in a pure development role through to others that have done some software architecture/design before. Despite the differing levels of experience, feedback says that the course consolidates existing knowledge and provides clear pragmatic advice on how to actually tackle software architecture and design. We cut through buzzwords and industry fashions, instead taking a common-sense and no-nonsense approach to software design.

I'd say that the majority of people attending the course do have an understanding of their role in the organisation that they work for, although often that same view isn't always shared by everybody in their team. Our discussion of the software architecture role provides some very clear guidelines around this and, again, it's something that people really value because they can use it to help them shape their own role and responsibilities.

One of the things that prompted the enhancements to the course is that we've seen how people often struggle when it comes to tackling software design from a big picture perspective. I've seen this during my consulting work but it's also often apparent during the case study exercise where we provide a set of requirements and ask people to spend about half a day designing a software system. It sounds easy when you see the requirements, but in reality it's easier to get caught up in too much or too little detail. The former sees people thinking too much about the code while the latter sees the system designed as a single box on a sheet of paper. Successful software design needs a balance of both and understanding this is exactly what the case study exercise is all about. It's also worth pointing out that the same techniques can be used when dealing with major system enhancements, so it's not all about greenfield software design.

The course has evolved a great deal over the past year and what we have now really does provide a very rounded, balanced and pragmatic view of software architecture. If you're tasked with designing software and aren't sure where to start, this could be the course for you. It doesn't seem to be the done thing for training providers, but I've published a preview of the course slides to give a feel for the content we cover and to illustrate that we have a very different approach to your regular slide-driven training courses. With only 146 slides over two days, you aren't going to get death by PowerPoint here!

In part 4 we'll look forward to 2010 and outline some of our plans.

2009 highlights and plans for 2010 - part 2

In addition to the new content, 2009 saw us present at a number of conferences and events over the year, with all of the slides being able to download and view online. Here are some highlights.

Documenting your software architecture - why and how?: This presentation was about why you should document your software architecture and how to do it. It complements our software architecture document guidelines.
Broadening the T: This presentation covered the skills needed by hands-on software architects; including seeing the big picture, dealing with non-functional requirements, using patterns at the architecture level, testing architectures, monitoring and diagnosing performance problems.
Pitfalls for new software architects: As it says on the tin ... what should you watch out for as a software architect?
From developer to architect: This is our one-day tutorial session that provides a whistle-stop tour of software architecture. It's basically a stripped down and older version of our recently enhanced two-day training course.

Stay tuned for details of our 2010 presentation schedule.

2009 highlights and plans for 2010 - part 1

Happy new year all! Despite the financial climate, 2009 turned out to be a fairly busy year. The rationale behind Coding the Architecture is to be a useful resource for hands-on, pragmatic software architects written by people with the same background. For this reason I'm delighted to report that most of my working time in 2009 was spent in front of Visual Studio writing C# code! There was, of course, a balance of the software architecture tasks, but the majority of my time *was* spent writing code. I've always believed that good software architects should remain hands-on to some degree and I still believe that today. Software architecture is about understanding how to design software from the big picture perspective while understanding the technology that you're going to use to ultimately build the software. Having both the big picture and the detail in mind puts you in an excellent position to deliver successful working software. And that's really what the software industry is about.

In the past I've tended to focus on writing about the role of the software architect and 2009 saw a broadening out to cover other aspects of software architecture such as how you start actually "doing" software architecture. There were a number of blog entries and essays written during 2009 - here are some of the highlights.

Strategy rather than code: What *is* enterprise architecture and is it the next step for your software career?
You don't need a UML tool: A short essay about why you don't need a UML tool to do software architecture.
Start with the big picture: This essay talks about the levels of detail you might go into when you're defining a software system.
The code doesn't tell the whole story: The code might be the ultimate deliverable, but it isn't everything.
Software architecture is a platform for conversation: An essay that explains why you should talk to people during the software architecture definition process.
The Other Interface: Why you shouldn't ignore logging in your software.
Software architecture document guidelines: Software documentation should be complementary to the code and describe what the code itself doesn't. This essay provides some guidelines as to what you might want to include.

If you're new to the site, have a look around because there's some excellent content that's easier to find now that we've reorganised the site into the what, role, define, share and deliver categories. Expect more to be added in the coming weeks and look out for part 2 where I'll run through some of our other highlights from 2009.

December 2009 training summary

I've had a few people ask me for a write-up of the recent training course, so I thought I'd put something together. This was the first time I've run the course with the new content and structure in place and the feedback was excellent. In the past, I think I'd always assumed that people had their own way of designing software so we never explicitly covered this in any detail other than offering guidance during the main case study exercise. The course now includes much more content and guidelines for designing software although it doesn't go so far as to define a complete end-to-end process. Jason Gorman has a good blog entry called Value Is Not The Opposite Of Waste: Why I Don't Buy Into Process Improvement that talks about how simply putting a process in place doesn't necessarily make things better. And I agree. I don't particularly want to preach a "software architecture process", but I do want to highlight the principles of good software design and how to successfully come up with a software architecture. I'd rather ensure people have the correct knowledge and understanding that can then be used and adapted to fit in with *their* way of working. Having said that, I still think that I'd like to put slightly more guidance around some techniques that can be used to get to the big picture and beyond. I have some ideas on this and will write them up after the Christmas break.

The reorganisation of the course content into the same five areas as the website has also worked really well and makes for a much more logical flow from introducing architecture and the software architecture role through to defining, sharing (e.g. documenting) and delivering/evaluating software architecture. I had a really great time in London running the course at the new Skills Matter offices. For those of you already booked on the March 2010 course in London, I look forward to seeing you there.

You don't need a UML tool

When tasked with the job of coming up with an architecture and design for a new software system, one of the first questions people ask is about which tool they should use. Such discussions usually focus around the Unified Modeling Language (UML) and whether their organisation has any licenses for some of the more well-known UML tools.

Read the full essay...