In a previous post we mentioned the existence of a "Software Factory Schema" file for an installed factory in our Rosario CTP. We now know, at some point, a "Factory" instance is created from this file that holds all the information that is stored in this schema file. Let's have another look at the software factory schema file of Service Factory to see if we can learn something more from this.  

One of the things to notice in this schema file is a viewpoint that is called "ServiceRootViewPoint". This viewpoint is the so called "root viewpoint" for this software factory. We can also see that there is another viewpoint within this root viewpoint that is called "ServiceContractDesignerViewpoint". As we can see, the root viewpoint holds a "Command" (ServiceRootCreationCommand) that contains a "CommandType" and a "CommandImplementationType. In this case both are implemented in the "Microsoft.Practices.ServiceFactory.Commands.dll" that we can find in the "InstallDir" (C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies) of this factory.

So, where do we need this CommandType and CommandImplementationType for? In a previous post, we have seen that when we executed the "CreateProduct" in the Application Explorer  

it popped up a dialog where we could select the software factory where wanted to create a product from. 

When we select a software factory in this window and hit OK, the ApplicationExplorer (and some helpers) retrieves the root viewpoint of the software factory and finds the Command that is associated with this. At that point the Command,implemented as a "FactoryCommand" is transformed into a more general "Command" that is implemented in "Microsoft.VisualStudio.ToolIntegration.Backplane.dll".

This is actually *very* interesting because this assembly implements a concept that is sometimes referred to as the "DesignerBus" (it is called Backplane at this moment) which hopefully makes it possible to, for example, implement references between models, references between models and designers, toolwindows, get a reference to a Service in VS.NET,etc.  It can actually be used to glue everything together ;) Anyone familiar with the DSL Tools knows that at this moment we only have DIS to create references between models and only in a very limited way. Maybe Backplane can help here! (More on this very exiting stuff in another post).

Let's continue with our Command... After the FactoryCommand is "converted" into a general command it gets executed. Below we can see a code snippet from the "Execute" method of the "ServiceRootCreateCommandImplementation" from the root viewpoint of Service Factory. The code might look funny to you but this is just because it is produced by reflector and not by me ;) You can see that "Backplane" is used here to get a reference to the "RecipeManager" and "DTE". Perfect! 

What we can also see is that basically all that happens here is, get a reference to the a Guidance Package and unfold a template (model.vstempate) to set the initial structure of our Service Factory solution. Please note that "model.vstemplate" is just a normal  .vstemplate that is located in the source tree of Service Factory (C:\Program Files\Microsoft Service Factory V3). This means, in Rosario CTP we can create command, hook it up to the root viewpoint of our software factory and Application Explorer makes sure it gets executed to set, for example, the initial structure for the product we are building in our factory. From there on, all "normal" (old) Service Factory V3 recipes should work as expected! (Decide for yourself if that is good or bad news)

Below you can see what Application Explorer looks like after we executed the "Create Product" and selected the "Web Service Software Factory" in the "New Product" dialog. Also note the "ServiceContractDesignerViewPoint" folder that we have seen in the software factory schema above.  

Solution Explorer looks like this. Note the .pdef files! (More on that later)

To be continued...

In a previous post we have seen the Application Explorer acting as a starting point for our software factory. To continue our journey, let's have a closer look at this Application Explorer. For example, where does it get the list of installed software factories from? 

A quick look at GAC on our Rosario VPC reveals a few new assemblies that (based on their name?!) might have something to do with software factories. these are:

• Microsoft.VisualStudio.SoftwareFactories.Runtime.dll
• Microsoft.VisualStudio.SoftwareFactories.Runtime.VSHost.dll
• Microsoft.VisualStudio.SoftwareFactories.ApplicationExplorer.dll 

The Application Explorer is obviously implemented in "Microsoft.VisualStudio.SoftwareFactories.ApplicationExplorer.dll". Currently, no (public) documentation is available so we have to use reflector to find out this assembly holds the "ApplicationExplorerPackage" (inherited from Microsoft.VisualStudio.Shell.Package) which is using the "FactoryManager" (more on that later). Besides the "ApplicationExplorerPackage" this assembly also implements the ApplicationExplorerToolwindow and the ApplicationExplorerControl which are representing the UI of the Application Explorer in Visual Studio.

Digging a little further, we can find out the "FactoryManager" (implemented in Microsoft.VisualStudio.SoftwareFactories.Runtime.dll) is using the "FactoryDescriptorsLoader" to search the Registry for installed software factories on the machine.

please note more classes are involved in this "discovery process" but I am only focussing on the high level to make this post not more confusing than it probably is already. I am sure you know how to use reflector yourself if you are interested in more details ;)

As we can see in the screenshot below the Registry (HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\SoftwareFactories) in the Rosario VPC holds information about two installed software factories. By looking at the Service Factory node we can see the Registry contains the Name, Description, InstallDir, Version and SchemaFileName of the software factory.

SchemaFileName?! hmm....is this in anyway related to the "Software Factory Schema that is discussed in the "Software Factories" book? Below a screenshot of the Schema File for Service Factory that we can find in the "InstallDir" of Service Factory (C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies). Pretty interesting to finally find concepts like "viewpoints" and "workproducts" related to software factory implementations.  

Without going into too much detail, how does this all work?

It all starts in the "VSPackage" (inherited from Microsoft.VisualStudio.Shell.Package) that can be found in "Microsoft.VisualStudio.SoftwareFactories.Runtime.VSHost.dll". At some point a "FactoryManager" (Microsoft.VisualStudio.SoftwareFactories.Runtime) is instantiated. This "FactoryManager" is using a "FactoryDescriptorLoader" to read the Registry and to create (and cache) a collection of "FactoryDescriptor" classes. The information contained in the software factory Schema File eventually ends up as a "Factory" instance that holds the "FactorySchema" which is the root for the FactoryViewPoint, Command, WorkProducts, etc. The Application Explorer on its turn is using the "FactoryManager" to list the installed factories, the viewpoints it contains and enables us to (for example) execute the "Create Product" action that we discussed earlier.

Again, just the high level overview! There are a lot more interesting classes and concepts involved in this but it hopefully gives some basic understanding. In a next post we will try to understand the purpose of the "Commands",  "Viewpoints" and "Workproducts" that we have seen in the software factory Schema File.

To be continued...

A few months ago "Rosario November 2007 CTP" became available for download. Based on the available documentation, walkthroughs and “mini stories” we can safely conclude that this release wasn’t really build to please the software factory guys out there! However, what it *does* contain is a (limited!) version of Service Factory that works on a very early (?) version of the Software Factory Runtime. This might be interesting. Let’s have a look if this version of Service Factory shed some light about what we might expect from Rosario in the software factory space.

(Of course, this CTP is relatively old already and hopefully a new one will arrive in the coming ? but maybe we can learn something from this CTP already...)

Ok, how does Service Factory looks like in Rosario CTP? To find out we can start a new Service Factory project by using the Application Design template that can be found under the “Distributed Systems” node in the “new project” dialog.

After the template unfolded, the first thing to notice in our new solution is the new “Application Explorer”. From this new “Application Explorer” tool window we can create a “Product” that is based on the installed software factories on the machine. As we can see in the screenshots below this machine has two factories installed and one of them is “Service Factory”.

By selecting "Web Service Software Factory" and pressing "OK" in the "New Product" dialog we end up in a situation that is similar to the one we are familiar with when using the current Service Factory. We can create a "New Model" and use the factory "as usual" from there.

Digging a little further in this CTP tells us (Add or Remove Programs) GAX is installed and GAT isn't! Further we can see that besides the package that looks like the "normal" Service Factory a package called "Web Service Factory Application Designer Integration" is installed.

A quick look at the installation location of Service Factory (C:\Program Files\Microsoft Service Factory V3) tells us that this version of Service Factory indeed looks like an ordinary software factory that is build on top of GAX. The installation folder still contains recipes, vstemplates, T4 templates, etc.

What does this mean? Can we use our current software factories (or at least parts of them) in Rosario? If so, do we benefit from anything new? How does Service Factory integrate in the Application Explorer? Where do we need this "Web Service Software Factory Application Designer Integration" package for? Is the "Software Factory Runtime" in this CTP of Rosario only implemented by GAX?

To be continued...

It is there, a new Software Factory Community Portal!

 Martin Danner, Jezz Santos and myself have been talking about starting up a community around software factories for some time and now we finally did it.  

This community is all about software factories, domain specific languages, Visual Studio Extensibility and other related topics. The portal includes a forum, blog aggregation, news and additional resources like links, articles, books, etc. We haven’t finished adding all resources yet but registered users are allowed to add new resources, provide ratings and add comments.

So, please join us there, start discussing and participate in building a community around software factories!

We already announced the availablility of part 1 in our "Packaging & Building Software Factories" series here. Today, part 2 called Automated Builds with Team Foundation Server is also published. Enjoy!

Finally, part 1 of  our (short) series about "Packaging and Building Software Factories" is published on MSDN. The goal of these articles is to help you with packaging your software factories and implementing a team build with Team Foundation Server. As you will see this isn't always as straight forward as you might expect! These are the parts in this series:

• Part 1 - Packaging with Visual Studio 2005
• Part 2 - Automated Builds with Team Foundation Server 

I co-authored the series with Jezz and my colleague Rene. Thanks guys! Also, many thanks to our reviewers: Gareth, Pablo, Attilah, David and Mark Nichols !

We also included reference implementations for you to download and created a CodePlex project (for part 2 in this series) that we will use to publish some additional MSBUILD tasks and 'utilities'.

Stay tuned for part 2 and let us know what you think!

Ok, part 1 in our "Building Software Factories" series is finally on MSDN! . This part called "What are we building and why" describes what a factory is in concrete terms and explains what it takes to build one. As you can read in this post from Jezz part 2 and 3 will follow (soon?!).

Also expect another series about Packaging and Building Software Factories REAL soon.

The slides and recording of our (Jezz and myself) session ‘Build Your Own Software Factory’ are now available for download.

From the statistics of my blog I know that most of my ‘readers’ don’t live in Japan, but If you ARE in Japan on 21st-24th August and plan to visit TechEd Yokohama, come join us and attend our session.

I was just checking my mail after a two week holiday and noticed an e-mail telling me I am awarded with a Microsoft MVP award (Visual Developer – Solution Architect).

Wow! Thank you very much!

Factories 201 Series - Building Software Factories

• What are they (concretely)? (Edward)
• When would you build one? (Jezz)
• What do I tell my Manager? (Edward)
• How long will it take? (Jezz)
• What would you build? (Jezz)
• With what would you build it? (Edward)
• How would you build it? (Jezz)
• What should you strive for? (Edward)
• What are the challenges? (Jezz)

Post authors: Edward Bakker and Jezz Santos.

Well, we have finally come to the end of this 201 series on ‘Building Software Factories’.

First time arriving here? - we have listed the entire series above – please have a look through those posts before ending it below.

If you are arriving here after reading (hopefully all) the posts in the series, we wanted to say, good on you, and thanks for sticking it out with us.

Series Wrap-Up

Well, we have spent quite a bit of time and thought in putting this series together for you. The motivation behind this effort has been that we’ve recognised that there is little practical information helping ordinary professional developers on getting started with building and understanding software factories. We have had quite a head start on this and wanted to share our knowledge and experiences with you and the community to promote the uptake of building factories, which in turn should promote the adoption of software factories and the industrialisation of software in general.

This series was created in a format that asks a logical sequence of questions that you might have when trying to figure out how to build software factories today. We have covered many such issues as they arose and shared much of the combined knowledge and experiences built up over the last few years in this space. We will be sharing more resources on this in future posts – so stay tuned to our blogs.

We hope that you can take the guidance represented in this series forward as a starting point for developing your own software factories further. We recognise openly and frankly in the series that this is not a trivial undertaking today, but hopefully we have shown you that it is very possible and how to successfully approach it. Hopefully we have also directed you to what’s most important, where you should direct your energies, and how to build factories practically and realistically.

Your Feedback

One of the primary objectives of this series was to connect with many more of you in the community and share ideas and innovations about everyone’s efforts at building factories today.

We have received a small number of comments to this series so far, which we have been keen to discuss at length, and hope we have done a good job at answering the questions appropriately. Hopefully, there are many more of you out there building factories, or at least considering building them, and so we hope to hear more from all of you on that. Please drop us a comment on the appropriate post and we will work hard to get you an answer you will find useful.

If we are doing a good job please let us know. If we are doing a poor job and you don’t like the guidance we are giving please let us know that also. This should shape any future guidance we give the community in this space, and at least we can start further discussions with those of you in this space. Hopefully, we will also get a feel for just how many of you are out there are in this space.

The Final Say

There should now be a little more information out there to help you build a software factory right now on the Microsoft platform with the current toolsets. This series was created exactly for that purpose to share with you the experiences we have had in building factories and give you insights into the issues we have faced on this road already.

As more and more people jump into this space we expect to see from the community more detailed, formal guidance on this subject, so that the community as a whole can learn from previous experiences and elevate the adoption and the application of software factories to real world projects.

After all we think that the act of building a software factory should leverage the tenants that software factories promote themselves, i.e.

“Package domain expertise and guidance in a form that others can re-use and manipulate to create solutions using simplified descriptions of the problem at hand.”

Hopefully we have done a good job of that for you, and hopefully you will consider the experiences we have shared in this series in your factory building efforts.

Come see us...

We are proud to announce that we will be presenting a session on ‘Real World: Building Software Factories’ at Tech-Ed 2007 in June this year.

The 300 level session will contain material from this series and demos and examples of other factories to explain the concepts. We would love to meet up with you there and answer your factory building questions.

Many Thanks, Jezz Santos and Edward Bakker