Edward Bakker

Software Factories

Edward Bakker (Edward Bakker) — Fri, 08 Jul 2005 13:00:08 GMT

I attended a Chalk & Talk session with Steve Cook this morning about Software Factories. Just some of the things that were discussed:

Today building software is mostly craftsmanship. Compared to other industries the software industry isn’t very successful. Poor reuse.

Only if you know all the stable and reusable parts or architectural components it makes sense to start building a Software Factory for it. Start bottom up and start small otherwise you will probably fail. You have to know all the details about the parts you like to build a Software Factory for.

One of the basic ideas behind Software Factories: define only the unique features of the system that needs to build. (Other parts can be reused).

Most of the things we currently do are a waste of energy. All of it is redundant work. Automate all the rote and menial tasks. Let people do the interesting work.

The idea is to get a general development environment (VS.NET for example) and load the Domain Specific stuff in to tailor it. The Software Factory knows were you are and what you need at that time and delivers the right assets in the right context.

The Software Factory Schema defines a set of viewpoints and their relationships. A viewpoint describes how to look at things a view is the things you see.

It looks like Microsoft is working hard on some samples of Software Factories. In this talk Steve showed us a little of a Powerpoint presentation that demonstrates how to build an 'online Petshop' by using a Software Factory. Like Steve said, it's only a presentation but I assume they didn't created all the screenshot on the 106 sheets by hand :-)

Service Oriented guidance

Edward Bakker (Edward Bakker) — Thu, 07 Jul 2005 17:21:52 GMT

Today I attended a great session of Arvindra Sehmi and Beat Schwegler. First Arvindra talked about the “new” way of modelling connected systems. He explained there is a need for a “Service Oriented Architecture Model” (SOAD) that sits between the business model and the technical model. While the business model is used to describe the needed capabilities (the “what” part) the SOAD model is al about modelling the contract of the service. At the end we have the Technical model that covers the technical details, like service interface, service implementation, etc. Of course the story covered a lot more details than the above description and it sounded pretty good.

The second part of the session was covered by Beat. He talked about the technical model. Currently he is working together with Cristhian Weyer and Maarten Mullender on a series of articles (first one can be found here) that will provide us with a set of recommendation for designing and implementing connected system (services). In this session Beat showed us that he is already working on the actual implementation of the recommendations. He showed us a Software Factory that is suports building services (by using the GAT). Pretty cool stuff!!!

From what you could see from the demo this series of articles (and implementation) will really show you some of the best practices for building these kinds of systems. Beat defined 8 steps that you have to do to design a service:

Design the data
Create the data classes
Design the messages
Design the interfaces
Create the transport interfaces (for example web services)
Create the adapters
Implement the internals
Connect the internals to the adapters

The artifacts of the above steps all formed a separate Visual Studio project within 1 solution.

I will not cover all of the above steps but some of the things were pretty interesting:

Within the first step (design the data) we create the XSD schema. This is actually the “data on the wire”. Based on these schemas the data classes are created by using for example XSD.exe. This of course is nothing new, but what we see most of the time now is that the product of step 1 is referred to as the messages. Beat actually showed us that in step 3 we create the actual message class that has a public field (result of step 2) which is actually the message payload. This messages class uses some techniques that I wrote about before to support for versioning and flexibility.

Another interesting thing is that in the “technical model”, when talking about the “service interface” we actually mean the interface definition (public interface IOrderService {}). Besides this the service has some “transport interfaces”, these are the actual implementations of the interface for a specific transport type (web service, Enterprise Service, etc.). Maybe nothing new here but is a good thing that is “written down” as a piece of guidance.

The last thing that I will write about is the introduction of “adapters”. These are actually a “layer” between the service interface (transport) and service internals. By using this technique the service implementation “knows” nothing about the actual message which makes it easier to change the message without breaking the service implementation. Of course in that case the adapter needs to be changed.

All of the artifacts that were created in the above 8 steps were supported by the “Software Factory”. Although it was very early work that Beat was showing it looked really cool, so makes sure to follow the series of articles!

Preparing for .NET 2.0 and Indigo

Edward Bakker (Edward Bakker) — Wed, 06 Jul 2005 15:21:42 GMT

While Tech-ed Europe is on its way it becomes clear to me that a lot of people are currently re-thinking how to implement their architectural requirements. A lot of people that I spoke are (of course) evaluating Visual Studio 2005 Beta 2, Indigo Beta 1 and WSE 3.0 CTP. Some of them (like me) are currently using some sort of a framework or toolset to support their architectural and service oriented needs.

During the talks I had with some people one of the issues that cam up was: do we need another framework on top of .NET 2.0, Indigo and WS-*? And after that: Is the guidance that we are using now (for the current technology) still valid when all the new stuff is available? And if not, what do we need and when! In my opinion all interesting issues that sooner or later become very valid questions for a lot of us.

Some of the people I spoke, planned to simply migrate their current framework to .NET 2.0 when that is available. This wouldn’t be my preferred strategy. I think there is a relatively big change that simply migrating existing stuff doesn’t use the full power of the new technology. On the other hand, if it takes very little effort to migrate it can be a valid option.

Others thought that simply wait for Indigo to ship is the best option. In the meantime try to decide what you need (framework, guidance, etc.) and try to get that ready as soon as possible. For new systems in the timeframe between .NET 2.0 arrival and Indigo, simply use .NET 2.0 and if needed use WSE 3.0 to solve the WS-* issues.

In my current set of frameworks, guidance, etc. there is special attention for “separating the cross cutting concerns from the actual business logic” and separating the service interface from the service implementation. This is enforced by using a framework. I’ am still thinking how to solve these issues in the new (.NET 2.0, Indigo) world. For separating the service interface from the service implementation I think you don’t really need the help of a framework. This is just a pattern that you can apply.

A little different might be solving the “separating the cross cutting concerns from the business logic issue”. I have some ideas about this but I’ am not sure yet. Unfortunately I haven’t met any people here at Tech-Ed that have some ideas about this, but I’ am sure they must be around here somewhere. Have any ideas about this and like to have a discussion? Let me know!!

Pillars of Connected Systems

Edward Bakker (Edward Bakker) — Wed, 06 Jul 2005 09:07:19 GMT

In his session Gianpaolo Carraro discussed the so called five pillars of connected systems. Up to now, when talking about connected systems and service orientation most of the discussion is about how to design services, the four tenets, best practises, etc. Of course these issues are essential when it comes to connected systems but there are other issues that comes in play when thinking of connected systems. This is where the “five pillars of connected systems” comes in.

The “messaging” pillar is the most fundamental and covers the connectivity possibilities of systems in a standardized way. This is actually the pillars that is discussed over and over already (and will definitely need some more discussion in the coming period).

The other pillars that can be identified are:

· Identity and Access

· Data

· Interaction

· Workflow

The thing that Gianpaolo tried to explain is that all connected systems that we will build in the future need (to some extend) attention on all of the five pillars.

After discussing the pillars briefly, he also presented his “6 rules for success when building connected systems”. 5 of the rules each apply to one of the 5 pillars and 1 rule just concerns some generic issues not related to any of the pillars in particular. It was actually this one (generic) rule that makes sense to me.

This rule is about “accommodate and anticipate for change”. Sooner or later the system you are building will change, so it’s best to design for that. Some of the techniques he mentioned for that is; make use of abstract factories, provider model, pipeline architecture, separation of concerns and inception points.

I had a little more difficulty with the other 5 rules for success so I will not quote them here. To me they didn’t seem to be “rules” but looked more like summing up some attention points. I think some more details are needed in this area to become real rules.

At the end of the presentation it became clear that all of the 5 pillars will get some extra attention in the near future and the so called rules will be supported by (new) features of some of the Microsoft tools or technologies.

More information about the 5 pillars of connected systems can be found on the blog of Gianpaolo. Not everything is there yet, but according to his blog will arrive soon!

Update: changed the name of the “ intergration pillar” into “ interaction pillar”. These postings are written during the Tech Ed talks, not a lot of time to validate the content. Thanks Carlo for commenting on this!

Building and using Software Factories

Edward Bakker (Edward Bakker) — Tue, 05 Jul 2005 13:29:57 GMT

One of the sessions that I attended today at Tech-Ed Europe is “Building and using Software Factories” with Steve Cook and Annie Matthewman.

I have been reading quite some stuff about Software Factories lately. I even started the book called “Software Factories” but haven’t finished it yet. Although there is quite some information available it kind of bothered me that most of it is purely theoretical, I haven’t seen any real implementation of a Software Factory yet (until now).

Steve first gave some basic information about Software Factories. One of the, maybe obvious, things he stated was that is it only useful to build a Software Factory if you build similar systems every time. If that is the case, the next thing you have to define is a “package” of reusable knowledge that eventually can form the Software Factory. So, in order to be able to build a Software Factory you first need to know what is available and how it can be reused.

The reusable items can vary from a piece of documentation, an architecture baseline, code snippets, wizards, etc.

Summarized, a Software Factory can be described as:

· (customizable) structured collection of assets.

· Software Schema that defines the context for the assets.

· Explains people what to do.

· Helps people do it.

One of the goals for Software Factories is: easy things should easy and difficult things should be possible.

The second part of the session covered a demo of a real implemented Software Factory. The Software Factory provided guidance for building a “wizard like” windows application communicating with web services.

To support building Software Factories, there are actually two new “technologies/toolkits”. One of them concerns Domain Specific Languages (DSL) and helps building DSL end the appropriate DSL designers. The other toolkit is the Guidance Automation Toolkit (GAT).

For the Software Factory that was demonstrated Steve and Annie actually build a “new” DSL for this problem domain and an appropriate designer for the new DSL. Building this wasn’t covered in this session, but will be covered in another session.

The GAT is a relatively new toolkit that is downloadable from the Microsoft website. The GAT can be best described of a Software Factory for building Software Factories.

From what I saw in the demo one of the pieces of GAT is a (very) big XML file that describes the activities, actions and their contexts that together form the (part of) Software Factory. When a Software Factory is build by using the GAT the end result all integrates very nice with Visual Studio.NET helping the developer building the piece of software that is supported by the Software Factory.

I haven’t actually spent time on evaluating the GAT yet but the demo looked pretty cool so I think I will give it a try soon.

Tech-Ed Europe 2005 schedule

Edward Bakker (Edward Bakker) — Mon, 04 Jul 2005 21:19:32 GMT

This is my schedule for Tech-Ed Europe 2005. Looking forward to some (in my opinion) very interesting sessions and speakers. The sessions are a mix of the “connected systems“ and “architecture“ track. For most of the timeslots I choose an alternative session, just in case there are no seats left in the room when I arrive.

If you happen to be in the same sessions, say hello, I’ am the one carrying a Tech-Ed bag J

Day	Start	Finish	Location	Code	Session
Tuesday
05/07/2005	10:00	11:30	Keynote (8a)	KEY001	Ready For Business
05/07/2005	12:00	13:15	Room 3a	ARC302	Building and Using a Software Factory
05/07/2005	12:00	13:15	Room 8b	CTS370	Introducing "Indigo" - The Unified Framework for Building Connected Systems
05/07/2005	14:45	16:00	Room 8a	ARC309	Microsoft Visual Studio 2005 Team Edition for Software Architects: Developing Service-Oriented Systems
05/07/2005	14:45	16:00	Room 2c	CTS349	Beyond the Wizards: A Practical Approach to Web Services Security with WSE
05/07/2005	16:30	17:45	Room 3b	CTS365	Implementing "Indigo" Endpoints – Addresses, Bindings and Contracts
05/07/2005	16:30	17:45	Room 9b	ARC310	Microsoft Visual Studio 2005 Team Edition for Software Architects: Developing Logical Datacenters
05/07/2005	18:15	19:30	Room 8a	ARC315	The 5 Pillars of Connected Systems
05/07/2005	18:15	19:30	Room R	CHT072	Drilldown into Visual Studio 2005 Team System (VSTS)
Wednesday
06/07/2005	08:30	09:45	Room 3b	CTS360	Not Really Complicated Asynchronous Messaging Techniques and Technologies
06/07/2005	08:30	09:45	Room S	CHT071	Software Factories
06/07/2005	10:15	11:30	Room 9b	CTS366	Implementing "Indigo" Endpoints – Secure, Reliable, Transacted Messaging
06/07/2005	12:00	13:15	Room 8c	ARC314	SOA - Same Old Architecture?
06/07/2005	12:00	13:15	Room M	CHT019	Testing, Testing...
06/07/2005	12:00	13:15	Room R	CHT031	Implications of "Indigo" and Service Orientation for Architects and Architecture
06/07/2005	13:45	14:30	Room Auditorium	PNL003	WS-I_M_REALLY_CONFUSED
06/07/2005	14:45	16:00	Room R	CHT030	Turn Left or Right? How to Best Design Your Web Services Interface
06/07/2005	14:45	16:00	Room 8b	ARC419	The Grey Area of Implementing Services Using Object-Oriented Technologies
06/07/2005	16:30	17:45	Room 8b	ARC313	Patterns for Service-Oriented Architecture (SOA)
06/07/2005	16:30	17:45	Room 3a	CTS381	The Day "Indigo" Met the "Tiger"
06/07/2005	18:15	19:30	Room 8b	CTS358	Introducing System.Transactions and New Features
Thursday
07/07/2005	08:30	09:45	Room 8c	ARC312	The Fallacies of Enterprise Development
07/07/2005	08:30	09:45	Room S	CHT073	Integration, Service Orientation and Pattern Driven Design
07/07/2005	10:15	11:30	Room 8a	ARC311	Event-Driven Architectures
07/07/2005	10:15	11:30	Room 8b	CTS467	"Indigo" Under the Hood
07/07/2005	12:00	13:15	Room 9b	CTS354	Web Services Interoperability
07/07/2005	13:45	14:30	Room Auditorium	PNL006	Agile Development
07/07/2005	14:45	16:00	Room 8c	ARC411	Domain Specific Language (DSL) Tools for Model-Driven Development in Microsoft Visual Studio 2005
07/07/2005	16:30	17:45	Keynote (8a)	KEY002	The Future of Software
07/07/2005	18:15	19:30	Room 3a	CTS449	BizTalk Server 2004 and "Indigo"
Fryday
08/07/2005	08:30	09:45	Room T	CHT070	Walkthrough: Building a Designer with Domain Specific Language Tools for Visual Studio 2005
08/07/2005	08:30	09:45	Room 3b	CTS350	What's New in Web Services Enhancements (WSE) 3.0
08/07/2005	10:15	11:30	Room U	CHT071	Software Factories
08/07/2005	12:00	13:15	Room 8a	ARC412	Designing for Concurrency
08/07/2005	13:45	14:30	Room Auditorium	PNL002	Software Factories: How and When?
08/07/2005	14:45	16:00	Room 3b	CTS359	Retry, Abort, Cancel? Appropriate Handling of Transaction Failures in Connected Systems Application Code
08/07/2005	16:15	17:30	Room 8c	CTS465	From Dusk Til Dawn: Choose Your Approach to Design and Develop Web Services Applications on the .NET Platform