Microsoft’s Smart Client Software Factory

What does a software developer want to know of the Smart Client Software Factory (SCSF) of Microsoft? That is the question that kept me occupied from time to time during the last couple of weeks. Not entirely unimportant, because it came to my attention that a lot has already been written about the SCSF, but these texts did not give a clear impression of it. Not with me, any way, and taking into account all the questions that are being asked about it, not with a lot of other people either. This is Microsoft’s attempt at providing you with an “Overview” of the SCSF:

“This software factory provides proven solutions to common challenges found while building and operating composite smart client applications. It helps architects and developers build modular systems that can be built and deployed by independent teams. Applications built with the software factory use proven practices for operations, such as centralized exception logging.

The software factory contains a collection of reusable components and libraries, Visual Studio 2008 solution templates, wizards and extensions, How-to topics, automated tests, extensive architecture documentation, patterns, and a reference implementation. The software factory uses Windows Forms, Windows Presentation Foundation, Windows Communication Foundation, and the Enterprise Library 3.1 – May 2007 release. With this release, the Composite UI Application Block is included in the software factory.”

A summary is not an enumeration

The overview above makes me think of an important rule in the world of debating: “A summary is not an enumeration!”. This rule is known, because beginning debaters nearly always make the mistake of doing just the opposite: they use their last, summarizing plead of five scarce minutes to just sum up everything they have already said, but then faster.

Why does an enumeration not work as a summary? This is a nice question, about which a lot has already been written, so I will stick to the main point: a summary should abstract the essence of a story, in other words, it should be a model of it. The nice thing about it is of course that we, software developers, recognize this fenomenon and use it quite often too. Third generation languages abstract the important concepts (in 80% of the cases) of second generation languages, a domain model models a problem domain en deliberitly leaves out the unimportant details.

The noble art of leaving out. The famous quote: “I have had to make this letter rather long, because I didn’t have the time to shorten it.” [1] hits the nail right on the head. Everything a text or source code contains besides the essence, distracts and makes it overly complex and thus, less effective. Surely there are numerous other connections, especially with agile techniques like refactoring [2] and the methaphor [3]. But, as you might have thought already, I am rather off topic..

So, back to business, what is it then, the SCSF?

Let us focus again on the first question about the SCSF, because I can now answer it. I think most software developers will be helped with a short description that sticks. It is a good thing it needs to be short, because this post is already quite long. And all the details can be found in the descriptions by Microsoft and others.

First a short explanation of the term Composite Smart Client Application. This describes a smart client that combines several loosely coupled modules in one shell. They for instance share a menu, status bar and several services, but remain independant besides those. A smart client is the name that is used, mainly by Microsoft [4] , for a client application that combines the rich GUI of the well-known windows applications like Word and Excel (the fat client) with the connectedness of a browser application (thin client).

The Smart Client Software Factory, that has such a smart client as an end result, consists of:

1) A number of libraries that give you the possibility to make a smart client with a composite GUI. These libraries also contain solutions for recurring problems in logging, caching, etc.

2) The possibility to combine these standard elements in a configurable and pre-determined manner to form an application. This is done through the use of wizards in Visual Studio.

Multiple libraries

The SCSF makes use of the Composite UI Application Block (CAB). This application block is meant to support the development of a smart client with a GUI that contains dynamically loaded modules that are loosely coupled between each other and to the GUI. This loose coupling is realised by events with a (string based) url, standard commmand objects that can be dynamically loaded and services that are declares as interfaces. The coupling is performed by the CAB when a module is loaded. This architecture is built with a regularly changing mix of modules in mind. Changing, because of roles and rights of users and availibility of new modules fresh out of production.

Basis opzet van een Composite Smart Client GUI

Figure 1: Basic design of a Composite Smart Client GUI

Next to the CAB, the use of the Enterprise library is recommended. This library consists of several other Application Blocks with microsoft’s recommended patterns in a number of other well known technical problem domains. Examples of these are logging, caching and security, but be sure to have a look for yourself at the microsoft website about the Enterprise Library for a complete list.

Code generation to support the consistency

The developers of the Patterns & Practices team of Microsoft have had a certain way of usage in mind while developing the CAB and Enterprise library (the by Microsoft recommended patterns and practices). This way of using them is put into a number of templates. These templates can be configures and added to the application that you are developing. For this purpose the Guidance Automation Extension is used. The generated code is configurable and extensible as well.

Automation Guidance in Visual Studio

Figure 2 a and b: The use of guidance automation to make wizards in Visual Studio

So is this a software factory? Did that not have to do something with an development line?

Of course the name “software factory” is, like many terms in IT, linked to several definitions. Microsoft chooses to call this solution software factories , just like some others for equivalent, but technically different results (for web services, mobile and web clients). Developers are not included and other things sometimes associated with software factories are not part of the package, like: version control systems, bug tracking systems and continuous integration servers.

But that was not the answer we were expecting, so again the question: why the name software factory?

The following arguments can be make in favor of using the name software factory:

– The end result of a software factory is normally a composite (smart/web/mobile) application. Like that of the SCSF.

– It makes it possible for one team to change the templates, add them and delete them, so that certain company wide decisions and solutions can be used as a basis to build on by all indivual development teams (of the modules). For this purpose you need the Guidance Automation toolkit, a soft of SDK for Guidance Automation.

The influence of software factories on software development

Is software development going to be an industrial process and will this Software Factory contribute to that?

Of course the motto should be “may the best win” and if the success that Ordina [5] has with her development factory line puts others to rest or to follow the path, only time will tell. But until now the reality in software development turnes out to be just a little bit different to the “real” world of mass production and factories. The sofware factory is the next in line of a tradition of attempts to automate the software development process [6]. And curiously, most of these attempts have had a focus on speeding up the build process of software, not the necessary repairs and changes during its lifetime.

Actually, every time a piece of software is made again, in the same way, it is one time to many. This means that if the sofware factory sticks to its own tradition of turning out mass products, it will not amount to much. The only thing you would do with it is configure and integrate a series of standard components.

Personally, I think software development is most comparable to architecture and engineering in the “real” world. In engineering several attempts at standardizing the process have been made, and there are some that have met some success. But this is in no way a standardized world with a nice and clean process. En the first architect that says “how would you have your house configured” will probably not get his clients enthousiastic. In the case of architecture, esthetics is the main reason for shying away from standard designs, in enterprise software it is the wish to get a competitive advantage out of the new software.

While coming up with the structure of a software factory the designers paid attention to the fact that not everything can be realised with a standard mold of configurations and couplings of standard components. So it is made with the possibility of configuration and rewrite at the code level. In that sense it looks a bit like SAP: you can buy the standard suite of SAP, but at the end of development, every SAP application is changed so much, that none of them will look alike (in Dutch this turns out a bit funnier than in English). The question afterwards is, which of the advantages in repairs and extensibility remain of the once so standard suite.

In short, I suspect that in the first place there will be a lot of work left in and around the factory and second, more important: the really innovative applications, gui’s and architectures are not te be found there. That will be the fun projects that remain. En as long as there are enough people complaining about the current range of applications, there is still enough demand for the new possibilities that are yet to be invented. I suspect that software factories will remain a solution for only a part of the market place: software design houses that deliver a lot of mostly the same. You should be asking yourself if you belong to that group before you turn to software factories.

  1. Originally in French, said to be written by the french philosopher Blaise Pascal, although Cicero is also linked to this quote. Nice background info for software developers is that Pascal has made one of the first calculators and that he is indeed the person after which the famous programming language is named.
  2. In the case of refactoring it is especially so that more time means less code. See the WikiWikiWeb for more background info regarding Refactoring
  3. Abstraction of a system to enhance the communication of a development team. See the WikiWikiWeb for more background info regarding Metaphor
  4. The marketing department of Microsoft would like you to believe that you are smart when you make an application this way, this might also be one of the considerations.
  5. Ordina makes use of the software factory of Microsoft in their Ordina Software Factory. See: http://www.ordinasoftwarefactory.nl/~
  6. Think of the 4G languages “visual programming”, the CASE tools “Develop your software top-down, in UML” and the 5G languages “define the wanted end-result and the result will follow from that”.

No Comments - Leave a comment »

RSS feed for comments on this post. TrackBack URL

Leave a comment

Powered by WordPress | Aeros Theme | TheBuckmaker.com WordPress Themes