Components have been introduced in order to support software reuse. Components are reusable building blocks for larger systems consisting of units (code pieces) and their construction plan. Technologies like COM+, .Net, CORBA JavaBeans and EJBs (or web services which may be considered as web-based components) have been developed to support the component concept. However, components still have the problem of both unavailable and unreliable documentation of their properties. Moreover, a lack of validation support concerning the components' or composed systems' behavior may be observed. In other words, there is a lot of knowledge about how to combine components technically but less experience to validate the interactions between the components. In this paper we introduce an approach to model components and their compositions as a base for automatic validation techniques to check the components composition and their interactions. The validation aims at deriving the component models from the implementation which allows comparing the specifications with the real components code.
Model-based methodologies such as the Model-Driven Development (MDD) and Model-Based Testing (MBT) are being explored, in the recent decade, for automation in embedded software engineering projects. In this context, the target of this paper is to demonstrate the adoption and applicability of the Uniﬁed Modeling Language (UML) and the UML Testing Proﬁle (UTP) for deploying MBT in Resource-Constrained (RC)-Real-Time Embedded Systems (RTES). Though the UTP standard has been introduced several years ago, concrete approaches or tool support for generating the test artifacts based on the UTP is currently unavailable. This paper aims to close this gap and discusses a concise set of UTP artifacts in the context of MBT for RC-RTES. A detailed discussion on the test artifacts generation algorithm demonstrating the applicability of our approach in a real-life RC-RTES example is presented.
In the recent decade, new automated methodologies such as the Model Driven Development (MDD) and Model-Based Testing (MBT) are under evaluation for embedded systems development and testing. However, most of the currently existing MBT approaches are neither integrated with the software development process nor transferred to real-life embedded software engineering projects. There is also a lack of usage of corresponding modeling languages for the MDD and MBT phases. In this context, this paper discusses the applicability of an integrated model-based approach and test framework which addresses the aforementioned gaps. The approach is evaluated in a spark extinguishing embedded system example based on a real-life embedded software engineering project. A test framework generation algorithm which generates the necessary artifacts for deploying MBT in resource-constrained embedded systems is discussed. A prototype implementation of the proposed approach and illustrative examples are presented.
Regulatory compliance management is a critical and challenging task, especially in the context of Business Process Management. It requires a comprehensive framework for dealing with compliance requirements: elicitation, modeling, static and dynamic checking and reporting. We previously defined CoReL, a domain specific language for the domain of compliance decision-making. This paper shows how CoReL can be used to model compliance requirements using an illustrative example. In particular, we show how CoReL's agnosticism of logical formalisms and coverage of enterprise business aspects leverages the task of compliance modeling to the business user level.
Regulatory compliance management is now widely recognized as one of the main challenges still to be efficiently dealt with in information systems. In the discipline of business process management in particular, compliance is considered as an important driver of the efficiency, reliability and market value of companies. It consists of ensuring that enterprise systems behave according to some guidance provided in the form of regulations. This paper gives a definition of the research problem of regulatory compliance. We show why we expect a formal policy-based and model-driven approach to provide significant advantages in allowing enterprises to flexibly manage decision-making related to regulatory compliance. For this purpose, we contribute CoReL, a domain-specific modeling language for representing compliance requirements that has a graphical concrete syntax. Informal semantics of CoReL are introduced and its use is illustrated on an example. CoReL allows to leverage business process compliance modeling and checking, enhancing it with regard to, among other dimensions, user-friendliness, genericity, and traceability.
A robust model-based debugging and testing technique integrated with the Model Driven Development (MDD) approach for memory size constrained, real-time critical embedded target systems is still in its nascent stages. This is especially true for the industry standard MDD-based tools. In addition, a model-based debugging technique or tool chain based on the newly introduced timing diagrams in UML 2.x is not yet available. In this paper, we discuss a model-based, design-level debugging approach with which the timing behavior of embedded targets is visualized with the aid of UML timing diagrams on the host side, in real-time. The proposed approach is suitable for memory size constrained, real-time embedded target systems as the overhead introduced is negligible, constant and known beforehand. Hence, the end-user has the option to include the overhead in the system design phase, thereby making use of a model-based debug solution and at the same time adhering to temporal constraints. A prototype implementation of the proposed approach is discussed and an illustrative example is presented.
There are numerous concepts and tools for modeling business processes and several academic approaches to verify business processes. However, most modeling tools don’t integrate the checking of the processes. The three-tier architecture of the Business Application Modeler (BAM) provides the graphical representation of business models and rules (presentation layer) as well as integrates a veriﬁcation mechanism layer with an intermediate transformation layer. The hierarchical architecture allows to extend the checking system with additional features supporting the use of the veriﬁer in an industrial environment of commercial information system development. Examples for such add-ons are the improved graphical rule notation and an enhanced functionality of the veriﬁcation system supporting the expressiveness in the business modeling domain.
Model driven design and development of real-time embedded systems has been gaining a lot of attention in the recent past. It is imperative for a hard real-time embedded system to execute and respond to sequenced exchanges of messages under critical temporal constraints. The UML provides artifacts such as communication diagrams, sequence diagrams and timing diagrams to aid software engineers to model and precisely document such a schedule of interactions or state changes at the design level. While modeling at the design level is interesting on one hand, it is also significant to understand the run time behavior of the embedded software. A step forward in this direction is to provide a real-time representation of the target system behavior on the host side. We propose an approach to realize a target debugger on the host side with a monitor solution in the target side. With the back annotated information from the target, a visual representation of the system behavior in real-time is now available at the design level. This way, a debugging solution in real-time is provided, thus taking a step forward towards understanding the behavior of the embedded software at hand. We illustrate our proposed approach with a prototype and examples.
There have been several model based approaches used in the recent past for alleviating complexity in design, development and test case generation for real-time embedded software systems. However, deploying/executing these test cases in the embedded target without affecting the real-time behavior of the system still remains a challenging and unanswered question. To address this, we propose a novel architecture to perform an integrated model based testing for embedded systems. We introduce a holistic model based design, development and testing approach with the aid of a monitor and target debugger solution for real-time embedded systems. Our proposed approach eliminates the need for dynamic source code instrumentation inserted into the target to execute the software test routines. This will result in preserving the real-time behavior which is a boon especially for real-time critical and code size constrained embedded systems. We illustrate our proposed approach with a prototype and an example.
Process and workflow models are typical means to describe the dynamic activities of a system. Therefore, it is of high interest to validate these models. Many kinds of (business) rules, best practices, patterns, legal regulations may serve as specifications which the models have to fulfill. An already established technique to validate models of dynamic activities is model checking. In model checking the requirements are expressed by temporal logic. Temporal logic allows describing temporal dependencies. The models to be verified by model checkers are automata. In this context the question is how to transform process or workflow models into automata and how to specify the temporal logic in the way that the semantic of the process models is considered sufficiently. In our paper we present three approaches to transform process models to checkable automata. We use the example of ARIS Event-driven Process Chains. In particular, the third approach introduces specializers enabling semantic-rich requirement specifications. This reduces the gap between process models (consisting of different model element types) and verification models.
The automated generation of systems (e.g. within model-driven development) is a considerable improvement of the software development. However, besides the automated generation the verification of these generated systems needs to be supported, too. By applying generators it is not necessarily guaranteed that the generation outcome is correct. Typical problems may be, firstly, the use of a wrong operator resulting in an erroneous generation (static aspects of the generation). Secondly, the interactions between the different generated system assets (snippets) of the generated outcome might be incorrect, since the snippets might be connected in a wrong sequence (dynamic aspect of the generation). Therefore, the hierarchical dependencies of the snippets which are the input of the generator as well as the dynamic behavior resulting from the generation have to be checked. We describe the hierarchy in a version model based on Boolean logic. The temporal behavior may be checked by model checkers. For the generation we apply our XOpT concept which provides domain-specific transformation operators on the XML representation. Besides the principles of the static and dynamic elements of our checking approach the paper presents the way to map program assets to the version model and to finite state automata which are the prerequisite for the checking. Though the proposed checking is presented at the code level the approach may be applied to different kinds of assets, e.g. also on the model level.
A variety of models and notations are available to support the software developers. Such models help to gather requirements and to build a system implementing these requirements. However, it is often neglected to verify that the requirements are actually fulfilled in the design and implementation. The increasing demand for compliancy to requirements (e.g. due to laws) together with the increasing system complexity re-attracts notice to automatic verification technologies for that purpose. The low user-friendliness and, thus, the low applicability of the verification technologies often prevents their employment. In this paper we aim at closing the gap between software development models with their rich notation and semantics (e.g. Event Process Chains, EPCs) on the one hand and verification-oriented models (typically just simple structures like finite state automata) on the other hand. This is approached by extending the verification model in a controlled manner towards more semantics resulting in our extended Kripke structure. To profit from such a semantic extension we, in addition, extend the temporal logic language CTL. Our new temporal logic language allows to express the expected requirements more precisely.
In process-centric enterprises, business processes (BPs) are at the center of value-creating activities. Governing enterprise BPs requires the ability to control and guide BP behavior. Ensuring compliance of processes to legal regulations and strategy directives becomes a critical requirement. Implementing business process compliance makes means for modeling and enforcing compliance measures necessary. In this work, we motivate the need for automation and semantic consistency in compliance management and defend the use of policies for this purpose. We then propose a policy-based framework for business process compliance management and further detail its architecture as part of the SUPER research project on semantic business process management (SBPM). Finally, we introduce the ontology stack we propose for compliance modeling and conclude by an investigation of the main challenges ahead in order to provide an implementation of the proposed framework. This work seeks to lay down the fundaments of a comprehensive architecture for semantic compliance modeling and enforcement in the context of BPM.
Based on the experience in the e-commerce domain, we propose a concept for the development of higher-level transformation languages. Transformation is a key factor in this domain as the market requires a fast reaction to frequent changes in the interfaces and exchange data. Moreover, a typical e-commerce system is divided into different services which are offered and hosted by different vendors which results in a complex integration problem. Our proposed solution is based on the operator hierarchy concept which allows to define transformation operator hierarchies containing different levels of transformation operators. The concrete realization of such a higher-level transformation language construction is demonstrated by an application of the XML operator hierarchy concept to the transformation language XSLT. XSLT serves as an example which is employed to provide the elementary transformation operators. On top of these elementary operators the layered concept allows the definition of new higher-level operators, e. g. domain-independent and domain-specific ones. The construction of the higher-level language XML2DSV is presented, for instance. This is a stand-alone domain-specific transformation language, which creates delimeter-separated values (DSV) files from XML documents, on the base of XSLT.
Service oriented architecture (SOA) has emerged as a popular software paradigm for integrating distributed applications. Services are generally regarded as interoperable building blocks for constructing, integrating, and merging applications. However, existing SOA based solutions often focus on solving technical integration problems while neglecting business-level capabilities which are most important for organizations. In this paper, we introduce the notion of capabilities as an important concept for business management. We identify major shortcomings of the existing service based solutions and outline a novel approach for capability oriented configuration and management that can react to the dynamically changing nature of business integration environments.
XML has a broad acceptance as a standardized flexible text format for storing and exchanging of a wide variety of data. As a result, transformations between XML documents become more and more important. A scalable transformation approach requires the possibility to express transformation definitions in terms of domain-specific constructs. Only in this case, the domain knowledge is explicitly available and not hidden into, e. g., Java or XSLT code. Consequently, domain experts can easier understand, validate, and modify the transformation themselves. This paper presents a generic composition concept that relies on transformation itself. It allows the definition of transformation operator hierarchies containing different levels of transformation operators, e. g. domain-independent and domain-specific ones. We apply the proposed operator hierarchy concept to XSLT, and build new complex operators on top of existing ones which are specifically suited to develop transformations in a certain application area.
System development is usually processed by applying different models both on the same and different levels of abstraction. This supports the stepwise refinement, the dealing with the inherent complexity and allows the tailored documentation and specification of the different aspects of the system. This paper presents the XOpT approach to support the composition and adaptation step. It provides a framework based on XML, DOM and XPath technology with an hierarchy of transformation operators. These are either generic or specifically suited for (and thus also restricted to) a certain domain. New operators may be added on top of existing ones on demand. XOpT is a unification of composition and weaving techniques as it operates on the standardized XML data format. Furthermore, this language independence allows the manipulations on different abstraction levels in parallel preserving model consistency. The concepts have been applied to an e-commerce system based on ARIS which also serves as example in this paper.
Since the first discussion about the software crisis in 1968 many concepts in order to improve the software development and reuse have been introduced. Some of them like frameworks or components aim on the reuse of code others capture experiences with system architecture, design or coding recommendations. This paper focuses on a way to express the reuse of pieces of software and design reasoning. We apply versions in order to describe sets of features we want to have in a system. Conditions are used to formulate these requirements. Then these conditions are integrated into UML models using the existing mechanisms for extensions. This enables a tight integration of versions and modeling constructs and enhances integrity of models. The use of version is demonstrated by an example from the eCommerce domain. This paper also discusses the effects of the integration of version into UML models.
With Aspect-Oriented Programming (AOP) a new type of system units is introduced (aspects). One observed characteristic of AOP is that it results in a large number of additional (coarse-grained to fine-grained) system units (aspects) ready to be composed to the final application. With this growing number of system units the dependencies between them become vast and tangling. This results in the necessity of an improved management of the dependencies between these system units. Our paper investigates this problem, proposes a more general model (version model) to capture different facettes of AOP as well as a partial solution towards unit consistency based on versions.
Existing process models for software development are too resource intensive for small organisations. This paper proposes EProMS, an e-commerce based process model which takes into account the limited resources of these organisations. It distributes the software development process over several small organisations. These organisations, then, co-operate through an e-commerce layer to produce market-driven software. On competitive markets the distribution allows organisations in the co-operation to specialise in specific aspects of software development. This helps them to reduce costs and time to market and achieve a high degree of users' satisfaction.
Software reuse usually has the drawback that the documentation of the software units is rather incomplete and inaccurate. It is hard to verify that such a component offers both the required and promised features / behavior. In this paper we present an approach to describe the components' features and dynamic behavior as finite state machines which may automatically be verified by model checkers. The model of the component is derived from the code providing consistency between documentation and implementation. The models of several components may be combined to larger systems (according to the composition of the real code components). To deal with the state explosion problem, our approach allows to "abstract" of the complete component's behavior as needed (compression and inflation). In the beginning of a reuse-based system development the requirements are modeled similarly as the reusable code assets. Model checking can be employed to determine the consistency between these requirement models and the models of the complete systems, subsystems or components. The tool support eases incremental system development and rapid prototyping / checking. The impact of a composed component (the component's model respectively) may be instantly examined (against the modeled requirements).
The composition of software units has been one of the main research topics in computer science. This paper addresses the composition validation problem evolving in this context. It focuses on the composition for a certain kind of units called aspects. Aspects are a new concept which is introduced by aspect-oriented programming aiming at a better separation of concerns. Cross-cutting code is captured and localised in these aspects. Some of the cross-cutting features which are expressed in aspects cannot be woven with other features into the same application since two features could be mutually exclusive. With a growing number of aspects, manual control of these dependencies becomes error-prone or even impossible. We show how assertions can be useful in this respect to support the software developer.
Over the recent years aspect-oriented programming (AOP) has found increasing interest among researchers in software engineering. Aspects are abstractions which capture and localise cross-cutting concerns. Although persistence has been considered as an aspect of a system aspects in the persistence domain in general and in databases in particular have been largely ignored. This paper brings the notion of aspects to object-oriented databases. Some cross-cutting concerns are identified and addressed using aspects. An aspect-oriented extension of an OODB is discussed and various open issues pointed out.
The collaboration-based approach is a powerful means to develop modularised systems by stepwise refinement. In this paper we introduce a new approach to realise a collaboration-based design. Our approach is based on the well-known observation that the knowledge about inter-object collaborations cannot be localised within objects but cross-cuts many objects. Such cross-cutting concerns are effectively addressed by applying the separation of concerns principle. We have, therefore, employed Aspect-Oriented Programming (AOP) to build collaboration-based designs. In the paper we illustrate and discuss our aspect-oriented approach both for the horizontal (i.e. the collaborations) and vertical (i.e. the refinements) dimensions. Although the example implementations are based on AspectJ0.4beta7 from Xerox PARC, the approach is generic enough to be implemented using other AOP techniques.
One of the consequences of evolution can be the inability to access objects created using the older schema definition under the new definition and vice versa. Instance adaptation is the conversion of objects to a compatible definition or making objects exhibit a compatible interface. Existing evolution approaches are committed to a particular instance adaptation strategy. This is because changes to the instance adaptation strategy or an attempt to adopt an entirely different strategy would be very costly. This paper proposes a flexible instance adaptation approach for systems employing class versioning to manage evolution. Flexibility is achieved by encapsulating the instance adaptation code in aspects - abstractions introduced by aspect-oriented programming to localise cross-cutting concerns. This makes it possible to make cost-effective changes to the instance adaptation strategy. The flexibility of the approach is demonstrated by using two instance adaptation strategies: error handlers and update/backdate methods.
We illustrate how to combine CORBA as a distributed system with aspect-oriented programming (AOP) and the resulting positive impacts. In particular, we focus on the question how AOP can be applied to a CORBA application aiming at a better separation of concerns. The paper shows with implementation examples a practical way to package the distribution issues of a CORBA application into separated aspects (with AspectJ). This supports the distributed application design and leads to increased flexiblity.