Who Loves Process? by Ivar Jacobson

Right now I am in my home in Switzerland to take a break and ski. I ski during the days and I work mornings and nights. Sleep takes too much time so I do as little as possible of that.:) One of the questions I often get nowadays is “Does Process come from the top or from the bottom?” Before answering I will start with two questions that I usually ask during my presentations. “How many of you love process?” In a group of 750 people, I usually see 3-5 raised hands. These are of course the people who work with process implementation, and they don’t have to follow a process themselves. Then I ask provocatively “How many of you hate process”. Now I get a very different answer. Usually 60-70% of the audience raise their hands!

Why is it like that? I believe that in many larger companies process has been pushed down on the people who know how to develop software. This won’t work anymore. The competent will speak up to get the process they want, which is good. What worries me though is that the pendulum will swing over to the other extreme. Instead of process push-down we will get process pop–up.

People do as they want. If every team gets their own process, they will not be able to learn from other teams, they will not get common set of tools and they will not harvest reusable assets. What we really need is a balance between push-down and pop-up.

For a very long time (since 1987) I have told my clients that one of the most important success factors for process adoption is to identify both a sponsor and a champion for the process improvement. The champion is a developer with many years of experience, great competence and with high credibility among his comrades. The sponsor is a higher level manager who wants to improve the way his organization develops software to support the company’s business. Without support from both don’t bother to adopt any new process.

Another of success factor is to use experienced people to coach the team adopting the new process. However in many cases management wants process but doesn’t want to invest in coaching. They just hope that people will adopt the process offered to them without proper coaching. As a consequence a lot of organizations have failed in process adoption. Management tried a shortcut, but it became a detour. The money an organization spends on product development is a factor of ten higher than the money it spends on proper coaching. For twenty years I have told my clients that without adequate training and coaching don’t bother to adopt any new process.

A third success factor is to balance the need for process from the top (the management) and from the bottom (the developers). This is true for any process whether it is a software development process or a business process. Only working from the bottom is a very slow process, and working only from the top creates a lot of resistance. Unfortunately, in many organizations management pushed down process on people counter to our recommendations. The developers were not enthusiastic but they tried to adopt the new process. That was not easy. Management believed their people were using the process but the developers did what they wanted to do, usually what they always had done. We got a gap, sometimes a huge gap, between what the process said and what people actually did. We call it the process-project gap. Thus we got failures and people started to hate process.

We need to change this. My recipe contains four ingredients:

  1. Reduce complexity. Instead of adopting a big process consisting of many practices, adopt a practice at a time. This will significantly reduce the complexity of process improvement.
  2. Balance the push-down from the top and the pop-up from the bottom, instead of just doing one or the other.
  3. Allow teams to change the practices so they work in their projects. The way you really work must be fed back as a change to the practices. We want a process that is alive and not just a dead book. This allows us to close the gap. One challenge here is of course that traditional process hard-heads will demand that all deviations from the described practices must be documented and perhaps even be given formal exemptions. If that is necessary then people will feel that it is easier to do what is demanded than to do what is right. What we need is a utilitarian perspective on process rather than dogma. :)
  4. Activate the practices and bring them alive in a way traditional process has never been able to do. While activated, a practice can help with all kinds of things. It can review what the developers are doing and suggest corrections. It can automate mundane tasks transparent to the developers. It can train the developers on the job reducing the need for classroom training and traditional human mentors. The selected practices should give context-sensitive help to the developers. This means that they should only give the developers help when they want it and only the help they really want and no more. The goal is to give the developers more time to think and create and to remove a substantial part of the no-brain work that developers suffer from today.

We have had a period of process push-down. The pendulum is now swinging to the other extreme – process pop-up. After a few oscillations the pendulum will hopefully swing to a new position where we will get processes that balance both the need for governance and for the need for creativity.  

Software is International by Ivar Jacobson

Since my last postcard I have been traveling around the world talking about the Next Generation Process -- which actually is not about process but about practices.

I have been meeting customers and given seminars in San Francisco, Seoul, Beijing, Taipei, Tokyo, Boston, New York, Jacksonville, London and now I am in Stockholm for a few days. When I see that people need a break from technical stuff in my sessions, I usually give them a break.

Sometimes I ask the audience if they know where object-orientation and components were born. Which was the very first object-oriented programming language ever designed? Usually, I get some mumbling as an answer so then I go on saying: OK, I will teach you some geography and history :-).

Up there in the north (I point in some direction which is not very precise), there is a large, beautiful country that looks like a rectangle called Sweden. To the west of Sweden is a tiny, totally uninteresting country called Norway :-). It is unbelievable but the first OO language was born in Norway (created by Ole-Johan Dahl and Kristen Nygaard). It was in 1967 and the language was Simula. Simula had everything important about OO that you find today in for example Java.

At the very same time, in Sweden, components were born. Everything important about components and component-based development was used in the Ericsson AXE system. The software component idea was my first baby. Thus it is not true that Microsoft and Bill Gates invented software components.

The problem was that we in Sweden didn’t know what our neighbors were doing. Even if the geographical distance between Sweden and Norway is small, the intellectual distance is huge :-). In the minds of Swedes, nothing of intellectual value can come out of Norway. Swedes are even surprised that Norwegians have the capacity to have the reverse opinion :-).

South of Norway is another tiny, totally uninteresting country called … and I hope for an answer…yes, Denmark. Do you know what came out of Denmark? Do you know who the father of C++ was? Yes, Bjarne Stroustrop. Bjarne had studied Simula and when he joined ATT in the US he made C look like Simula and called it C++ :-).

Then, we have another country to the east of Sweden called … yes, Finland. Do you know what came out of Finland? Nokia? More? Linux, yes. Do you know who the father of Linux was. No? Linus Torvalds. In Finland about 5% of the habitants have Swedish as their mother-tongue. Linus is Finnish-Swedish :-).

Anyway, you may wonder why I tell you all this? Well, I want to point out that everything important about software was not born in the US :-). However, if you want to make money from it, you have to make the leap over the pond to the US! :-) 

Software Engineering meets Social Engineering by Ivar Jacobson

There is a conflict between people who support Software Engineering approaches (such as Rational Unified Process RUP) and people who support Agile methods (such as SCRUM or XP). This is understandable since the two approaches are described in an incompatible way. However that is unnecessary, since the ideas behind the two are in all essentials complementary. The trick is how to combine them in a way fair to both of them.

In the software world we like swinging. We are swinging from one way of working to another way of working -- from one extreme to the other. Some people have been swinging for their whole life and have had enough of it.

Once, about five years ago, when I spoke in Singapore for a small group of 50 people, a senior guy stepped up, very frustrated, and told me that UML and RUP would be dead in five years and I would be gone as well. I like provocations so I asked him calmly what he based that upon. He told us that he had worked with software his whole life. “In the 60s we all worked with assemblers, then we got Cobol and Fortran, then we got database design” and he continued describing a zigzag path with new methodologies in every step: “structured programming, structured analysis and design, object-orientation, components and so on.” He felt it was awkward hearing about a new standard modeling language. I told him that there was another path: Assembler, components with assembler, component with a programming language, components with structured programming, components with objects and now components with objects and aspects. And we have all the time used a modeling language that can be described as UML.

Well, I am still here and I intend to be here for many more years…knock on wood. The guy who was so unhappy became even unhappier next day when he was fired by his boss. However, it is true that UML and RUP have lost some momentum, but they are far from dead. They are just taking a break while the world is swinging.

We are swinging from the extreme of doing everything with UML following what many believe is a prescriptive Software Engineering process. And we are swinging to another extreme called Agile. Very young people are having their first swing and now they are Agile. Middle-aged people, what a cute label, are right now swinging from the extreme of working with Software Engineering to another extreme called Agile. We swing and our companies swing with us.

Today everyone is agile. Of course. Everything else would be silly. Let me say it loud and clearly: I am a big fan of agile. My teams at Ericsson were extremely agile.

However, most people I talk to have a fuzzy understanding of what agile really is about. I participated in a panel discussion with agile evangelists in the UK last March. The organizers had hoped I would be against agile. They were surprised. The audience asked us to define agile. The panelists claiming they were agilists started to ramble. They repeatedly said that the most important property of agile was that it was iterative. That is dead wrong. Iterative development is one of the key practices in RUP and it has been around long before RUP. It was previously called spiral development and created by Barry Boehm in the late 70s. So I had to help explain what agile is:

Agile is about three things:

  1. Most important, agile is about social engineering. This is what actually made agile different. It is about how to work as a team, how to make people motivated, how to collaborate, etc.
  2. Agile is about lightweight. Instead of relying on explicit knowledge like in RUP, agile relies on tacit knowledge. In RUP we tried to write down what we know are good practices. However, since people don’t read process books, it doesn’t make sense to have them. Instead agile assumes that people have knowledge in their heads that is enough to develop good software. This can of course be debated but that is what it is.
  3. Agile contributes some technical practices. This is the weakest part of agile. Very little is really new. Iterative and incremental development is as I already have said an old idea. User stories are a special kind of simplified use cases. Most interesting new idea is test-driven development. I am not claiming the agile technical practices are uninteresting, just saying that if it were just for these ideas we wouldn’t have been excited about agile.

As you see Software Engineering and Agile tackle different aspects of software development. Software Engineering’s strengths are about technical practices and Agile’s strength is about social engineering. Thus here the two are very complementary.

That Software Engineering is straightjacket and Agile is light is harder to tackle. The question is can we get the best from both worlds here. Yes, we can!

Finally, the Software Engineering camp has a set of technical practices, the different agile methods have other sets of partly overlapping practices. Can we find a way to live with both? Yes, we can!

To do that we have had to invent a new concept Practices. We don’t talk so much about process anymore; instead practices are first class citizens. Process is just a composition of practices. Instead of talking about second generation processes that are passive and monolithic (big process), we talk about a third generation process which is active and practice-centric. If you already now want to have a peek at a third generation process, please go to my web site www.ivarjacobson.com 

TechED by Ivar Jacobson

Barcelona is my last stop on an around the world trip that started Oct 17 from Stockholm. That morning I gave a talk to key developers at a key Swedish company developing key telecom products :). After my talk I rushed to the airport and flew to Tokyo to meet some key people from large software companies. After Tokyo I went to Taipei, followed by San Francisco and now Barcelona. This is my 6th around the world trip this year with one more to go before the end of year – three less than last year. As you can see I am slowing down.

Barcelona hosted one of the largest software conferences this year, the Microsoft Tech•Ed – Developer conference and yesterday I gave, together with my colleague Pan-Wei Ng, a talk on Next Generation Process (NGP). Here is the core idea of the talk:

The world of software development is constantly changing and evolving. New ideas arise all the time and existing ideas go in and out of fashion. Software development processes find it very hard to keep up with this rapid rate of change, especially as they find themselves quickly going out of fashion or becoming bloated as they bolt on more and more information. Teams find themselves struggling as they try to mix-and-match practices from various sources into a coherent way-of-working.

A new approach to capturing and sharing experience is required. In my company, Ivar Jacobson International, we have developed a fundamentally new way of managing software development that downplays the importance of process – in particular big process. Instead practices become important. A practice is a way of working with a clear beginning and a clear end. Following a practice should give a clear result of value. Instead of trying to give an academic definition, let me give some examples: Iterative development is a practice that you can imagine to use separately to how you specify requirement or define your architecture.

  1. Practices are First Class Citizens
  2. Practices can be made smart to truly help the developers in their work, this is achieved with WayPointer
  3. Practices can be used individually or in a multitude of combinations
  4. Process is just a composition of Practices, and
  5. Teams compose the process they need by selecting just the practices that they want to use

As you can see this is a paradigm shift. We move away from working with a big monolithic process (like RUP) to working with practices. Process is downplayed to just become a composition of practices.

To enable this, a number of innovations are required: innovations related to the way that practices are collected, presented and applied. We have developed two components to realize these innovations:

EssWork is a new set of tools for deploying practices in an organization. These tools allow you to author practices separately and to compose them to a process. They allow you to use a completely new way of learning, adopting, scaling up, and changing your selected practices. You use cards to describe your practices, to plan your project and to guide you in developing software. Cards are good because they force us to be very brief in describing process elements. You focus on the essentials, which makes practices very lightweight.

EssWork is available on top of several platforms: Eclipse, EPF, VSTS so you can have the same process independently from which vendor tools you use. On top of EssWork we have built a first set of eight practices called EssUP (Essential Unified Process).

EssUP is just a subset of all the practices we eventually will see on EssWork. Five of these practices are traditional Unified Process practices: use cases, architecture, iterations, components and products. Moreover, there is one practice which supports social engineering practices unique for agile methods, and one practice for process improvement derived from the process improvement camp such as CMMI.

However, we are not dogmatic about which practices you should use. You can replace any practice that we offer with a competing practice from your favourite methodology. You can also add practices that you have discovered yourself. Mix and match is our recipe.

Best of all: EssWork and EssUP are going to be Open Source! I can’t give a date, but it will happen as soon as possible.

The presentation was completely full (around 500 people) which was a fantastic result – there were people standing in the auditorium and watching on the remote screen outside So there is much to do going forward.

Various Podcasts were arranged. This is one:
http://www.mseventseurope.com/TechEd/06/Pre/Live/VideoDev9.aspx?id=3#an3 
 

UML 2.0 by Ivar Jacobson

For many years I travelled regularly to Japan. I became acquainted with many companies and many individuals. Several of my books were translated to Japanese so I got many “friends” there. However, since 2001 I have not been back to Japan, so I was very excited to return when I hit the ground in Japan two days ago.

I was invited to give a keynote at a UML conference in Tokyo. My presentation was on the Essential Unified Process with the Essential Unified Modeling Language, EssUP+EssUML. You already know what EssUP is from my previous postcards, but I have so far not described our work on EssUML.

UML was originally developed by a very tight team with Grady Booch, Jim Rumbaugh and I as members. We were nicknamed The Three Amigos – a term I never really adopted myself. Once we had defined what we wanted to achieve other methodologists from around the world were invited to participate. The core of the UML came from the work by the three of us, no doubt about that, but several other individuals made significant contributions. Grady, Jim and I had regular teleconferences in which most decisions were taken. We worked very efficiently. The first reasonably well-defined version of the language was UML 1.1 which was adopted by OMG in the fall of 1997, which was less than a year after we started to work seriously together. This must be a record for any kind of language standardization effort.

UML 2.0 was the next step in the evolution of UML and it was achieved in a very different way following standard OMG procedures. Now a committee with more than twenty persons took over. While we worked on UML 1 in an agile way, the committee worked on UML 2 in any other way than agile. At the UML World conference in Austin, Texas, June 16, 2005, during a panel discussion on UML, Steve Cook said something to the effect “UML 1 was excellent, whereas UML 2 is terrible.”

UML 2 is too big. Its specification is about 1,000 pages long! It includes many good ideas but it is written by tool vendors for tool vendors. No practitioner will read this specification.

There is a lot to be said about what happened in moving from UML 1 to UML 2. UML 1 needed a consolidation period for experience gathering and fine tuning, which it unfortunately never got. Instead the work on UML 2 started with a, too a large extent, new group of persons willing and wanting to change anything they didn’t fancy.

Grady and I were not involved in the UML 2 work. Many questionable changes were made. As an example, I found out that the committee had decided to change use cases from being what they always had been since I first introduced them to being something completely different. They claimed that I really didn’t understand what use cases were, and they had to fix it! Yes, this is a true story.

Once the decision to change use cases was taken, and I was informed about it, I wrote an email to the committee and expressed my severe concerns. I told them that I would not be able to support UML 2 if they changed the fundamental meaning of use cases. That email had no effect, the committee knew better! Thus I had to bring my concerns to top management at Rational. Rational made it clear to the committee that if changes of this nature were made, the user community would react very negatively and the reputation of the language would be seriously damaged. Rational expressed that this was unacceptable and more or less threatened to walk away from the UML 2 effort. Our two participants in the UML 2 committee were instructed to be very cautious with changes and to consult with a team of Rational experts before accepting any changes.

As you can understand this period was quite dramatic for anyone involved. There was a time when I believed I would have to publicly denounce UML 2. Fortunately, the UML committee came to their senses and I didn’t need to take such a dramatic step. Still, UML grew too much under the influence of a large committee. Today all UML fans suffer from this mistake.

However, at its roots UML is good. The basic techniques are proven as practical for many years. As an example, Ericsson could claim that it used UML already in 1969, because at that time we used component diagrams, sequence diagrams, collaboration diagrams, state charts and state transition diagrams (a combination of state charts and activity diagrams).

Thus on one hand UML has a sound base but on the other hand it has become too bulky. We know that with less than 20% of UML you can model more than 80% of all software systems. What we need to do is to extract these 20% that people need and define it precisely. We have started doing this and we call these 20% EssUML. EssUML is not a new language. It doesn’t even change UML. It is just a proper subset of UML.

EssUML is one more thing though. It presents UML in a way attractive to developers, quite unlike the UML 2 specification which intended audience is meta-modellers and tool builders. To achieve this we use a similar technique as when presenting EssUP. Every language element is represented by a card or a set of cards, and its description is usage centric (or use-case centric).

Now you may ask yourself, what are those 80% that we don’t need in the UML? In this case the expression “the devil is in details” could not be truer. The UML elements and their graphical representation in diagrams are simply overloaded with too many nice to haves that rarely are useful (or used). Essential UML is, as the name indicates, about extracting what is truly essential. What this exactly means in terms of diagram types and element types is a bit early to say but my personal opinion is that, e.g., Activity Diagrams (and all their associated element types and detail) do not qualify as essential. The experience is that it is not cost effective to develop and maintain this kind of diagram, especially if you also produce textual flow-of-events descriptions.

While they are not really defined as part of the language there is often (at least in tools) an artificial division into various types of structural diagrams, such as class diagrams, component diagrams, deployment diagrams, and package diagrams. I think this division often misleads people to believe that they need all these diagram types and that they are distinctly different from each other and that is of course not true. Anyway, going forward we will define this and also specifically what the 80% that we don’t need are. Every diagram and element type will eventually have a card describing its essentials, child elements, relationships and so on. In particular the card should focus on describing the use cases of the diagram/element.

As an example a card representing the component diagram (if we choose to have such a diagram type) could look like this:

Of course a card doesn’t contain enough information about the component diagram so we provide a guideline that goes a bit deeper. In most cases this is enough as developers will learn more as they use the diagram in practice.

The guideline is 2-4 pages and it describes the essential content of the diagram, its use cases, hints and tips and common mistakes. It also references the OMG specification and other UML books. However, in general developers don’t read much. There is a law of nature:

Law of Nature: People don’t read books

Over the years I have come to realize that even if people may buy books it does not necessarily mean that they read them. This is certainly true for manuals such as process manuals or language specifications. I believe we can get everyone in a team to read the cards. If we write really well we might get up to 25% of the developers to read the guidelines, but almost no one will read the books being referenced. Additionally we of course have to acknowledge that the Essential 20% varies a bit depending on the specific situation at hand, i.e., the underlying business reason for modelling in the first place can vary.

  • Are the diagrams/models key ingredients in driving the understanding and design as we go, or are they primarily useful as documentation to, e.g., the next project?
  • Is our intent to generate code for large parts of the system or do we model to simply illustrate key aspects of the system and its design?
  • What is the size, complexity and longevity of the product/project?

The answers to questions such as these will of course have an impact on the process we use and follow, the amount of documentation we produce, and of course how much and how detailed we model.

As you know, I am a strong believer in that intelligent agents is the most efficient way to capture and disseminate knowledge and that is of course applicable for practices as in EssUP as well as for technological underpinnings like EssUML. I strongly believe in having intelligent agents to provide context-sensitive advice and training on line. They can help you by performing mundane tasks, recognize design patterns that you may want to apply, review your work, etc. These are some of the things that WayPointer can help you with.

My keynote in Tokyo was very well received. I was invited to come back to this exciting city and I will be back real soon. It was five years since I was here the last time. As it looks like now I will be back almost every month. This is wonderful and I really look forward to it.

Meeting with Dave Thomas by Ivar Jacobson

Meeting with Dave Thomas

The weekend July 8-9, Dave Thomas visited me at my country house in the Stockholm archipelago. Some of you have already met Dave. He is a very dynamic and colourful Canadian. He is very popular in some camps and he is feared in others.

His great strength is really finding innovative, competitive solutions to people's business problems which can be solved by software; and assembling and motivating people to move towards a goal. He looks many years ahead at the business/competitive climate and navigates a path through to a goal. He uses the best things he can find to solve the problems and doesn't generally constrain his solutions to the practices or technologies that are popular or widely available. If everyone uses the same process, technology and tools then he doesn't see where one gets competitive advantage since everyone can hire smart people. Hence he seeks strategies which others don't see and competitive opportunities to use them. This is why so many companies have problems today including MS, IBM but also companies like Fujitsu, Samsung etc. Unlike Google for example they did not think out of the box, they just run hard. MS has a hard time to understand enterprise clients, and IBM doesn't really understand how to build and deliver software as a service. Smalltalk was successful because Dave made IBM do it (The IBM Smalltalk), and Eclipse is successful because Dave created a strategy to disrupt the tool market. This is his real strength, managing software is something he does for fun. :)

The first time he visited my country house was 1988. At that time I had founded Objectory a year earlier and we discussed what I should do. He strongly believed in my vision and technology. He gave me some advice which included the following:

You should write a book about use cases and objects – no more that 150 pages. Then that book will become a market leader. He saw my hesitation. I said something like software development is serious work; you can’t describe that in 150 pages. He responded, of course you can’t, but people want simple solutions, they don’t want complex books. And, then you can come out with an improved version every year, and people who bought the first version want to by every other version. :) This is how you create market leadership. Of course, I should have done as he suggested.

Dave and I had a great time together at my country house as you can see from the photo below.

We did some good work together on EssUP and NGP as this picture shows: 

He likes our work and he will help us communicate it in the software community. I will write again about the specific results of the meeting which will come in the next few months.

EssUP Launches by Ivar Jacobson

Yesterday we launched Essential Unified Process in the UK. We had around 180 attendants and these were all invited by us. We wanted participants that could help us understand if we are on the right path.

I think we can count this event as very successful. We all felt very upbeat afterwards when we met at a pub.

In the picture above I am the guy who gesticulates. The others are from left to right: Agneta Jacobson (CEO of Jaczone), Pan Wei Ng and Ian Spence (both Chief Scientists of Ivar Jacobson Consulting) and Chris Littlejohns (managing director of Ivar Jacobson Consulting UK).

The most central idea behind the Next Generation Process (NGP) is that Practices are First Class Citizens and Process is just a composition of Practices. This is then followed up by three innovations (in no particular order):

  • Practice Separation and Composition. This is an idea I first presented at the Agile Conference in New Orleans in August 2003.
  • Practice User Experience using the card metaphor to move the focus to the developers away from the process engineers. This idea originates from Brian Kerr at Ivar Jacobson Consulting in the UK.
  • Practice Smartness using intelligent agents to make process active. This comes from Jaczone’s WayPointer.

Essential Unified Process is a first incarnation of the NGP. It is a package of practices…8 to be exact. It could equally well have been 5 or 10, the most important things are the practices and not the package. Apart from the three major innovations mentioned earlier, there are many other ideas in what we mean with NGP. We have alphas and betas, competencies instead of roles, aspect-oriented thinking, how we make EssUP agile with social engineering practices, etc. Ian Spence showed how we have created three games to play the cards. There is a process assembly game, a process planning game and a project game in which the team actually develops software. (We have a paper to be published in August in Dr Dobb’s Journal). Today, on the surface RUP is hardly recognizable in EssUP (but of course EssUP is a great way to move to RUP; it is also very easy to move a RUP customer over to EssUP).

NGP Infrastructure has been developed to prototype status. Pan Wei Ng demonstrated navigation through practices, authoring of practices and cards, composition of practices. I think it is fair to say that the audience was very impressed getting a glimpse of NGPI. Many people came up to me afterwards and said that our work on NGPI really gives us credibility. EssUP with physical cards is a good start. With an electronic version of the cards we give the card metaphor a face in the tool world. I believe that NGPI helps us to move people from being excited about EssUP to wanting to plan their first EssUP project, something our launch proved.

WayPointer is now a mature and proven product. Several persons came up to me and said that the latest version is a big step forward. WayPointer is already very effective when it comes to to the complete adoption of software development best practices by a team. With our practice-centric approach another role of WayPointer becomes evident. For each practice we can now offer cards and guidelines with the most essential knowledge and as additional leverage provide support from intelligent agents to help people both with the cards/guidelines but also with all the other more specific and context sensitive advices that are made explicit in books or elsewhere. WayPointer will of course also provide automation and real-time quality checks for the practices. Together these components provide an unprecedented framework for process dissemination. The story starts to get together in a wonderful way.

We have a fantastic story. People definitely see us as The Thought Leaders on Process. However, this is not enough for us. We don’t just want them to see us as thought leaders. We want them to come to us and ask for services and products. Thanks to our very strong team we can deliver that.  

A Practice Approach by Ivar Jacobson

I have just left the RSDC 2006 in Orlando. This was my 10th Rational user conference. It is my favorite conference because I always meet many friends from my days at Rational – both customers and colleagues. And this is where I introduce the latest thinking of our team on software development practices – including people from Jaczone and people from Ivar Jacobson Consulting.

This year I presented our work on Next Generation Process and its first incarnation: Essential Unified Process. Essential Unified Process is just a package of separate practices. Some of them are well-known to those of you who are familiar with Unified Process or Rational Unified Process. We have given these practice names like: Component, Model, Iteration, Architecture and Use Case. However, we also have some new ones. One is about Process Improvement, helping you to achieve many of the values with CMMI. Another one is the Team Practice which is about social engineering or with a more modern word: it is about (the core of) agility.

Much of my understanding of teams was formed many years ago as a soccer player. As very young I was a passionate player. I was playing soccer every hour awake. I was also coaching several teams at the same time as I was an active player. Soccer has always fascinated me. It is played almost in the same way all around the world. Millions of people can play it and billions understand and enjoy it.

There are many similarities between playing soccer and a project, such as developing software. At the core of it is the team. Even if the team consists of individuals, the individuals must be team players. The values of the team have in both cases an enormous impact:

A soccer team consists of eleven players. A player has some competences such as goalkeeper (one player only), defenders, midfielders and forwards. A player that is a good forward is usually not a good defender.

The soccer team also has some other members; the most important one is the coach. The coach doesn’t play himself, but has an important role in creating the team. Typically, a coach is someone who once played soccer himself but has grown and matured. (Are there any similarities to software? :)) He is a leader and makes the team adopt important core values. He selects the players to make up the team. He sometimes has to make hard decisions abstaining from top individuals because they aren’t team players – they don’t buy into the core values. In professional soccer, the coach is the buyer of players from other teams. It is clear that not all players have the same price or the same salary. The difference may be ten- or hundredfold. And that is a manageable problem in team building.

However, while preparing for, playing or learning from a match, we are all members of the team. Although we are aware that the team is made up of individuals and that it is individuals that make heroic achievements, the success of the team is dependent on the whole team and that every member of the team is doing a good job. It doesn’t make sense to say “We forwards were very successful today by scoring three goals. However, they (the defense) were not doing well; they let in four goals.” We are all part of the whole. We want to be proud of the team. There is an expression Proud People Perform which is very applicable here. No one is more important than anyone else. We respect one another, we help, we make mistakes, we repair them and we move forward. The goal is to win, to succeed – to loose, to make a failure is out of the question. We take precautions to get to the right place.

What I just described could equally well have been practices adopted by a software team. There are many good patterns in modern software development that are incorporated in the Team practice, and more will come.  

Essential Unified Process by Ivar Jacobson

After two very intense days in Ottawa I am on my way to China, Taiwan and Korea. Two intense but very memorable days. In Ottawa I gave two talks on the Essential Unified Process, the first to Statistics Canada while the second was a public seminar arranged by IBM Rational Canada.

The welcome I got at Statistics Canada was mind-blowing. Andrew Konecny who organized the event compared it to when Rolling Stones visited Ottawa in the summer of 2005: Sold Out. Around 250 persons attended the seminar and the introduction that Andrew gave was most memorable and made me feel very welcome. Every attendant got a black T-shirt with the logos of Jaczone, IBM Rational and Ivar Jacobson Consulting on the front and a listing of all my postcards on the back. It was really fun.

I presented the Essential Unified Process. So what is it?

The Essential Unified Process stands on the shoulders of modern software development practices. It is a fresh start integrating successful practices from three camps: the unified process camp, the agile methods camp and the process maturity camp. Each of them contributes different capabilities: structure, agility and process improvement.

The Essential Unified Process is very different from other processes or methods in how it is presented. It relies in many ways on a new idea: Separation of Concerns (SOC or aspect-oriented thinking). When you apply this general idea it will be dramatically simpler to work. It will be much easier and much more pleasant to select your tailor-made software process. Most important, it will be more natural and intuitive to plan and execute a software project. To make this concrete let me describe a number of situation where we have applied the idea of SOC:

  1. The Essential Unified Process separates the essentials from the non-essentials. This allows us to create a core lightweight process with unprecedented growth potential. We have learnt over the years that very few people really read process materials whether it is in a book or on the web. Therefore it doesn’t make sense to give them a lot. Instead, provide the real essence and let them learn the rest the way they want. Some may want to learn it by studying and there are a lot of articles and books available to do that. Some will learn by working with people who have already gained the knowledge. The effect of this separation is that the process will be very light and easy to adopt and change.
  2. Each practice is kept separate from other practices. The Essential Unified Process comes with the essentials of our five foundation practices:
    1. Component Based Development,
    2. Model-Driven Development,
    3. Iterative and Incremental Development,
    4. Architecture-Centric Development and
    5. Use-Case Driven Development.

These practices have been used in 1000s of projects and proved to be very successful. By keeping them separate, we can simplify the process description dramatically. The process description is presented as a set of individual practices. Each such practice can be developed, adopted and applied separately from the other practices. This is a significant difference compared to the Unified Process where all practices are intertwined. Moreover, you can easily select only the practices you need without having to deselect activities and artefacts. You just select the practices you want and compose them with your already existing process.

  1. You can easily separate elements from your existing process from the elements of the Essential Unified Process. This allows you to improve what you already have, one practice at a time in an evolutionary way. You start from a generic platform and describe your own process using a very simple technique inspired by the game industry. Based on this we can add our practices without requiring a revolutionary adoption of all our practices. You take what you need and what you think your organization can adopt without taking any severe risks.
  2. It separates two different views of the process: the process authors’ view and the software developers’ view. In the past processes have almost entirely focused on the authors’ needs. The Essential Unified Process prioritizes the developers’ perspective. It uses techniques from the game industry to develop, teach, apply and use the process to make it lightweight and agile. And, I promise, much more fun.
  3. It separates explicit knowledge from tacit knowledge in a balanced way. Tacit knowledge is knowledge you acquired one way or the other – you have it in your “head”. Explicit knowledge exists in the form of descriptions made available to you. In the past the Unified Process tried to capture all knowledge in explicit form. Though this is a good ambition, it makes the process heavy. The Essential Unified Process makes only the essentials explicit. The rest is either tacit or referenced from the essentials. However, the most elegant form of dealing with knowledge is to deliver it through intelligent agents when needed – this is what we call a smart process. As you all know, WayPointer is the first commercial product that makes smart process available.
  4. It is prepared to separate creative work from no-brain work. This will allow developers to spend their time on what humans are good at – being creative – and leave the no-brain work to intelligent agents. Once again, this is made possible with WayPointer.

Our long term vision for the Essential Unified Process and WayPointer is to move from a ‘process’ era when everyone is forced to think about process to an ‘invisible process’ era, a time when we don’t talk specifically about process but take it as a given.

Now you may wonder: Does WayPointer support the Essential Unified Process? The answer is indisputably; YES! WayPointer already today supports the core of the foundation practices. Over time as the Essential Unified Process grows WayPointer support will grow too. As an example, the first released practice, “Use Case Driven development” is fully supported in the upcoming release of WayPointer. 

A Visit to Costa Rica by Ivar Jacobson

I have just had some fantastic days in Costa Rica where I was invited to speak at an architecture conference sponsored by Microsoft and Club Investigacion Tecnologica. My speech was about the Essential Unified Process which I will tell you more about it in another postcard. Today I want to tell you about a completely new experience for me: the canopy.

Yesterday, I got up early to go to the rain forest. My driver Luis picked me up at 8 am and we drove for three hours to get to a large and active volcano. We were lucky. The volcano roared just as we got out of the car for a view of it. A roaring volcano is frightening and it makes you feel very small. It spit out huge blocks of stone rolling down the slopes with tails of white dust. When the volcano had spoken it became so quite that you could hear all kind of sounds that were new to me. Monkeys were hi-hoing to one another, birds were calling one another and Luis told me it was time to move on.

We came to a farm where Luis put me on the back of a horse and then he said “goodbye, see you in the evening”. The horse took me on a one hour ride in the company of other horses -- with attached tourists. I am not a rider. I have been on a horse twice before. The first time the horse started to gallop, and since no one had told me how to steer, it ran straight towards a big fence. The horse was smart; it didn’t run into the fence but stopped just in front of it. However, I didn’t stop. That could have stopped my career. :) 

From now on my horse was very kind. He knew he had a bag of flesh on his back and that he needed to keep that bag from falling off. Nevertheless, I had a tough time to hold on to the horse and it was all very painful. The saddle was as hard as if it was made of steel. I am glad I was not on a two week tour, but just on a one hour trip. My lower body was in severe pain, the skin was gone and I could hardly walk, sitting was out of the question.

I didn’t need to sit though, because now we had reached the canopy. In the rain forest wires about 1.5 cm thick were stretched from one point to another, lower point, about 900 meters away. The idea was for me to slide along the wire from the higher point to the lower point all about 60 m above the ground. I got a harness on my lower body which was attached to a rail via a strong elastic rope. The rail was to slide on the wire. I also got a one cm thick glove to control the speed and to keep my body from rotating while sliding.

Before going on this trip people had told me that some people never get back from the canopy so don’t go. Well, saying that was the best way to get me to do it. Scary? Yes. However, once on the wire it was fantastic. It was a new experience, like skiing or snorkeling the first time. I loved it. The area had 10 such wires and I did them all. Afterwards I was very relaxed and enjoyed a great dinner with a view of the sunset over the beautiful volcano. In his ambition to make me happy Luis had even invited a young Finnish tourist to share dinner with us. I was too exhausted to pay her any attention, so Luis had to entertain her himself. In fact he did that so well that he totally forgot about me and I could drop off on our way back to the hotel.

I really want to come back to Costa Rica to again meet Luis, Jimmy, Roberto and all the new friends I made.  

Page 13 of 16« First...78910111213141516