Testimonials for SoftCASE Consulting

Testimonials

The very act of developing software systems is a creative process. And as with any creative activity software developers are wary of set rules and restrictions. Such rules and restrictions are defined by the methodology adopted by the organization. Most organizations choose their methodology to ensure rigour in all development activities. Developers, however, need flexibility to do certain activities and ignore others. MaxUML from SoftCASE gives both flexibility and rigour to any development process.

Barry McGibbon
www.mcgibbons.net

Methodologists Need Configurable Tools: A really useful MDA and UML case tool by Ian Graham, TriReme International Ltd. (http://www.trireme.com)

The Object Management Group's Model Driven Architecture (MDA) has attracted a lot of attention since it's announcement. MDA sees development in terms of a series of transformations between models. A Computation Independent Model (CIM) of the business is transformed to a Platform Independent Model (PIM) that involves computational aspects but no technology choice. Then the PIM is transformed into a Platform Specific Model (PSM) that may be tailored to such platforms as .NET or J2EE. Finally the PSM is transformed into actual code. It is argued that it is possible to build tools to automate much of the transformation process.

Already several tools exist that support aspects of the MDA process and vision. However, most of them focus on the PIM to PSM and PSM to code transformations: the code generation end of the life-cycle. Kleppe et al. (2003) go so far as to argue that automating the CIM to PIM transformation is impossible, because it involves so much human judgment. This ignores what for us is the really exciting innovation of MDA: the recognition that good modelling is the critical success factor in systems development. Furthermore, it is the CIM and PIM that give the greatest and longest-lasting benefit for businesses. J2EE and .NET may be passing fads and will eventually be replaced by some new technology or other. Platform and code independent models of a business or an application usually have a much longer shelf life and, besides, deliver results earlier in the development life-cycle - so that benefits can be obtained sooner.

Certainly, automatic code generation will be useful as the technology matures. Just as few people write machine code or assembler now that good optimizing compilers can do the job as well as a human, one day no one will need to write Java or C#. Transforming the PIM to a PSM is also automatable. The most promising approach is to base the transformation rules on patterns and frameworks, as suggested in TriReme's Catalysis™ method (D'Souza and Wills, 1999; Andrews, 2004). In addition to this a scripting language is required to automate the code generation fully - otherwise only stubs and headers can be generated.

Conventional UML case tools rely on the developer writing the methods in Java or its equivalent. Current MDA tools - such as iUML from Kennedy-Carter or ArcStyler from Interactive Objects - use very low level scripting languages such as ASL (Action Semantics Language), Executable UML or OCL. However, we may confidently foresee the emergence of a high level language at some point in the future.

Even then, though, current and projected MDA tools are aimed solely at technologies such as J2EE, ASP and .NET. They offer scant assistance when transforming a PIM to some legacy platform or, worse still, a horrid goulash of legacy and new systems.

We think it may be far more profitable to improve tools at the front end of the MDA process. Our experience teaches us that part of the transformation between the CIM and the PIM can be automated. This problem is closer to the territory occupied by conventional case tools than the current clutch of MDA tools, though the latter most certainly have a rôle to play. Switching attention then to conventional tools we find that most of them don't help - or even hinder.

UML is a language, not a method. Some tools offer support for the language - drawing diagrams - but give no method. Others embed methods or method fragments that are, frankly, bad. At worst developers are shoehorned into these bad methods by the tools. The purpose of this article is to review a new tool that breaks the mould.

MaxUML from SoftCase Consulting is almost exactly the tool that UML practitioners and methodologists like us have been waiting for. The fact that it supports all UML concepts (for version 1.4 at present) is less significant than its ability to be configured for different methods. To do this it uses UML profiles: subsets of the UML notation together with stereotypes and specific constraints that implement methods and techniques. These constraints can be written in MaxUML's scripting language or in OCL. Using this approach MaxUML has already incorporated support for some of the techniques of Catalysis, such as snapshots. Snapshots are a useful way of visualizing the effects of use cases and their relationship to the type model (class diagram). For a summary of Catalysis see (Graham, 2001).

Because it is configurable, MaxUML is really a metacase tool; but unlike other metacase tools it exposes its metacase features to the user - for the cost only of the effort of writing a metamodel of his method. We can implement any method from Catalysis or, indeed, from TriReme's approach to requirements and business modelling, such as use case associations. These provide inter alia a way to show sequential dependencies that result from business rules on use case diagrams - rather than forcing the modeller to overdetermine the model in a sequence diagram. We can also implement our technique for handling use case exceptions without resorting to the dangerous "extends" dependency. Returning to Catalysis support, we can also implement the patterns from Catalysis II (Andrews, 2004) that transform PIM models to layered distributed architecture models independently of whether they are to be implemented under .NET or J2EE. Catalysis II extends Catalysis, incorporating and generalizing techniques from UML Components (Cheesman and Daniels, 2000). Effectively, all these techniques are pertinent to automating the transformation of the CIM to the PIM. In is in this area that MaxUML proffers the greatest leverage of a modeller's skills.

MaxUML runs under Windows 2000 or XP and is a multi-user system, using a check-in/check-out system, with checked-out items visible but locked. It interchanges models with other systems using XMI, which makes it possible to envisage using it in tandem with other business modelling tools, spreadsheets and with MDA and code generation tools such as ArcStyler, iUML or Compuware's OptimalJ. Its strengths are in the CIM®PIM®PSM portion of MDA rather than the PIM®PSM®Code area that other MDA tools concentrate on. It appears to be very robust and is competitively priced compared to its most obvious rivals for your budget. Its greatest strength however is its configurability.

No longer do we have to accept the restrictions of restrictive notations half-baked methods embedded in tools when we know perfectly well that there is a better way.

References

Andrews, D. (2004) Catalysis Components, Harlow, England: Addison-Wesley (in preparation)
Cheesman, J. and Daniels, J. (2000) UML Components, Harlow, England: Addison-Wesley
D'Souza, D.F. and Wills, A.C. (1999) Objects, Components and Frameworks with UML: The Catalysis Approach, Reading MA: Addison-Wesley
Graham, I. (2001) Object-Oriented Methods: Principles & Practice - Third Edition, Harlow, England: Addison-Wesley
Kleppe, A., Warmer, J. and Bast, W. (2003) MDA Explained. The Model Driven Architecture: Practice and Promise, Boston: Addison-Wesley
MDA - http://www.omg.org/mda

There is no magic bullet or single technique that will produce a software product; however an understanding of the business domain and the system will go a long way towards helping to produce software that works correctly. Building models helps this understanding, but the model must be built quickly and accurately - tools help with this. Many UML tools are geared towards a particular style of development, and this frequently gets in the way of capturing an accurate model quickly and succinctly. What is needed is a tool that can easily be configured to a particular problem, is easy and quick to use - MaxUML satisfies these criteria.

There is a further advantage, any UML tool, should conform to the OMG standard as this will enable interchange; it should not just support the tool manufacturer's "in-house" version of UML. More important, supporting the OMG standard gives the ability to use additional development tools; the MaxUML tool conforms to the OMG standard and thus avoids the "in house" problem and could be the basis of a development toolset.

Derek Andrews
www.trireme.com