In an industrial context, software systems are rarely developed by a single organization. For software product lines, this means that various organizations collaborate to provide and integrate the assets used in a product line. It is not uncommon that these assets themselves are built as product lines, a practice which is referred to as multi product lines. This cross-organizational distribution of reusable assets leads to numerous challenges, such as inconsistent configuration, costly and time-consuming integration, diverging evolution speed and direction, and inadequate testing.

Adaptability and reusability are important quality attributes for software targeted for global market due to diverse market needs, ever increasing number of features, rapidly changing technologies, and various laws/standards of different countries. In response to these requirements, software development organizations are interested in product line engineering and searching for support tools. However, most of the existing tools for supporting product line engineering focus only on providing mechanisms for instantiating products without adequately supporting development of software assets that are adaptable and reusable.

Many of the benefits expected from software product lines (SPL) [1-2] are based on the assumption that the additional investment required for domain engineering, pays off during application engineering when products are derived from the product line [3]. However, to fully exploit this we need to optimize application engineering processes and handle the reusable artifacts of an SPL in a systematic and efficient manner. In this context, the joint MAPLE/SCALE workshop focuses on two closely related aspects: how model-driven approaches can help to achieve systematic and efficient derivation of products and how scalability challenges can be addressed that arise from the application of SPL techniques to SPLs of realistic size and complexity. The workshop aims to explore and explicate the current status and ongoing work in model-driven approaches and/or scalability of SPLs and the transfer of knowledge between different disciplines and application domains.

In software product line engineering (SPLE), commonality and variability across products of a product line domain are captured typically by a feature model. Reusable components are then developed from features. However, mapping features to components remains a complex task requiring a systematic way of exploring and analyzing various concerns arising from inadequate/insufficient domain assumptions. Essentially, those concerns prevent SPLE from achieving various quality attributes. This paper proposes a problem frames-based approach to addressing this problem. An elevator product line example is used to demonstrate the feasibility of the approach.

Product line assets must be designed so that inclusion or exclusion of variable features causes little changes to components implementing other features. In order to achieve this goal, various relationships or dependencies that variable features have with other features must be analyzed thoroughly before designing product line assets. An object-oriented approach has been proposed to manage operational dependencies between features. However, it still suffers from code scattering and tangling problems. To address these problems, this paper introduces aspect-oriented implementation patterns which separate feature relations and dependencies from components implementing core functionality of features. Using these patterns, we can improve adaptability, scalability (modifiability in general), and configurability of product line assets. A simple calculator product line example is used to validate this approach.

Recently, product line software engineering (PLSE) is gaining popularity. To employ PLSE methods, many organizations are looking for a tool system that supports PLSE methods so that core assets and target software can be developed and tested in an effective and systematic way.ASADAL (A System Analysis and Design Aid tooL) supports the entire lifecycle of software development process based on a PLSE method called FORM (Feature-Oriented Reuse Method) [6]. It supports domain analysis, architecture and component design, code generation, and simulation-based verification and validation (V&V). Using the tool, users may co-develop target software and its test environment and verify software in a continuous and incremental way.

Dynamic product reconfiguration refers to making changes to a deployed product configuration while a system is running. Recently, there have been increasing demands for dynamic product reconfiguration in various application areas (e.g., ubiquitous computing, self-healing systems, etc.); however, most product line engineering methods in the literature have focused on the development of reusable core assets for statically configured products. In this paper, we propose a feature-oriented approach to develop dynamically reconfigurable core assets. This approach takes feature binding analysis results as a key design driver for identifying and managing variation points of dynamically reconfigurable products. We also provide a conceptual model for a reconfigurator, which monitors and manages product reconfiguration at run time. The method is illustrated with a home service robot product line example

Feature-oriented analysis (FOA) provides key information for developing reusable and adaptable product line assets. The information includes commonalities and variabilities, various dependencies between features, and their binding time information. On the other hand, aspect-oriented programming (AOP) provides effective mechanisms for encapsulating crosscutting concerns into separate entities, called aspects. By tightly coupling FOA with AOP, we can enhance reusability, adaptability, and configurability of product line assets. In this paper, we present detailed guidelines on how FOA and AOP can be combined. To validate our approach, we applied it to the engineering of an intelligent service robot product line.

Typical robot development requires that hardware be mostly functional before significant software development begins. Utilizing virtual prototype of hardware and its environment can reduce development time and manufacturing cost. Virtual prototyping is, however, a highly challenging task requiring in-depth knowledge in many disciplines. Few of simulation tools developed to alleviate this difficulty fully manage the complexity caused by the fact that developer must design and manage form (physical shape), function, and behavior altogether incrementally. Also, such simulation tools often do not support co-development of the target software and its test environment from requirements analysis to implementation. In this paper, we present our experience of developing a virtual prototype of Samsung Home Robot (SHR) with Samsung Advanced Institute of Technology (SAIT) using ASADAL/OBJ. Virtual prototyping in ASADAL/OBJ enables incremental co-development of both target system and its test environment in an object-oriented way. Furthermore ASADAL/OBJ facilitates concurrent development of form, behavior, and function. These features increase productivity as well as confidence through incremental refinement and validation. We give a brief background on the ASADAL/OBJ framework, then illuminate our experience of developing a virtual prototype of SHR.

Home service robots have received much attention from both academia and industry because home service robots have wide range of potential applications such as home security, cleaning, etc. The robots need to add or update services frequently according to the changing needs of human users. Furthermore, reactive nature of the robots add complexity to develop robot applications. These challenges raise safety issues seriously. Considering that safe operation of home service robots is crucial, current practice of validating robot applications is, however, not mature enough for wide deployment of home service robots. In this paper, we present our experience of developing and formally verifying discrete control software of Samsung Home Robot (SHR) using Esterel. We give a brief background on Esterel, then illuminate our result in formally verifying stopping behavior of SHR. Through the verification, we could detect and solve a feature interaction problem which caused the robot not to stop when a user commanded the robot to stop.

With the advances of robotics, computer science, and other related areas, home service robots attract much attention from both academia and industry. Home service robots present interesting technical challenges to the community in that they have a wide range of potential applications, such as home security, patient caring, cleaning, etc., and that the services provided by the robots in each application area are being defined as markets are formed and, therefore, they change constantly.Without architectural considerations to address these challenges, robot manufacturers often focus on developing technical components (e.g., vision recognizer, speech processor, and actuator) and then attempt to develop service robots by integrating these components. When prototypes are developed for a new application, or when services are added, modified, or removed from existing robots, unexpected, undesirable, and often dangerous side-effects, which are known as feature interaction problem, happen frequently. Reengineering of such robots can make a serious impact in delivery time and development cost.In this paper, we present our experience of re-engineering a prototype of a home service robot developed by Samsung Advanced Institute of Technology. First, we designed a modular and hierarchical software architecture that makes interaction among the components visible. With the visibility of interactions, we could assign functional responsibilities to each component clearly. Then, we re-engineered existing codes to conform to the new architecture using a reactive language Esterel. As a result, we could detect and solve feature interaction problems and alleviate the dificulty of adding or updating components.

Architecture evaluation to confirm that the quality requirements were satisfied by the developed software architecture is one of the most important issues in architecture-based software development approaches. Architecture Tradeoff Analysis Method (ATAM) is one such method, and the scenario-based quality requirement elicitation is an important factor for applying the method. We applied the method to factory-process-controlling systems with our industrial partner and this paper presents difficulties for quality requirement elicitation and a strategy to address these problems.

A real-time system consists of control software, the hardware controlled by the software, and the environment that physically interacts with the controlled hardware. Simulating control software with simplistic assumptions of the environment characteristics is not sufficient for meaningful real-value simulation. The hybrid systems development methods with their simulation environment are a good solution that provides meaningful real-value co-simulation of the target system and its execution environment. It also gives the results that might be gathered when using on-line test-beds. The problem with most of such methods is that the integration and simulation take place too late because they are done after the target system and its environment are fully developed. This paper shows a co-development method, and its supporting environment, which facilitates the repetitive testing of on-going system specifications.

Most real-time embedded control software feature complex interactions with asynchronous inputs and environment objects, and a meaningful simulation of a real-time control software specification requires realistic simulation of its environment. Two problems that need to be addressed in the simulation of a target software system and its environment: First, integration and simulation of the specifications of a target software system and its artificial environment are often performed too late in the lifecycle to provide any significant value. Second, real world objects in the environment usually have spatial characteristics (form) such as shape, motion, etc. that must be specified for simulation, and there is no method to express these spatial characteristics at various levels of abstraction that are adequate for the required simulation fidelity.To address these problems, we have developed a method that supports incremental specification and simulation of both the target software system and its environmental objects. The method includes: (1) a specification method for behavior, function, and form integrated objects; (2) form specification primitives that abstract common spatial characteristics of real world objects, their typical spatial relations, and spatial interactions; and (3) a methodology that refines, verifies, and validates behavior, function, and form specification of both the real-time embedded control software and its environment in a systematic and incremental manner. The proposed specification, verification, and validation method has been applied to a robot control system example to demonstrate its effectiveness and usefulness.

Object-oriented technology is gaining popularity among software engineers with the goal of building reusable and adaptable software. Unfortunately, however, most methods introduced so far are not domain-oriented and do not address the issue of reuse directly. For these methods, software reuse is not the primary goal; it is only a by-product. The feature-oriented reuse method, FORM, is extended in this paper for improving the object-oriented engineering of applications for reuse. FORM concentrates on analyzing and modeling commonalities and differences in the applications of a given domain in terms of capability, operating environment, domain technology, and implementation technique features. These features are used to systematically derive objects that are tied to the features, and to develop reusable and adaptable domain architectures. We found that FORM facilitates analysis of variability (and commonality) of software before engineering and implementation start, and with this understanding, adaptability and reusability can be built into software. Feature modeling has been found to be an effective method for identifying and modeling reusable objects. Copyright © 2000 John Wiley & Sons, Ltd.

PBX (private branch exchange) systems are evolving rapidly due to fast expanding services, ever-changing communication technology, continuously evolving standards, and diverse communication laws and standards in different countries. As new features are added continuously, the detection of feature interaction problems early in the development lifecycle and the resolution of these problems through adaptable software are difficult challenges which all PBX software engineers face. A feature-oriented reuse method (FORM), introduced in this paper, concentrates on analyzing and modeling commonalities and differences in applications of a given domain in terms of features. The analysis results are then used for both the analysis of feature interactions and the engineering of domain-oriented software with a high level of adaptability (and reusability). We found that FORM facilitates the analysis of feature interactions and the variability (and commonality) of software before engineering and implementation begin. By understanding the variability, adaptability and reusability could be built into the software. The software architecture and modules are implemented based on information hiding and encapsulation principles and could easily accommodate new features that have not been considered in the initial feature analysis.

For real-time performance, virtual reality systems often employ various performance optimization techniques. One of the most popular methods is using geometric models with different “Levels of Detail (LOD)”. In a previous paper by this author [1], we have proposed to use software engineering principles such as the concept of hierarchical and incremental modeling, and simultaneous consideration of form, function and behavior for modeling VR objects. Each refinement stage driven by such a modeling philosophy produces step-by-step form, function and behavior specifications of a VR object. We can make good use of these by-products as LOD for adaptive display and simulation by additionally specifying conditions for LOD switching. These specifications can be simulated and analyzed in advance for an estimation of performance for a given VR execution environment. Such an engineering process deals with behavior and geometry together; different geometric LOD may possess different behaviors and vice versa. A certain function or behavior might dictate an inclusion of a particular geometric feature that may not be possible to preserve, if the geometric LOD were to created in a bottom-up fashion (e.g. using the mesh simplification algorithms). We demonstrate our approach by modeling an automobile object with three levels of geometric and behavior detail in a top-down manner, simulate their instances in a small virtual town, and based on the simulation result, make predictions to the maximum allowable number of vehicles that will maintain an acceptable frame rate if executed in a faster simulation environment. We believe that our approach combines the idea of hierarchical refinement of virtual objects and the use of LOD in a very natural and intuitive manner.

Specification and validation of a real-time system are often based on making simplistic predictions and assumptions about relevant behavior of the external environment and the controlled device interacting with it. However, in many cases, real-time systems physically interact with other external objects in a complex manner in a dynamically changing world and thus, their form (e.g. physical properties such as shape, mass, material, and configuration) can play a critical role in producing a correct specification and obtaining realistic simulation output. We present ASADAL/PROTO, a specification and simulation tool for real-time systems, that takes form into account in addition to the function and behavior handled by ASADAL/SIM, its predecessor. Simulation of the control system specification runs in conjunction with the environmental simulation, and the resulting interactive behavior of the controlled system is observed visually for analysis. Our vision is to incrementally model, simulate and analyze all three views (behavior, function, and form) of real-time system specification for its increased level of confidence at early prototyping stage.

Incorporating a high level of adaptability and reusability into software is one challenge that all software engineers face. PBX (Private Branch Exchange) is one such system that requires a high level of adaptability and reusability because of rapidly expanding service features, ever changing communication technology, continuously evolving standards and diverse communication laws and standards in different countries. The software engineering community has made various efforts to address the problem of enhancing software adaptability and reusability. As a result, many programming concepts, such as information hiding, encapsulation, object orientation, abstract data type and modularization, have been developed. Although adequate application of these principles requires the domain or program family perspective, most methods, so far, have been oriented toward developing a single application. FORM (Feature-Oriented Reuse Method), the domain-based software reuse method applied in this paper, concentrates on analyzing and modeling commonalities and differences in applications of a given domain and using the analysis results to develop domain-oriented architectures and software components. The model that captures commonalities and differences is called the ‘feature model’ and it is used for both the engineering of reusable domain artifacts and the development of actual application software with reusable artifacts. We found that FORM facilitates analysis of variability, as well as commonality, of software before the start of engineering and implementation. With this understanding, adaptability and reusability can be built into software. Also, feature modeling has been found to be an effective method for identifying objects. Copyright © 1999 John Wiley & Sons, Ltd.

Software reuse is generally considered by both practitioners and researchers as one of the most effective ways of increasing productivity and improving quality of software. To achieve successful software reuse, commonalities of related systems must be discovered and represented in a form that can be exploited in developing similar systems. FORM (Feature-Oriented Reuse Method) (K.C. Kang et al., 1998), extended from the FODA (Feature-Oriented Domain Analysis) method (K.C. Kang et al., 1990), is a systematic method that focuses on capturing commonalities and differences of applications in a domain in terms of "features" and using the analysis results to develop domain architectures and components. Once a domain is described and explained in terms of common and different "units" of computation, they are used to construct different "feasible" configurations of reusable architectures. Features are distinctively identifiable functional implemented, tested, delivered, and maintained. Therefore, they are the first class objects in the development of domain oriented software.

Developing a virtual reality application is a dificult task.FOT one thing, it requires an in-depth knowledge and understanding in many different disciplines.However, the most dificult part lies in the effective management of simultaneous design of form, function and behavior of virtual objects.Up to now, only little focus has been given to methods and tools for rapid prototyping VR software and modeling virtual objects.Most VR applications are developed by modeling the needed objects on conventional CAD systems first, then by programming their functions and behavior using low-level graphics libraries OT high level simulation packages.In this paper, we advocate for a structural and pedagogical approach to developing VR applications, and add the component of "form" to an existing real-time system development methodology so that the resulting methodology (and the prototyping environment) supports simultaneous and hierarchical engineering of form, function and behavior.Using the proposed methodology and supporting tool, it is our hope that VR maintained effectively.

Despite considerable advancement in software engineering methods during the past three decades, requirements engineering of large and complex software systems still remains a difficult and active research problem. One such difficulty lies in developing correct and useful methods for the validation and verification of real-time software specifications. One way of analyzing and validating/verifying software specifications is to mathematically derive or prove desired system properties based on formal specification languages. A full scale system analysis using such formal methods is limited in practice because of the required mathematical skills and computational costs. Formal methods are often used to check only a few very critical real-time properties. Simulation is a complementary approach to testing various system characteristics and validating user requirements. It is especially good for providing a rough picture of final system behavior. This paper presents ASADAL/SIM, a tool for multi-level simulation and analysis of real-time software specifications. It is a subsystem of a larger computer-aided real-time software development environment called ASADAL, and complements ASADAL/PROVER, another subsystem of ASADAL which is a formal verification module.1. With ASADAL/SIM, simulation primitives can be added to evolving specifications in order to assign stochastic behaviors to external entities and internal processes, and to build a simulation model. ASADAL/SIM can execute the model and, at the same time, demonstrate the final system behavior by graphically showing internal workings of the system; catch undesirable system behaviors with breakpoints; and present various analytical results and system statistics ASADAL/SIM, following ASADAL's philosophies of hierarchical system modeling and early system validation, allows users to simulate ‘evolving’ specifications at different, mixed, and wide levels of detail. In particular, algorithmic details may be specified for low level behavioral blocks, and simulated with abstract entities yet to be refined to such a level. This facilitates the tracking of critical data values at the specification level, and eases the next transformation into code level implementation. With ASADAL/SIM, ASADAL becomes an effective and comprehensive supporting tool for various existing software engineering approaches, particularly top-down refinement and incremental development practices. © 1998 John Wiley & Sons, Ltd.

There have been many analysis methods proposed for the verification of safety properties of real-time systems. Most of these methods, however, are not powerful enough for complex and safety-critical real-time systems due mainly to the lack of language primitives for specifying complex requirements (e.g., ESM) or heuristic verification procedures that do not provide verification results with certainty (e.g., Statechart and Modechart). A new approach for the verification of safety properties of real-time systems is introduced. This approach adopts Statechart to specify real-time systems behaviors. The authors redefined the step semantics of Statechart to address the problems of the synchrony hypothesis inherent to the original step semantics. A operational semantics of Statechart is defined based on the step semantics and a verification method for safety properties is developed based on the operational semantics of Statechart. This method verifies safety properties using a reachability graph derived from a Statechart diagram. They did not sacrifice the practicality or expressive power of Statechart for the simplification of analysis. Useful event and action primitives including the timeout event tm() and scheduled-action sc!() are included in the analysis. A train gate system is used as an example to illustrate the concepts in the paper.

Areasof computer application are being broadened rapidly due to the rapid improvement of the performance of computer hardware.Applications that were not feasible before are now becoming feasible with

Areas of computer application are being broadened rapidly due to the rapid improvement of the performance of computer hardware. This results in increased demands for computer applications that are large and have complex temporal characteristics. This paper introduces a real-time systems anlaysis method named PARTS. PARTS supports analyses from two viewpoints: external viewpoint, a view of the system from the user's perspective, and internal viewpoint, a view from the developer's perspective. These viewpoints are specified using formal languages, which are Real-Time Events Trace (RTET) for the external viewpoint, and Time Enriched Statechart (TES) and PARTS Data Flow Diagram (PDFD) for the internal viewpoint. All PARTS languages are based on the Metric Temporal Logic (MTL), and consistency of the specifications made from the two different viewpoints are analyzed based on the same MTL formalism.

Most electronics products have an embedded MICOM (MIcro COMputer) in which a control program runs. These programs, called microprograms, have usually been developed by electronics engineers in an ad hoc way. Severe competition among electronics companies, however, has forced them to adopt a systematic, engineering method. A model-based software engineering approach is developed in this paper to improve the process of MICOM software development. This approach consists of two major phases: the model development phase and the model-based applications development phase. The model development phase focuses on the development of a domain model for the MICOM applications domain and use of the domain model to develop models for product families (e.g. TV, microwave oven). Product family models are used in the model-based development phase to analyze requirements and design software for specific products in the same family. The TV application family was used to illustrate this approach.>

Areas of computer application are being broadened rapidly due to the rapid improvement of the performance of computer hardware. This results in increased demands for computer applications that are large and have complex temporal characteristics. This paper introduces a real-time systems analysis method named PARTS. PARTS supports analyses from two viewpoints: external viewpoint, a view of the system from the user's perspective, and internal viewpoint, a view from the developer's perspective. These viewpoints are specified using formal languages, which are: Real-Time Events Trace (RTET) for the external viewpoint, and Time Enriched Statechart (TES) and PARTS Data Flow Diagram (PDFD) for the internal viewpoint. All PARTS languages are based on the Metric Temporal Logic (MTL), and consistency of the specifications made from the two different viewpoints are analyzed based on the same MTL formalism.>

Software reuse is generally received by both practitioners and researchers in Korea as one of the key elements in increasing productivity and improving quality of software, and there have been several isolated industry efforts and government funded researches since mid-1980s. The coverage of research areas has been unbalanced and most research efforts have concentrated on developing reusable libraries or issues related with reusable libraries such as component classification and retrieval. Reuse efforts up until recent years can be characterized as software engineering with reuse. In recent years, reuse research efforts are slowly progressing towards techniques for developing software for reuse, centring mostly around object-oriented techniques. Also, research areas are being broadened and diversified. Some recent academic and industrial research efforts are summarized.>