Foreword


Creating a modeling language that is also an executable language has long been a goal of the software community. Many years ago, in 1968 to be exact, while working with software components to successfully develop a telecommunications system, we created a modeling language that was the forerunner to UML. To model components we used sequence diagrams, collaboration diagrams, and state transition diagrams (a combination of state charts and activity diagrams). Our modeling language then seamlessly translated the component models into code. Each code component was in its turn compiled into an executable component that was deployed in our computer system. The computer system was a component management system thus we had "components all the way down."

Thanks to the seamless relation between the modeling language and the programming language, almost 90% of the code could be generated. Changes in the code could translate into models. However, this had to be done manually, because at that time we didn't have the tools to do the job. It was almost a clerical event. We called it a job for monkeys. Of course, I asked myself the question, if we only need the programming environment to create 10% of the code, do we really need two languages? Couldn't we integrate the modeling language and the programming language and make one language with a visual as well as a textual syntax and with common semantics. Having such a powerful language would dramatically eliminate work and it would make life more enjoyable to the developers. In 1980, I suggested this move in writing as a next step in the development of our products.

Several years latter, the International Telecommunication Union (ITU), headquartered in Geneva, created a standard for object modeling, known as the Specification and Description Language (or SDL). SDL was very much inspired by the modeling language we were using in developing our telecommunication system. We referred to it as "The Ericsson Language". In the early 1980s we added to SDL constructs to formally define algorithms and data structures. It was very simple, but at last we had a language that would allow us to execute our design models long before these models had been translated into a programming environment.

Steve Mellor and Marc Balcer now move the concept of "executableness" a step further. Steve in particular, advances the idea of making an abstract, platform independent, executable model of a software system which then, with specially designed tools (bridges), generates or transforms the model into executable software to run on target computer systems. The specially designed tools transform platform independent models to platform dependent code.

Steve has long been an advocate of this idea. I remember that Steve was on a panel discussing this several years ago. He was met by a lot of skepticism by other panelists. After the panel I told him, "There is in my mind no doubt that you will be proven right in particular for a small stereotypical class of systems, but it may take 25 years to get there for the majority of software development." After five more years and all the work done by Steve and others, I think we can get there even sooner.

Steve has now moved his work from Shlaer-Mellor notation to UML as the base modeling language. He has been the driving force behind the work on action semantics in UML, which was the missing piece to make UML an executable language. This is now part of the OMG standard for UML. He has gone even further. His work on transforming from a platform independent executable model to executable code via bridges is one of the cornerstones on which rests the OMG's new initiative: Model Driven Architecture (MDA).

However, to quote Winston Churchill, "This is not the end. It is not even the beginning of the end. But it is, perhaps, the end of the beginning." Having an executable UML for modeling platform independent software is a great step forward. We can work on abstract models, validate (debug if you want) them early before we introduce the platform dependencies and make sure that the system behaves functionally as expected. However, I believe we need to take one step further to eliminate a very expensive impedance in software development. We should move forward and design the missing link to make UML the language to also execute platform dependent software, to make UML a third generation language that eventually will replace existing programming languages. This is not a technical problem. This could be done today if the big platform vendors wanted to do it. We would eliminate the two-language problem (having both a modeling language, UML, and a programming language like C# or Java). We would get a language that would be both. A language that would be used for use cases, for platform-independent design, for platform dependent designs whether this would be done by transformers as Steve advocates or by doing the job by interconnecting components some of which being new, some of them already being harvested.

Getting an executable UML to be used both for platform independent models as Steve and Marc describe in this book and for platform dependent ordinary source code will be an important step in the future of software development.

Ivar Jacobson



Executable UML. A Foundation for Model-Driven Architecture
Executable UML: A Foundation for Model-Driven Architecture
ISBN: 0201748045
EAN: 2147483647
Year: 2001
Pages: 161

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net