The workshop connects to the central theme “Educating for the Future” of CSEE&T 2020 and thus explores opportunities to improve Software Engineering education and training by using Essence. Essence, an OMG Standard, delivers essential, universal elements found in all Software Engineering (SE) endeavours and a language to describe and extend these elements and their use in concrete practices to tailor SE methods to teams' needs. Its Kernel separates the stable What and Why from the more adaptable How. That way, it provides an essential thinking framework facilitating the adoption and customization of practices and methods. As such, it supports multiple ways of educating SE students as well as training practitioners for the future. The first deployments of Essence in industry and academic courses around the globe show promising results. But since it is an entirely new way to think about SE practices, methods, and their building blocks—it requires some effort and thought to dive into the standard. This workshop facilitates the adoption by sharing experiences, best practices, and lessons learned.

The ever increasing complexity of software and rapidly changing development environments continues to drive the evolution of new technologies, techniques, and tools. This special issue, Software Engineering in Practice, provides the software engineering community with a valuable collection of current high-quality research articles that explore topics driven by real problems in industry. The inspiration for this special issue has drawn upon the ICSE Software Engineering in Practice Track (ICSE SEIP 2019)1, part of the Industry Program at the 41st International Conference on Software Engineering2; it builds upon the success of the previous special issue with the same theme.1 The ICSE SEIP Track provides a premier venue for researchers and practitioners to discuss innovations and solutions to concrete software engineering problems. The guest coeditor team for this special issue is an international collaboration involving the co-organizers of the ICSE SEIP 2019 Track, Helen Sharp and Michael Whalen, and two editors of the Journal of Software: Practice and Experience3 (JSPE), Judith Bishop and Kendra M. L. Cooper. The Call for Papers was designed to encourage submissions that presented novel and innovative ideas that broadly spanned the software engineering discipline; ideas that provided rigorously validated solutions for real problems encountered by practitioners. In order to promote an inclusive environment, the call was broadly disseminated as an open call; it was advertised on the JSPE and the ICSE SEIP 2019 websites, established software engineering newsgroups (eg, SEWORLD) and conference announcement sites (eg, WikiCFP), in addition to numerous professional and social media platforms. The call required submissions be original manuscripts that had not been previously published and were also not under consideration for publication elsewhere. Submissions of research article, survey papers, short communication, and extended conference papers were welcome; extended conference papers were required to include at least 30% additional novel contributions. The response from the software engineering community was enthusiastic: the special issue received 25 manuscripts submitted by authors from 13 countries. Submissions featured international collaborations from researchers in academia and industry, cases studies from industry, and the use of open source data sets and systems provided by the broader community. The submissions were reviewed according to the JSPE standards, with a goal of publishing the online version of the articles in a timely fashion. Ultimately, six articles were selected for the special issue. Overviews of these accepted manuscripts are presented below, organized into two groups. Novel contributions in the area of intelligent code analysis are explored in several of the papers in the special issue. Kim et al present an automated code analysis approach based on machine learning to recommend an appropriate level for logging runtime events. Rong et al present an automated code analysis approach based on templates and rules to generate documentation in a timely manner within agile DevOps environments. In addition, Huang et al present an automated code analysis approach to identify the need for header comments with the goal of supporting the long-term evolution of the product. Several of the papers in the special issue are related to the broader topic of reuse, from different perspectives. Weir et al present an on-going lightweight security training program that has the potential to be reused by a wide range of development teams; the research has a grounded theory foundation. Koziolek et al present a reference architecture to further the standardization and automation of IoT integration. Hu et al present a data mining-based approach to search and filter existing code samples with the goal of establishing high quality software repositories. We would like to extend our warmest thanks to all the authors who submitted their manuscripts, the anonymous reviewers who provided timely, high-quality review comments in their generous service to the community, and the JSPE editorial board and personnel.

Learning requirements engineering (RE) notations is a tedious task for most people, because this learning activity is all but engaging. As an alternative to traditional educational methods, we propose BakeRE, a serious educational game for RE. The game focuses on specific learning objectives: the specification and analysis of requirements with user stories. BakeRE is the first game proposed to address these learning objectives. It is a multilevel puzzle game that can complement courses (traditional or on-line), such as a general software engineering or a specialized RE course. The player assembles user stories for a specific system by combining building blocks (roles, actions, benefits) from a predefined collection. As the player progresses through the levels, the difficulty increases. At the end of each level, learning feedback is provided to the player. Besides describing the game and its learning objectives, we present the game design process and outline in-progress research that aims to extend BakeRE through its embedding within an RE course.

The ever-increasing complexity of software and rapidly changing development environments continues to drive the evolution of new technologies, techniques, and tools. This special issue, Software Engineering in Practice, provides the software engineering community with a valuable collection of current, high-quality research articles that explore topics driven by real problems in the industry. The inspiration for this special issue has drawn upon the ICSE Software Engineering in Practice (ICSE SEIP 2018) Track, 1 part of the Industry Program at the 40th International Conference on Software Engineering. 2 The ICSE SEIP Track provides a premier venue for researchers and practitioners to discuss innovations and solutions to concrete software engineering problems. The Guest Co-editor team for this special issue is an international collaboration involving the co-organizers of the ICSE SEIP 2018 Track, Frances Paulisch and Jan Bosch, and an editor of the Journal of Software: Practice and Experience 3 (JSPE), Kendra M. L. Cooper. Methodology The Call for Papers was designed to encourage submissions that presented novel and innovative ideas that broadly spanned the software engineering discipline—ideas that provided rigorously validated solutions for real problems encountered by practitioners. In order to promote an inclusive environment, the call was broadly disseminated as an open call; it was advertised on the JSPE and the ICSE SEIP 2018 websites, established software engineering newsgroups (eg, SE World), and conference announcement sites (eg, WikiCFP), in addition to numerous professional and social media platforms. The call required submissions be original manuscripts that had not been previously published and were also not under consideration for publication elsewhere. Submissions of research article, survey papers, short communication, and extended conference papers were welcome; extended conference papers were required to include at least 30% additional novel contributions. The response from the software engineering community was enthusiastic: the special issue received 41 submissions. Submissions featured international collaborations from researchers in academia and industry, case studies from industry, and the use of open source data sets and systems provided by the broader community. The submissions were reviewed according to the JSPE standards, with a goal of publishing the online version of the articles in a timely fashion. Ultimately, nine articles were selected for the special issue. Overviews of these accepted manuscripts are presented below, organized into three groups. Overview of the collection Novel contributions in the area of data analytics are explored in some of the papers in the special issue. Astekin et al present a framework for automated analysis of large system logs to detect anomalies. Karna et al employ data mining methods on the software engineering process itself and use these techniques for effort estimation. Marijan et al introduce a novel learning algorithm to optimize the continuous integration and testing practice. In addition, Martens et al investigate the problem of data migration between legacy and newly developed IT systems. Research problems centered on mobile application code are the focus of two papers in the special issue. Ochoa et al apply static analysis techniques on Android applications to detect context leaks in the code. Wang et al also study mobile applications; these authors report on approaches to obfuscate mobile application code with the intent of impeding efforts to reverse engineering applications. Techniques based on the model-driven development paradigm are presented in several of the papers in the special issue. Nooraei and Ajoudanian present a framework to ensure the on-going integrity of the transformation between the platform-independent model (PIM) and the corresponding platform-specific model (PSM) of a system via regression testing. Markthaler et al present a model-driven method for the automotive domain that spans multiple layers of software engineering artifacts; on-going consistency checking between the layers is supported in addition to the generation and re-generation of test cases. O'Shea et al present a three-layer design model for a virtualized test automation framework; a key feature of this model is the virtualized infrastructure layer. We would like to extend our warmest thanks to all the authors who submitted their manuscripts, the anonymous reviewers who provided timely and high-quality review comments in their generous service to the community, and the editorial board and personnel of the Journal of Software: Practice and Experience.

Educational environments continue to rapidly evolve to address the needs of diverse, growing student populations, while embracing advances in pedagogy and technology. In this changing landscape ensuring the consistency among the assessments for different offerings of a course (within or across terms), providing meaningful feedback about students' achievements, and tracking students' progression over time are all challenging tasks, particularly at scale. Here, a collection of visual Topic Dependency Models (TDMs) is proposed to help address these challenges. It visualises the required topics and their dependencies at a course level (e.g., CS 100) and assessment achievement data at the classroom level (e.g., students in CS 100 Term 1 2016 Section 001) both at one point in time (static) and over time (dynamic). The collection of TDMs share a common, two-weighted graph foundation. An algorithm is presented to create a TDM (static achievement for a cohort). An open-source, proof of concept implementation of the TDMs is under development; the current version is described briefly in terms of its support for visualising existing (historical, test) and synthetic data generated on demand.

Educators continue to face significant challenges in providing high quality, post-secondary instruction in large classes including: motivating and engaging diverse populations (e.g., academic ability and backgrounds, generational expectations); and providing helpful feedback and guidance. Researchers investigate solutions to these kinds of challenges from alternative perspectives, including learning analytics (LA). Here, LA techniques are applied to explore the data collected for a large, flipped introductory programming class to (1) identify groups of students with similar patterns of performance and engagement; and (2) provide them with more meaningful appraisals that are tailored to help them effectively master the learning objectives. Two studies are reported, which apply clustering to analyze the class population, followed by an analysis of a subpopulation with extreme behaviours.

We present a summary of the 4th ICSE Workshop on Games and Software Engineering. The full day workshop is planned to include a keynote speaker, game-jam demonstration session, and paper presentations on game software engineering topics related to software engineering education, frameworks for game development and infrastructure, quality assurance, and model-based game development. The accepted papers are overviewed here.

Engineering ethics often receives attention in separate courses or modules, however other critical elements of professionalism are not directly addressed in a curriculum. Graduates coming to industry frequently lack proficiency in vital skills such as being adept in appropriate interpersonal communications, quickly adapting to industry protocols, and effectively acclimating to corporate hierarchy, culture and accountability. Many programs assume that professionalism is indirectly socialized through faculty modeling and classroom management. Such an assumption does not serve our students well, or the SE industry that hires them and then must put a tremendous effort into new employee orientation to create a productive work environment. This highly interactive tutorial provides practical resources for those who seek to introduce professionalism education into the SE curriculum but cannot create whole new courses devoted to the subject. Participants who will come away with concrete plans to assess, create, and integrate professional development opportunities into their academic Software Engineering curricula or industry training programs. This tutorial is a fertile opportunity for SE educators, advisors, administrators and representatives from SE undergraduate professional societies who want to respond to a vital concern for many campuses.

We present a summary of the 3rdICSE Workshop on Games and Software Engineering: Engineering Computer Games to Enable Positive, Progressive Change in this article. The full day workshop is planned to include a keynote speaker, panel discussion, and paper presentations on game software engineering topics related to requirements specification and verification, software engineering education, re-use, and infrastructure. The accepted papers are overviewed here.

This short paper presents a preliminary meta-model for educational games. A meta-model facilitates the development of high-quality, engaging, educational games because it explicitly ties knowledge requirements, transferable skills and course outcomes to game production. Our meta-model is designed to be transferable across curricula, as it modularizes domain specific bodies of knowledge (BOK), a learning taxonomy (e.g., Bloom's), and skill based challenges. The model situates learning opportunities in a plotline wherein the student-player advances by succeeding against non-player adversaries. Knowledge-based challenges framed by a learning taxonomy develop the transferable skills required by international accreditation standards and provide feedback to both the player and the faculty member. Situating assessment challenges in an immersive game environment makes them more engaging and imaginative than typical on-line tests or assignments. Here, we present our meta-model tailored for educational game development in software engineering education.

Summary form only given. Spoken language technologies have reached enough maturity to be integrated in many applications in eHealth and eLearning. The challenges and the potential are enormous. There are many other areas in which this claim could be equally made, but these two areas share many technical issues and, of course, they also share a huge significance from a social point of view. This was the driving force for our recent efforts at the Spoken Language Systems Lab of INESC-ID in terms of eHealth and eLearning. This talk tries to give an overview of these efforts and, in spite of the fact that they will be demonstrated for the Portuguese language, it will also try to emphasize how easily they can be extended to new languages.

Recently, there has been an interest in finding ways to combine reuse and customization as practiced in software product line engineering with concepts like iterative development and minimalism as preached by agile methods.This special issue presents cutting-edge research in the area of agile product line engineering.For the past few decades, the software community has put forward numerous efforts to lower the cost of software development, shorten the time-to-market of software products, and improve quality.Software product line engineering is one paradigm that aims to achieve these goals by means of systematic reuse and customization.In a software product line, similar software systems in a given domain are built using a library of core assets (typically developed in a phase called domain engineering).These assets can then be tailored to satisfy customer-specific needs (typically in a phase called application engineering).Another popular approach to achieve rapid delivery of software with minimal overhead is agile software development.Agile development promotes fast delivery of working software over a series of iterations, and it preaches concepts of simplicity and minimalism to cut waste (e.g.lengthy documentation, extensive modeling, and process definitions).Recently, there has been an interest in finding synergies between software product line engineering and agile software development in order to amplify production capabilities even further.This special issue presents the recent research in this direction.For this special issue, a call for papers was announced during the second XP workshop on agile product line engineering.The workshop was co-located with the 11th International Conference on Agile Software Development (XP2010) in Norway.Six submissions were received.For each submission, reviews were solicited from at least two independent reviewers.After two rounds of reviews, four articles were selected to be included in this issue.Two of the articles describe case studies conducted in software companies, while the other two are systematic reviews with different foci.The article by Jan Bosch and Petra M. Bosch-Sijtsema 'Introducing agile customer-centered development in a legacy software product line' discusses software product lines and agile methods in light of the issues associated with large-scale software development such as high coordination overhead, slow release cycles, and increasing error density.The authors present a case study of a Fortune 1000 company that delivers mostly finance and accounting software solutions.The company owns a product line that is the market leader in its domain in the U.S. with a market share of around 75%.In the article, the authors report on 14 semi-structured interviews that were conducted in the company to collect data on the challenges the company had faced with their original product line approach.The interviews covered discussions on the old and the new processes and the change towards the new process.The interviews along with other collected data were systematically coded, labeled and categorized over a number of iterations.The data revealed four main challenges, namely: the lack of customer feedback, heavyweight processes, inefficient utilization of resources, and low engagement of team members.The authors proposed a new approach to address these challenges.The approach used elements from design thinking, agile software development, and self-organizing teams.The results of adopting the new approach demonstrated improved customer involvement throughout the development process, reduced process overhead through the transition from component teams to feature teams, more efficient use of resources by enabling personnel to work in parallel, and increased team autonomy and motivation.Geir K. Hanssen's article 'Agile Software Product Line Engineering: Enabling Factors' reports the results of an extensive industrial case study to identify and understand enabling factors

Abstract Estimating the number of defects in a software product is an important and challenging problem. A multitude of estimation techniques have been proposed for defect prediction. However, not all techniques are applicable in all cases. The selection of the proper approach to use depends on multiple factors: the features of the approach; the availability of resources; and the goals for using the estimated defect data. In this paper a survey of existing estimation techniques and a decision support approach for selecting the most suitable defect estimation technique for a project, with specific goals, is proposed. The results of the ranking are a clear indication that no estimation technique provides a single, comprehensive solution; the selection must be done according to a given scenario. Copyright © 2009 John Wiley & Sons, Ltd.

Summary form only given.The Bayesian Belief Network (BBN) is a very powerful tool for causal relationship modeling and probabilistic reasoning. A BBN has two components. First is its structure a directed acyclic graph (DAG) whose nodes represent random variables and whose arcs represent the dependencies between the variables. The second component is its parameter in the form of Conditional Probability Tables (CPTs).The BBN is widely used in many different areas, excelling itself in Prediction, Risk Analysis, Diagnosis and Decision Support.

Choosing suitable Requirement Engineering (RE) techniques for a particular project is a challenging and time-consuming task, requiring substantial expertise and efforts. In this paper, an expert system based approach is proposed to help solving this problem. This expert system is capable of modeling and selecting suitable RE techniques for a software project. An on-line questionnaire is created in the first place to collect the expertise available in the community. A new algorithm is proposed to convert the raw data to a training data set suitable for building a complete Bayesian Belief Network (BBN). The resulting BBN is used to build sub-BBNs for RE techniques in six RE phases. The sub-BBNs integrated with a user interface form the expert system. Empirical study shows that the expert system outperforms other predictors in selecting suitable RE techniques. A case study is conducted to show the application of the expert system in the real world.

Component-based software development techniques are being adopted to rapidly deploy complex, high quality systems. One of its aspects is the selection of components that realize the specified requirements. In addition to the functional requirements, the selection must be done taking into account some non-functional requirements such as performance, reliability, and usability. Hence, data that characterize the non-functional behavior of the components is needed; a test set is needed to collect this data for each component under consideration. This set may be large, which results in a considerable increase in the cost of the development process. Here, a process is proposed to considerably reduce the number of test cases used in the performance evaluation of components. The process is based on sequential curve fittings from an incremental number of test cases until a minimal pre-specified residual error is achieved. The incremental selection of test cases is done in two different ways: randomly and adaptively. The accuracy and performance of the proposed approach are dependent on the values of the desired residual error. The smaller the residual error, the higher the accuracy. However, performance has an opposite behavior. The smaller the error, the larger the number of test cases needed. The results from experiments with image compression components are a clear indication that a reduction in the number of test cases can be achieved while maintaining reasonable accuracy when using the proposed approach.

An accurate prediction of the number of defects in a software product during system testing contributes not only to the management of the system testing process but also to the estimation of the product's required maintenance. Here, a new approach called ED3M is presented that computes an estimate of the total number of defects in an ongoing testing process. ED3M is based on estimation theory. Unlike many existing approaches the technique presented here does not depend on historical data from previous projects or any assumptions about the requirements and/or testers' productivity. It is a completely automated approach that relies only on the data collected during an ongoing testing process. This is a key advantage of the ED3M approach, as it makes it widely applicable in different testing environments. Here, the ED3M approach has been evaluated using five data sets from large industrial projects and two data sets from the literature. In addition, a performance analysis has been conducted using simulated data sets to explore its behavior using different models for the input data. The results are very promising; they indicate the ED3M approach provides accurate estimates with as fast or better convergence time in comparison to well-known alternative techniques, while only using defect data as the input.

Autonomous adaptive systems (AAS) have been proposed as a solution to effectively (re)design software so that it can respond to changes in execution environments, without human intervention. In the software engineering community, alternative approaches to the design of AAS have been proposed including solutions based on component technology, design patterns, and resource allocation techniques. A key limitation of the currently available approaches is that they detect constraint violations, but they do not support the prediction of constraint violations. In this work we propose an architectural framework for the design and analysis of autonomous adaptive systems, hereafter referred to as KAROO, which provides a key, new contribution: the capability to predict when a system needs to adapt itself. The results of extensive experimental evaluation of a KAROO-based system are excellent: 100% of the violations are predicted; the system is able to avoid the violations by adapting itself almost 98% of the time. The framework is a novel integration of control-theory-based adaptation, multi-criteria decision making and component-based software engineering techniques.

Realizing the quality of service (QoS) requirements for a software system continues to be an important and challenging issue in software engineering. A software system may need to be updated, or reconfigured, to provide modified QoS capabilities. These changes can occur at development time or at run-time. In component based software engineering, software systems are built by composing components. When the QoS requirements change, there is a need to reconfigure the components. Unfortunately, many components are not designed to be reconfigurable, especially in terms of QoS capabilities. It is often labor-intensive and error prone work to reconfigure the components, as developers need to manually check and modify the source code. Furthermore, the work requires experienced, senior developers, which makes it costly. The limitations motivate the development of a new rule-based, semi-automated component parameterization technique that performs code analysis to identify and adapt parameters and changes components into reconfigurable ones. Compared with a number of alternative QoS adaptation approaches, the proposed rule-based technique has advantages in terms of flexibility, extensibility and efficiency. The adapted components support the reconfiguration of potential QoS trade-offs among time, space, quality, etc. The proposed rule-based technique has been successfully applied to two substantial libraries of components. The F-measure or balanced F-score results for the validation are excellent, that is, 94 percent.

This paper proposes a rule-based expert system model to assist developers in enhancing the quality of embedded software. The expert system supports semi-automated source code enhancements from multiple perspectives including optimization, reconfiguration to achieve quality of service (QoS) trade-offs, conformance to coding standards, etc., by defining a rule base that is composed of modularized and extensible rule sets. The rule sets are composed of re-usable rules; the rules capture the in-depth knowledge of different software experts. The expert system also adopts a technique to support automated fact generation. This allows the expert system to support processing programs developed in different programming languages

The need to rapidly develop high quality, complex software has driven research in separate communities, including product line and agile methods. This workshop brings together participants from both communities to investigate what the approaches have in common, how they differ, and the potential costs and benefits in developing an agile product line engineering approach.

Much attention has been focused on the problem of effectively designing software architecture to meet non-functional requirements (NFRs). The significant benefits of such work include detecting and removing defects earlier, which reduces development time and cost while improving the quality of the design; in turn the improved quality of the design makes it easier to maintain as the system evolves. The Formal Design Analysis Framework (FDAF) is an aspect-oriented approach proposed to support the design and analysis of multiple NFRs for distributed, concurrent, and real-time systems. In FDAF, non-functional requirements are realized and represented as reusable aspects in the repository; designs are captured in an extended version of the Unified Modeling Language (UML). FDAF supports the automated translation of extended UML designs into existing formal notations. Subsequently, the analysis of an aspect design is achieved using existing formal analysis tools, which leverages a large body of work in the research community. This paper focuses on the modeling and analysis of the response time performance aspect. The algorithms for translating extended UML diagrams into Rapide, the proofs of correctness for the algorithms, and an illustration of the FDAF approach using the Domain Name System are presented.

Many critical application systems require reconfigurability in order to adapt under changing environment. To achieve system reconfigurability, it is possible to use adaptation mechanisms that are external to components or to use parameterized components. This paper focuses on making components reconfigurable in terms of QoS tradeoffs. We propose a new component parameterization technique which can transform individual components to reconfigurable ones such that they can support various QoS tradeoffs to achieve overall system QoS requirements. The parameterized components can be used to develop both statically and dynamically reconfigurable systems. The proposed technique is rule based, which provides flexibility and extensibility to enhance and improve the technique. A tool set has been developed based on the proposed technique to achieve semi-automated component parameterization.

Component-based development (CBD) techniques have been widely used to enhance the productivity and reduce the cost for software systems development. However, applying CBD techniques to embedded software development faces additional challenges. For embedded systems, it is crucial to consider the quality of service (QoS) attributes, such as timeliness, memory limitations, output precision, battery constraints. Frequently, multiple components implementing the same functionality with different QoS properties can be used to compose a system. Also, software components may have parameters that can be configured to satisfy different QoS requirements. Composition analysis, which is used to determine the most suitable component selections and parameter settings to best satisfy the system QoS requirement, is very important in embedded software development process. In this paper, we present a model and the methodologies to facilitate composition analysis. We define QoS requirements as constraints and objectives. Composition analysis is performed based on the QoS properties and requirements to find solutions (component selections and parameter settings) that can optimize the QoS objectives while satisfying the QoS constraints. We use a multiobjective concept to model the composition analysis problem and use an evolutionary algorithm to determine the Pareto-optimal solutions efficiently.

The problem of effectively designing and analyzing software system to meet its nonfunctional requirements such as performance, security, and adaptability is critical to the system's success. The significant benefits of such work include detecting and removing defects earlier, reducing development time and cost while improving the quality. The formal design analysis framework (FDAF) is an aspect-oriented approach that supports the design and analysis of non-functional requirements for distributed, real-time systems. In the FDAF, nonfunctional requirements are defined as reusable aspects in the repository and the conventional UML has been extended to support the design of these aspects. FDAF supports the automated translation of extended, aspect-oriented UML designs into existing formal notations, leveraging an extensive body of formal methods work. In this paper, the design and analysis of response time performance aspect is described. An example system, the ATM/banking system has been used to illustrate this process.

The proposal of CAT (component aware techniques) is effectively using components that meet the stakeholders' needs for a component based application (CBA). Matching off-the-shelf (OTS) components, using a representation of OTS components as an aggregate of their functional and non-functional requirements and architecture is an important activity. This paper explores the relationship between matching effectiveness with the richness of OTS component structure illustrated using a home appliance control system (HACS) example. Intuition tells that the richer the structure of OTS component, the more effective the matching is. This paper shows positive relationship between OTS model richness and matching effectiveness with experimental study.

Summary form only given. Visual modeling techniques play an important role in the design and understanding of complex, software intensive systems. Block diagrams in systems engineering and the Unified Modeling Language (UML) in software engineering, are prominent examples of such visual modeling techniques.

Component-based development (CBD) techniques have been widely used to enhance the productivity and reduce the cost for software systems development. However, applying CBD techniques to embedded software development faces additional challenges. For embedded systems, it is crucial to consider the QoS attributes, such as timeliness, memory requirement, output precision, power consumption, etc. When a system is composed of components, the appropriate components have to be selected such that the composed system is guaranteed to satisfy its QoS requirements. In this paper, we investigate the model for composition analysis. Based on the analysis model, we develop algorithms for selecting components to compose the designated system such that the overall system QoS properties can be pare to optimal. An overview of a repository-based embedded software development methodology was first presented. Then we discuss the composition analysis techniques. A case study is presented to illustrate our approach finally.

The goals of developing systems better, faster, and cheaper continue to drive software engineering practitioners and researchers to investigate software engineering methodologies. In requirements engineering, the focus has been on modeling the software engineering process and products for systems that are being built from scratch. As the size and complexity of systems continues to grow the use of commercial off the shelf (COTS) components is being viewed more and more as a promising, and also perhaps inevitable, solution. The effective use of COTS components, however, requires a systematic approach that provides a set of concepts for modeling the subject matter, a set of guidelines for using such concepts, and tool support to assist the developer.In this paper, we present a COTS-Aware Requirements Engineering (CARE) approach that explicitly supports the use of COTS components. Our CARE approach is knowledge based, has a defined process, and is agent- and goal-oriented. In particular, we present part of our meta-model for the knowledge base and a prototype of the CARE Assistant Tool. Our CARE approach is validated using a part of a Digital Library System example.

Synchronization constitutes an important research field in multimedia communication. The synchronization problem has been addressed in the literature in two distinct levels: specification and design. On the specification level, several formal models have been proposed, which are mostly variations of the Petri net model. Although some models are deemed to be better than others in some aspects, there has not been a comprehensive comparison of these specification models. This paper provides a critical review of the existing Petri net specification approaches for specifying synchronization constraints, including object composition, extended object composition, dynamic timed and time stream Petri net models, and applies them to the specification of an interesting, relatively straightforward synchronization example for a qualitative and quantitative evaluation of their strengths and weaknesses.