From Unified Method to Unified Language

Products and Processes in Software Engineering

Here is a diagram illustrating the history of UML.

When we look at this picture, one remark comes immediately to mind.

Why this change, between 1995 and 1996 from “Unified Method” to “Unified Language“? The reason is that, at this period people realized that there was no possibility to propose a unique software development method. The goal of the OOAD at OMG was not only too ambitious, but is was an impossible mission.

There is an infinity of possible software processes answering the question of who is doing what, when, how and why in the software development and maintenance world.

The decision of OMG to reduce the ambition of this initiative was most clever. The goal was then reduced only to define a language for describing a subset of software artefacts. The name was chosen to be Unified Modeling Language. And the discussions on process description were ignored and delayed for further studies. Only when UML got stabilized in its first versions, people at OMG came back to the problem of process description and this effort finally produced the SPEM contribution (Software Process Engineering Metamodel).

This move was not a surprize and corresponded to the classical separation between process and product in most advanced engineering disciplines (think of chemistry for example).

But the language to describe software artefacts (UML) and the language to define software processes (SPEM) could not be completely independent. The idea was thus to consider them as two languages conforming to a common language as a matter of fact a metalnguage. And this metalanguage already existed at OMG: the MOF (Meta Object Facility).

This is not sufficient to make explicit the relations between SPEM and UML, but at least having both languages expressed in terms of a common metalanguage should facilitate in the future the precise expression of their relations.

This entry was posted in OMG, Software Engineering. Bookmark the permalink.

2 Responses to From Unified Method to Unified Language

  1. Ed Seidewitz says:

    Actually, the change from “Unified Method” to UML happened well before OMG was involved. This was a decision made by Booch and Rumbaugh while UML was still under development at Rational, with the idea that they could better get it accepted in the wider community if they focused on notation, not method. And they were very right!

    OMG originally got involved with an RFP that primarily looked for a common metamodel to allow interchange between modeling tools, not necessarily a common notation. But when Rational submitted UML in response to this RFP (they were not the only initial submitter, by the way), the specification quickly became focused on the notation as much as the metamodel.

    (Booch and Rumbaugh eventually got back to method with the “Unified Process”, once Jacobson was also on board, but this never formally standardized and it is mostly the specific “Rational Unified Process” that got used. UML is still intended, as much as possible, to be “methodology agnostic”.)

    • jbezivin says:


      Thanks for this answer.

      What I said is that, from an outsider attending OOPSLA’95, the official message was still then “unified method” and not yet “unified language“.
      From an outsider view, the move from method to language appeared a bit later, between 1995 and 1996.

      I quote here some documents:

      “SANTA CLARA, Calif.–(BUSINESS WIRE)–Sept. 26, 1995–Jim Rumbaugh and Grady Booch, two leading object-oriented methodologists, have announced the timeline for releasing a unified method for object-oriented development that incorporates the best elements of existing methodologies.
      In addition, the pair will present a draft of the new method and initiate a process to gather public comment on the method at the Object-Oriented Programming Systems, Languages, and Applications (OOPSLA) trade show and conference in Austin, Texas, October 15-19, 1995.
      Booch and Rumbaugh have been working on the unified method since Rumbaugh joined Rational Software Corporation in October 1994 as a Rational Fellow. The two methodologists are developing a unified, industry-standard method and notation for object-oriented analysis and design.
      Booch is the originator of the Booch method and Rumbaugh is the chief developer of the Object Modeling Technique (OMT). Combined, the two methods constitute more than 50 percent of the object-oriented analysis and design market, according to a recent study by market research firm International Data Corporation.”

      “AUSTIN, Texas–(BUSINESS WIRE)–Oct. 16, 1995–Jim Rumbaugh and Grady Booch, two leading object-oriented methodologists, have released a draft of the notation that will be part of the unified method for object-oriented development.
      The draft of the new notation is being presented this week at the Object-Oriented Programming Systems, Languages, and Applications (OOPSLA) conference in Austin, Texas. In addition, Ivar Jacobson, newly appointed vice president of business engineering at Rational and founder of Objectory AB, which recently merged with Rational, has joined Booch and Rumbaugh in the unification effort.”

      So, from my memory, at the end of 1995 the religion was still the unified method.

      But, the dates are not very important. We agree that, on the influence of Rational and the three amigos, there was a move from “method/process” towards “language for describing software artefacts” in a very short time, between 1995 and 1996. And this is the important point.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s