VISUG event : Web service Software factory

Hello ,


The Belgian Visual Studio User group (VISUG) invited yesterday (21/02/2008) Olaf Conijn to give a presentation about Software Factories and the Web service Software factory modelling edition.

Olaf has worked together with Microsoft patterns & Practices group on the Web service Software factory modelling edition (WSFm) where he was responsible for the extensibility part of the WSFm. Later he implemented Software Factories in the Netherlands (Capgemini BV). So you could not image a better person to give this presentation. Currently Olaf is trying to make the world a safer place as he's implementing software to alert the world in case of outbreaks of pandemics.( http://instedd.org/).

Olaf’s presentation was divided in several logical parts

• The “What” of Software factories
• The “Why” of Software factories
• The “How” of software factories in the form of demo’s of the WSFm
  
  

Some key point I got from the presentation and the talk with Olaf afterwards:

• There are many definitions of Software factories : some are more academic, some are more pragmatic and more tool-focused. Like the one Microsoft is using for example (MS SF). (http://msdn2.microsoft.com/en-us/library/bb871630.aspx) Although the differences, they all share some common motivator : helping the developer (or designer/architect) to get the job done in a more efficient way (time-to-market) and more with more quality. (http://appdevchronicles.blogspot.com/2007/10/software-factory.html)
• MS SF is about guidance. It should feel having an experienced person next to you and advising you what you should , when you should do it and how you should do it .
• MS SF is also about automation. Capturing this expertise/best practices/guidance into integrated, automated features of Visual Studio and letting Visual Studio do some tasks in a consistent (so less error-prone) way , takes away some chores from the developer. You could say SF are about re-use but not only code but also expertise.
• MS SF is now also geared towards abstraction: This was very apparent in the WSFm (hence the name of course). The patterns and best practices to build a web service are not directly translated into code but there’s is an intermediary step: You model all the different parts of a web service like the MS engineers envision them. This gives you an opportunity to delay certain implementation decisions. It enforces you to think about it first. So the model is not the code but a very visual abstraction of what you’re trying to establish.
• The models are visualized with special “shapes” and their corresponding properties. The look&feel is like the Class diagram tool in Visual Studio. So it is not UML (too generic) . The designers that enable the modelling features are actually build with the DSL toolkit. For each of the three model (service, data and hosting) you get different designers. From the demo it looked very slick.
• There are several key technologies that make MS SF possible : GAX/GAT is about leveraging the automation possibilities of Visual Studio in the field guidance. DSL are geared toward modelling and code generation.
  MS Software factories come in different forms and shapes (Web client SF, Smart Client SF , Web Service SF, etc). So there isn’t a general SF that can encompass all types of applications. The main reason for this specialisation is that the more focused you are on a domain, the more specific you can make the abstractions and the better you can generate code from this models. Note that domain is not necessarily technical but also can be created for a particular sector like healthcare or finance.
• Extending the WSFm is possible . P&P identified some 11 scenarios. Some of them , like changing something in the exiting code Text templates are very easy , while other require you the download the source code for the WSFm and modify (and maintain ) it yourself.
• You can even build your own SF. Olaf figures , based on own experiences in the Netherlands, that make a SF is 2 to 3 times more expensive than building the product that the SF has to build (if I understood him correctly).
• So building a SF only makes sense if you build multiple applications based on the same architectural principles that the SF enforces. Olaf estimates that you earn the SF build back if you “sell” 5 project build with SF. So you only should invest in SF you expect “economies of scale”
• If you embark on a “journey/ordeal” to make your own SF , be sure to have “domain” experts at hand, be technical or functional in nature.
• But building a SF doesn’t have to automate everything . You can also make more “pragmatic” SF that only focus on very explicit stuff your trying to implement. For example creating a skeleton for a solution with the GAX/GAT
  
  

Some concerns ( expressed in the form : “I wish I knew how to …”)

• H2 assess the adoption grade of MS SF in organization…. And this is not the same as announcing the number of downloads :-)
• H2 assess the importance in MS SF in the big scheme of development tools at MS. MS SF came out of the P&P group. One of the key technologies GAX/GAT) has been a CTP for a long time (sine 2005) . It just recently got the label release. As far I can tell the DSL (another key technology) is maintained by another group. Why are these technologies not in the Visual Studio release cycle?
• H2 integrate VB.NET into the WSFm. In the version (I presume the latest at the time) we show you could not select VB.NET as your language. When Olaf added a WCF implementation in created a c# project. According to him , you only need to translate the text templates. If it is so easy , why didn’t P&P do it for us?
• H2 find proper “guidance” to build “guidance tools” with GAT and DSL besides books and blogs.
• H2 cope with generated code, your own code and the model (keeping it synchronized).
• H2 position agile techniques with model-driven development. Are they opposites or do the complemented each other ?
• H2 interpret the disappearance of the data access wizard in the previous versions of the WSF (at least I didn’t see it in the demos). These wizards enabled you to generate data access code and business entities. Maybe the advent of Linq to SQL an the Entity data framework have something to do with it.
  
  

Some references mentioned (or I heard from other participants)

• Microsoft patterns & practices SF ( http://msdn2.microsoft.com/en-us/teamsystem/aa718951.aspx)
• Software Factories: Assembling Applications with Patterns, Models, Frameworks and Tools (Jack Greenfield & Keith Short)
• Compuware Belgium SF focus group: http://intofactories.net/
• Code generation Conference 2008 ( http://www.codegeneration.net/conference/index.php)
• Domain-Specific Development with Visual Studio DSL Tools (Microsoft .NET Development Series) by Steve Cook, Gareth Jones, Stuart Kent, Alan Cameron Wills.
  
  
  

Maybe you some own thoughts or opions? Be sure to drop a line ....

Thanks to VISUG for inviting people like Olaf to Belgium. Be sure to keep an eye on the VISUG site (http://www.visug.be/) because the one of the next speaker will be none less than Juval Lowy. Keep up the good work.



Best regards,


Alexander