Irv Badr, IBM, USA
Flexibility, scalability, power consumption, and in the case of consumer devices, an optimized user-experience are main requirements posed by tomorrow’s real-time and embedded systems. System scalability and flexibility are key factors in fast-time-to-market and allow manufacturers and service providers to be competitive. Executable models and virtualization techniques become a vital part of the workflow used in software development for scalable parallel hardware architectures
Alex Henri, BLU AGE
Abstract: Since the process of Java EE or .NET business application generation is 100% automated using MDD approach, the question of OO and non OO legacy modernization can be seriously considered. The purpose of this session is to present an overview of advanced techniques implementation such as KDM and ADM. These techniques combined with integrated M2M and M2T mechanisms under Eclipse, allow PIM extractions from legacy applications. Extracted models can be then used to generate automatically Java EE or .NET pure code, and to update customized business processes evolutions. During this session we will demonstrate a successful modernization experience from VAP Cobol legacy application into Java EE web based application.
Frank Wille, Novulo
The trend of creating higher abstraction levels in software development has moved to the next step with Model Driven Development. Higher productivity, better quality, and easier maintenance are already well-known advantages, as well as simplifying the communication process. However, do our model presentations foster effective communication with the business users? Can we be certain that presenting a UML diagram or a data model to business stakeholders will allow them to confirm that it fits their specific needs?
At Novulo, we believe that the gap between business and IT is not bridged by MDD in its current form. Rather, by providing a no-nonsense and fully graphical presentation of UI, conditions and workflows in the model, and by facilitating the dependencies of data modeling and application modeling, we have created a new means of communicating productively with business stakeholders in the modeling phase.
Gil Segal, SAPIENS
The Sapiens environment demonstrates the large productivity benefits delivered when a modern Model-Driven Development (MDD) tool is coupled with an event-driven Business Rule Engine (BRE) and with a Rich Internet Application (RIA) engine. eMerge tools enable rapid prototyping and iterative development of rich Internet applications, all driven from enterprise models. The combination of MDD with an Event-Driven Architecture (EDA) yields exceptionally flexible middleware. In this session we will demonstrate the use of enterprise models to rapidly develop and deploy a small application and we will show unique UML models encompassing both the logical data structure and business logic of the application.
Andrei Kirshin, IBM Haifa Research Lab, ISRAEL
This talk presents the work that is being done in IBM Haifa Research Lab in the area of Model Driven Engineering (MDE). The talk contains three parts: Model-based Testing, Product Lines Engineering, and Telco Service Creation Environment.
Model-based Testing: Model-based Testing already proved itself as a methodology that improves effectiveness and efficiency of testers. We developed a tool suite that leverages the power of UML and enables automatic test generation based on behavioral system models, debugging of such models and manual test editing.
Product Lines Engineering: Product Lines Engineering is rapidly emerging as an important paradigm, allowing order-of-magnitude improvements in time to market, maintenance cost, quality, and mass customization support. Our tools and methodologies facilitate software reuse, support integration of suppliers’ components in the supply-chain domain, and enabling transformations into various product artifacts.
Telco Service Creation Environment: Our work describes a model based approach for rapid creation of Next Generation Networks Services. Our tooling enables designers to create models of such services without knowledge of the underlying protocols and to generate runnable services from them without additional code being written.
Philippe Desfra., ModelioSoft
Abstract: Modelio (www.modeliosoft.com) is a modeling tool addressing both Business and IT, that supports IS to business alignment. The MDA technology has been too much focused on software aspects, mainly on code generation or technical architecture aspects. MDA must be much more used to support methodologies and sustain modeling on the entire enterprise scope. This paper presents how, by integrating in a single repository the entire enterprise scope modeling coverage, by providing strong MDA capacities and by allowing an efficient and flexible distributed team cooperation, Modelio allows a global MDA approach, empowering thus MDA to the enterprise wide application
Danilo Beuche, pure-systems, Germany
In this demonstration the integration of pure::variants, a leading tool for variant management in (software) product lines (SPL), and model driven development (MDD) environments will be shown. The pure::variants framework currently integrates with tools suites for development of domain specific modeling languages (e.g. openArchitectureWare), generic modeling languages (UML e.g. Enterprise Architect) and domain specific modeling tools (e.g. MATLAB/Simulink).
The demonstration will briefly cover pure::variants basics such as feature modeling and will then show some use cases with SPL MDD approaches.
Andrey Sadovykh, Shape
We present the SHAPE project tool set dedicated to Model Driven Engineering (MDE) methodology for Service Oriented Architectures (SOA) and Semantically-enabled Heterogeneous service Architectures (SHA).
Arnaud Cuccuru, CEA LIST, France
MDA is with no doubt a very good paradigm to support company teams all over the design and development process of software systems. This approach can be even more effective if tooling support is close to process practices and concepts used in application domains. This was one of the main motivations at the origin of Papyrus UML. This toolset is a general purpose UML2 graphical modeler (http://www.papyrusuml.org/). Its main strength besides its strong compliance to UML 2 relies on its ability to exploit all the expressive power of advanced profiles management including static profiles to achieve cutting edge customization leading not only to profile storage and application but really to tool customization for domain specific applications. In the presentation, we illustrate this feature of the tool on a customization example to support EAST-ADL, an architecture description language for automotive. In a second part, we show how MARTE profile can be used to annotate models with temporal constraints and perform schedulability analysis at an early stage of modeling. Finally, we present code generation facilities.
Patrick Mäder, Ilmenau Technical University, Germany
We will present the core functionality of traceMAINTAINER, a prototype tool that enables the semi-automated maintenance of traceability relations held between different models of software systems expressed in UML. The demonstration will cover: how traceMAINTAINER integrates with UML modeling tools, such as Enterprise Architect; how traceability updates are handled based upon the recognition of development activities; what happens when decisions about a traceability update cannot be made fully automatically; and how to tailor the rules that guide the traceability maintenance process.
Thomas Goldschmidt, FZI Research Center for Information Technology Karlsruhe - SAP, Germany
Building views on abstract models is one of the key concepts of model-driven engineering. Different views help to present concepts behind a model in a way that they can be understood and edited by different stakeholders or developers in different roles. Within graphical modeling several approaches exist allowing the definition of explicit holistic, partial or combined graphical views for models. On the other hand several frameworks that provide textual editing support for models have been presented over recent years. However, the combination of both principals, meaning textual, editable and decorating views is lacking in all of these approaches. In this presentation, we show FURCAS (Framework for UUID Retaining Concrete to Abstract Syntax Mappings), a textual decorator approach that allows to separately store and manage the textual concrete syntax from the actual abstract model elements. Thereby we allow to define textual views on models that may be partial and/or overlapping concerning other (graphical and/or textual) views.
Alexander Broekhuis (luminis) and Jeroen Kouwer (Thales)
Thales-luminis, The Netherlands
Thales radar systems are highly complex and demanding products. These distributed real-time systems are modeled on heterogeneous platforms with multiple technologies (languages, RTOSes and protocols). A typical radar system consists of more than 50 boards and processes data at a rate over 140 Mbytes per second.
This presentation is aimed on sharing the experiences of a model-driven approach to the software development of radar systems. Technical experiences on defining correct meta-models, model validation through the use of OCL and writing proprietary transformation rules. Important success factors in introducing MDA in the Thales software development process will be discussed. Such as the use of modeling guidelines, first level support and experience exchange meetings.
Within Thales the first step of introducing software development based on MDA is aimed on: the modeling of system structure, data communication between distributed software components and the mapping of software on specific hardware components. Using an Eclipse based tool chain UML models are validated through the use of OCL and transformed to XML. Finally code is generated in the form of component specific interfaces and technology specific optimized code for the target hardware platforms.
Used tools and technologies: openArchitectureWare, Eclipse Modeling Framework, UML 2, QVT, OCL. The audience is expected to be familiar with: UML, XSD/XML and MDA principles in general
T. Margaria, C. Kubczak,
TU Dortmund & Universität Potsdam, Germany
eXtreme Model-Driven Design (XMDD) is a new development paradigm designed to continuously involve the customer/application expert throughout the whole system's life cycle. In technical practice, user-level models are successively enriched and refined from the user perspective, until a sufficient level of detail is reached, at which elementary services can be implemented that solve tasks at the application level. The realization of the individual services should be typically simple: they are often based on functionality provided by third-party and by standard software systems. We demonstrate jABC, a flexible framework designed to support systematic development according to the XMDD paradigm. jABC allows (end-)users to develop service-oriented systems by composing reusable building blocks into flow graph structures. As a case study we present a heterogeneous service mashup that makes extensive use of today's service technologies like REST or Web services. Furthermore we introduce a temporal logic-based synthesis approach that automatically delivers process flows that conform to declarative formal specifications on the basis of semantic information annotated to the service components.
TU Dresden, Germany
Textual Syntax (TS) as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. In this demo we present EMFText, an EMF/Eclipse integrated tool for TS development, where we focus on its abilities to generate re_neable default syntaxes and handling of large languages, e.g. Java., with EMFText.
Cyril Ballagny, LIUPPA, University of PAU, France
We describe MOCAS (Model Of Components for Adaptive Systems), a state-based component model which enables the self-adaptation of software components (behavior, implementation, properties) together with their coordination. A MOCAS component has its structure constrained by an UML profile. It embeds an UML state machine to realize its behavior at runtime. MOCAS relies on three different tools: a plug-in of the Eclipse-based TopCased platform for modeling MOCAS components and generating Java code, a engine for executing UML state machines running on the top of the Eclipse modeling framework (EMF) and an administration platform for managing MOCAS components.