Daniel Cazzulino recently wrote a nice article called "Building Software Factories Today" where he outlines some of the challenges and techniques you can use (and we will be using) to make effective factories on today's platform. Here's an excerpt:

First and foremost: this article is NOT about the grand vision (still underway, rest assured, but nevertheless in the realm of the future) outlined in The Book: Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools by Jack Greenfield, Keith Short et all. I will talk about technologies that are ready for production today. This also means that the strict concept itself of a SF outlined in the book needs to relaxed for what's currently possible with the available tools. You can think of today's factories as infants that will grow with features as times goes by and the end-to-end SF vision becomes a reality. That doesn't prevent the "infant" from giving you a big boost in terms of productivity and software quality.

You can build SF today by using a combination of the following two tools:

• DSL Tools: or Domain Specific Language Tools. This is a toolkit for creating VS-integrated graphical notations for a given model that you basically make up. It allows you to construct a custom-tailored designer for a model for your problem domain.
• GAT/GAX: or Guidance Automation Toolkit/Extensions. This is a toolkit for extending VS with solution, project and item templates, code snippets and so-called recipes (or developer use cases) exposed as context menus within VS, that guide the developer in completing a complex task.

The problem is that integrating the two is not a trivial task. Why you may ask? Aren't they both coming from Microsoft? And how does GAT/GAX fit in the SF vision? After all it's not even mentioned in The Book!

Go read the rest of it on Daniel's blog.

From Tom Hollander's Blog:

The patterns & practices team is pleased to announce the availability of the first "official" release of the Web Service Software Factory. The Service Factory is the latest addition to our fast-growing crop of factories, including the Smart Client Software Factory and the Mobile Client Software Factory.

I know many of you have been following the evolution of our factories for a long time, so I won't bore you with too many details again - but if you are one of those people who are allergic to betas, you're now out of excuses - so I'll give a very quick spiel on what the Service Factory is about.

Like all of our factories, the Service Factory is a collection of guidance to help you build applications of a particular architectural style - in this case, service-oriented applications that expose an ASMX web service interface and provide security and business rules over a database. We have a nice graphic (which is updated from an older one you're probably already familiar with) that shows the basic architecture and scope of the Service Factory:

The factory itself is a combination of several forms of guidance:

• Written documentation, including architecture overviews, patterns and step-by-step guidance on how to build applications within the specified architecture
• Guidance packages, built using the Guidance Automation Toolkit, which automate many development tasks, including creating service contracts, translating between different entity types, generating stored procedures and creating data access logic classes
• Reference implementation, which is a made-up but realistic sample application which shows what type of services you can build with the factory.

The other very cool thing about the factory is that it is completely customizable (we ship all of the source) - so if the architecture or implementation details don't quite match what you need for your organization or project, you can just go ahead and modify the factory.

Thanks to everyone who helped deliver this project, including our fantastic project team (Jason, Don, Chris, Nelly, Sanjeev, Ed, Wojtek, Pablo, Hernan, Brian, Juan, Larry, Carlos, Tushar, Arun, Lonnie, Paul to mention but a few); our expert advisors; everyone who has participated in our community by downloading previews and providing feedback, and countless other people in and outside of Microsoft who have given their advice and support. We hope you enjoy the result!

A couple of final notes: the version of Service Factory on MSDN today only supports C#, but we are working on a VB version now and we will get this out to you as soon as possible. Also, we've already started working on the next version of Service Factory, so please keep the feedback coming to help us make the next release even better.

Congrats to the team for a job well done!

A few weeks ago I was interviewed by the DDJ/Dr.Dobbs guys to talk about CAB, the Smart Client Software Factory and Agile Software Development.

Now, the first of those interviews is live on ddj.com.

Enjoy!

The great team over on Mobile Client just released their software factory to MSDN. In addition to the guidance packages and reference implementations, one thing you should certainly look at if you do mobile work is the "Orientation Aware Control" (OAC).

That alone is worth the download.

Congratulations to the team!

Want to see the Enterprise Library application blocks in action in a realistic service oriented application? And would you like automated guidance to help you build your own applications that comply with a proven architecture? Then check out the July Communtiy Drop of the Web Service Software Factory. In addition to providing a reference implementation, written and automated guidance around building service interfaces with ASMX, this latest drop includes a new data access guidance package that makes it easy to build a data access layer using the Enterprise Library Data Access Application Block.

Please visit the project site at GotDotNet.com to download it.

The Client Team at patterns & practices is pleased to announce the release of the Smart Client Software Factory.

We'd like to thank everybody in this community for the feedback and participation. Special thanks to those who have closely followed each drop since we started and to our Expert Advisory Board.

We really appreciate the time you invested in helping us identify high priority areas for us to work and steer the project in the right direction.

What's next? Hands-On-Labs for Developers and Architects, a ClickOnce chapter, VB Guidance packages, and a few other surprises.

Stay tuned and keep the great feedback coming!
p&p Client Team

The patterns & practices team is please to announce the availability of the June 2006 CTP of the Guidance Automation Extensions (GAX) and Guidance Automation Toolkit (GAT)! As reported previously, this is a relatively minor update to the previous December 2005 CTP which includes some important bug fixes and usability improvements.

What are GAX and GAT anyway?

GAX and GAT are really the foundation of Microsoft's Software Factories initative. Software Factories built on these technologies are collections of guidance that help architects and developers build specific types of applications with improved consistency, quality and productivity. This is achieved by integrating automated guidance related to the factory's application scenario deeply into Visual Studio - for example, using templates, wizards, recipes and code generation, along with supporting patterns and architectural documentation. The patterns & practices team is currently working on several Software Factories, including the Web Service Software Factory, Smart Client Software Factory and Mobile Client Software Factory.

The Guidance Automation Extensions (GAX) extend Visual Studio 2005 to provide the core runtime environment for the guidance packages included in these factories. GAX allows you to install and enable a guidance package for a Visual Studio Solution, and it will add the appropriate templates, recipes and wizards to the development environment to make it easy for you to complete tasks, such as adding a service interface or business entity to your web service solution. The new version of GAX also includes a new window called the Guidance Navigator which makes it easy to discover the available guidance and read any related documentation. You must have GAX installed before you can use any guidance packages.

The Guidance Automation Toolkit (GAT) provides a simple guidance package that lets you author new guidance packages or customize existing guidance packages. This is extremely important, since even though we are working hard to make our Software Factories as relevant as possible, each organization and project is different - so by customizing the guidance packages you can ensure that they fully meet your requirements and comply with your architecture and environment. You do not need GAT installed to use a guidance package, but over time it's likely you'll want to customize something so it's definitely worth installing now.

Should I upgrade from the previous release?

Yes - while this is a relatively minor update from the previous December 2005 CTP, it does contain some important fixes and enhancements as outlined earlier by Wojtek. Even more importantly, the wave of p&p Software Factories that will be hitting the streets over the next few months will require the new release, so upgrading is definitely recommended.

Unfortunately it is currently necessary to uninstall any guidance packages you already have installed (including GAT) before you can uninstall the old GAX. You can then install the new GAX and reinstall any guidance packages you want to use. Believe me we know this is a pain (we've gone through this process a lot in our projeccts) - so it's definitely something we'll work to improve in the future.

Will existing guidance packages still work with the June 2006 release?

In general, yes - but there are a couple of tricks you'll need to know.

First, there are some minor changes in the new version of the T4 text templating engine that we include in this release (it's the same version that's in the June 2006 release of DSL Tools). Depending on how the templates were originally authored, it may be necessary to make minor changes to any included T4 templates so they can run on the new version. In general this just involves adding the declaration <#@ assembly name="System.dll" #> to the top of the file.

The other thing to watch out for is that the version numbers for the GAX and GAT assemblies have changed. We install binding redirects with the new GAX to enable older guidance packages to redirect to the new versions - but this only works at runtime, not when compiling the source with Visual Studio. So if you open the source of an old guidance package with the new GAT/GAX installed, you will need to update your assembly references.

You can get more details on these issues in the Release Notes installed with GAX.

Why is this still a CTP? What's the future of this technology?

Like the previous releases, this new release is still labeled a Community Technology Preview. This is because the deliverables are still unsupported, and we can't promise to maintain compatibility as we continue to evolve the technologies. Keep in mind that both GAX and GAT are only designed to run on development machines, not production servers, so even if something does blow up, it's not going to blow up your production systems. That said, we've gone through the same quality gates with GAT and GAX as we do with any other p&p release, and we are confident we have a high quality release. Since all of our factories will depend on this technology, we need to be!

We really are very excited by the potential of this technology and of Software Factories, and we are continuing to work on enhancing the infrastructure, authoring environment and the factories themselves. While we don't yet have a solid product plan that we can commit to, we are working to significantly enhance these deliverables and integrate them much more deeply into Visual Studio and Team System. The goal is that eventually most of the capabilities you see in GAX and GAT will be absorbed into Visual Studio. We're going to need your help to figure out what areas we should be focusing on, so expect to hear much more about this work on my blog and on the Guidance Automation Toolkit Forum.

This posting is provided "AS IS" with no warranties, and confers no rights.

Editor’s note: This post was copied verbatim from Tom Hollander’s announcement post. Since the end of the 2006 fiscal year is upon us (actually past us by the time you read this), you can expect a smattering of announcements from patterns & practices.

From Tom Hollander’s blog:

The patterns & practices team is pleased to announce that the first public drop of the Web Service Software Factory is now available from our new community site at http://practices.gotdotnet.com/projects/svcfactory. We're looking forward to having you as a member of the community, and your feedback and questions will help us make this deliverable more relevant to your needs.

But first things first, what is the Web Service Software Factory? Here's what Don has stated so eloquently on the community site:

    The Service Factory is a cohesive collection of various forms of guidance that have been built with the primary goal of helping you build high quality connected solutions in a more consistent way with less effort. In addition to the forms of guidance you may have already seen from the patterns & practices team, there is a new form of guidance in here, called a guidance package, that allows guidance to be automated from inside Visual Studio 2005 through the use of a wizard-based dialog than can be modified (by an architect perhaps) to fit the needs of a specific solution.

Keep in mind that we're still pretty early in the development process, and we'll do plenty of work to improve the architecture, features and user experience before the final release. Currently the features are very "top heavy" in that we've got lots of guidance around the web service interface, but the plan is to go much deeper into the service boundary and provide more guidance around topics such as persistence and service agents, and we'll also start to integrate other p&p guidance including Enterprise Library into the solution. So for now, we'd love to hear your feedback but we know it's not ready and we don't suggest that you use it for real projects.

Those of you who follow our work closely may have heard us refer to an upcoming project called the "Service Baseline Architecture Toolkit" or "Service BAT". The Service Factory is one and the same project, but it's been renamed as a Software Factory. Expect to hear a similar story about the Smart Client BAT soon. So what's up with this Software Factory name? We'll discuss this in much more detail shortly, but for now I'll just say that after many, many hours of discussion we've come to realize that what we've been building as BATs is very much in line with the Software Factories vision and it makes sense to label them accordingly. That doesn't mean that our first generation of factories will include everything outlined in the vision, but we plan on getting there eventually. Plus, to me at least, Software Factory sounds way cooler than BAT!

Nice job team.

The p&p Client Team is pleased to announce the CTP release of the Smart Client Baseline Architecture Toolkit.

Check out the downloads section in the SC-BAT gotdotnet codegallery site. The new release includes several bug fixes, complete documentation (including How Tos, architecture descriptions, etc), the first Reference Implementation (Appraiser Workbench) and Guidance Packages to automate common developer tasks.

We strongly suggest you should take a look at the "Getting Started" document included in the distribution that explains the recommended way of exploring this guidance offering.
We would like to take the opportunity to thank this community for the support and feedback provided during the development of this deliverable. Please continue to help us!

The patterns & practices Client Team

A few weeks ago at the Redmond patterns & practices Summit I joined Ron Jacobs, Eugenio Pace and Wojtek Kozaczynski for a chat about the new Smart Client Baseline Architecture Toolkit project (aka SC-BAT). Today, Ron posted an audio podcast of that session to Channel 9. Here’s the description from the site:

Have you ever wished that someone would just tell you how to build the thing you want to build?  Like one of those do-it-yourself furniture projects?  Well if you are building a Smart Client application the patterns & practices team has just what you need in the Smart Client Baseline Architecture Toolkit (SC-BAT).  Recorded live at the patterns & practices summit in Redmond this session features Eugenio Pace, Peter Provost and Wojtek Kozaczynski detailing what SC-BAT is and how it will help you.

If you weren’t able to attend, please check it out.