Model Driven Architecture (MDA) "provides an open, vendor-neutral approach to the challenge of interoperability, building upon and leveraging the value of OMG's established modeling standards: Unified Modeling Language (UML); Meta-Object Facility (MOF); and Common Warehouse Meta-model (CWM). Platform-independent Application descriptions built using these modeling standards can be realized using any major open or proprietary platform, including CORBA, Java, .NET, XMI/XML, and Web-Based platforms."
From the document "Model Driven Architecture: A Technical Perspective":
IT systems have historically been developed, managed and integrated using a range of methodologies, tools and middleware and there appears to be no end to this innovation. What we have seen in the last few years, especially as a result of efforts at OMG and W3C is a gradual move to more complete semantic models as well as data representation interchange standards. OMG contributions include CORBA, UML, XMI, MOF and CWM. W3C contributions include XML, XML Schema, and the ongoing work of XML-PC working group. These technologies can be used to more completely integrate the value chain (or life cycle) when it comes to developing and deploying component based applications for various target software architectures.
The life cycle of an application can vary dramatically depending on whether we are building a new application from scratch or just surgically adding a wrapper to an existing application. The cost of enhancement and maintenance of an application as well as the cost of integrating new applications with existing applications far exceeds the cost of initial development. In addition the application life cycle itself can be quite complex, involving several vendors in each of the life cycle phases. Hence the need for information interchange and interoperability between tools and middleware provided by different vendors (a very common situation in enterprises today) is critical.
The MDA supports many of the commonly used steps in model driven component based development and deployment. A key aspect of MDA is that it addresses the complete life cycle analysis and design, programming aspects (testing, component build or component assembly) as well as deployment and management aspects...
Unified Modeling Language (UML): UML addresses the modeling of architecture, objects, interactions between objects, data modeling aspects of the application life cycle, as well as the design aspects of component based development including construction and assembly. Note that UML is powerful enough that we can use it to represent artifacts of legacy systems. Artifacts captured in UML models (Classes, Interfaces, UseCases, Activity Graphs etc.) can be easily exported to other tools in the life cycle chain using XMI.
XML Metadata Interchange (XMI): XMI is a standard interchange mechanism used between various tools, repositories and middleware. XMI can also be used to automatically produce XML DTDs (and soon XML Schemas) from UML and MOF models, providing an XML serialization mechanism for these artifacts. XMI has been used to render UML artifacts (using the UML XMI DTD), data warehouse and database artifacts (using the CWM XMI DTD), CORBA interface definitions (using the IDL DTD), and Java interfaces and Classes (using a Java DTD).
Meta Object Facility (MOF): MOF provides the standard modeling and interchange constructs that are used in MDA. These constructs are a subset of the UML modeling constructs. Other standard OMG models, including UML and CWM, as defined in terms of MOF constructs. This common foundation provides the basis for model/metadata interchange and interoperability, and is the mechanism through which models are analyzed in XMI. MOF also defines programmatic interfaces for manipulating models and their instances spanning the application lifecycle.These are defined in IDL and are being extended to Java.
Common Warehouse Metamodel (CWM): CWM is the OMG data warehouse standard. It covers the full life cycle of designing, building and managing data warehouse applications and supports management of the life cycle. It is probably the best example to date of applying the MDA paradigm to an application area...
Historically, the integration between the development tools and the deployment into the middleware framework, has been weak. This is now beginning to change by using key elements of the MDA -- specific models and XML DTDs that span the life cycle, and profiles that provide mappings between the models used in various life cycle phases. XMI, which marries the world of modeling (UML), metadata (MOF and XML) and middleware (UML profiles for Java, EJB, IDL, EDOC etc.) plays a pivotal role in the OMG's use of XML at the core of the MDA. It also provides developers focused on implementation in Java, VB, HTML etc., a natural way of taking advantage of the software platform and engineering discipline, when a more formal development process is desired. In essence XMI adds Modeling and Architecture to the world of XML.
References:
Announcement: "OMG Pursues New Strategic Direction to Build On Success of Past Efforts: Model Driven Architecture." [cache]
"Model Driven Architecture: A Technical Perspective." By the Architecture Board MDA Drafting Team. Draft 21st February 2001. Document Number ab/2001-02-04. [cache]
EDOC Standard. Enterprise Distributed Object Computing. EDOC is proposed as the modeling framework for Internet computing, integrating web services, messaging, ebXML, .NET and other technologies under a common technology-independent model. The EDOC profile of UML was adopted by the OMG in November of 2001 as the standard for modeling enterprise systems. It is the modeling standard for Internet computing - providing for model driven development of enterprise systems based on the Model Driven Architecture (OMG-MDA).
[July 06, 2006] OMG Systems Modeling Language (OMG SysML) Specification. Object Management Group (OMG) Final Adopted Specification. May 2006. Reference: 'ptc/06-05-04'. 282 pages. "This specification defines a general-purpose modeling language for systems engineering applications, called the OMG Systems Modeling Language (OMG SysML). SysML supports the specification, analysis, design, verification and validation of a broad range of complex systems. These systems may include hardware, software, information, processes, personnel, and facilities... SysML is designed to provide simple but powerful constructs for modeling a wide range of systems engineering problems. It is particularly effective in specifying requirements, structure, behavior, and allocations, and constraints on system properties to support engineering analysis... SysML is intended to be supported by two evolving interoperability standards: the OMG XMI 2.1 model interchange standard for UML 2.1 modeling tools and the ISO 10303-233 data interchange standard for systems engineering tools... Annex D: 'Model Interchange' describes several methods for exchanging SysML models between tools. The first method discussed is XML Metadata Interchange (XMI), which is the preferred method for exchanging models between UML-based tools. The second approach describes the use of ISO 10303-233 Application Protocol: Systems engineering and design (AP233), which is one of the series of STEP (Standard for the Exchange of Product Model Data) neutral data schemas for representing engineering data. Other model interchange approaches are possible, but the ones described in this annex are expected to be the primary ones supported by SysML. UML 2.0 is formally defined using the OMG Meta Object Facility (MOF). MOF can be considered a language for specifying modeling languages. The OMG XML Metadata Interchange (XMI) 2.1 standard specifies an XML-based interchange format for any language modeled using MOF. This results in a standard, convenient format for serializing UML user models as XMI files for interchange between UML tools. The XMI specification also includes rules for generating an XML Schema that can be used for basic validation of the structure of those UML user model XMI files. An XMI 2.1 representation of the SysML profile (i.e., the UML Profile for SysML) is provided as a support document to this specification. As with UML, XMI provides a convenient serialized format for model interchange between SysML tools and basic validation of those files using an XML Schema as well..." [source PDF]
[July 07, 2003] "Tools for the Code Generation." By Johanna Ambrosio. In Application Development Trends (July 01, 2003). "Model-Driven Architecture, or MDA, embodies the conundrum: Is the glass half full or is it half empty? Even though the MDA standard is still evolving, many products claim to be compliant with it and early adopters are developing apps with them. MDA vendors claim that today's products can generate between 40% and 80% of the completed code for a given app based on models created with UML, and customers and analysts back up those claims. MDA's purported benefits go beyond automatic code generation and the reduction of development costs, but those advantages are longer-term and most have yet to be proven outside of theoretical conversations. They include factors like eventual code and model reuse, and more effective fulfillment of user requirements. One advantage touted by the MDA camp is the ability to swap out underlying technologies -- OSs or languages, for example -- by simply revamping the platform-specific model and then regenerating the applications. Still, a split remains between current users of these products -- mostly architects who speak UML or another modeling language -- and the targeted group of developers who believe they can do a better job of writing apps than any code generator... Currently, there are at least 40 tools that incorporate at least one of the major aspects of MDA: UML-based modeling; transformation between the app's overall design models and the models that are specific to the underlying computing architecture (.NET, EJB and so on); and the generation of code in a specific language. Jon Siegel, the OMG's vice president of technology transfer, calls MDA adoption in the marketplace 'extremely enthusiastic,' and said there are another 'couple of dozen' products in the works. The OMG does not necessarily know about them all, he noted, because vendors need not license or pay to use OMG standards. Still, he said, MDA adoption has caught on faster than any other OMG standard... Bob Carasik, an enterprise architect at Wells Fargo in San Francisco, said that going with MDA is 'a matter of the project leadership making the decision to do so, and then making the tools available.' Wells Fargo is using MDA to convert interfaces written in CORBA to interfaces written in J2EE with XML messaging. Almost all the bank's apps use these interfaces, including mainframes, client apps that run various online apps and the corporate telephone response center. In the bank's case, in-house developers handcrafted the tools used to make the switch from CORBA middleware..."
[June 17, 2003] "Developers Expect Nod for UML 2.0 Standard." By Darryl K. Taft. In eWEEK (May 26, 2003). "The Object Management Group will meet in Paris next week to vote on Version 2.0 of Unified Modeling Language, a language that supports analysis and design in a variety of tools and promises to open new horizons for developers. The first UML 2.0 specifications were adopted as OMG standards in March -- covering Infrastructure, Object Constraint Language and Diagram Interchange Protocol. A fourth specification, Superstructure, is expected to be voted on at the meeting next week, completing the recommendation process for the latest UML version. Few developers will be looking forward to UML 2.0 more than IBM. Sridhar Iyengar, a Distinguished Engineer with IBM, in Raleigh, N.C., and a member of the OMG Architecture board, said IBM researchers are looking into several innovations using the new specification. IBM will be looking to build a UML profile for testing. This work will lead to 'using modeling not just for analysis and design but for testing,' Iyengar said. 'We expect this technology will become a standard,' he said. IBM's approach to modeling signals a race with Microsoft Corp., which is warming up to the OMG for similar purposes. Microsoft will support modeling in its upcoming Jupiter e-business suite, which will compete with IBM's WebSphere... In addition to its use of the MDA (Model Driven Architecture) specification, IBM is pushing toward a new area, which Iyengar calls Model Driven Business Integration, while the company also has a focus on model-driven tool integration and model-driven application development, he said. MDA allows developers to design, build, integrate and manage applications throughout the life cycle while separating technology and business concerns, Iyengar said. EMF (Eclipse Modeling Framework) is the glue that holds together IBM's modeling strategy. 'EMF is the technology that unifies the world of modeling in WebSphere and DB2,' Iyengar said. 'The use of EMF will increase within IBM and externally,' among members of the IBM-sponsored Eclipse.org organization, which oversees the Eclipse open-source development platform, he said..."
[June 10, 2003] "Java and the Model Driven Architecture." By Peter Varhol (Compuware Corporation). In JavaPro Magazine Volume 7, Number 6 (June 04, 2003), pages 40-41. ['Applications whose architectures are tied closely to supporting dynamic technologies don't have to become obsolete before their time. Employ MDA's core modeling techniques to separate architecture from implementation and extend the shelf life of distributed applications.'] "One software development error that has long-term ramifications, especially for large distributed applications, is that the application architecture is often written with a specific hardware and operating system set in mind. This situation may present no problem initially, but over time both hardware and operating systems change, often in unpredictable ways. Then there's other software you may depend on, such as the application server, browser, or database management system. In many cases, these applications tend to be even more dynamic than the underlying hardware and OS. The end result is that underlying technology changes often require significant changes in the application for it to continue working. In some cases, the architecture of the application is tied so closely to its supporting technologies that as these technologies change, the entire application has to be scrapped and redesigned. Enter MDA, the Model Driven Architecture. MDA is a way to separate the architecture of an application from its implementation. By doing so, its proponents hope that changes to supporting software and hardware won't render an otherwise still-useful enterprise application obsolete before its time. More important, by decoupling the application architecture from its execution environment, MDA could result in better designs that will have a longer useful life and can more easily be ported to other underlying platforms. As you might expect, MDA is based on the Unified Modeling Language (UML), along with the Meta-Object Facility (MOF) and Common Warehouse Metamodel (CWM). In addition, MDA consists of a few core models, or profiles -- for enterprise development and another for real-time development (real time in the sense that hardware/software systems must have predictable response times). Other core models will be developed and offered up as standards as time progresses. The entire MDA structure and process is a standard of the Object Modeling Group, the same standards body that maintains the CORBA and UML standards... UML lets developers work at a higher level of abstraction, while letting software do the detail work. In the past, this was good enough for producing generic code or for targeting a specific platform and set of underlying technologies. MDA represents the next stage in application development, one that promises to further improve the sometimes-chaotic process of building J2EE applications..."
[May 19, 2003] "Microsoft Courting OMG Again." By Darryl K. Taft. In eWEEK (May 12, 2003). "After years of bitter battles with the Object Management Group, Microsoft Corp. may be poised to rejoin the consortium to make use of the OMG's architecture expertise. Unisys Corp. has been brokering a thaw in the relationship between Microsoft and the Needham, Mass., standards body that had become strained while Microsoft was still a member of the group, said sources. The two sides effectively parted ways in the late 1990s over the OMG's support for Common Object Request Broker Architecture, which competed with Microsoft's Component Object Model for a standard distributed computing model. Sources said Microsoft is now warming up to the OMG because the Redmond, Wash., company is delving more into modeling and architecture work, two areas where the OMG holds key specifications and expertise -- in UML (Unified Modeling Language) and MDA (Model Driven Architecture). Microsoft has sponsored two four-day OMG Web services workshops this year, one in Munich, Germany, and one last month in Philadelphia, where Microsoft representatives gave presentations on services-oriented architectures and MDA issues. Unisys, a member of the OMG and a tight Microsoft integration partner, jointly presented with Microsoft. Their presentation was titled 'Microsoft 'Jupiter' and the Unisys MDA Process'... Microsoft supports UML today in its Visual Studio .Net Enterprise Architect edition, and sources said Microsoft plans to support MDA in Jupiter, the code name for its upcoming e-business suite and collaboration portal software. Another source close to Microsoft said the company is becoming more interested in model architectures because of the growing complexity in enterprise systems. The warming toward models and the OMG does not signal a total burying of the hatchet between the organizations. For instance, sources said Microsoft does not agree with everything the OMG does with MDA, such as automatic code generation..."
[September 10, 2002] "IBM Gears Up for Modeling." By Darryl K. Taft. In eWEEK (September 09, 2002). "IBM is readying new features for its open-source development platform that will speed application development, but what users are most intrigued by is planned full support for Model Driven Architecture. The support for MDA, which will be included in Eclipse Version 2.0 when it is released this fall, will enable developers to create applications based on models rather than hand coding, which also reduces cost. To make it happen, IBM will tap its EMF (Eclipse Modeling Framework) technology and incorporate it into Eclipse 2.0, according to company officials. MDA will be a core development technology for integrating tools with Eclipse. Eclipse currently includes limited support of MDA through plug-ins from Rational Software Corp., said Sridhar Iyengar, an IBM distinguished engineer with the company's Application and Integration Middleware group, in Raleigh, N.C. EMF, internal IBM technology the company uses in its WebSphere integration solutions, is a step above other options, which enable integration of tools and data only at the metadata and model levels, said Iyengar... Iyengar said the technology is key for users developing Web services and UML (Unified Modeling Language) and XML applications. Along with MDA support, Eclipse 2.0 will include a new plug-in design featuring wizards to ease deployment of Eclipse plug-ins; support for Sun Microsystems Inc.'s Java Development Kit 1.4; and enhanced team programming models to enable a team of developers to work together more easily using Eclipse. But support for MDA is the key, said Eric Newcomer, chief technology officer at Iona Technologies plc., a Web services and enterprise application integration products supplier... Rational -- which also licenses its modeling technology to Microsoft Corp. -- Hewlett-Packard Co. and Borland Software Corp. are among the growing number of development tool vendors that support MDA. In May, Sun introduced MDA support in its NetBeans open-source development platform..."
[September 30, 2002] "XML, The Model Driven Architecture (MDA), and RDF." By Uche Ogbuji (Fourthought, Inc). Paper presented at XML Europe 2002 (Barcelona, Spain). "These are exciting times for application development: in many ways there is a fundamental shift in how developer perceive of applications. And XML is one of the main axes of this re-conception. XML promises to give a powerful framework for dealing with semi-structured metadata in applications. At the same time, the Object Management Group (OMG) is shifting its world view to a focus on the abstract models that underlie computer applications. This new approach to development: the Model-Driven Architecture (MDA) promises to build a bridge from successful design technologies such as UML to the very concepts that underpin the uses we have for computers. The Resource Description Framework (RDF) is another technology positioned to change the way concepts are synthesized into applications, both in localized data-driven systems and in the future Semantic Web. This presentation will discuss how these three technologies come together to provide powerful patterns for solid and maintainable software design... The OMG acknowledges that this is an age where systems integration often occurs at Internet scope, and where 'virtual enterprises' often encompass the roles of multiple development with completely different chains of responsibility (for instance, each partner in a commerce supply-chain has to synchronize certain concepts according to contract, but develops separate software for doing this). Building on lessons from the pioneers of development within this expanded horizon, the OMG has developed the Model-Driven Architecture (MDA) as the method for projects in this new generation. The MDA separates the fundamental understanding of concepts in development projects from the respresentation of these concepts for particular implementations technologies. This means even separating this abstract modeling layer from the object-oriented orthodoxy, which has been the bedrock of the OMG in the first place. Basically, the OMG is admitting that no model tainted with implementation considerations can survive the disjoint between multiple development groups, or different processing environments, as are common in Internet integration and establishing vertical alignment. The UML, despite its most common use in object-oriented modeling, is designed to be a much broader modeling language, and has been put to the test in at least one very prominent Internet-scale model that requires far more sophistication that mere objects do not approach. The Common Information Model (CIM), which models concepts related to the management of technological assets, is expressed in a UML that would probably be entirely alien to most developers, and this flexibility of UML is what the OMG uses to justify its being the language of the most abstract modeling under the MDA. This paper will take a brief look at how XML, RDF and MDA come together to revolutionize modeling for software development..." Also available in PDF format.
[May 07, 2002] "MDA Brings Standards-Based Modeling to EAI Teams." By Tushar K. Hazra. In Application Development Trends Volume 9, Number 5 (May 2002), pages 48-52. ['Application Integration & Management. Model-Driven Architecture is based on UML, MOF and CWM standards. Its creator, the OMG, promises the new modeling standard will evolve to follow and incorporate more standard technologies.'] "The Model-Driven Architecture (MDA) is an innovative approach to constructing an enterprise architecture. Created by the Object Management Group (OMG), MDA abstracts and visualizes business requirements in the form of platform- and implementation technology-independent models, and separates implementation details from business functions. Once interfaces are identified and implementation technologies are selected, models are transformed into platform-specific software architectures. MDA is a new software architecture principle in the sense that it follows, incorporates or supports most industry standards. It enhances the capability of the software architecture to be flexible, extensible and adaptable to new technologies or standards, and to abstract business application components in the early stages of EAI initiatives. Most importantly, MDA enables business experts and software engineers to focus on business risks, issues and concerns, ensuring the effective use of existing and evolving technologies. As described by the OMG, MDA is founded on three established modeling standards -- the Unified Modeling Language (UML), Meta-Object Facility (MOF) and the Common Warehouse Meta-model (CWM). UML is widely accepted and supported by the software industry as a standard modeling notation, and most modeling tool vendors comply with it. EAI initiative teams of any size can share UML-based visual models across platforms. MOF and CWM allow users to capture a specific domain, data warehousing-related information or meta data in UML-based models. With the help of appropriate tools and repositories, EAI teams can exchange and transform the models to define, design and implement desired interfaces independent of a specific platform. As a next step, OMG standard mappings support the generation of CORBA, XMI/XML, J2EE, .NET and Web services-based interfaces. The interfaces can utilize various pervasive services such as directory, transactions, events and security services to build enterprise software architectures. At present, MDA targets space, manufacturing, finance, e-commerce, telecom, healthcare and transportation industry-related EAI initiatives and promises to cover more soon..."
[May 07, 2002] "Sun Hails Open-Source Meta Data Repository." By Paul Krill. In InfoWorld (May 07, 2002). "Sun Microsystems on Tuesday [2002-05-07] plans to announce that it has contributed meta data repository modules to the NetBeans open-source development project as part of the Object Management Group's MDA (Model Driven Architecture) effort. The repository can, for example, assist in the development of Web services applications by enabling developers to quickly locate objects to be fitted with SOAP (Simple Object Access Protocol) interfaces, according to Sun. CORBA and other infrastructure standards also can be supported. The NetBeans open-source project is a Java-based effort that is being positioned as a compliant solution for the MDA specification. The OMG MDA is designed to protect software investments by providing a framework in which application infrastructure components, such as databases and programming languages, can be changed without requiring enterprises to change their underlying application architecture. A meta data repository, which can hold information about programming objects so they can be reused, is critical to supporting the MDA, said Drew Engstrom, product line manager for Sun's ONE Studio tools, in Menlo Park, Calif. "When an organization is doing object-based development, typically you end up with a library of hundreds of objects," Engstrom said. The meta data repository is expected to be included in an upcoming version of the NetBeans IDE (integrated development environment), to be known as build 4.0, in six to eight months, according to Engstrom. It has been available in an experimental mode, according to Sun... Other companies that have submitted MDAs include IBM, with WebSphere, and Rational, with XDE..." See the Sun announcement: "Netbeans: First Open Source Tools Platform to Implement Model Driven Architecture (MDA). MDA to Simplify Implementation of Web Services by Separating Architecture from Deployment Infrastructure."
[May 03, 2002] "Modeling XML Applications. Part 2." By Dave Carlson (Ontogenics Corp., Boulder, Colorado). In Software Development Magazine (April 2002). "Models are an essential part of system analysis and design, be they specified in UML or defined by the structure of software artifacts such as XML schemas. However, models that are tied too closely to today's deployment technology may be short-lived. If your company decides to switch from J2EE to Microsoft's .NET, will your system's design survive the migration? The answer is yes, if you build in resilience from the start by using a model-driven architecture (MDA). MDA enables a separation of domain models from specific deployment platforms... Let's examine an MDA in which a generic purchase-order specification is refined into two platform-specific models (PSMs) for deployment, one to XML Schema and the other to an Oracle database. Platform-independent models (PIMs) are the cornerstone of distributed systems. Otherwise, without a shared domain model, similar concepts must be designed for each platform, and then those implementations must be synchronized and integrated -- the classic headache when dealing with legacy systems... My preferred approach for mapping between a PIM and a PSM for XML Schema is to define a UML profile that adds XML-specific definitions to a UML model. With this method, the only difference between a PIM and PSM is the addition or subtraction of UML profile information, which is composed of stereotypes and tagged value properties that extend the core UML metamodel for XML design. When reverse-engineering a previously defined XML Schema to UML, I create a logical domain model that includes profile definitions required to re-create an equivalent schema. The PSM may not be structurally identical to the schema (for example, a child element in XML may be mapped to a UML attribute), but the profile stereotypes and tags capture this difference. Then, to create a PIM, I simply remove the XML-specific profile information from this view in UML. In an alternative approach, I define a PSM that is structurally identical to the implementation language. In a relational database, the PSM includes a one-to-one correspondence between classes in UML and tables in the database. The platform-specific model in UML also includes attributes for all primary and foreign keys, and separate classes are included for many-to-many associations. However, this PSM may not represent the good conceptual-level view desired for a PIM domain model. A conceptual view should be close to the terms and structure used by human experts, whereas the PSM must conform to the implementation language. So, to map between the PIM and PSM using this approach, the UML classes and relationships may require significant structural transformation, in addition to the use of a UML profile. This second approach is used by the Rational Rose UML modeling tool for both database modeling and DTD modeling. Rose does not yet include support for XML Schemas. In the case of the Rose PSM for DTD design, each child element in the XML structure is represented as a first-class object in UML, even if it represents a simple string value. To create a PIM from a reverse-engineered model, the PSM must be transformed to a more logical object-oriented structure. As a result, the PIM and PSM are two completely separate model instances, or possibly two packages within a parent model... In my next two articles in this series, we'll continue the discussion of these transformation techniques for XML."
[April 30, 2002] "Object Management Group Meets in Yokohama, Japan. Advances Modeling and Biotechnology Standards. Members Also Charter Real-Time and Embedded Systems Task Force." - "Members of the Object Management Group (OMG) met in Yokohama, Japan, from April 22 through April 26, 2002 at a meeting sponsored by the Distributed Objects Promotion Group (DOPG), an organization of fifteen Japanese vendors of distributed computing technology. Application modeling standards, used in every computing discipline, form the foundation of OMG's specification suite. At this meeting OMG members initiated adoption of a modeling infrastructure standard that will define metamodels for Queries, Views, and Transformations in the revised 2.0 version of the Meta-Object Facility (MOF). Also at this meeting, the group formally adopted a new specification standardizing a representation for Gene Expression in distributed biotechnology applications. Defined in OMG's new Model Driven Architecture (MDA), the Gene Expression specification is specified as a Unified Modeling Language (UML) model, which defines an XML DTD (Document Type Definition) along with conforming data structures in the programming languages Java and C++. ... With well-established standards covering software from design, through development, to deployment and maintenance, the Object Management Group (OMG) supports a full-lifecycle approach to enterprise integration. Based on the established Object Management Architecture (OMA) and emerging Model Driven Architecture (MDA), OMG's standards cover application design and implementation. OMG's Modeling standards include the UML (Unified Modeling Language) and CWM (Common Warehouse Metamodel). CORBA, the Common Object Request Broker Architecture, is OMG's standard open platform. OMG also issues the CORBAservices and a rapidly-growing set of industry-specific standards in vertical markets including healthcare, telecommunications, biotechnology, transportation and a dozen other areas. The OMG is headquartered in Needham, MA, USA, with an office in Tokyo, Japan as well as international marketing offices in the UK and Germany, along with a U.S. government representative in Washington, DC."
[February 7, 2002] "Object Management Group Charters MDA Infrastructure Task Force. Adopts First MDA-based Domain Standard." - "Members of the Object Management Group (OMG) gathered in Anaheim, CA, USA from January 28 through February 1, 2002 at a meeting co-sponsored by Hewlett-Packard Company and the Borland Software Corporation.A key development was the formation of the Middleware and Related Services (MARS) Platform Task Force (PTF) to adopt infrastructure and services standards in the Model Driven Architecture (MDA). The new task force will standardize both object-oriented and message-oriented request broker technology, as well as Pervasive Services for the multiple middleware platforms supported by the MDA including Web Services, Enterprise JavaBeans, and XML/SOAP, in addition to OMG's vendor-independent middleware platform, the Common Object Request Broker Architecture (CORBA). The MARS PTF replaces the Object Request Broker and Object Services (ORBOS) PTF, whose scope was restricted to CORBA. Members also chartered the Business Enterprise Integration (BEI) Domain Task Force, which will adopt MDA-based standards for integration in general business and electronic commerce... At this meeting, the Life Science Research (LSR) Domain Task Forces (DTF) completed member evaluation and started the final adoption vote on OMG's first MDA-based domain specification. The Gene Expression Representation and Exchange Standard is based on a model built in the Unified Modeling Language (UML). In the MDA, this platform-independent base model is used to generate equivalent versions of the standard on one or several middleware platforms, as needed by the industry that uses it. LSR DTF members selected the popular data language XML as the best platform for the Gene Expression standard, defining it as a set of DTDs. Under the MDA, OMG standards are not restricted to any single platform -- each can be defined and implemented on the platform or platforms best suited for it, and its industry. The LSR DTF also issued a Request for Proposals (RFP) initiating work on a new specification to manage biochemical samples..."
[October 05, 2001] "Meta Data Conundrum Carries On." By Richard Adhikari. In Application Development Trends Volume 8, Number 10 (October 2001), pages 49-53. [Data Management Feature Article.] "A new approach to managing meta data currently in the works will free CIOs from having to cope with constantly changing technological standards. The Needham, Mass.-based Object Management Group (OMG) is leading work on this approach with the support of major software vendors, including IBM, Sun Microsystems and Oracle. The new approach consists of a model-driven architecture that will transcend individual technologies so it will be valid even when underlying technologies change. To create the new architecture, its builders have expanded the meaning of meta data. They are also leveraging the object-oriented paradigm so that corporations can create reusable meta data objects from data about their existing resources -- including computer languages, file systems and software architecture--by wrapping the data with Extensible Markup Language (XML) descriptions. The new architecture will be the sole enterprise meta data management standard available because the OMG merged last year with another standards body, the Meta Data Coalition, whose efforts were built around Microsoft's Open Information Model (OIM), and OMG is merging OIM-based work with its own. But XML is fragmented, and pulling together cross-industry definitions is a Herculean task... While it does not matter which language the meta data is expressed in, XML has become the language of choice because it is a good means of transmitting data between different systems. One example of leveraging XML meta data wrappers is an application created by custom software developers Interface Technologies Inc., Raleigh, N.C., for a Boston-based client. The client, startup firm Virtual Access Networks, wanted an application that would help end users migrate personalization data such as bookmarks and address books from their existing desktop systems to new ones during upgrades. Normally, such data is not migrated during hardware or operating system upgrades... UML is a common modeling language for application development and it is an OMG standard. It was extended to create an object-oriented meta data standard, Meta Objects Facility (MOF). MOF consists of the core OO model from the Unisys repository, Urep, which was integrated with UML. MOF lets developers build meta data for the various domains in a consistent, object-oriented fashion, Brodsky said. IBM and other major vendors are working with the OMG to standardize these key meta data domains by creating models of the type of information to be obtained from the domains. The OMG's new approach will take meta data management to the next level. Called the Model-Driven Architecture (MDA), it is being built around MOF and UML. Until August 2000, there were two meta data management standards: the OMG's Common Warehouse Metamodel, and the Meta Data Coalition's Object Information Model (OIM), which was created by Microsoft. At the end of August, the OMG and Meta Data Coalition merged, and OIM is being subsumed by CWM. CWM is built on UML, XML and XMI. It establishes a common meta model (a model about models) for warehousing and also standardizes the syntax and semantics needed for import, export and other dynamic data warehousing operations. CWM supports data mining, transformation, OLAP, information visualization and other end user processes. Its specifications include application programming interfaces (APIs), interchange formats and services that support the entire life cycle of meta data management, including extraction, transformation, transportation, loading, integration and analysis... A whole slew of standards revolve around MDA. There is MOF, which lies at the core of MDA. Then there is the Java Meta data Interface (JMI), a mapping from MOF to Java. Because MOF is an abstract model, there are also mappings from MOF to XML and Interface Definition Language (IDL), an OMG standard for any CORBA environment, similar to Microsoft's and DCE's IDLs. MOF is an extension of UML; it ties in with CWM, which includes OIM. MOF will be integrated with J2EE, and a New York-based company called MetaMatrix is 'the first company that said they will do this integration,' Iyengar said. JMI will be integrated with J2EE..."
[September 21, 2001] "OMG Members Meet in Toronto, Charter Web Services Special Interest Group. Multiple Activities Advance Model Driven Architecture Specifications." - "...OMG's Unified Modeling Language (UML), which provides the basis for the MDA, is currently undergoing a major upgrade to Release 2.0. At this meeting, OMG members evaluated proposals for two parts of this new release: UML Infrastructure, and the Object Constraint Language. These proposals will be revised over the next several months to take into account member comments, and then presented at a future meeting for re-evaluation and subsequent adoption. The remaining parts of the revision, UML Superstructure and Diagram Interchange, will be evaluated at OMG's next meeting in Dublin, Ireland, to be held during the week of November 9, 2001. Of the five new specifications which passed final member evaluation and started the adoption vote process at the meeting, three enhance OMG's modeling specifications: one tailors the UML to Enterprise Distributed Object Computing; another adds the ability to model scheduling for real-time computing systems, while the third enables XMI, OMG's XML-based model interchange language, to take advantage of the W3C's new XML schema definition. Two additional specifications enhance OMG's vendor-independent middleware specification, the Common Object Request Broker Architecture (CORBA), in key areas: One defines a facility to manage membership in security domains, while the other provides air traffic control systems with a standard facility to manage surveillance of aircraft... The OMG initiates the process that defines new standards by issuing a Request for Proposals (RFP). At this meeting, members issued two RFPs to enhance CORBA: One will define a procedure and set of interfaces for online upgrades, standardizing the way CORBA systems provide 7X24 service without interruption for software upgrades; the other will standardize an MDA-based publish-subscribe data distribution service for real-time CORBA systems. Any company may join OMG and submit in response to an RFP. These and all other active RFPs may be accessed from the web page www.omg.org/schedule. Membership information appears at www.omg.org/membership. Dates and locations of future meetings are listed on www.omg.org/news/schedule/upcoming.htm..."
[August 14, 2001] "The House That CORBA Built." By Paul May. In Application Development Advisor Volume 5, Number 5 (June 2001), pages 30-32. ['The OMG's Corba hasn't been talked about much recently, outside of mission-critical developments in key vertical markets. But now, explains Paul May, the organisation is trying to reposition itself at the centre of interoperability with the Model Driven Architecture.'] "The OMG has introduced a newly rationalised context called Model Driven Architecture (MDA). This initiative is designed to provide a framework for integrating new applications with older, legacy software, using key modelling standards including the Unified Modelling Language (UML), the Meta Object Facility (MOF) and the Common Warehouse Metamodel (CWM) at its core. These modelling standards will be middleware-independent, meaning that they can hook into, say, Corba, XML or Java. With this 'one size fits all' approach, the OMG is promoting MDA as an all-embracing standards framework for application development, relying on UML's authority as much as its containment of Corba. The move is a shrewd one, opening up new vistas for the OMG; MDA provides an ongoing context for Corba, while designating it as just one of many potential infrastructure layers. In this way, it can keep itself involved in new developments, such as the burgeoning Web services market... While the OMG's original impact on the software industry derived from the Corba standard's role in the middle tier, with the MDA launch, the body is promoting itself as a broader standards-setting group for the systems development community. MDA is a forward and backward-looking systems development and integration strategy, designed to reduce developers' dependency on any one product type, vendor or platform which supports XML-based languages. One example is XMI (XML Metadata Interchange), an XML standard that enables analysts and designers to exchange modelling information. These domain-specific XML standards are appearing widely. Developers throughout the industry are embracing XML as an elegant, efficient base technology for expressing semantics of all kinds, from engineering specifications to online monetary transactions. XMI was inspired by practitioners and UML can be seen as the result of practitioner pressure for a standard modelling approach in the face of previous industry confusion. The confusion was all the more frustrating when the analysis and design gurus at the heart of the modelling movement tended to disagree with each other more than they agreed." [cache]
[May 09, 2001] "Model-Driven Architecture: Vision, Standards And Emerging Technologies." By John Poole (Hyperion Solutions Corp). April 2001. ['A paper submitted to ECOOP 2001 Workshop on Metamodeling and Adaptive Object Models. It discusses the MDA standards (including CWM), current Java platform initiatives, and they could ultimately be used to build totally dynamic systems.'] "Recently, the Object Management Group introduced the Model-Driven Architecture (MDA) initiative as an approach to system-specification and interoperability based on the use of formal models. In MDA, platform-independent models (PIMs) are initially expressed in a platform-independent modeling language, such as UML. The platform-independent model is subsequently translated to a platform-specific model (PSM) by mapping the PIM to some implementation language or platform (e.g., Java) using formal rules. At the core of the MDA concept are a number of important OMG standards: The Unified Modeling Language (UML), Meta Object Facility (MOF), XML Metadata Interchange (XMI), and the Common Warehouse Metamodel (CWM). These standards define the core infrastructure of the MDA, and have greatly contributed to the current state-of-the-art of systems modeling. As an OMG process, the MDA represents a major evolutionary step in the way the OMG defines interoperability standards. For a very long time, interoperability had been based largely on CORBA standards and services. Heterogeneous software systems inter-operate at the level of standard component interfaces. The MDA process, on the other hand, places formal system models at the core of the interoperability problem. What is most significant about this approach is the independence of the system specification from the implementation technology or platform. The system definition exists independently of any implementation model and has formal mappings to many possible platform infrastructures (e.g., Java, XML, SOAP). The MDA has significant implications for the disciplines of Metamodeling and Adaptive Object Models (AOMs). Metamodeling is the primary activity in the specification, or modeling, of metadata. Interoperability in heterogeneous environments is ultimately achieved via shared metadata and the overall strategy for sharing and understanding metadata consists of the automated development, publishing, management, and interpretation of models. AOM technology provides dynamic system behavior based on run-time interpretation of such models. Architectures based on AOMs are highly interoperable, easily extended at run-time, and completely dynamic in terms of their overall behavioral specifications (i.e., their range of behavior is not bound by hard-coded logic). The core standards of the MDA (UML, MOF, XMI, CWM) form the basis for building coherent schemes for authoring, publishing, and managing models within a model-driven architecture. There is also a highly complementary trend currently building within the industry toward the realization of these MDA standards in the Java platform (i.e., standard mappings of platform-independent models to platform-dependent models, where the platform-dependent model is the Java platform). This is a sensible implementation strategy, since development and integration is greatly facilitated through common platform services and programming models (interfaces or APIs), provided as part of the Java platform. Java 2 Platform, Enterprise Edition (J2EE), has become a leading industry standard for implementing and deploying component-based, distributed applications in multi-tier, Web-centric environments. Current efforts within the Java Community Process to develop pure Java programming models realizing OMG standards in the form of J2EE standard APIs (i.e., JMI, JOLAP and JDMAPI) further enhance the metadata-based interoperability of distributed applications. This paper surveys the core OMG MDA standards (i.e., UML, MOF, XMI and CWM) and discusses the current attempts at mapping these standards to J2EE, as examples of PIM-to-PSM translations that are currently under development. These forthcoming APIs will provide the initial building blocks for a new generation of systems based on the model-driven architecture concept. The progression of these initial MDA realizations to AOMs is the next logical step in this evolution." [cache]
[July 23, 2001] "OMG Standards Efforts Moving to New Model Driven Architecture. Members Adopt CAD Services and Laboratory Equipment Control Specifications, Enhance CORBA." - "The Object Management Group's (OMG) latest Technical Meeting Week, sponsored by IONA, attracted about 600 OMG members and guests to Danvers, MA, USA, north of Boston, where they advanced the organization's standards efforts and participated in other related activities. At this meeting, OMG members moved to adopt the Model Driven Architecture (MDA) as the group's base architecture in which future standards will be defined. In the MDA, a specification starts out as a Platform-Independent Model (PIM) defined in UML; from it, MDA-based development tools produce platform-specific models and implementation definitions on multiple platforms. This allows MDA to support application portability and interoperability across a wide range of middleware platforms, and extends OMG's reach beyond CORBA to such platforms as Enterprise Javabeans (EJB), XML/SOAP, .Net, and others. MDA business benefits include: (1) Full support throughout the application life-cycle; (2) Reduced costs from beginning to end; (3) Reduced development time for new applications; (4) Best possible representation of business rules, the foundation of every application; (5) Scalability, robustness, security, implemented in the best possible manner; (6) Stable, model-based approach extends usable application lifetime and thereby maximizes ROI from software investment; (7) Smooth integration across middleware platform boundaries; (8) Rapid inclusion of emerging technologies into existing systems. OMG members completed technical work on seven new specifications. Two of these new specifications come from OMG's Domain Technology Committee (DTC), which defines computing standards for specific industries. The DTC defined a Computer Aided Design (CAD) Services standard for manufacturing, and a set of Laboratory Equipment Control interfaces. Spearheaded by OMG's Life Science Research Domain Task Force, the Laboratory Equipment Control interfaces will be useful in laboratories everywhere. OMG's Platform Technology Committee (PTC) adopts infrastructure and modeling specifications. It is standardizing an extension to CORBA for load-balanced processing in data parallel programs, a dynamic scheduling service for Realtime processing, and a multicast protocol for delivery of events in distributed systems. CORBA security, already well developed, gets a new standard for Security Domain Membership, and the OMG's modeling specification suite adds a metamodel and UML profile for Software Process Engineering... OMG members initiated a new technology adoption by issuing a Request for Proposals (RFP), stating requirements and deadlines. In Danvers, OMG members issued four new RFPs: The DTC issued one RFP, which will standardize Telemetric and Command Data handling for space and ground-based systems. The PTC issued two RFPs that will enhance CORBA: One, coming out of the Telecommunications Domain Task Force, will define interworking between the CORBA Notification Service and the Java Messaging Service (JMS); the other will update the mapping to the well-established language C to include valuetypes and other recently-added enhancements. A third PTC RFP will define a UML profile supporting software testing, allowing this important capability to be defined into an application at the model... A workshop on Objects in Bio- and Chem-Informatics (OiBC) attracted over 175 attendees. OMG members viewed live demonstrations of eleven different CORBA products, and attended tutorials on CORBA, the Object Management Architecture, XML in CORBA systems, the Unified Modeling Language (UML), and UML modeling of Real-time systems... For more information about the MDA, see www.omg.org/mda.
