Search

In Software Engineering many text-based languages and supporting tools are used, forming the grammarware technical space. Currently model driven engineering is the new emerging paradigm for software engineering, which uses modelling languages and tools, forming the modelware technical space. Transition to the new technical space and interoperability between these two technical spaces is needed in many development scenarios. Building a bridge between these two technical spaces is a tedious task, that has to be repeated for each language to be transformed. Therefore, we propose a generic bridge between grammarware and modelware technical spaces, that can generate a specific bridge based on the EBNF of a given language semi-automatically. The generation comprises of two steps, (1) automatic generation of metamodel corresponding to the EBNF and (2) annotations to provide the additional semantics not captured by the EBNF. The generated bridge is capable of bi-directional transformations between sentences (programs) and corresponding models and can be used in re-engineering applications and for integration of text-based and model-based tools. [ABSTRACT FROM AUTHOR]

Model-Driven Engineering is a form of generative engineering, by which all or at least central parts of a software application are generated from models. Model Driven Engineering should be seen as an integrative approach combining existing software engineering techniques (e.g., testing and refinement) and technical spaces (e.g., 'ModelWare', 'XmlWare') that have usually been studied in separation. The goal of the workshop is to improve common understanding of these techniques across technical spaces and create bridges and increase the synergies among the spaces. This year's WiSME workshop will concentrate on two complementing themes: Bridging Technical Spaces and Model-Driven Evolution. This paper reports on a workshop held at the 8th UML/MoDELS conference. It describes motivation and aims, organisational issues, and abstracts of the accepted papers. [ABSTRACT FROM AUTHOR]

We present Tefkat, an implementation of a language designed specifically for the transformation of MOF models using patterns and rules. The language adopts a declarative paradigm, wherein users may concern themselves solely with the relations between the models rather than needing to deal explicitly with issues such as order of rule execution and pattern searching/traversal of input models. In this paper, we demonstrate the language using a provided example and highlight a number of language features used in solving the problem, a simple object-to-relational mapping. [ABSTRACT FROM AUTHOR]

Model Transformations in Practice (MTiP) 2005 was a workshop which provided a forum for the model transformation community to discuss practical model transformation issues. Although many different model transformation approaches have been proposed and explored in recent years, there has been little work on comparing and contrasting various approaches. Without such comparisons, it is hard to assess new model transformation approaches such as the upcoming OMG MOF/QVT recommendation, or to discern sensible future paths for the area. Our aims with the workshop were to create a forum that would help lead to an increased understanding of the relative merits of different model transformation techniques and approaches. A more advanced understanding of such merits is of considerable benefit to both the model transformation and wider modelling communities. [ABSTRACT FROM AUTHOR]

This paper presents ATL (ATLAS Transformation Language): a hybrid model transformation language that allows both declarative and imperative constructs to be used in transformation definitions. The paper describes the language syntax and semantics by using examples. ATL is supported by a set of development tools such as an editor, a compiler, a virtual machine, and a debugger. A case study shows the applicability of the language constructs. Alternative ways for implementing the case study are outlined. In addition to the current features, the planned future ATL features are briefly discussed. [ABSTRACT FROM AUTHOR]

Aspect oriented design (AOD) research is fragmented. Barriers to AOD adoption are, in part, due to this fragmentation. Individually, many approaches provide elegant solutions to subsets of particular key issues related to AOD. Collectively, a significant set of these issues are addressed. We propose integrating existing AOD approaches through a generic AOD process. It is our intuition that such integration will consistently address the issues relevant to AOD. [ABSTRACT FROM AUTHOR]

Crosscutting concerns are pervasive in embedded software, because of the various constraints imposed by the environment and the stringent QoS requirements on the system. This paper presents a framework for modularizing crosscutting concerns in embedded and distributed software, and automating their composition at the modeling level, for simulation and validation purposes. The proposed approach does not extend the semantics of the UML in order to represent aspects. Rather, it dedicates a metamodel to the representation of the composition semantics between aspects and core models. The paper illustrates this approach by presenting a model weaver for SDL statecharts developed at Motorola Labs. Crosscutting behavior is designed with plain SDL statecharts and encapsulated into modules called aspect beans. The weaver looks at the aspect beans and the core SDL statecharts from a perspective that is defined by lightweight extensions to the SDL and UML metamodels. A connector metamodel defines the structure of the aspect-to-core binding definition. Finally, a weaver behavioral metamodel defines composition primitives for specifying weaving strategies. [ABSTRACT FROM AUTHOR]

This report summarizes the outcome of the 7th Workshop on Aspect-Oriented Modeling (AOM) held in conjunction with the 8th International Conference on Model Driven Engineering Languages and Systems - MoDELS 2005 - in Montego Bay, Jamaica, on the 2nd of October 2005. The workshop brought together researchers and practitioners from two communities: aspect-oriented software development (AOSD) and software model engineering. It provided a forum for discussing the state of the art in modeling crosscutting concerns at different stages of the software development process: requirements elicitation and analysis, software architecture, detailed design, and mapping to aspect-oriented programming constructs. This paper gives an overview of the accepted submissions, and summarizes the results of the different discussion groups. [ABSTRACT FROM AUTHOR]

This work is motivated by the recent Request For Proposals issued by OMG for a new UML Profile named "Modeling and Analysis of Real-Time and Embedded systems". The paper describes first some domain concepts for annotating Non-Functional Properties (NFPs), whose focus is on supporting temporal verification of UML-based models. Particular emphasis is given to schedulability and performance analysis for real-time systems. We discuss next some general requirements for NFP annotations and evaluate how the UML profiles for "Schedulability, Performance, and Time Specification" and for "Modeling Quality of Service and Fault Tolerance Characteristics and Mechanisms", address these requirements. Last but not least, the paper proposes a preliminary framework for describing NFPs by considering the major requirements previously stated and by analyzing some UML mechanisms to attach NFPs to model elements. [ABSTRACT FROM AUTHOR]

While traditionally the environment considered by an autonomous mechatronic systems only consists of the measurable, surrounding physical world, today advanced mechatronic systems also include the context established by the information technology. This trend makes mechatronic systems possible which consist of cooperating agents which optimize and reconfigure the system behavior by adjusting their local behavior and cooperation structure to better serve their current goals depending on the experienced mechanical and information environment. The Mechatronic UML approach enables the component-wise development of such self-optimizing mechatronic systems by providing a notion for hybrid components and support for modular verification of the safe online-reconfiguration. In this paper, we present an extension to the formerly presented solution which overcomes the restriction that only purely reactive behavior with restricted time constraints can be verified. We present how model checking can be employed to also verify the safe modular reconfiguration for systems which include components with complex time constraints and proactive behavior. [ABSTRACT FROM AUTHOR]

This paper presents an overview of the workshop MARTES on Modeling and Analysis of Real-time and Embedded Systems that has taken place for the first time in association with the MODELS/UML 2005 conference. The main themes discussed at this workshop concerned (1) methodologies and tools for quantitative analysis and (2) methodologies and languages for modeling quantitative aspects of real-time and embedded systems in the context of model driven development. [ABSTRACT FROM AUTHOR]

It is well known that errors introduced early in the development process are commonly the most expensive to correct. The increasingly popular model-driven architecture (MDA) exacerbates this problem by propagating these errors automatically to design and code. This paper describes a round trip engineering process that supports the specification of a UML model using CASE tools, the analysis of specified natural language properties, and the subsequent model refinement to eliminate errors uncovered during the analysis. This process has been implemented in , a tool suite that enables developers to specify and analyze a UML model with respect to behavioral properties specified in terms of natural language. [ABSTRACT FROM AUTHOR]

We present in this paper a rigorous and automated based approach for the behavioral validation of control software systems. This approach relies on metamodeling, model-transformations and process algebra and combines semi-formal object-oriented models with formal validation. We perform the validation of behavioral aspects of object-oriented models by using a projection into a well-defined formal technical space (Finite State Process algebra) where model-checkers are available (we use LTSA; a model checker for Labeled Transition Systems). We then target an implementation platform, which conforms to the semantics of the formal technical space; in turn, this ensure conformance of the final application to the validated specification. [ABSTRACT FROM AUTHOR]

Rigorous design and validation methods appear to be more and more necessary in an industrial context. Software systems are becoming increasingly large and complex, and run the risk of serious failures from unpredictable behaviors resulting from interactions between sub-systems. Without proper standardization of modeling notations and approaches, human beings find it difficult to understand the systems. [ABSTRACT FROM AUTHOR]

Many popular methodologies are influenced by Design by Contract. They recommend to specify the intended behavior of operations in an early phase of the software development life cycle. Formal contract specification languages, however, are still rarely used because their semantics often mismatch the needs of software developers. Restrictive specification languages usually suffer from the "frame problem": It is hard to express which parts of the system state should remain unaffected when the specified operation is executed. Constructive specification languages, instead, suffer from the tendency to make specifications deterministic. This paper investigates how a combination of OCL and graph transformations can overcome the frame problem and can make constructive specifications less deterministic. Our new contract specification language is considerably more expressive than both pure OCL and pure graph transformations. Keywords: Design by Contract, Behavior Specification, Graph Grammars, OCL, QVT. [ABSTRACT FROM AUTHOR]

Analysis and design by contract allows the definition of a formal agreement between a class and its clients, expressing each party's rights and obligations. Contracts written in the Object Constraint Language (OCL) are known to be a useful technique to specify the precondition and postcondition of operations and class invariants in a UML context, making the definition of object-oriented analysis or design elements more precise while also helping in testing and debugging. In this article, we report on the experiences with the development of ocl2j, a tool that automatically instruments OCL constraints in Java programs using aspect-oriented programming (AOP). The approach strives for automatic and efficient generation of contract code, and a non-intrusive instrumentation technique. A summary of our approach is given along with the results of an initial case study, the discussion of encountered problems, and the necessary future work to resolve the encountered issues. [ABSTRACT FROM AUTHOR]

The recent trend in software engineering to model-centered methodologies is an excellent opportunity for OCL to become a widely used specification language. If the focus of the development activities is shifted from implementation code to more abstract models then software developers need a formalism to provide a complete, unambiguous and consistent model at a very detailed level. OCL is currently the only language that can bring this level of detail to UML models. The purpose of the workshop was to identify future challenges for OCL and to discuss how OCL and its current tool support can be improved to meet these challenges. The workshop gathered numerous experts from academia and industry to report on success stories, to formulate wishes to the next generation of OCL tools, and to identify weaknesses in the language, which make OCL sometimes cumbersome to use. The workshop could also attract numerous people whose aim was to get an overview on the state of the art of OCL tool support and on how OCL can efficiently be applied in practice. [ABSTRACT FROM AUTHOR]

It was a tradition in the previous UML series to host a number of workshops. Workshops provide the opportunity for a small group of people to exchange recent or preliminary results and to conduct intensive discussions on a particular topic. They complement in a sense the main conference and are generally very appreciated by attendees, most of them also attending the main conference. [ABSTRACT FROM AUTHOR]

The goal of this workshop was to look at issues related to the integration of non-functional property expression, evaluation, and prediction in the context of component-based software engineering. The accepted papers looked at the issue from a very broad range of perspectives, such as development process, modelling for analysis vs for construction, or middleware componentisation. The afternoon session was completely used for discussions: discussion topics ranged from the limits of the research domain and the definition of fundamental terms and concepts to issues of compositionality. The workshop had a very inspiring and productive atmosphere, and we are looking forward to organising future instalments of the series. [ABSTRACT FROM AUTHOR]

Models have become more and more important in software development. The Model Driven Architecture (MDA) currently addressed by a large number of people, research groups, and tools documents this emphasis on having models as central artifacts in software engineering. Typically, a model undergoesmany changes in its lifetime, in the same way as an end product (software) does. If it does not, the model might have been a throw away artifact which is no longer connected to the software developed from it. To prevent having throw-away models, we believe that one needs strong tool support for the evolution of models which allows us to continuously develop and refine existing models. [ABSTRACT FROM AUTHOR]

This paper outlines some partial results of my PhD research on how to use Model-Driven Engineering to systematically generate reflective middleware family configurations. [ABSTRACT FROM AUTHOR]

This Ph.D. research investigates a generic model-driven development (MDD) framework that supports various domain-specific solutions (i.e. modeling, programming and development processes to directly deal with domain concepts), and empirically evaluates a series of techniques to develop such a framework. Steps towards creating the proposed framework include investigating a generic foundation to handle arbitrary Domain Specific Languages (DSLs); strategies, principles and tradeoffs in different DSL designs (e.g. DSL syntax and semantics); building blocks for modeling and programming domain concepts; transformation strategies from domain concepts to the final (compilable) source code; development processes to leverage the proposed framework well; model-driven approaches for maintenance and tests; and performance implications of major functional components in the framework. [ABSTRACT FROM AUTHOR]

Today, model-driven development is getting more sophisticated and is used for modeling enterprises and developing application systems. To develop more and more complex systems efficiently, the trend is to intelligent infrastructure services. Since current interoperability solutions operate essentially at a syntactical level, technologies have to be developed enabling interoperability based on middleware, and development platforms have to be enriched with machine-understandable semantics. Our approach of ‘Ontology-based Model Transformation' will contribute to these challenges by lifting syntactical metamodel description into ontologies. [ABSTRACT FROM AUTHOR]

The objective of this research is to develop techniques that integrate alternative security concerns (e.g., mandatory access control, delegation, authentication, etc.) into the software process. A framework is proposed to achieve composable security definition, assurance, and enforcement via a model-driven framework that preserves separation of security concerns from modeling through implementation, and provides mechanisms to compose these concerns into the application, while maintaining consistency between design models and code. At modeling-time, separation of concerns (e.g., RBAC, MAC, delegation, authorization, etc.) is emphasized by defining concern-specific modeling languages. At the implementation-level, aspect-oriented programming (AOP) transitions security concerns into modularized code that enforces each concern. This research assumes the use of an underlying object-oriented language with aspect-oriented extensions, and infrastructure to implement the applications and support secure access to the public methods of classes, e.g., Java with AspectJ or C++ with AspectC++. [ABSTRACT FROM AUTHOR]

This paper describes the research I am currently performing as a PhD student at the Illinois Institute of Technology with my advisor Dr. Tzilla Elrad. The focus of my research is Aspect-Oriented Modeling and reactive systems. In particular I am interested in the modeling of reactive objects using statecharts and scenarios. [ABSTRACT FROM AUTHOR]

Modern systems are software-intensive and must meet increasingly demanding requirements in order to cope with significant degrees of uncertainty, dynamic environments, and to provide greater flexibility. Agent-based development metaphors and technologies provide well suited structures and techniques to handle such complexity. However, when developing complex open systems, the tools provide insufficient support for effective specification and implementation of such systems. [ABSTRACT FROM AUTHOR]

One of the latest technologies in the automotive industry is "X-by-Wire", where mechanical components are replaced by electronic functions typically controlled by software. X-by-Wire impacts on the overall vehicle safety for example: by eliminating the steering column, the likelihood of it intruding into the passenger compartment during a collision decreases. X-by-Wire also provides the driver with convenient features such as variable steering ratio for ease of manoeuvrability. [ABSTRACT FROM AUTHOR]

Currently there are some young and promising approaches in software development, such as Model-Driven Development (MDD), and Aspect-Oriented Software Development (AOSD). While MDD focuses on the systematic use of models, where the software is built through a chain of model transformations, AOSD aims to offer enhanced mechanisms to identify, model and compose crosscutting concerns. But what AOSD proposes doesn't it involve just a specific kind of modelling? And regarding composition, isn't it a special kind of model transformation? If these questions are true, will MDD absorb AOSD in the end? If not, what are then the true crosscutting relationships between MDD and AOSD? [ABSTRACT FROM AUTHOR]