Search

Event-based communication is used in different domains including telecommunications, transportation, and business information systems to build scalable distributed systems. Such systems typically have stringent requirements for performance and scalability as they provide business and mission critical services. While the use of event-based communication enables loosely-coupled interactions between components and leads to improved system scalability, it makes it much harder for developers to estimate the system's behavior and performance under load due to the decoupling of components and control flow. In this paper, we present our approach enabling the modeling and performance prediction of event-based systems at the architecture level. Applying a model-to-model transformation, our approach integrates platform-specific performance influences of the underlying middleware while enabling the use of different existing analytical and simulation-based prediction techniques. In summary, the contributions of this paper are: (1) the development of a meta-model for event-based communication at the architecture level, (2) a platform aware model-to-model transformation, and (3) a detailed evaluation of the applicability of our approach based on two representative real-world case studies. The results demonstrate the effectiveness, practicability and accuracy of the proposed modeling and prediction approach. [ABSTRACT FROM AUTHOR]

The term solution space is widely used in the engineering community; yet there is little known about their evolution. Theoretical research in the field of systems science indicates that requirements can only reduce the solution space. Yet, some authors state that on the contrary requirements can be used to expand to or open new solution spaces. Furthermore, some practitioners defend that the requirement to use a previously nonexistent technology would actually increase the solution space or move it to a new area, while others state that more requirements make life more difficult. Who is right then? The present paper provides initial answers to this question using systems theory. In order to achieve this, the present paper differentiates between various types of solutions spaces, which depend on the systems they include. Finally, the paper provides practical examples to showcase the results of the theoretical findings within real contexts. [ABSTRACT FROM AUTHOR]

This paper will produce three areas of discussion in the field of cost estimation for unmanned autonomous systems. First, this paper will propose a common definition of an Unmanned Autonomous system. Second, it will introduce a method to estimate the cost of unmanned autonomous systems utilizing existing parametric cost estimation tools: SEER – HDR, COCOMO II, COSYSMO, and two relationships – weight and performance. The third discussion will focus on challenges surrounding autonomy. To address these challenges from a cost perspective, this paper recommends modifications to parameters within COCOMO II – via the use of object oriented function points in lieu of current methods, and COSYSMO – via the introduction of two cost driving parameters, namely, TVED and HRI-T. Finally, in summary this paper will identify areas of further research. [ABSTRACT FROM AUTHOR]

Model composition plays a central role in many software engineering activities, e.g., evolving design models to add new features. To support these activities, developers usually rely on model composition heuristics. The problem is that the models to-be-composed usually conflict with each other in several ways and such composition heuristics might be unable to properly deal with all emerging conflicts. Hence, the composed model may bear some syntactic and semantic inconsistencies that should be resolved. As a result, the production of the intended model is an error-prone and effort-consuming task. It is often the case that developers end up examining all parts of the output composed model instead of prioritizing the most critical ones, i.e., those that are likely to be inconsistent with the intended model. Unfortunately, little is known about indicators that help developers (1) to identify which model is more likely to exhibit inconsistencies, and (2) to understand which composed models require more effort to be invested. It is often claimed that software systems remaining stable over time tends to have a lower number of defects and require less effort to be fixed than unstable systems. However, little is known about the effects of software stability in the context of model evolution when supported by composition heuristics. This paper, therefore, presents an exploratory study analyzing stability as an indicator of inconsistency rate and resolution effort on model composition activities. Our findings are derived from 180 compositions performed to evolve design models of three software product lines. Our initial results, supported by statistical tests, also indicate which types of changes led to lower inconsistency rate and lower resolution effort. [ABSTRACT FROM AUTHOR]

The accuracy of performance-prediction models is crucial for widespread adoption of performance prediction in industry. One of the essential accuracy-influencing aspects of software systems is the dependence of system behaviour on a configuration, context or history related state of the system, typically reflected with a (persistent) system attribute. Even in the domain of component-based software engineering, the presence of state-reflecting attributes (the so-called internal states) is a natural ingredient of the systems, implying the existence of stateful services, stateful components and stateful systems as such. Currently, there is no consensus on the definition or method to include state-related information in component-based prediction models. Besides the task to identify and localise different types of stateful information across component-based software architecture, the issue is to balance the expressiveness and complexity of prediction models via an effective abstraction of state modelling. In this paper, we identify and classify stateful information in component-based software systems, study the performance impact of the individual state categories, and discuss the costs of their modelling in terms of the increased model size. The observations are formulated into a set of heuristics-guiding software engineers in state modelling. Finally, practical effect of state modelling on software performance is evaluated on a real-world case study, the SPECjms2007 Benchmark. The observed deviation of measurements and predictions was significantly decreased by more precise models of stateful dependencies. [ABSTRACT FROM AUTHOR]

Aspect Oriented Software Development is gaining wide attention because of its key feature modularization. Aspect Oriented paradigm supports the separation of concerns that are scattered over the system which helps in achieving modularity. Aspect Oriented Software Development encompasses software engineering abstractions and complexity at new and different dimensions. So Aspect Oriented Software Development requires models to assess its external quality attributes. The quality attribute maintainability is vital, because maintenance tasks employs major chunk of the total software development cost. The quality, maintainability is indicated using metrics. This paper proposes a framework to build maintainability model for aspect oriented systems using already defined software measures. [ABSTRACT FROM AUTHOR]

The dynamic planning for a system-of-systems is a challenging endeavor. Department of Defense (DoD) programs constantly face challenges to incorporate new systems and upgrade existing systems over a period of time under threats, constrained budget, and uncertainty. It is therefore necessary for the DoD to be able to look at the future scenarios and critically assess the impact of technology and stakeholder changes. The DoD currently is looking for options that signify affordable acquisition selections and lessen the cycle time for early acquisition and new technology addition. This paper gives an overview of a novel methodology known as the Flexible Intelligent & Learning Architectures in System-of-Systems (FILA-SoS). This approach allows for analyzing sequential decisions in evolving SoS architectures. An ISR SoS example illustrates an application of the method. [ABSTRACT FROM AUTHOR]

Many software development, planning, or analysis tasks require an up-to-date software architecture documentation. However, this documentation is often outdated, unavailable, or at least not available as a formal model which analysis tools could use. Reverse engineering methods try to fill this gap. However, as they process the system's source code, they are easily misled by design deficiencies (e.g., violations of component encapsulation) which leaked into the code during the system's evolution. Despite the high impact of design deficiencies on the quality of the resulting software architecture models, none of the surveyed related works is able to cope with them during the reverse engineering process. Therefore, we have developed the Archimetrix approach which semiautomatically recovers the system's concrete architecture in a formal model while simultaneously detecting and removing design deficiencies. We have validated Archimetrix on a case study system and two implementation variants of the CoCoME benchmark system. Results show that the removal of relevant design deficiencies leads to an architecture model which more closely matches the system's conceptual architecture. [ABSTRACT FROM AUTHOR]

Copyright of Mendive - Revista de Educacion is the property of Universidad de Pinar del Rio and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

We present an approach to model-driven software product line engineering which is based on feature models and domain models. A feature model describes both common and varying properties of the instances of a software product line. The domain model is composed of a structural model (package and class diagrams) and a behavioral model (story diagrams). Features are mapped onto the domain model by annotating elements of the domain model with features. An element of a domain model is specific to the features included in its feature annotation. An instance of the product line is defined by a set of selected features (a feature configuration). A configuration of the domain model is built by excluding all elements whose feature set is not included in the feature configuration. To ensure consistency of the configured domain model, we define constraints on the annotations of inter-dependent domain model elements. These constraints guarantee that a model element may be selected only when the model elements are also included on which it depends. Violations of dependency constraints may be removed automatically with the help of an error repair tool which propagates features to dependent model elements. [ABSTRACT FROM AUTHOR]