A book on pragmatic software architecture, patterns and frameworks?

One of the major items on my wish list – that is on the professional half of it – is to write a book that displays my ideas on software architecture, patterns and frameworks. Yes I know, there are many books on software architecture, and there are many books that explain patterns, and yes there also are a lot of books that show you how to work with framework A, B or C.

So you would say, why on earth would you want to write a book on these subjects? Well there’s three major reasons. First, there’s not a lot of books out there that combine all these subjects into one single coherent story that will actually help you to write your applications better. Second, maybe I’m a bit arrogant on this, but I feel like I have something to all the stuff that’s out there. And last but not least, I finally need to get this stuff out of my head! Maybe ambitious, but let´s see!

Order from the menu

To be honest, you might like or not like all of the ideas in this book, or even may totally disagree with some of them. Actually, you probably will. But on the whole, I hope this book will be able to inspire you and illuminate you in how to build software. It´s often a matter of taste. So consider this book as a menu. Just order from it what you like. You don´t need to copy the C# and .NET code examples from the book, but rather I hope that use can use them to shape your own ideas on software architecture, frameworks and patterns. Take from it what you like, and forget about the few things you don’t like. 

A first step

What’s the first step towards writing this book? I’ve been teaching about software architecture, patterns and frameworks for .NET for quite a number of years, and the material from these courses will be a good start, similar to the way I shaped my book on UML – from iterating over the material I had for my UML courses.

PIC091019003 

Along with the course material comes the work I’ve done in projects, and as a result the work we (the core team) do on our ever-evolving and improving ADF.NET framework.

Architecture and frameworks

So here’s the overview of the material in the software architecture and patterns course:

  • Introduction. All the usual bla bla and thanks you stuff.
  • How to set up your software architecture? A mild and brief introduction. Thinking about layers, elements in layers,  collaborations (yes CRC). And of cause you can not start without summing up some of the good practices, such as
  • (Software architecture != List<Framework>). How people mix up architecture and frameworks.
  • How frameworks can kill your project. It’s all about dependencies guys. This chapter will be a write out of my talk with the same name.
  • Some patterns to help avoid getting killed. Explaining the different variations of layer super types, my fine descriptor pattern, and the use of dependency injection and the manager-provider pattern.
  • Glue 1.0. My first framework. Short introduction into setting up a minimal framework, using your architecture and the above patterns, minimizing dependencies between your application code and the frameworks you use. It should provide you with the glue to keep your “regular” developers in the loop.
  • Extension methods and fluent interfaces. Have got a bit (not all by far!) to say on how to use them to enable your application developers to code easier and more natural using your first framework.
  • Lasagna and ingredients. What layers would you need in your application? Suggesting presentation, process, domain and data/services. And suggesting a lot of elements in the different layers.

Presentation

In the next chapters I will slowly go through the individual layers. First, let’s investigate the presentation layer:

  • Panels and lists. The basic patterns of presentation layer elements. And a straightforward implementation of a user interface independent panel. Just for the fun of it.
  • The master of detail. Introducing some typical user interface patterns, such as manage, select, search, master-detail, list-detail and the effect of those patterns on your architectural and Glue 1.0 framework requirements.
  • MVWTF. Looking at the different variations in model-view patterns, and discussing the relevance. But briefly, there’s enough said on this stuff.
  • Binding and persisting. Coupling and de-coupling your models, view-models, domain objects, whatever to and from the user interface.
  • The view-model. Sense and non-sense of view-models.
  • Validations. Things to validate and things not to validate in the user interface.

Process

Next the process layer gets a rub:

  • Why do I need a process layer? Explaining the least well-understood layer in application architectures.
  • An brief introduction to smart use cases. Still an excellent unit of work, implementation and testing for projects. This chapter will follow the lines of my presentation on this particular topic.
  • Implementing smart use cases. Introducing the task pattern, and re-iterating the manager-provider pattern. Great stuff I think! Also re-visiting the MVWTF patterns again. 
  • Unit and regression testing smart use cases. How you can write your own extensions to regular unit test framework to allow regression tests over your smart use cases.

Domain

The layer it all revolves about:

  • About being domain driven. Design, code and test, do it domain driven. Now I’m not going to repeat Eric Evans’ book here, but I do repeat (briefly) the basic concepts that derive from his work. Think of entities, repositories, factories, value objects and services.
  • Augmenting your domain. However, we are using some additional patterns in our projects that are useful patterns. Here I’ll discuss the smart reference pattern, revisit value objects, and talk about cached domain objects. I might even introduce you to search objects.
  • Business rules and validations. How do you write and where do you place your business rules, and what validations do you execute in the domain layer?
  • Independent state. Domain objects, or entities, have identity and state. This state can come from a lot of place – not all being SQL Server. So the big question here is: can I keep my domain objects independent of how we get and set its state. Well yes you can, hence the internal state patterns jumps in.

Data, services and the outside world

All the way down to the bottom, in the cellar of your application, lies the data / services layer:

  • Does the data layer really exist? Hey weren’t we using NHibernate or Entity Framework? So why do we need a data layer, and if so, what is in it?
  • Map and wrap. When querying data sources it is very likely that you will need to provide some sort of mapping from your world to the outside world. I’ll show you some simple patterns of to achieve this mapping, allowing you to wrap your domain objects around the outside world’s objects.
  • Creating queries. Again, do you really need to implement a query patterns. We do have LINQ do we? Well yes, but LINQ does not cover all your possible sources of data – a lot, but not all. So a brief introduction of the query pattern – and some implementation aspects might not be a bad idea.
  • On the way out. Somehow you will need to reach out to the outside world of your application. Virtually the outside world can be just about anything. A (set of) databases of course, but what about OData, JSON, plain or not so plain XML, restful or restless web services, Twitter, Entity Framework, NHibernate, Facebook, you name it. The gateway pattern should help you here.

Concluding

    Mildly put, this little blog post could well be the introduction for this new book – except for the thank you notes. Do you miss anything, or already agree or disagree? Want to help annotating or reviewing the manuscript in progress? Don´t hesitate to become a part of the writing process. Please comment here!

November 25 & 26, 2010 – IT Works. Pragmatic modeling using UML

[Two day hands-on workshop at IT Works, Hotel Crowne Plaza, Antwerp. ]

On November 25 and 26 I will present the 32th edition of an intense two-day workshop on the pragmatic use of UML modeling techniques (and beyond) with lots of hands-on exercises.

IMAGE_073
Participants modeling activity diagrams with smart use cases

During this workshops we will go through the following subjects in depth:

  • A brief introduction of UML and its modeling techniques
  • A pragmatic YAGNI approach to modeling business processes and requirements.
  • Modeling hierarchical and chronological business processes.
  • Modeling traditional and smart use cases.
  • Modeling activity diagrams (for use cases).
  • Identifying test scenario’s for (smart) use cases using activity diagrams.
  • Modeling the user interface.
  • Modeling class diagrams.
  • Domain driven design.
  • Interaction modeling. Bringing together an applications structure and behavior, based on a pragmatic use case driven software architecture.
  • Modeling service oriented projects using smart use cases.
  • Modeling in agile projects.
  • A brief introduction to model driven software development.

Being Smart in enterprise agile

As agile is becoming more and more mainstream, organization are starting to do enterprise software development project using well-known but fairly basic lightweight agile processes.

IMAGE_089 

In many projects this has lead to surprisingly bad result, baffling the agile Certified Pokémon Trainers who are coaching these projects. The presentation below shows a number of accelerators or technique that projects can apply to tackle the challenges of enterprise agile projects.

Would be happy to hear your comments!

Spring 2010 speaking engagements

Again doing a lot of talks this spring on a wide range of subjects, from new technology, via enterprise agile to model driven development, but also about smart use cases, domain driven design, UML, and software architectures, design patterns, frameworks and .NET.

This season’s highlights? Not a difficult choice: doing talks both at Microsoft DevDays and TechEd North America is great. But revisiting SET in Zurich is not bad either. And what about the Dutch Testing Conference?

 DSC_0058

Check out my spring talks below (with links and logo’s):

  • Around the world in 80 slides.
    February 9. Keynote at Capgemini TechEd, Utrecht.
  • Pragmatic modeling using UML and beyond
    March 3-4. Two-day workshop at IT Works, Antwerp, Belgium.
    www.itworks.be
  • We’re not in Kansas anymore. New trends in Microsoft technology
    March 8. Capgemini Micrsoft Practice Meeting. Utrecht.
  • Pragmatic modeling using UML and beyond
    March 10-11. Two-day workshop at Array Seminars, Hilversum.
    www.arrayseminars.nl
  • CIO challenges. From enterprise agile to model driven development.
    March 16. Talk Capgemini customer event, Utrecht.
  • How smart use cases will change your life
    March 23. Guest lecture at Hogeschool Utrecht, Utrecht. .
  • Agile development in everyday practice
    March 24. Seminar at Array Seminars,  Nieuwegein.
    www.arrayseminars.nl
  • Do’s and don’ts in implementing extension methods
    March 30-31. Talk at Microsoft DevDays 2010. Den Haag
    www.devdays.nl 
    .
    image
  • Beyond agile testing
    April 7. Talk at Capgemini Testing Community Event, Utrecht.
  • Beyond agile testing
    Arpil 21. Talk at Dutch Testing Conference 2010, Nieuwegein.
    www.dutchtestingconference.nl
    .
    image
  • Mission impossible? How to survice agile SAP SOA projects
    May 18-20. Talk at SET 2010. Zurich, Switzerland.
    http://www.sigs-datacom.de/set/set-2010
    .
    image
  • Estimating with smart use cases
    May 26. Seminar at Array Seminars, Nieuwegein.
    www.arrayseminars.nl
  • Software architectures and patterns in .NET.
    June 2. Seminar at Array Seminars, Hilversum.
    www.arrayseminars.nl
  • How frameworks can kill your project and how to avoid getting killed
    June 7-11. Talk at TechEd US 2010, New Orleans, USA.
    northamerica.msteched.com
    .
    image
  • Pragmatic modeling using UML and beyond
    June 23-24. Two-day workshop at IT Works, Antwerp, Belgium
    www.itworks.be

Avatar, reuse and model driven software development

Last week my daughter Sam (13), her friend Joey and I went to see the movie Avatar in 3D at the IMAX theatre in Rotterdam. Following up on the hype and reading reviews I just got curious. Especially after reading an interview with director James Cameron, who previously directed Aliens and Titanic.

Being more than interested in model driven software development, this interview cracked me up. James Cameron states that there’s a model for every rock, every straw, every tree on the planet Pandora, and for every piece of skin and body of the inhabitants. That’s something for you.  On the one hand you might say: hey, this Avatar project took over 7 years to build, and it costs around 400 million dollar. No way should we do software development projects like that.

image
James Cameron: “Use the models for sequels”

But it gets more interesting. In the interview James Cameron also says that the argument that sold Avatar to studio 20 Century Fox is that these expensive and extensive models could be used for any number of sequels. To sum up why the studio put up with the length and price of the project in one simple word: it’s reuse.

Seeing is believing

I have to admit, seeing is believeing. This movie has the most incredible visual appearance I ever witnessed. And it’s all generated from the model. And that’s where I got jealous, or even a bit depressed.

There we are: enthusiastic software engineers building business software from our BPMN or UML models or our textual or visual DSL’s. Whatever abbreviation you follow, be it MDA, MDD, FMDD, or MDSD, we think we’re doing great jobs raising the level of abstraction just a little bit from hand-written code. But even this very little step  forward seems to be highly complex. The technology is hard, the meta-level thinking is harder, and convincing management and customers (the studios) that this is the way to go with software development is even more challenging.

Kindergarten stuff

But in comparison to the complexity and size of producing Avatar our whole MDx venue is kindergarten stuff. We’re not creating a highly detailed blasting 3D movie experience. We are only implementing a simple business process to change your address at your local bank. Pfff. Is that all?

image
Jake Sully: “Ha ha, changing your address at your local bank is difficult?“

Don’t get me wrong. We will simply have to move from hand-writing applications to modeling and generating applications. Raising the level of abstraction is the only way to deal with the rapidly increasing level of complexity of technology vendors present us with, and the ever increasing demand for new software, presented on new devices. There’s just no way we can keep with this demand just by hand-writing all the code, not with all the developers in the world, not with the best-of-class frameworks at hand, not with the best agile processes and techniques in place (let alone waterfall).

Even though model driven techniques are no silver bullet either it will play an increasingly important role in software development . Our work will be around simplifying customer demand, standardizing techniques and raising our levels of abstraction, writing less code and generating more code. And for those of you not yet convinced: go see Avatar or preferably one of its likely many sequels.

October 19. Talk. “Silverlight, .NET RIA Services and code generation”

SDC Conference, Papendal, Arnhem (www.sdc.nl)

Next week the annual SDC conference will take place at Papendal, Arnhem. As usual the organising SDN community has put together a long list of international appraised speakers, and challenging subjects on the matter of software development and software architecture.

SONY DSC 

A bit to my surprise, this year I was invited to do 3 talks, with very different subjects: Silverlight and code generation, smart use cases in service oriented projects, and .NET extension methods.

Putting model driven development to the test

The SDC website refers to my Silverlight talk as follows:

To be quite honest, this talk is putting model driven development (MDD) to the test. Model driven development – generating code from a model – is a concept that has long promised high productivity and quality to projects. There are many different approaches to MDD, some of them highly theoretical, some of them painfully oversimplified. Think of generating code from UML models, or using Oslo and M. And whatever happened to (graphical and textual) DSL’s?

As always Sander and his team follow a very pragmatic, straightforward approach to the subject, generating code from domain models and smart use cases. One of the benefits of true model driven development is that it allows to generate code from the same model to different target environments. Having done projects where code was generated in Windows applications, ASP.NET applications, and Java web applications, Sander will now use this approach to Silverlight line-of-business applications. In this talk Sander elaborates on how code generation works, how templates can be defined for Tobago MDA, a freely available MDD code generators, and will (try to) build up a Silverlight applications on stage.

Introducing .NET RIA Services

Unfortunately, my team was minimized due to illness and projects, and I had to figure out most of it myself – a though late night job. Especially since I want to pay attention to .NET RIA Services, a brand new way of buidling client/server applications in a distributed environment, where a lot of code generation takes place under the covers.

Let’s just I I can do some demo’s on the 19th…

Read more: Sander at SDC 2009.

October 8-9, 2009. Workshop. “Pragmatic modeling using UML and beyond”

IT Works, Crowne Plaza Hotel, Antwerp, Belgium

I will present an intense two day workshop in the Crowne Plaza in Antwerp. During this workshop I follow the pragmatic modeling approach presented in my book with the same title. During this highly interactive workshop participants will learn how the various modeling techniques from UML and beyond connect.

image

Learn everything about (smart) use cases and start working directly with UML in many exercises a pragmatic case – Dare2Date, an online dating site.

Topics include: UML overview, an agile approach to requirements, modeling smart use cases, testing use cases (with activity diagrams), user interface modeling, domain modeling (using class diagrams), modeling services, interaction modeling (with sequence diagrams), modeling in agile software development projects, and model driven development using UML.

Participants will receive a copy of the book Pragmatic Modelling with UML 2.0. This workshop always gets rave reviews. Note that this is the 29th edition of my UML workshops at IT Works!

See www.itworks.be

image

October 5, 2009. Talk. “Pragmatic model driven development”

Capgemini BAS, Faustlaan, Apeldoorn.

With Capgemini BAS joining Capgemini in 2009, some new initiatiaves in model driven development opened up, more particularly, hoping I’ve interpreted it correctly, based on naterual language. I discussed this initiative in June with Freek Bosch, manager of the unit where this natueral langauge based approach originated.

SONY DSC

During the same inspriing conversation I illustrated the pragmaitc model driven development approach in our Accelerated Delivery Platform (ADP). Immediately Freek invited me to present our approach during one of his unit’s meetings. Unfortunately my agenda left little room until now. So I will drive to Apeldoorn in the morning, and discuss our approach during a one-and-a-half hour lunch meeting.

Think I will talk about the following subjects tomorrow:

  • Brief introduction of the Accelerated Delivery Platform.
  • Our agile requirements approach.
  • Modeling smart use cases.
  • Domain driven design – including value objects, enumerations, smart references, repositories and services.
  • Our appoahc to pragmatic model driven development, as used by a growing number of organizations.
  • How our code generator Tobgao MDA works – including templates and Tobago’s DSL.
  • And of course, last but not least – a demo. Buliding a fully working ASP.NET multi-layered web application.

Writing better software faster

Published in my Interesting Things column in SDN Magazine, November 2009.

Looking back on twenty years of software development, I must have spent most of that time trying to improve the quality and productivity of software development.

Ever since I started to write small applications in Turbo Pascal in 1988 I got infected with the writing-better-software-faster virus. Right after I finished the second of fourteen of these applications, I wrote my first framework. It took some effort, but writing the following twelve applications took me less time than building the first two.

Darkening perspectives

There are good reasons for increasing productivity and quality. First of all, we have to increase productivity by a hundred-fold to meet up with current demands, says Gartner. Furthermore, technology is becoming increasingly complex. Ten years ago I was working in both Microsoft and Java projects. Anno 2009, I’ve let go of the idea that I even have an overview of either one of them. It is hard enough working with a small subset of frameworks. A Silverlight designer is not likely knowledgeable in NHibernate. Being a Spring guru does not guarantee foxy JavaFX user interfaces.

Despite this darkening perspective, there’s techniques and technologies that might keep you from drowning, by simply raising the level of abstraction. Good frameworks help. Smart use cases certainly do. And even UML assists. And then there’s model driven development a.k.a. model driven architecture a.k.a. model driven engineering a.k.a. domain specific languages. Different names for generating code and other deliverables from a model. What model? To be honest, any model will do the trick. Business process models, use case diagrams, user interface models, domain models, and last but not least data models.

Empirical start

Eight years ago I was helping a customer set up the domain model for a help desk application. After that I started to build the software in ASP.NET. Having modeled all domain objects, their properties and their services, I was typing them out in C#. So, as any decent developer would do I wrote a code generator. That helped.

I suspect most code generation efforts have a similar empirical start. That’s probably why there are so many approaches to generating code. Some really high-brow, squeezing everything-and-the-kitchen-sink into a model, and then trying to generate the whole application. From front  to back. Or, at the very low and of the spectrum, inspecting the database, generating create-read-update-delete screens in a flat two-tier architecture.

Where’s the value?

Recently I was invited in a panel on model driven development, together with some academic and commercial experts. For starters, each of the panel members introduced their position briefly to the audience. This noteworthy event learned me two things. One: never allow four enthusiastic innovators talk freely on their innovations. The word brief isn’t in their vocabulary. Two: coming from a business background, I didn’t have a clue to what model driven development does in the academic world. A whole new spectrum of approaches met my eye.

clip_image001

So where’s the value in this? Following the good old Scrum adagio I’d say: it depends. Model driven development can be highly rewarding for projects. But I’ve also witnessed projects that made a terrible mess of it.

In my opinion, being successful at model driven development requires some preconditions to be met:

  • Embed approach. Successful model driven development projects share a single principle: it’s all in a day’s work. Model driven development is never a goal. It’s just a means to an end. Making better software faster. No guru’s, no heroes.

  • Allow changes. Projects go through changes. That’s a fact of life. Model driven development should never be blocking changes, but rather should stimulate creativity, by allowing projects to show quickly what effect new or changing requirements have.

  • Stabilize architecture. Knowing how to model, and where to generate what code is key. Set up a stable (layered) software architecture, pick frameworks that match it, and only then elaborate on code generation.

  • Be pragmatic. My general advice in life also holds for model driven development. Be pragmatic. Never overdo it. Don’t try to squeeze the whole world in your model. It’s not necessarily a bad thing to still have to write some code manually.

Skepticism?

Having said all that, and having seen projects that very successfully apply model driven development, why is there still so much skepticism? After all, the paradigm really helps to deliver high quality at high productivity.

After witnessing both highly successful and extremely failing model driven development projects recently, I have given this some consideration. The vast majority of projects are in the middle of the wide spectrum of approaches. They run smoothly, being fairly practical. But it’s the failing projects at either end of the spectrum that draw the attention. Highly complex, slow moving, rigor projects on the one end, and oversimplified, bug-absorbing, underestimated projects on the other end. It’s no fun at either end.

No Jedi knight

My team and I have always adopted a highly pragmatic approach to model driven development, modeling smart use cases, applying domain driven design, run the model through our code generators (Tobago MDA) and we’re set to go. We do make better software faster.

Can life be this simple? It certainly can. We have applied this approach to all kinds of projects, and generated code in a variety of languages and frameworks, from Visual Basic to C#, from PHP and Java to Cobol. At the upcoming SDC, I’m going the check out a combination of Silverlight, .NET RIA Services, ADF and probably Fluent NHibernate. Should be fun!

To leave you with some words of wisdom (ahum). If there’s one thing I’ve learned from being successful at model driven development, it’s this: modeling and generating code should be everyday practice in your project. There’s no such thing as a “model driven development project”. There’s only software development projects. You don’t have to be a Jedi knight to steer a code generator. It’s all in a day’s work.

Pragmatic model driven development. Part III. Creating the domain model

Note. This series of posts is also published as a Capgemini group white paper and published in Software Release Magazine (in Dutch, in two parts).

The next step towards generated code, and other deliverables, is to create the domain model for the project. Next to the smart use cases, that capture the desired behavior, the domain model provides a structural view of the system.

Roughly said, the domain model captures the key concepts, types, rules, validations, and services of the business domain, expressed in customer terminology. Furthermore,  the model identifies the relationships between all major types.

In this pragmatic approach we follow and extend on the principles stated by Eric Evans in his domain driven design paradigm. As your might expect, the domain model is expressed in UML class diagrams. Primarily, the domain model models domain objects (or entities) such as Customer, Order, Subscription or Course and their relationships, expressed as associations. Next, the properties and their types are modeled.

image17

We consider five different categories of property types, that are all applicable in different situations:

  • Basic types. In general, people tend to model property types in basic types, such as string, integer, boolean or date. However, we have more knowledge on most property types than that it’s just a string or integer. In this case it’s better to use value objects.
  • Value objects. A value object holds no identity, but reflects a value. In short, value objects are good for modeling property types that can be validated, such as Bsn, Isbn or Email.
  • Enumerations. We model property types as an enumeration, if the property can only have a limited, fixed number of different values. Think of ContractType, Gender or Level.
  • Smart references. Another pattern we apply to modeling property types, is the smart reference. We have agreed to model a property as smart reference if the property can only have a limited, but possibly changing number of different values. Here you could consider properties such as Department, Prefix or Country (if no other information on countries is required).
  • Associations. If a property has a type that itself is a domain object, we model an association. Note that in UML an association is actually defined as properties on both ends of the association.

Each of these categories of property types can be used nicely in code generation. For instance, enumerations and smart references can be used to fill drop down lists, and associations of course can be used to generate master-detail behavior or object-relationship mapping configuration files. Moreover, the multiplicity, role names and composite parts of associations can all be used in code generation.

Pragmatic model driven development. Part II. A pragmatic approach

 

Note. This series of posts is also published as a Capgemini group white paper and published in Software Release Magazine (in Dutch, in two parts).

In projects that are executed using the Accelerated Delivery Platform, Capgemini’s open knowledge platform for agile software development, a lightweight, pragmatic approach to model driven development is used.

This approach can be expressed in a small number of steps:

  1. Model smart use cases. We model our functional requirements using highly standardized smart use cases. A growing collection of over 30 standard types of smart use cases exist, making life easier when it comes to requirements analysis, project estimation, testing, but also code generation.
  2. Create the domain model. Next we create the domain model, containing the entities, value objects and other classes from the problem domain of the project.
  3. Decorate the model. To be able to generate code we combine the smart use cases with the elements from the domain model, and a the appropriate stereotypes. For instance, we associate the smart use case Search Customer  with the Customer class, and decorate this association with the stereotype «search».
  4. Import model. Then we import the model in Tobago MDA, our code generator of choice. Tobago MDA can apply text templates to the model, and generate any desired text based deliverable, ranging from Word documents and Excel spread sheet to the actual code.
  5. Generate code based on reference architecture. To sort maximum effect, we base most of the application we develop on a straightforward reference architecture, that is supported by a number of frameworks, both in Java and in .Net, although other technology also apply.

Modeling smart use cases

Primarily use cases are identified at user goal level. Here, each use cases typically captures a single elementary business process. Normally for this use case the successful scenario is described (also called the happy day scenario), and additionally all deviations to this scenario are described as alternative flows.

image19

Using this approach, very limited use is made of the UML use case diagram modeling technique. Requirements are captured in text, and are mostly described in Word documents. As a good example of this type of use cases, at a large international financial institution a use case called Change Address was written. It covered 65 pages of text, 12 screens and numerous alternative flows. As these types of use cases vary enormously in scope, complexity and size, it is very hard, if not impossible to generate code from user goal level use cases.

Alternatively, when the use cases at user goal level are identified (even better: the elementary business processes for the project have been identified), it is possible to use the use case diagram technique to add use cases at fish level to the diagram. We have defined a number of clear guidelines on when these additional use cases apply. These include not handling more than one form per use case, handling complex calculations, handling services in service oriented projects, or even handling ETL in BI projects. The following diagram is a good example smart use case diagram. Please note that this model is not a work breakdown, the user goal level use case has it’s own responsibilities.

image18

Using this approach each of the elementary business processes is modeled out in such as diagram with any number of actors, a single user goal level use cases, and a number of accompanying use cases at sub-function level. The collection of these use cases (at both levels) is referred to as smart use cases. Again, for each of these smart use cases a description is written. However, these are much more lightweight than in the previous scenario and often contain only a few (or even no) alternative flows. We not only model these smart use case diagram in traditional multi-tier scenario’s, but also host service oriented and even cloud scenario’s.

Stereotyping smart use cases

An important step towards generating code from use cases is the recognition of smart use case stereotypes, which describe standard behavior. This extreme requirements standardization streamlines the requirements analysis, but also enables us to define templates per stereotype that implement this behavior in for instance Java or C#. Currently we harvested over 30 of these smart use case stereotypes, including maintenance use case in Manage, Master Detail, Select or Search, such as in the depicted diagram, but also Collect in BI projects, and several types of service handling stereotypes in service oriented projects.

Pragmatic model driven development. Part I. Code generation scenario’s

Note. This series of posts is also published as a Capgemini group white paper and published in Software Release Magazine (in Dutch, in two parts).

With the economy at a low point in time, organizations and project are clearly resetting their goals. Long term multimillion projects are being halted, in favor of short, agile projects, with feasible goals and good time-to-target. To realize these stringent goals, projects are striving for lower costs and higher productivity. On the one hand these goals might be reached by outsourcing, on the other hand standardization, industrialization and reuse could also contribute.

A long term promise in the field of increasing productivity and reuse is to handcraft less code, but to generate code from the project’s design or model. In general this is called model driven development

When is model driven development effective?

Although many alternative strategies exist towards model driven development, we feel that a pragmatic approach works best. The more theoretical an approach gets, the harder it is to apply it to projects. In this paper, we present such a highly pragmatic approach to model driven development. We model and standardize smart use cases and the domain model for a project, and generate code and other deliverables from these models using a straightforward tool set. This approach has proven to be very effective in many projects.

Model driven development can be effective when code and other deliverables can be generated rather than written or hand coded. Thus tedious repetitive work is avoided, such as creating web forms, user interface panels, domain objects, table create statements, service interfaces and even writing use case documentation. Developers can now focus on developing business logic, or tuning the user interface. We have witnessed very high productivity in projects that apply pragmatic model driven development. For example, a recent project (.Net) at a large Dutch government agency was realized in 20% of the time the customer estimated the project.

As it is also fairly easy to create new types of deliverables simply by investigating your existing code and derive template from this, we can save time and effort in many scenario’s and development environments. Model driven development has proven to be successful in (partly) generating solutions for various types of projects, including ASP.Net, Silverlight, SharePoint, Visual Basic Window Forms, Java, service oriented applications (.Net and SAP), and even back end functionality.

Moreover, as code generation is based on proven templates, generated code is of higher quality then hand written code. Thus, model driven development also contributes to lowering maintenance costs of delivered software. This effect is further increased because the documentation as presented in the model is directly traceable to the application’s code.

Last but not least, in model driven development, analysts and designer actively participate in delivering working software, as the models they help creating, are now directly converted into code. Model driven development is a collaborative scenario, where, especially in agile projects even end-users can participate directly in software development. To illustrate this, we usually model the smart use cases and the domain model that, underlie the software we produce, during interactive workshops with the end users, and generate working software either in these workshops, or shortly after.

IMG_0242[1]

Code generation scenario’s

Generating code from a model can be done in a wide variety of scenario’s, and with a even wider range of goals and deliverables to strive for:

  • Proprietary techniques. Traditionally there’s tools such as Oracle Designer and Developer or Cool:GEN that host both the model as the coding environment. Using these environment high productivity can be achieved, because a lot of assumptions can be made on the target environment. In general such development environments deliver highly proprietary models and code.
  • DSL’s. Domain Specific Language (DSL) are textual or visual representations of custom domains, for which specific modeling language can be defined, think of web service definition or even a language for defining the mortgages or life assurance domain. With DSL’s again has the promise of high productivity, if and only if, the target environment can be clearly defined, for instance in the software architecture and framework that are used.
  • UML. The Unified Modeling Language (UML) provides a set of techniques for modeling behavior and structure of applications. These standardized techniques, such as use case or class diagrams are used in projects around the world, however in different variations and dialects. Generating code or other deliverables from a UML model is highly possible, again if the target environment is well defined.
  • Database. With proper modeling techniques lacking, many tools take the approach of generating (parts of) applications from the database structure. Although this approach seems appealing and fast, there are limitations. The generated application will mimic the database, and thus will be very data-centric, instead of providing support for the work processes to be automated. Besides that, in the current era of service orientation and cloud computing, many application do not even have their own database.

September 3, 2009. Panel Discussion “Model Driven Development”

Devnology Meeting, Atos Origin, Utrecht.

On September 3, the Devnology community will organize a panel discussion on model driven development. The panel will consist of a number of expert from both practical and academic backgrounds. As you might have guessed, I’m a member of the panel – albeit probably not from the academic view point, although very interesting of course.

image

Picture taken at previous Devnology meeting

Invitation [in Dutch]

Here’s the Dutch invitation text from the Devnology web site (at www.devnology.nl):

Voor de meeste ontwikkelaars is MDD nog ver verwijderd van de dagelijkse praktijk van software engineering. Op deze avond stellen we de vraag: hoe lang is dat nog het geval? Wanneer gaat MDD de beloftes waarmaken, en onder welke omstandigheden is MDD een geschikte benadering?

We horen van het panel graag wat MDD nu precies is, hoe het zich verhoudt tot al die andere acroniemen (MDE, MDA, DDD, DSL’s), welke nieuwe ontwikkelingen te bespeuren zijn vanuit de academische wereld, en of/wanneer de tooling hiervoor volwassen is. Welke verschillende benaderingen zijn te onderkennen en welke specifieke problemen brengen deze met zich mee? Wat betekent introductie van MDD voor het development proces?

Voor deze avond is gekozen voor een panel discussie, de deelnemers zijn experts op dit vakgebied vanuit de praktijk van MDD, dan wel vanuit een academische achtergrond.

Het panel bestaat uit de volgende personen:

  • Jurgen Vinju
    Jurgen Vinju is senior researcher bij het Centrum voor Wiskunde en Informatica.
  • Sander Hoogendoorn
    In zijn rol als Principal Technology Officer bij Capgemini houdt Sander zich bezig met innovatie op het gebied van software ontwikkeling.
  • Erik S.C. van de Ven
    Erik werkt als senior architect voor Cordys, en daarvoor meerdere jaren als principal consultant voor Microsoft Nederland.
  • Eelco Visser
    Eelco Visser is associate professor bij de TU Delft waar hij onderzoek verricht op het gebied van model-driven engineering, domain-specific languages, program transformation, en software deployment.
  • Discussieleider: Edwin van Dillen
    Edwin van Dillen is als CTO bij Sogyo verantwoordelijk voor het uitzetten van de inhoudelijke visie.

June 2009

My talks in June 2009.

June 3. Agile software development in everyday practice.

Full-day seminar on doing agile projects for IT Works, Hotel Pullman, Diegem, Belgium. With guest speaker Stefaan van Royen, Mediamine. See www.itworks.be.

June 9. Pragmatic .Net development.

Full-day seminar on software architectures and patterns for .Net software development for Array Seminars, .NBC Nieuwegein. See www.arrayseminars.nl.

June 15 & 16. Smart use cases from front to back.

Custom two-day interactive workshop for information and business analysts of large Capgemini client at Capgemini Papendorp, Utrecht. Includes introduction of smart use cases, estimating smart use cases, smart use cases in service oriented architecture, testing smart use cases, domain driven design, agile, Smart / Scrum.

June 18. Mission impossible? Introducing agile in service oriented SAP projects.

Talk at Integrate Agile Conference with Twan van den Broek, Topforce, for the Agile Consortium Benelux, Claus, Badhoevedorp. I didn’t notice that I have a double booking until now… trying to solve it.

June 18 & 19. Pragmatic modeling using UML and beyond.

Fully packed two-day workshop on UML, modeling, smart use cases, requirements, domain driven design, model driven development and modeling in agile projects for IT Works, Hotel Crowne Plaza, Antwerp, Belgium. See www.itworks.be.

June 25. Navigating through the hypes. How frameworks can kill your projects, and how to prevent that.

Interactive talk on frameworks and how they can kill your projects at software architecture SDN Meeting in Hotel Houten, Houten. www.sdn.nl .

June 26. Agile anti-patterns. Yes, your agile projects can fail too.

Entertaining talk on how to make your agile project fail at the SDN Event in Hotel Houten, Houten. www.sdn.nl

Implementing smart use cases in agile projects

Guest lecture Hogeschool Utrecht, January 13, 2009

When asked who to invite for presenting a guest lecture, the students of the Hogeschool specifically requested for Sander. My lecture will be titled Implementing smart use cases in agile projects. Process, techniques, architecture and patterns.

During this very interactive lecture Sander will speed through a wide variety of subjects, such as agile software development best practices, Smart, modeling smart use cases, standardizing modeling in UML, testing smart use cases, domain driven development, model driven architecture and applying reference architectures. Of course, the speaker will demonstrate several of the accelerators from the Capgemini agile Accelerated Delivery Platform (ADP).

Some of my talks in 2008

Smart use cases. Past present and future

Keynote at Smart Use Case Conference, Capgemini Conference Center, Utrecht, Netherlands, May 28, 2008
Capgemini has organized an inspiring conference on the subjects of smart use cases. This event took place at Capgemini’s conference center in Utrecht. The large number of delegates witnessed talks on smart use cases, smart estimation, smart use cases in agile projects, project management and smart use cases, requirements management and rapid solution workshops for establishing smart use cases. As one of the founding father of these techniques, I delivered the keynote.

See wiki.trinidadplatform.org

Best practices in agile software development

Talk at management meeting Philips, Evoluon, Eindhoven, Netherlands. May 27, 2008
Talk giving an overview on waterfall failure, agile principles, Scrum, Smart, XP and agile best practices, but also giving an overview on Capgemini’s Accelerated Delivery Platform, smart use cases, smart estimation, code generation and model driven development.

Best practices in agile software development

Talk at knowledge sharing meeting DSDM Atern Consortium, Kasteel de Schaffelaar, Barneveld, Netherlands. May 26, 2008
Open two hour talk on waterfall failure, agile principles, Smart, Scrum and best practices.

Model driven development, smart use cases, domain models and Silverlight

Talk at Microsoft DevDays, RAI Amsterdam, Netherlands. May 22, 2008

It will be quite interested to see if I can add up this peculiar combination of keywords into one talk, also including some issues on software architecture, dependency injection, value objects, smart references, and live code generation (both web and Silverlight) in a mere five quarters of an hour. Brrr.

See www.devdays.nl.

Estimating with smart use cases

Seminar in Holiday Inn, Leiden, Netherlands. May 21, 2008.
Half day seminar on estimation, planning and modeling smart use cases. Organized by Array Seminars.

See www.arrayseminars.nl.

Smart use cases in BI projects

Talk at SET Conference, Zurich, Switzerland. May 6, 2008
Together with Sandra Wennemers I presented a talk at the TDWI Conference, which is an international conference on business intelligence. The talk covered two subjects, using UML in BI projects, and executing these projects in an agile manner.

Applying software development techniques to BI projects

Talk at Trends in Informatiemanagement conference, Leiden, Netherlands, March 18, 2008
With colleague Sandra Wennemers I present a talk at Trends in Informatiemanagement, a seminar on information management. This particular talk covers two subjects, using UML in BI projects, and executing BI projects agile.

See Trends in informatiemanagement

20070320-trends-in-im-468×60.gif

Some of my talks in 2007

Pragmatic model driven development .Net using use cases

Guest lecture at Hogeschool InHolland, Alkmaar, Netherlands. December 21, 2007
Informal guest lecture for students graduating this year. Likely subjects are software architecture, patterns, modeling and implementing smart use cases.

Project anti-patterns

Talk at Javapolis, Antwerp, Belgium. December 12, 2007
Presented my well known talk on project anti-patterns at Javapolis, the biggest Java event in Europe with over 3200 (!) delegates. Stephan Janssen sure does a great job at organizing this event.
See www.javapolis.be

Pragmatic development in .Net

Seminar in Lapershoek, Hilversum, the Netherlands. November 29, 2007
Practical one day seminar on software architecture, patterns and best practices in implementing multi-tier applications in .Net for Array Seminars.

Dimensional versus UML modeling

Talk at TDWI Conference, Schiphol-Rijk, the Netherlands. November 20, 2007
Together with Sandra Wennemers I presented a talk at the TDWI Conference, which is an international conference on business intelligence. The talk covered two subjects, using UML in BI projects, and executing these projects in an agile manner.
See www.sigs-datacom.de/tdwi

The days are just packed. My talks in May and June 2009

The months May and June are notorious for the number of talks – as Rick van der Lans describes: May and June are speaker’s season. Just to remind me not to forget any of my upcoming talks, here’s a list:

  • May 12. Project estimation with smart use cases. At Capgemini, Utrecht. Presentation at internal software estimation seminar for Community of Practice Methods & Tools.
  • May 13. Achieving business flexibility with smart use cases. Keynote at seminar on  business flexibility at Synobsis, Castle Lage Vuursche, Baarn. See www.synobsys.nl.
  • May 14. Estimating with smart use cases. Half-day seminar for Array Seminars, NBC Nieuwegein. See www.arrayseminars.nl.
  • May 25. An introduction to smart use cases. Presentation at Capgemini event for large customer, Utrecht.
  • May 26. Agile requirements and smart use cases. Half-day presentation at Capgemini BAS, Apeldoorn.
  • May 28. Navigating through the hypes. Software architectures and patterns to help avoiding your projects to crash. Interactive talk on frameworks and how they can kill your projects at Microsoft DevDays, Congrescentrum Den Haag. See www.devdays.nl.

DSC_6268

  • June 3. Agile software development in everyday practice. Full-day seminar on doing agile projects for IT Works, Hotel Pullman, Diegem, Belgium. With guest speaker Stefaan van Royen, Mediamine. See www.itworks.be.
  • June 9. Pragmatic .Net development. Full-day seminar on software architectures and patterns for .Net software development for Array Seminars, .NBC Nieuwegein. See www.arrayseminars.nl.
  • June 15 & 16. Smart use cases from front to back. Custom two-day interactive workshop for information and business analysts of large Capgemini client at Capgemini Papendorp, Utrecht. Includes introduction of smart use cases, estimating smart use cases, smart use cases in service oriented architecture, testing smart use cases, domain driven design, agile, Smart / Scrum.
  • June 18. Mission impossible? Introducing agile in service oriented SAP projects. Talk at Integrate Agile Conference with Twan van den Broek, Topforce, for the Agile Consortium Benelux, Claus, Badhoevedorp. I didn’t notice that I have a double booking until now… trying to solve it.
  • June 18 & 19. Pragmatic modeling using UML and beyond. Fully packed two-day workshop on UML, modeling, smart use cases, requirements, domain driven design, model driven development and modeling in agile projects for IT Works, Hotel Crowne Plaza, Antwerp, Belgium. See www.itworks.be.
  • June 26. Agile anti-patterns. Yes, your agile projects can fail too. Entertaining talk on how to make your agile and Scrum projects fail, at the SDN Event in Hotel Houten, Houten. www.sdn.nl

Slide deck on Pragmatic model driven development at J-Spring

Model driven development has a promise of high productivity. However, many approaches fail to deliver. Sander Hoogendoorn (Capgemini) and Rody Middelkoop (Avisi) will present a very pragmatic approach to model driven development, based on modeling smart use cases and domain models in UML. The speakers elaborate enthusiastically on this approach and the techniques used, and they will model and generate a fully deployable Java applications live on stage!

Rody Middelkoop and I will deliver the following talk on the J-Spring Conference, April 15, 2009 in ‘t Spant in Bussum.

More information: www.smartusecase.com.

Talk at J-Spring conference. Pragmatic model driven development using smart use cases and domain driven design

Today Rody Middelkoop, senior technology consultant at Avisi and lecturer at the HAN and I will do an amusing talk at the J-Spring Conference in Bussum on model driven development, using a highly pragmatic approach. Talk includes a live demo where we will build a Java web application on stage in a few minutes (the build process will likely take most of that time. A good moment to tell some jokes I suppose). In projects we execute using the Accelerated Delivery Platform, either with .Net or Java, we generate code from our standardized smart use cases and the domain model, using our Tobago MDA tool set. See www.accelerateddeliveryplatform.com for more details.

In our daily practice we generate for a variety of architectures in the .Net space. For instance, we apply our own frameworks, or combine these with open source frameworks such as nHibernate, and blocks from Microsoft.

image

Rody however used our created a set of templates to also facilitate that, resulting in the generation of large parts of Java applications. In short: model driven development has a promise of high productivity. However, many approaches fail to deliver. Rody and I will present a very pragmatic approach to model driven development, based on modeling smart use cases and domain models in UML. The speakers elaborate enthusiastically on this approach and the techniques used, and they will model and generate a fully deployable Java applications live on stage!

We will share our very pragmatic approach to delivering software using model driven development. First, I will elaborate on the modeling and code generation approach, that relies on smart use cases, smart use case stereotype, a solid software architecture and domain driven design. Next, Rody will take the stage and demonstrate how this approach effects in building Java web applications, generating a fully deployable Java EAR live on stage! Although other architectures and frameworks can be applied, Rody will use open source Java frameworks such as Ant, FreeMarker, Struts2, Spring and JPA/Hibernate3.

Cool isn’t it?

For more information: www.accelerateddeliveryplatform.com
J-Spring: www.nljug.org

Digg This

Outline for new pragmatic book on smart use cases

We (my team and I and a lot of people that contributed from projects) have been working on the concept of smart use cases on and off over the last ten years. I think it was back in 1998 that we coincidentally started modeling use cases at bit different than was custom, in a workflow oriented project. We not only pictured a single use cases with one or more associated actors, but discovered ways to use the use case diagram in a much more visual way, adding supporting use cases and actors, and by using use case relationships to a greater extend. This eventually led to the definition of what we now refer to as smart use cases.

Finally .. the book?

After having trainer over 2.000 people in the past 6 to 7 years, and having seen a growing number of organizations and project use the techniques, it’s probably time to write the book (if I can find the time). Likely the book will cover the following subjects.

User-goal level and sub-function level

Over time we have seen all kinds of new ideas, and extensions to this core thoughts back in 1998. First of all Alistair Cockburn’s model gave the different levels a name; user-goal level use cases and sub-function level use cases. Then we discovered different approaches to identifying smart use cases, from business processes and project scope, but also from existing applications, or functional documentation.

image

Modeling smart use cases

We quickly gained on tips and tricks on modeling the smart use cases, including splitting diagrams into service consuming and service provision, modeling in colors, how to use include and extend, and when to model supporting actors, and when not. Even further we discovered a lot of patterns in how smart use cases work together.

Testing smart use cases

Testing was always high up on the agenda. During a project for a large pension fund it appeared that a test technique called a project cycle test worked very well on our smart use cases, so we elaborated on that further, and transformed the original technique using UML activity diagram and generated test scenario’s.

Stereotypes

Originally we were modeling smart use cases for “normal” types of projects, such .Net, web applications, PowerBuilder, Java. Later on we found out that modeling smart use cases also appeared to be useful in SharePoint, BI and even SAP projects. From all these projects a growing list of standard types of smart use cases evolved, containing standard types (which we refer to as stereotypes) for data manipulation, reporting, service orientation, BI (ETL), and much more.

Estimating smart use cases

Later on, we added a very useful an pragmatic estimation scale for estimating smart use cases. This scale has proven to be extremely efficient in a wide variety of project types. It was only last week that we have modeled out a service oriented SAP implementation and estimated the project at 276 smart use cases points (SUCP). We call this technique smart estimation. Of course, all of our stereotypes match the scale so we can estimate fairly quick.

We soon picked up agile estimation techniques like smart estimation poker to establish team estimates for smart use cases, but also use a quick estimate spread sheet, to gives reliable results in no-time.

Being smart at agile

Talking of agile, in the same period that smart use cases were defined, an agile methodology saw the light that embeds the above techniques in a mature agile process. This methodology is called Smart (not the acronym) – hence smart use cases. In it’s core the Smart process is smart use case driven.

Smart use cases in code

And last but not least, the most important step of all: transforming smart use cases to code. There are very sensible ways of mapping smart use cases to your software architecture, and we promote having a process layer in your architectures, that hosts your use cases. In our own software architectures and frameworks, we have elaborated on mechanisms and design patterns (more specific the task pattern) to implement our smart use cases directly in code.

Even further, the stereotypes we apply helps us to generate lots of code (and other deliverables) from the model, using a model driven code generator (in our case called Tobago MDA).

So .. next step is the book?

There is so much to tell about smart use cases, that I have to start writing it down, even if it is just to keep my head from exploding. Than there’s only one way to go forwards from here, and that’s to write a book. This blog post is a short outline on the contents of this book-to-be. I would love to receive your examples, thoughts, ideas, annotations and models (e.g. in Enterprise Architect’s EAP format). You will be mentioned.

Pleas e-mail me all your input at: smartusecases@gmail.com. Thanks! For more information check out www.smartusecase.com


Share this post :

Digg This

Pragmatic model driven development in Java with smart use cases and domain driven design

In our Accelerated Delivery Platform we generate code from our standardized smart use cases and the domain model, using our Tobago MDA tooling. See www.accelerateddeliveryplatform.com for more details.

In our daily practice we generate for a variety of architectures in the .Net space. For instance, we apply our own frameworks, or combine these with open source frameworks such as nHibernate, and blocks from Microsoft.

image

Until recently, we did not have templates to generate Java. However, Rody Middelkoop from Avisi in Arnhem. He created a set of templates to also facilitate that, resulting in the generation of large parts of Java applications. Rody and I decided to send in a proposal for the upcoming J-Spring Conference. Here it is:

Model driven development has a promise of high productivity. However, many approaches fail to deliver. Sander Hoogendoorn (Capgemini) and Rody Middelkoop (Avisi) will present a very pragmatic approach to model driven development, based on modeling smart use cases and domain models in UML. The speakers elaborate enthusiastically on this approach and the techniques used, and they will model and generate a fully deployable Java applications live on stage!

In this unstable economy, organizations target software development at shorter time-to-market and high productivity. Model driven development has a promise of raising productivity in projects. However, many approach fail to deliver this promise. During this high-paced, interactive talk speakers Sander Hoogendoorn (Principal Technology Officer and agile thought leader at Capgemini) and Rody Middelkoop (Technical evangelist at Avisi, and lecturer at the Hogeschool Arnhem Nijmegen) share their very pragmatic approach to delivering software using model driven development. First, Sander will elaborate on the modeling and code generation approach, that relies on smart use cases and smart use case stereotype, a solid software architecture and domain driven design. Next, Rody will take the stage and demonstrate how this approach effects building Java web applications, generating a fully deployable Java EAR live on stage! Although other architectures and frameworks can be applied, Rody will use open source Java frameworks such as Ant, FreeMarker, Struts2, Spring and JPA/Hibernate3.

Reblog this post [with Zemanta]

Application migration using smart use cases and a model driven development approach

Application migration is the process of migrating older applications (often referred to as legacy) to application that have more of less similar functionality, but are developed in newer technology. Application migration has proven to be a crucial but very hard part of software development over the years. Key to such projects is:

  • Automated migration is hardly ever possible. It is hard for tools to migrate towards new development models, such as from Windows to web, because underlying different platforms have totally different programming models.
  • Business logic is scattered. In most legacy applications, the business logic is scattered all over the place, from user interface to the database. New architectures and platforms often serve best when applying domain driven design and development to centralize such logic. Migrating business logic is often hard.
  • Process logic is in the user interface‘. While current platforms and architectures offer to build software around business processes, this wasn’t always the case. Previously, lots of software was built around maintaining the database. Process logic is therefore either not present, or entwined in the user interface, which makes it hard to unlock.
    Using our Accelerated Delivery Platform (ADP) we have done some successful application migration projects. The ADP holds a number of accelerators that contribute in lowering your workload in such projects to a great extend.For instance, we model requirements using smart use cases and domain models. Smart use cases are an excellent unit of work to estimate, plan, and reuse functionality. See the example model below. Moreover, we generate a lot of code from both models using our generator Tobago MDA, but instead you might use other code generators, such as Velocity or CodeSmith.
    Task
    This code runs under (our) proven .Net frameworks. But, smart use cases also serve as a great unit of requirements when remodeling existing applications.

Strategy for application migration

Using these accelerators a clear strategy for solving re-engineering assignments such as yours is defined as follows:

  • Re-model in smart use cases. Examine the existing applications and model smart use cases from that.
  • Model the domain. Create a model the domain, for instance from existing data models.
  • Generate the new application. Generate the larger part of the new application using our model driven approach and Tobago MDA.
  • Examine business logic. Examine the old code for business logic and extend the generated application with this logic (in the domain layer).
  • Round up user interface. Finish of the newly generated user interface by examining the old user interface.

Of course, this approach does not solve all of your problems, and still leaves manual work discovering the business and user interface logic. But this approach reduces a lot of work. Even better, since the new application was modeled and generated, it is possible to migrate the model to several different platforms, such as mobile and web, or to migrate to a new platform much more easily in the future.

We have applied the accelerators in this platform in many projects and at many customers. Currently we support generating both Windows applications and ASP.NET web applications, and we have started to support Silverlight front ends and (even) Java applications.

Generated code is plain C# (or VB.NET or Java) and can be read and extended at any time. As the platform is shared with our customers in a open source-like manner, all accelerators in our platform come free of cost (also for our customers). There are 8 different training courses available to come up to speed with the platform.

This presentation will explain this approach to application migration into more detail.

So much to write, so little time

It’s too bad there’s only 24 hours in a day. There are so many ideas in my head that I still have to write down, that I have to make a (short) list now to keep my head from exploding.

So here it is:

  • White paper on how to do agile SAP projects using smart use cases.
  • Article on applying smart use cases in BI project (started).
  • White paper on agile accounting models (80% done).
  • White paper on my agile methodology Smart.
  • Book on agile / Smart in everyday practice (lay-out done). Have to find publisher.
  • Book on software architecture and patterns for .Net projects (started). Need to find publisher.
  • White paper on pragmatic model driven development.
  • Wiki page on how to use Tobago MDA.
  • Article on pragmatic model driven development in Java (with Rody).
  • Article on Descriptor pattern
  • Article on Smart Reference pattern (80% done).
  • Blog on agile mediocrity.
  • Article on application migration using smart use cases and the Accelerated Delivery Platform (started).
  • Ugly blog on the hype of cloud computing, following and extending the hypes around service orientation and component based development.
  • White paper on distributed agile software development.
  • Book on project anti-patterns (lay-out done).
  • White paper on our three references architectures, identifying all types in the layers, and their responsibilities.
  • Update the wiki with Smart 3.0 (30% done).
  • White paper on level of ceremony in agile methodologies (30% done)
  • Wiki page on mixing Scrum and Smart.
  • Wiki page on splitting smart use cases to work items.
  • Wiki page / article on testing smart use cases (80% done).
  • Newsletter item on visit of .NET PAC in Redmond.
  • Book on smart use cases.

And moreover (added February 6):

  • White paper on agile for software product development.
  • White paper about implementing agile smart.
  • Blog on questions raised during recent discussion on implementing agile at a large international bank.
  • Blog post(s) on going from Twitter API to service oriented software.

So help! Any votes or assistance offered?

For more information around these subjects see: www.accelerateddeliveryplatform.com

Talk at Javapolis 2007. Popular project anti-patterns

This is the video from Parlays.com that presents the talk I gave at the last JavaPolis conference in Antwerp, Belgium. During the talk I ask myself the question how everybody in their own role can attribute to making our project fail, as it is far too complicated to make your projects succeed.

The talk presents popular anti-patterns I’ve gathered over the years, such as Titanic Projects, the Bob-the-Builder Syndrome, PowerPoint Architecture. Enjoy.

Guest lecture Hogeschool Utrecht on implementing smart use cases in agile projects

On January 13 from 14:30 – 16:00 the Hogeschool Utrecht organizes a guest lecture by Sander Hoogendoorn, Principal Technology Officer at Capgemini.

When asked who to invite for presenting a guest lecture, the students of the Hogeschool specifically requested for Sander.

Lecture by Sander Hoogendoorn

His lecture will be titled Implementing smart use cases in agile projects. Process, techniques, architecture and patterns. During this very interactive lecture Sander will speed through a wide variety of subjects, such as agile software development best practices, Smart, modeling smart use cases, standardizing modeling in UML, testing smart use cases, domain driven development, model driven architecture and applying reference architectures. Of course, the speaker will demonstrate several of the accelerators from the Capgemini agile Accelerated Delivery Platform (ADP).

Please check out our Accelerated Delivery Platform at: www.accelerateddeliveryplatform.com.

Increasing the productivity of software development

Earlier this week I presented a talk at the inspiring Software Developers Conference 2008 in Noordwijkerhout, the Netherlands. My talk had an inspiring, or at least intriguing title: How to keep our jobs. Why? Well, let me share some thoughts on the productivity of software development projects.

A 100-fold

Recent research by Gartner shows that the productivity of software development will need to increase by a 100-fold. According to Gartner, there are 2 very simple and straightforward reasons for this:

  • Not enough newbies. The number of university graduates, and other people starting new with software development is too limited.
  • Increasing demand. The demand for new software is ever increasing, for instance becomes of emerging technologies and platforms (think of mobile and web 2.0).

And from my personal experience I would add:

  • Poor quality software. I perform a lot of code audits on applications, often quite large – say of over 1.000.000 lines of code. Even with such large applications, built by respectable companies, the quality is often brain damaging poor, frequently due to failing or total lack of software architecture. Such software is therefore very hard to maintain or extend with new features.
  • Ongoing business. There is a vast amount of software present in the marketplace that will need to be maintained for a very long time. Large transactional systems with banks (nationalized or not), governmental organizations or packaged software such as SAP and PeopleSoft. Although not mind-blowing, this work still needs to be done, and limits the amount of resources available for new development.
  • No silver bullet. There is no single methodology, technology or company that is able to provide the productivity to meet up the Gartner challenge, no matter how hard vendors will try to convince you that their new tool or framework will get you there.
  • Complexity of technology. Technology is ever more increasing in complexity. As much as you might suggest that tools and technologies have evolved over the past 20 years – about as long as I have been in this business – we do not reach higher productivity in projects than we did back then during the client-server era. In good old PowerBuilder projects we reached productivities of around 2.5 hours per function point. Nowadays, when applying our full blown agile Accelerated Delivery Platform we can about get to the same level, as was recently calculated by a respectable customer. And this is 20 years later. Another quick example? Take service oriented architecture. Often presented by vendors and architects as an approach where you just model the business processes and out comes your new software. Yeah right. Building service oriented software is still hard and technologically complex work. And no matter who gave you the idea that service orientation will help you get rid of object orientation, don’t believe it. You will need good old object technology to build all this stuff architects come up with: user interfaces, process logic, business logic, interfaces to middleware. It’s just not that simple.
  • Band wagons. We developers tend to go along with every new tool, framework or language extension that comes of the Microsoft, Sun, IBM, Oracle or open source band wagons and base our software architectures on these new, unproven technologies. This results in much time being spend on solving technology issues, rather than customer issues. And I should know, I have been (re)building frameworks over the past 20 years.
  • Snail speed projects. Projects are often executed at snail speed, and have enormous amounts of slack – time wasted by people just waiting for other people to finish their work or waiting on decisions not being made. My worst case? I once spent 4 months lingering in a project that was on hold until a board high up in the organization – indeed, a large international bank – approved on the new budget. And I wasn’t the only one – there were 60 of us.

The sun always shines

As said, there is no technique or technology that will lift our productivity a 100-fold. No sir. Moreover, there is not even a combination of technologies that will do so, no matter how much vendors would like you to believe that they’ve just invented the silver bullet. We’re just not there yet. But we could try. There are promising technologies, tools and methodologies. There always have been. Some ideas will help us get underway slowly and steadily (alas):

  • Become agile. Letting go of large process and waterfall styled methodologies will produce better software a higher velocities. Agile software development is more cooperative, responsive to changes, and removes much of the air from waterfall styled projects. Not only in small, but also in very large and even distributed projects. After having evangelized agile software development for the past 10 years, I know see agile finally moving into the mainstream.
  • Become communicative. Do not design and write your software under water, and submerge after months. Keep in touch with your customer during the whole project. Preferably execute (at least a large part) of your project at the customers’. Let him or her be in the lead. Shorten your feedback cycles to a daily, if not hourly basis.
  • Become standardized. Why does every new project define its own software architecture? And why are a large number of these new architectures so poorly designed? Why do we developers go along with every new (and often unfinished) technology fad? Standardization on good, sound architecture (domain driven of course) will help create better quality software that is easier to maintain and extend in the future. But be pragmatic, travel light. Even better, standardized software architectures allow for advanced, productivity increasing techniques, such as model driven software development and further down the road domain specific languages.

Again, none of these ideas are the silver bullet to solve all our problems. And the current financial crisis doesn’t help either. But, enough said. I’m not into pessimistic locking. We geeks have the best jobs in the world. The sun always shines from our asses. Just think of it. What other job will just let us write code all day?

Talk on DevDays 2008 combining smart use cases, model driven development, software architecture, Silverlight and WCF

At the last Microsoft DevDays Conference (2008) in Amsterdam I did a talk (sorry, it’s in Dutch) that covered a lot of subjects, including software architecture, agile software development, dependency injection, domain modeling, smart use cases, Silverlight, WCF, model driven development, Tobago MDA, our Accelerated Delivery Platform and a lot of other stuff that I can’t remember (getting old).

In the meantime I try to build (live) a couple of applications, that is model, generate and finish the code. During the talk I’ve created a server side application that provide web services, an ASP.NET front end, and a Silverlight front end. Pff. And all that in merely an hour.. As you might expect, my pace was rather high.

Well, without further ado, here’s the video Microsoft shot of my talk. Enjoy.

http://www.microsoft.com/emea/msdn/spotlight/sessionh.aspx?videoid=932