Suitable Component Based Software (CBS) metrics are necessary for the efficient quantification of quality attributes of a system. One of the major quality attributes of Component Based Software systems is the complexity generated due to interactions among components. The Cyclomatic complexity of a Component Based System is independent of the physical size of the component. The Cyclomatic complexity mainly depends on the decision structure present in the component. To calculate the overall complexity of a Component Based Software System, it is necessary to include the coupling properties (intercomponent- interactions) among the components as well as the cohesive properties (intra-component-interactions) of the individual components. In this paper, a new method is proposed for Cyclomatic complexity computation for Component Based Software Systems. This method includes the individual complexities of the participating components as well as the complexities of the interacting components. McCabe's Cyclomatic complexity computation method is used as the base method to calculate the complexity of individual components. The main goal of the proposed method is to find the Cyclomatic complexity of software where multiple components interact with each other for accessing or providing services.
Big Data aims at the efficient processing of massive amounts of data. Performance modeling is often used to optimize performance of systems under development. Based on experiences from modeling Big Data solutions, we describe some problems in applying performance modeling and discuss potential solution approaches.
In model-driven engineering, modeling languages are developed to serve as basis for system design, simulation and code generation. Like any software artifact, modeling languages evolve over time. If, however, the metamodel that defines the language is badly designed, the effort needed for its maintenance is unnecessarily increased. In this paper, we present bad smells and anti-patterns that we discovered in a thorough metamodel review of the Palladio Component Model (PCM). The PCM is a good representative for big and old metamodels that have grown over time. Thus, these results are meaningful, as they reflect the types of smells that accumulate in such metamodels over time. Related work deals mainly with automatically detectable bad smells, anti-patterns and defects. However, there are smells and anti-patterns, which cannot be detected automatically. They should not be neglected. Thus, in this paper, we focus on both: automatically and non-automatically detectable smells.
Component-based software engineering (CBSE) is based on defining, implementing and composing loosely coupled, independent components, thus increasing modularity, analyzability, separation of concerns and reuse. However, complete separation of concerns is difficult to achieve in CBSE when concerns crosscut several components. Furthermore, in some cases, reuse of components is limited because component developers make certain implementation choices that are incompatible with the non-functional requirements of the application that is being built. In this paper we outline how to integrate CBSE and concern-oriented reuse (CORE), a novel reuse paradigm that extends Model-Driven Engineering (MDE) with best practices from aspect-oriented software composition and Software Product Lines (SPL). Concretely, we outline how to combine the Palladio Component Model (PCM) capable of expressing complex software architectures with CORE class and sequence diagrams for low-level design. As a result, multiple solutions for addressing concerns that might even crosscut component boundaries can be modularized in a reusable way, and integrated with applications that reuse them using aspect-oriented techniques. Additionally, thanks to CORE, component developers can avoid premature decision making when reusing existing libraries during implementation.
While designing dependable systems, a large number of asset combinations (system configurations) with contrary quality objectives needs to be investigated. Basically, each feasible configuration should be investigated. For fault-tolerant embedded systems this problem is extended by anticipating hardware faults leading to changed deployments of stressed resources in redundant constellations. The identification and evaluation of the best-fitting configuration remains a computationally intensive and difficult task at all. We propose a multi-stage approach (1) to sample Paretooptimal configurations for redundant system designs within hostile environments, (2) to check satisfiability of structural constraints and (3) to measure and identify quality degradation in fault scenarios. Thus, allowing developers to identify design flaws, leading to large quality degradations in case of emerging faults. We use genetic algorithms (NSGA-II) for sampling a wide range of system designs and demonstrate our approach by means of an exemplary fault-tolerant system.
