Hitchhiker's Guide to Software Architecture and Everything Else - by Michael Stal

Friday, November 03, 2006

Architect always implements

This night I had a dream. I was supposed to have a surgery. Eventually, the physician came to the room. I heard him whispering to a nurse, giving her a document. It was a list of instructions he had written down. Oh, no! The nurse was going to be the surgeon!
Sounds like a nightmare. But isn't it something at least some "software architects" should be familiar with? A group of architects is specifying a software architecture. Once finished they throw it over the fence to the developers, and dissapear. I know that the comparison is like comparing apples and oranges. However, there is some truth in it.
In my last tutorial on software architecture Scott Meyers asked me why I recommend the "architect always implements" principle. And that is exactly the point. The task of a software architect starts early in the process and spans maintenance and evolution. After the strategic core design is complete, architects help to refine this core to obtain the more concrete, tactical design. And software architects always need to supervise the implementation as well as decide for tools and technologies. Find more details in my former postings.
If you consider these tasks, a software architect is only capable of fulfilling these tasks when she/he gets some implementation practice. Another issue is "eat your own dog food". You as an architect should make sure your designs work as expected by helping with their implementation. That also gives you more credibility with respect to other project members. And the other point is: how could you possibly recommend tools and technologies without practical experience? Would you trust a software architect who did not implement for the last ten years and has no clue about UML, middleware, C++/Java/.NET, Eclipse, Visual Studio, databases, Subversion, Clearcase, Maven, ... ?
Does that mean you need to implement a lot? Definitely not. It rather implies, you should implement some smaller parts that are not on the critical path because you will still have a lot of other work such as communication with stakeholders, refactorings, meetings, refinements, you name it.
Of course, it also depends on project size. In a small project with only 5 people, you cannot afford that an architect does not implement. In a large scale project with maybe hundreds of people involved , it might not be feasible to implement anything, at least not for the lead architect. However, if you're a lead architect, you should keep yourself knowledgeable by applying tools, technologies in small toy projects, and by participating in design reviews and code reviews. Of course, a software architect as I described in a former posting, is not born as such but will start as an excellent developer and then may turn into a software architect after a couple of years. Thus, she/he should like implementing, anyway.
In the projects I've been involved "architect always implements" has proven to be an excellent principle. That's the reason why I am wholeheartedly recommending it.

3 Comments:

  • I agree that the architect should be very close to the project he architected, and "feel the pain" (learn) associated with the architecture options, in all phases of the project: development, deployment, maintenance, ...

    Having an architect mandatorily develop is, in my opinion, not stricyl required.

    By Anonymous João Martins, at 1:46 PM  

  • It's spelled surgeon, not surgent!

    By Anonymous Anonymous, at 1:28 PM  

  • There exist an alternative that I've seen applied in Siemens by a specific architect very successfuly. In the projects he tooke the lead he would create the specification of the sub-systems interfaces, complete information model, etc. Then, or better, while at it, this would go to a bunch of artifacts - e.g. XML based specifications - from which the technology specific interfaces, the documentation in HTML, etc was generated.

    It was very productive and the systems architected this way would follow the architectural patterns and principles defined previously by the architecture team.

    In such a system, it is very easy to move from sub-system to sub-system (i.e., work in them) since they have all the same basis. The architect continued working in the project, improving the executable specification as required and making his initial vision into the final product.

    By Blogger euluis, at 3:35 PM  

Post a Comment

<< Home