The Black Pearl is a custom made autonomous underwater vehicle developed at Mälardalen University, Sweden. It is built in a modular fashion, including its mechanics, electronics and software. After a successful participation at the RoboSub competition in 2012 and winning the prize for best craftsmanship, this year we made minor improvements to the hardware, while the focus of the robot's evolution shifted to the software part. In this paper we give an overview of how the Black Pearl is built, both from the hardware and software point of view.
When developing complex software-intensive systems, it is nowadays common practice to base the solution partly on existing software components. Selecting which components to use becomes a critical decision in development, but it is currently not well supported through methods and tools. This paper discusses how a decision support system for this problem could benefit from a software ecosystem approach, where participants share knowledge across organizations both through reuse of analysis models, and through partially disclosed past decision cases. It is shown how the architecture of this ecosystem becomes fundamental to deal with efficient knowledge sharing, while respecting constraints on integrity of intellectual property. A concrete proposal for an architecture is outlined, which is a distributed system-of-systems using web technologies. Experiences of a proof-of-concept implementation are also described.
Settling down the software architecture for embedded system is a complex and time consuming task. Specific concerns that are generally issued from implementation details must be captured in the software architecture and assessed to ensure system correctness. The matter is further complicated by the inherent complexity and heterogeneity of the targeted systems, platforms and concerns. In addition, tools capable of conjointly catering for the complete design-verificationdeployment cycle, extra-functional properties and reuse are currently lacking. To address this, we have developed Pride, an integrated development environment for component-based development of embedded systems. Pride is based on an architecture relying on components with well-defined semantics that serve as the central development entity, and as means to support and aggregate various analysis and verification techniques throughout the development - from early specification to synthesis and deployment. Pride also provides generic support for integrating extra-functional properties into architectural definitions.
This report describes the component model developed within PROGRESS. In addition to defining the syntax and semantics, it also gives some background and motivation, and describes how this work relates to the overall PROGRESS vision and to the work in other areas of the project.
In this paper we propose to use components for managingthe increasing complexity in modern vehicular systems.Compared to other approaches, the distinguishingfeature of our work is using and benefiting from componentsthroughout the development process from early designto development and deployment, and an explicit separationof concerns at different levels of granularity. Basedon the elaboration of the specifics of vehicular systems (resourceconstraints, real-time requirements, hard demandson reliability), the paper identifies concerns that need to beaddressed by a component model for this domain, and describesa realization of such a component model.
The complexity of software and electronics in vehicular systems has increased significantly over last few years - up to the point when it is difficult to manage it with existing development methods. In this paper we aim at using components for managing the complexity in vehicular systems. Compared to other approaches, the distinguishing feature of our work is using and benefiting from components throughout the whole development process (from early design to development and deployment). Based on the elaboration of the specifics of vehicular systems (resource constraints, real-time requirements, hard demands on reliability), the paper identifies concerns that need to be addressed by a component model for this domain. It also outlines basic features and characteristics of such a component model and discusses how relevant existing formalisms and component models relate to it and how they could be reused within the proposed approach.
One way for modern embedded systems to tackle the demand for more complex functionality requiring more computational power is to take advantage of heterogeneous hardware. These hardware platforms are constructed from the combination of different processing units including both traditional CPUs and for example Graphical Processing Units (GPUs). However, there is a lack of efficient approaches supporting software development for such systems. In particular, modern software development approaches, such as component-based development, do not provide sufficient support for heterogeneous hardware platforms. This paper presents a component model extension, which defines specific features for components with GPU capabilities. The benefits of the proposed solution include an increased system performance by accelerating the communication between GPU-aware components and the possibility to control the distribution of GPU computation resources at system level.
Platforms equipped with GPU processors help mitigating the ever-increasing computational demands of modern embedded systems. Such systems can be specifically developed by using component-based development thanks to the concept of flexible components. Through this concept, a component can be transparently executed either on a CPU or a GPU. However, this flexibility complicates the allocation process because it adds additional complexity (i.e., due to the undecided CPU or GPU execution) and constraints to consider (i.e., CPUs and GPUs properties). In this work, we address this problem by providing an optimization model for component-based embedded systems executing on both CPU and GPU. The model addresses important optimization goals, characteristic to the embedded system domain, such as memory usage, energy usage and execution time. A novelty of this work is the formal description of the optimization model, which supports the usage of mixed integer nonlinear programming to compute optimal allocation schemes. To examine the feasibility of the proposed method, we apply the optimization model on a vision system constructed using the industrial Rubus component model.
In a quest to improve system performance, embedded systems are today increasingly relying on heterogeneous platforms that combine different types of processing units such as CPUs, GPUs and FPGAs. However, having better hardware capability alone does not guarantee higher performance; how functionality is allocated onto the appropriate processing units strongly impacts the system performance as well. Yet, with this increase in hardware complexity, finding suitable allocation schemes is becoming a challenge as many new constraints and requirements must now be taken into consideration. In this paper, we present a formal model for allocation optimization of embedded systems which contains a mix of CPU and GPU processing nodes. The allocation takes into consideration the software and hardware architectures, the system requirements and criteria upon which the allocation should be optimized. In its current version, optimized allocation schemes are generated through an integer programming technique to balance the system resource utilization and to optimize the system performance using the GPU resources.
One pressing challenge of many modern embedded systems is to successfully deal with the considerable amount of data that originates from the interaction with the environment. A recent solution comes from the use of GPUs, providing a significantly improved performance for data-parallel applications. Another trend in the embedded systems domain is component-based development. However, existing component-based approaches lack specific support to develop embedded systems with GPUs. As a result, components with GPU capability need to encapsulate all the required GPU information, leading to component specialization to specific platforms, hence drastically impeding component reusability. To facilitate component-based development of embedded systems with GPUs, we introduce the concept of flexible components. This increases the design flexibility by allowing the system developer to decide component allocation (i.e., either the CPU or GPU) at a later stage of the system development, with no change to the component implementation. Furthermore, we provide means to automatically generate code for adapting flexible components corresponding to their hardware placement, as well as code for component communication. Through the introduced support, components with GPU capability are platform-independent, and can be executed, without manual adjustment, on a large variety of hardware (i.e., platforms with different GPU characteristics).
Nowadays, there are many embedded systems with different architectures that have incorporated GPUs. However, it is difficult to develop CPU-GPU embedded systems using component-based development (CBD), since existing CBD ap- proaches have no support for GPU development. In this context, when targeting a particular CPU-GPU platform, the component developer is forced to construct hardware-specific components, which are problematic to (re-)use in different contexts. More- over, hard-coding specific GPU-usage characteristics (e.g., the number of utilized GPU threads) inside the component is not possible without making detailed assumptions about the system in which the component is used, which conflicts with separation- of-concerns CBD principle. The paper presents a solution to allow component-based development of platform-agnostic CPU-GPU embedded systems through: i) high-level API, ii) adapters, and iii) code template. The API abstracts the specifics of the different platforms, while the adapters externalize hardware-specific activities outside components. We also raise the decision regarding the GPU- usage specifications, from the component to the system level. Furthermore, to minimize the development effort, we provide a code template that contains ready-made code fragments required for GPU development. As a case study, we examine the feasibility of our solution applied on a component-based vision system of an underwater robot.
Today, embedded systems incorporate GPUs through a multitude of different architectures. When it comes to the development of these systems with GPUs, component-based development is ill-equipped as it does not provide support for GPUs. Instead, the component developer needs to encapsulate inside the component, besides functionality, settings and environment information that are specific to a particular GPU architecture. This binds the component this GPU architecture. Using these hardware-specific components characterized by restricted reusability, the system developer is confined to a limited design space which may negatively impact the overall system feasibility.
In this paper, we introduce the concept of flexible components, which are components that can be executed indifferently on CPU or GPU, regardless of the architecture. Using flexible components, component developers are relieved from the side development activities (e.g., environment information) which are automatically handled by component-level mechanisms. To enhance component communications, connection elements (i.e., adapters) are generated to handle component data transmission, taking in consideration the platform characteristics. Finally, our proposed solution is evaluated by using flexible components to implement the vision system of an underwater robot, and execute it on three platforms with different GPU architectures.
Today, the newly available embedded boards with GPUs provide a solution to satisfy the ever-increasing requirements of modern embedded systems. Component-based development is a well-known paradigm used to develop embedded systems. However, this paradigm lacks GPU support to address the specifics of these new boards. This leads to components that typically have reduced reusability, poor maintainability and portability. One way to tackle the existing shortcomings is through flexible components, i.e., platform-agnostic components that, at design time, offer the possibility to be executed either on CPU or GPU. The current realization of flexible components, i.e., as regular components with functionality tailored for the selected hardware, introduces additional overheads such as component communication overhead. In order to tackle the introduced overheads, our solution groups connected flexible components under a flexible group that conceptually behaves as a component. We introduce an algorithm to identify the existing groups in a given component-based system and the generation rules that automatically realizes groups as regular components. To evaluate the feasibility of the new concept, the flexible group is implemented using a state-of-the-practice component model (i.e., Rubus) and examined through the vision system of an underwater robot.
To support the complex functionality expected of modern embedded systems, the trend is to supplement CPUs with Graphical Processing Units (GPUs), thus creating heterogeneous embedded systems. However, taking full advantage of GPUs increases the complexity of the development and requires dedicated support, and no such support exists in the component models currently available. The only solution today is to completely encapsulate all GPU-specific information and operations within the components, which increases the communication overhead and reduces component reusability, thus significantly limiting the applicability of component-based development to heterogeneous embedded systems. In this paper, we propose to extend Rubus, an industrial component model for embedded systems, with dedicated support for GPUs. We introduce new constructs, including GPU ports and automatically generated adapters to facilitate seamless component communication over the heterogeneous processing units, regardless of whether the components use the CPU, GPU, or both. A running example is used for the problem description, the proposed extension, and to evaluate our solution.
Software architecture is no more a mere system specification as resulting from the design phase, but it includes the process by which its specification was carried out. In this respect, design decisions in component-based software engineering play an important role: They are used to enhance the quality of the system, keep the current market level, keep partnership relationships, reduce costs, and so forth. For non trivial systems, a recurring situation is the selection of an asset origin, that is if going for in-house, outsourcing, open-source, or COTS, when in the need of a certain missing functionality. Usually, the decision making process follows a case-by-case approach, in which historical information is largely neglected: hence, it is avoided the overhead of keeping detailed documentation about past decisions, but it is hampered consistency among multiple, possibly related, decisions.The ORION project aims at developing a decision support framework in which historical decision information plays a pivotal role: it is used to analyse current decision scenarios, take well-founded decisions, and store the collected data for future exploitation. In this paper, we outline the potentials of such a knowledge repository, including the information it is intended to be stored in it, and when and how to retrieve it within a decision case.
As software complexity increases in embedded systems domain, component-based development becomes increasingly attractive. A main challenge in this approach is however to analyze the system's extra-functional properties (such as timing properties, or resource requirements), an important step in a development of embedded systems. Analysis of such properties are computational and time consuming, and often difficult. For this reason reuse of the results of the analysis is as important as the reuse of the component itself, especially in case of modifications of the context in which the component is used. This paper presents concepts and mechanisms that allow to automatically discover whether a property value is still valid when related components evolve: a value context language is proposed to formally define the validity conditions and identify possible threats
The essence of component-based software engineering is embodied in component models. Component models specify the properties of components and the mechanism of component compositions. In a rapid growth, a plethora of different component models has been developed, using different technologies, having different aims, and using different principles. This has resulted in a number of models and technologies which have some similarities, but also principal differences, and in many cases unclear concepts. Component-based development has not succeeded in providing standard principles, as for example object-oriented development. In order to increase the understanding of the concepts, and to easier differentiate component models, this paper provides a Component Model Classification Framework which identifies and quantifies basic principles of component models. Further, the paper classifies a certain number of component models using this framework.
This paper describes PRIDE, an integrated development environment for efficient component-based software development of embedded systems. PRIDE uses reusable software components as the central development units, and as a means to support and aggregate various analysis and verification techniques throughout the whole lifecycle - from early specification to deployment and synthesis. This paper focuses on support provided by PRIDE for the modeling and analysis aspects of the development of embedded systems based on reusable software components.
In the last decade a large number of different software component models have been developed, with different aims and using different principles and technologies. This has resulted in a number of models which have many similarities, but also principal differences, and in many cases unclear concepts. Component-based development has not succeeded in providing standard principles, as has, for example, object-oriented development. In order to increase the understanding of the concepts, and to differentiate component models more easily, this paper identifies, discusses and characterises fundamental principles of component models, and provides a Component Model Classification Framework based on these principles. Further, the paper classifies a large number of component models using this framework.
Modern embedded systems utilize the advances in heterogeneous platforms that enable implementing functions in software (SW) and hardware (HW) components. A proper configuration of SW and HW components can significantly improve the values of the extra-functional properties such as performance and energy savings. However, due to increasing application complexity, it is difficult to find the best combination of HW and SW components. The problem basically boils down to calculate, for a given architecture, the system properties from the components' ones. In this paper, we address the problem of composability of EFPs at system level. Although in general this is not a solvable problem, we present that, under strictly specified constraints, it is possible to compose the system EFPs starting from the component ones. We start by detailing constraints related to the system architecture, platform and process development and, based on these constraints, we provide composition rules for different types of EFPs. We demonstrate the results through an industrial example.
The cloud computing paradigm provides remote computing resources to the cloud service consumers and businesses. When combined with Internet of Things (IoT), both technologies open up a wide range of new possibilities for more agile and flexible applications. However, guaranteed quality of service is essential in provisioning of cloud services, which makes Service Level Agreements (SLAs) a focal point in the cloud computing and IoT ecosystem. The SLA definition and modeling phase is crucial in establishing SLAs between service providers and consumers. This paper identifies that the research on definition and modeling of SLAs for cloud services in IoT is widely dispersed and there is a lack of a systematic and comprehensive literature review. Thus, in this paper we build on top of a previously conducted systematic mapping study on management of SLAs for cloud computing and IoT to perform a comprehensive systematic review and discuss sub-categorization of the definition and modeling aspects of SLAs for cloud services in IoT. Furthermore we analyze the extracted relevant literature, present commonalities in the studies, identify gaps and discuss opportunities for further research in the area.
In this paper, we present an approach allowing dynamic reconfiguration in wireless sensor networks (WSNs). This proposition is based on a twofold work. First we propose Valentine, a new component-based operating system (OS) for WSNs, allowing dynamic administration of components at runtime. This OS will be generated from the Think framework. Second, we discuss and present a specific mechanism for dynamic reconfiguration in the constrained context of WSNs.
The rapid development of Industry 4.0 and Industrial Cyber-Physical Systems is leading to the exponential growth of unprocessed volumes of data. Industrial cloud computing has great potential for providing the resources for processing this data. To be widely adopted, the cloud must ensure satisfactory levels of Qualityof Service (QoS). However, the lack of a standardized model of quality attributes hinders the assessmentof QoS levels. This paper provides a comprehensive systematically defined map of current research trends,results, and gaps in quality attributes and QoS in industrial cloud computing. An extract of the main insights is as follows: (i) the adoption of cloud technologies is closely related to performance indicators, however other quality attributes, such as security, are not considered as much as they should; (ii) solutions are most often not tailored to specific industrial application domains; (iii) research largely focuses on providing solutions with outsolid validation, unsuitable for effective and fruitful technology transfer.
Hierarchical component models allow to better manage system design complexity compared to flat component models. However, many analysis techniques lack support for dealing with hierarchical models. This paper presents a general approach to use existing analysis on hierarchical component systems by means of a flattening transformation. The transformation can be partially applied, which provides a possibility for tradeoffs between analysis scalability, result precision and reusability concerns. The general approach has been implemented and evaluated in the context of ProCom, a hierarchical component model for real-time embedded systems. As a result, the paper describes a flattening transformation which preserves the ProCom operational semantics and presents the related optimizations. © 2011 IEEE.
It is nowadays widely accepted that extra-functional properties (EFPs) are as important as functional properties for system correctness, especially when considering systems such as safety-critical embedded systems. The criticality and resource-constrained nature of these systems necessitate to be able to predict tight and accurate extra-functional property values all along the development, from early estimations to measurements. By using a hierarchical component model that allows implementing components as an assembly of subcomponent instances, the same component can be instantiated in several assemblies, i.e. in different usage contexts. Many EFP values are sensitive to the usage context and knowing information about the enclosing assembly enables refining the values of the properties on the subcomponents. Such refinement is usually not supported and the consistency between refined values and the original ones not ensured. This paper presents the concepts and mechanisms to support EFP refinement in hierarchical component models with explicit property inheritance and refinement policies which formally define consistency constraints between refined value and the original one. These policies are interpreted and ensured for all actors and in all workspaces. The paper also describes the related experiments performed on the ProCom component model. © 2011 ACM.
Quality requirements deal with how well a product should perform the intended functionality, such as start-up time and learnability. Researchers argue they are important and at the same time studies indicate there are deficiencies in practice. Our goal is to review the state of evidence for quality requirements. We want to understand the empirical research on quality requirements topics as well as evaluations of quality requirements solutions. We used a hybrid method for our systematic literature review. We defined a start set based on two literature reviews combined with a keyword-based search from selected publication venues. We snowballed based on the start set. We screened 530 papers and included 84 papers in our review. Case study method is the most common (43), followed by surveys (15) and tests (13). We found no replication studies. The two most commonly studied themes are (1) differentiating characteristics of quality requirements compared to other types of requirements, (2) the importance and prevalence of quality requirements. Quality models, QUPER, and the NFR method are evaluated in several studies, with positive indications. Goal modeling is the only modeling approach evaluated. However, all studies are small scale and long-term costs and impact are not studied. We conclude that more research is needed as empirical research on quality requirements is not increasing at the same rate as software engineering research in general. We see a gap between research and practice. The solutions proposed are usually evaluated in an academic context and surveys on quality requirements in industry indicate unsystematic handling of quality requirements.
Context The development of software-intensive systems includes many decisions involving various stakeholders with often conflicting interests and viewpoints. Objective: Decisions are rarely systematically documented and sporadically explored. This limits the opportunity for learning and improving on important decisions made in the development of software-intensive systems. Method: In this work, we enable support for the systematic documentation of decisions, improve their traceability and contribute to potentially improved decision-making in strategic, tactical and operational contexts. Results: We constructed a taxonomy for documentation supporting decision-making, called GRADE. GRADE was developed in a research project that required composition of a common dedicated language to make feasible the identification of new opportunities for better decision support and evaluation of multiple decision alternatives. The use of the taxonomy has been validated through thirty three decision cases from industry. Conclusion: This paper occupies this important yet greatly unexplored research gap by developing the GRADE taxonomy that serves as a common vocabulary to describe and classify decision-making with respect to architectural assets.
This paper introduces a decision canvas for capturing architecture decisions in software and systems engineer- ing. The canvas leverages a dedicated taxonomy, denoted GRADE, meant for establishing the basics of the vocabulary for assessing and choosing architectural assets in the development of software-intensive systems. The canvas serves as a template for practitioners to discuss and document architecture decisions, i.e., capture, understand and communicate decisions among decision-makers and to others. It also serves as a way to re- flect on past decision-making activities devoted to both tentative and concluding decisions in the development of software-intensive systems. The canvas has been assessed by means of preliminary internal and external evaluations with four scenarios. The results are promising as the canvas fulfills its intended objectives while satisfying most of the needs of the subjects participating in the evaluation.
Engineering software-intensive systems is a complex process that typically involves making many critical decisions. A continuous challenge during system design, analysis and development is deciding on the reference architecture that could reduce risks and deliver the expected functionality and quality of a product or a service to its users. The lack of evidence in documenting strategies supporting decision-making in the selection of architectural assets in systems and software engineering creates an impediment in learning, improving and also reducing the risks involved. In order to fill this gap, ten experienced researchers in the field of decision support for the selection of architectural assets in engineering software-intensive systems conducted a workshop to reduce traceability of strategies and define a dedicated taxonomy. The result was the GRADE taxonomy, whose key elements can be used to support decision-making as exemplified through a real case instantiation for validation purposes. The overall aim is to support future work of researchers and practitioners in decision-making in the context of architectural assets in the development of software-intensive systems. The taxonomy may be used in three ways: (i) identify new opportunities in structuring decisions; (ii) support the review of alternatives and enable informed decisions; and (iii) evaluate decisions by describing in a retrospective fashion decisions, factors impacting the decision and the outcome.
The choice of which software component to use influences the success of a software system. Only a few empirical studies investigate how the choice of components is conducted in industrial practice. This is important to understand to tailor research solutions to the needs of the industry. Existing studies focus on the choice for off-the-shelf (OTS) components. It is, however, also important to understand the implications of the choice of alternative component sourcing options (CSOs), such as outsourcing versus the use of OTS. Previous research has shown that the choice has major implications on the development process as well as on the ability to evolve the system. The objective of this study is to explore how decision making took place in industry to choose among CSOs. Overall, 22 industrial cases have been studied through a case survey. The results show that the solutions specifically for CSO decisions are deterministic and based on optimization approaches. The non-deterministic solutions proposed for architectural group decision making appear to suit the CSO decision making in industry better. Interestingly, the final decision was perceived negatively in nine cases and positively in seven cases, while in the remaining cases it was perceived as neither positive nor negative.
Energy is an important constraint in embedded systems, and there exists a huge expertise in this domain about monitoring, managing and optimizing energy consumption in the computer systems. The aim of this paper is to present the energy management addressed in the research literature. Based on a systematic review, the paper presents a taxonomy of energy consumption and management in embedded systems.
With the emergence of "Industry 4.0", the integration of cloud technologies and industrial cyber-physical systems becomes increasingly important to boost productivity. The industrial cyber-physical systems infrastructures and their fusion with the cloud lead to massive amounts of data acquired for controlling particular processes, but also for supporting decision-making. Although cloud-assisted systems are increasingly important in many domains, and ensuring their dependability is crucial, existing platforms do not provide satisfactory support to meet the dependability demands of industrial applications. The overall goal of the ACICS project is to provide models, methods and tools that facilitate a substantial increase of dependability of cloud-based platforms for industrial cyber-physical applications, with respect to consistency, security and interoperability of data, timing predictability of using shared virtual resources, together with a framework of guaranteeing quality-of-service enforcement by formal analysis and verification. In this paper, we present the main conceptual ideas behind the ACICS approach.
The continuously increasing complexity of embedded systems is a major issue for their development, which, in addition, must also consider specific extra-functional requirements and constraints, such as limited and shared resources, distribution, timing, and dependability. Thus, embedded systems call for development solutions that can efficiently and predictably cope with these issues. Component-based software engineering is a proven paradigm to handle complexity. Yet, for efficiently managing extra-functional properties, a component model needs to have dedicated mechanisms that provide a suitable support for their management. The objective of this thesis is to build this support.
We have performed a systematic analysis of existing component models and identified challenges of applying a component-based approach to embedded system development. Based on these challenges we have advanced the current state-of-the-art by developing a new component model, called ProCom, that accommodates the specifics of embedded systems through its well-defined execution semantics and layered structure. Centered around ProCom, we have also developed PRIDE, the ProCom Integrated Development Environment. PRIDE supports the development from early specification to synthesis and deployment, providing the means to aggregate various analysis and verification tools.
The main contribution of the thesis is in the design and implementation of an extra-functional property management framework that enables to seamlessly specify, manage and integrate multi-valued context-aware extra-functional properties of component-based embedded systems. Properties can be attached to architectural elements of component models and their values can be compared and refined during the development process. In particular, having multiple context-aware values allows values from different sources to be compared. The proposed concepts have been demonstrated on several representative example systems.
New trends in software engineering recently emerged to cope with even more complex systems which in turns highlight problems software shortfalls and defects. The SQUADE (Software QUAlities and their DEpendencies) workshop focuses on increasing the understanding of the nature of Software Qualities (SQs), i.e., nonfunctional properties or extra-functional requirements (e.g., reliability, security, maintainability, etc.), and their interrelationships with the aim of bringing them into practice of software engineering. The topic is highly relevant due to the current trend of designing and developing software-intensive systems with larger complexity, increased autonomy, higher speed of changes, and growing need for interoperability within systems of systems. Unfortunately, this new trend comes with more software shortfalls and defects, which are widely and publicly spread. The primary goal of the workshop is to bring together researchers and practitioners to build more solid foundations when dealing with software qualities.
The way software properties are defined, described, and measured, is different across different domains. When addressing these properties, several challenges commonly emerge, among which: synonymity, polysemy, paronymy, incomplete and inconsistent specification. In this paper we introduce PROMOpedia, an online encyclopedia, to tackle these challenges. PROMOpedia uses a web-content management system coupled with crowd-sourcing of scientific contents related to properties and their evaluation methods. The core concepts of PROMOpedia are built upon a property models ontology previously proposed by the authors, and is intended to target the needs of both researchers and practitioners. Website: http://www.mrtc.mdh.se/promopedia/
Teaching of model-driven software engineering in a software engineering master program curriculum suits well with the maturity of the students and their ability to understand the concept. Still the education might
fail if the teaching is not based on convincing arguments and relations to the research or practice. We are about introducing a model-driven engineering
course in our software engineering master curriculum and our goal is to relate the teaching with both research results and industrial practice. In this paper, we describe our approach - how to utilize the research results and how to relate the course to the requirements from industry we have cooperation with.
—In software development, software quality is nowadays acknowledged to be as important as software functionality and there exists an extensive body-of-knowledge on the topic. Yet, software quality is still marginalized in practice: there is no consensus on what software quality exactly is, how it is achieved and evaluated. This work investigates the state-of-the-art of software quality by focusing on the description of evaluation methods for a subset of software qualities, namely those related to software security. The main finding of this paper is the lack of information regarding fundamental aspects that ought to be specified in an evaluation method description. This work follows up the authors’ previous work on the Property Model Ontology by carrying out a systematic investigation of the state-of-the-art on evaluation methods for software security. Results show that only 25% of the papers studied provide enough information on the security evaluation methods they use in their validation processes, whereas the rest of the papers lack important information about various aspects of the methods (e.g., benchmarking and comparison to other properties, parameters, applicability criteria, assumptions and available implementations). This is a major hinder to their further use.
Efficient development of high quality software is tightly coupled to the ability of quickly taking complex deci- sions based on trustworthy facts. In component-based software engineering, the decisions related to selecting the most suitable component among functionally-equivalent ones are of paramount importance. Despite sharing the same functionality, components differ in terms of their extra-functional properties. Therefore, to make informed selections, it is crucial to evaluate extra-functional properties in a systematic way. To date, many properties and evaluation methods that are not necessarily compatible with each other exist. The property model ontology presented in this paper represents the first step towards providing a systematic way to describe extra-functional properties and their evaluation methods, and thus making them comparable. This is beneficial from two perspectives. First, it aids researchers in identifying comparable property models as a guide for empirical evaluations. Second, practitioners are supported in choosing among alterna- tive evaluation methods for the properties of their interest. The use of the ontology is illustrated by instantiating a subset of property models relevant in the automotive domain.
The paper presents Save-IDE, an Integrated Development Environment for thedevelopment of component-based embedded systems. Save-IDE supports efficient development of dependable embedded systems by providing tools for design of embedded software systems using a dedicated component model, formal specification and analysis of component and system behaviors already in early development phases, and a fully automated transformation of the system of components into an executable image.
In this paper we present an Integrated Development Environment Save-IDE, a toolset that embraces several tools: a tool for designing component-based systems and components, modeling and predicting certain run-time properties, such as timing properties, and transforming the components to real-time execution elements. Save-IDE is specialized for the domain of dependable embedded systems, which in addition to standard design tools requires tool support for analysis and verification of particular properties of such systems.
Management of extra-functional properties in component models is one ofthe main challenges in the component-based software engineering community.Still, the starting point in their management, namely their specification in acontext of component models is not addressed in a systematic way. Extra-functional properties can be expressed as attributes (or combinations of them)of components, or of a system, but also as attributes of other elements, such as interfaces and connectors. Attributes can be defined as estimations, or can be measured, or modelled; this means that an attribute can be expressed through multiple values valid under different conditions. This paper addresses how this diversity in attribute specifications and their relations to component model canbe expressed, by proposing a model for attribute specifications and their integrations in componentmodels. A format for attribute specification is proposed,discussed and analyzed, and the approach is exemplified through its integration both in the ProCom component model and its integrated development environment.
In this paper we focus on design of a class of distributed embedded systems that primarily perform real-time controlling tasks. We propose a two-layer component model for design and development of such embedded systems with the aim of using component-based development for decreasing the complexity in design and providing a ground for analyzing them and predict their properties, such as resource consumption and timing behavior. The two-layer model is used to efficiently cope with different design paradigms on different abstraction levels. The model is illustrated by an example from the vehicular domain.
This paper addresses the challenge of designing embedded real-time systems in an uniformed view no matter what their targeted utilisation domain is. Although Component-Based Development is an acknowledged approach for developing non real-time and non embedded systems, it still struggles to emerge in embedded real-time domains. This is mainly due to an inability to have accepted definitions and standards well-suited with the highly constrained characteristics (timing requirements, memory size, CPU speed) of such domain. In leaning upon a model-based framework, this paper describes a work-in-progress which aims at getting a common definition of what real-time components are as well as having a common structure to specify and design them.
When component-based development is applied in the domain of distributed embedded systems, where applications are often safety-critical and subject to real-time constraints, it is of significant importance that reliable predictions of functional and extra-functional properties can be derived at design-time. Preferably, analysis should be performed in early development phases, where the cost of modifying the design is lower. Centered on an example application from the automation domain, we show how a component model specifically intended for embedded systems can be combined with a language for high-level formal behavior modeling. This allows modeling the behavior of individual components, in terms of functionality, timing and resource usage. In turn, this permits analysis of system level properties, while also supporting reuse of behavioral models when components are reused.
When component-based development is applied to distributed embedded systems, which are often safety-critical and subject to real-time constraints, it is of significant importance that reliable predictions of functional and extrafunctional properties can be derived at design-time. Preferably, analysis should be performed in early development phases, where the cost of modifying the design is lower. Centered on an example application from the automation domain, we show how a component model specifically intended for embedded systems can be combined with a language for high-level formal behavior modeling. This permits analysis of system properties, while also supporting reuse of behavioral models when components are reused.
Software engineering is decision intensive. Evidence-based software engineering is suggested for decision-making concerning the use of methods and technologies when developing software. Software development often includes the reuse of software assets, for example, open-source components. Which components to use have implications on the quality of the software (e.g., maintainability). Thus, research is needed to support decision-making for composite software. This paper presents a roadmap for research required to support evidence-based decision-making for choosing and integrating assets in composite software systems. The roadmap is developed as an output from a 5-year project in the area, including researchers from three different organizations. The roadmap is developed in an iterative process and is based on (1) systematic literature reviews of the area; (2) investigations of the state of practice, including a case survey and a survey; and (3) development and evaluation of solutions for asset identification and selection. The research activities resulted in identifying 11 areas in need of research. The areas are grouped into two categories: areas enabling evidence-based decision-making and those related to supporting the decision-making. The roadmap outlines research needs in these 11 areas. The research challenges and research directions presented in this roadmap are key areas for further research to support evidence-based decision-making for composite software.