Abstract Companies often develop new software conveniently and quickly with the clone-and-own (CAO) approach of copying and modifying existing artifacts. However, this development approach makes maintenance and tracking reuse opportunities more difficult as the number of products grows. Software product line engineering (SPLE) solves this problem of the CAO approach by constructing a platform that consists of reusable software assets, facilitating efficient development of a product family. So, migrating a product family that has been developed with the CAO approach to SPLE is a practical first step for many companies to realizing SPLE but it requires building a product line platform that can create products by identifying and integrating cloned codes among products in the product family. To help achieve that, this article proposes an approach that (i) extracts reusable common and variable code assets from the products developed with the CAO approach, (ii) automatically builds a reusable product line platform, and (iii) generates products based on the platform. We applied the proposed approach to seven subjects, and confirmed that the proposed approach automatically and correctly builds a product line platform capable of generating the original products in an efficient and scalable manner.

• To our knowledge, this is the first method that focuses on connectors for the reconstruction of an execution view. • We developed the tools that automate the steps of the method, which can handle large volumes of input data. • To evaluate our proposed method, we conducted three real-world case studies. • Our case studies demonstrated that the proposed approach reconstructs an execution architecture with more than 86 % F1-score and less than 13.9 person-hours. • The tools and evaluation results are available at our GitHub repository. An execution architecture view plays a crucial role in depicting the structure of a software system at runtime and analyzing its execution aspects, such as concurrency and performance. However, such execution views are frequently missing in real-world practices. Therefore, researchers have endeavored to reconstruct execution architecture views from software systems. However, existing approaches either require domain experts’ knowledge or are applicable only to systems with particular architecture styles. In this paper, we propose a systematic approach to reconstructing an execution architecture view, without prior knowledge of the components and connectors in the target system. With the proposed approach, by defining a candidate set of execution view connectors and mapping rules from source code to execution view connectors, developers can reconstruct an execution view. To evaluate the proposed approach, we applied it to three real-world software systems. Our evaluation results show that the proposed approach reconstructs an execution architecture with a higher than 86 % F1-score and less than 13.9 person-hours.

Cloned code clustering identifies identical or similar code fragments, i.e., cloned code, from products of a product family, and then constructs cloned code clusters, a set of files, each of which contains the same cloned code. It is an essential step for migrating from the Clone-And-Own (CAO) approach to the Software Product Line Engineering approach for developing a family of products. This paper proposes a method for cloned code clustering based on files that share cloned code. The method proposed in this paper identifies clusters to use for constructing a product line platform at the source code level in such a way that it works regardless of cloning-in-the-small or cloning-in-the-large; it does not need to know what code is original or what code is cloned; and its results remain consistent regardless of the comparison order or the relative similarity of products of a product family. For evaluation we applied our method to Apo-Games and ArgoUML developed with the CAO approach and confirmed that our method correctly constructs code clusters.

The LCS (Longest Common Subsequence) algorithm is a well-known algorithm that finds the longest subsequence from two different strings while preserving the relative order between the characters that make up the strings. When migrating from source code to Software Product Line Engineering (SPLE), the process of identifying commonality and variability is a crucial step and many studies have applied the LCS algorithm for this process, but this algorithm can be applied only to two sources although the cases of three or more sources are common. This study proposes a method that extracts common and variable code lines from three or more sources. The proposed method consists of the preprocessing phase that divides sources into sections by reflecting the characteristics of their programming languages, and the phase for applying the LCS algorithm. To evaluate the proposed method, we applied it to ArgoUML-SPL and compared the result with the original platform of ArgoUML-SPL, which confirmed that common and variable code lines were effectively identified.

Issue reports are documents with which users report problems and state their opinions on a software system. Issue reports are useful for software maintenance, but managing them requires developers’ considerable manual effort. To reduce such effort, previous studies have mostly suggested methods for automatically classifying issue reports. However, most of those studies classify issue reports according to issue types, based only on whether the report is relevant to a bug, whether the report is duplicated, or whether the issue is functional or nonfunctional. In this paper, we intend to link issue reports and a user manual and so propose a deep learning model-based method that classifies issue reports according to software features that are described in the user manual in order to help developers relate issue reports to features to make changes to a software system. In order to classify issue reports according to the feature descriptions in a user manual, our method uses a deep learning technique with a word embedding technique. The key insight in our method is that the sections of a user manual that describe software features contain the words and sentences similar to those in issue reports. Based on the insight, we construct a classification model that learns the feature descriptions (i.e. sections) in a user manual and classifies issue reports according to the feature descriptions. We evaluate the proposed method by comparing its classification performance with that of the state-of-the-art method, TicketTagger. The experimental results show that the proposed method yields 10% ∼ 24% higher classification f1-score than that of TicketTagger. We also experiment with two deep learning models and four word embedding techniques and find out that the Convolution Neural Network model with FastText (or GloVe) yields the best performance. Our study shows the feasibility of classifying issue reports according to software features, which can be the basis for successive studies to classify issue reports into software features.

Selective video encryption schemes for battery-powered video devices have been proposed to prevent illegal acquisition of recorded video during transmission. However, the transmission security of conventional schemes is lower than the fully encrypted transmission schemes because a substantial part of the recorded video remains unencrypted including significant metadata for decoding recorded video. In order to address this limitation, we propose a secure video transmission framework that selectively encrypts video metadata and frames on a per packet basis with a consideration of currently available computing power and transmission distance. Evaluation on a testbed demonstrates that the proposed framework provides enhanced video transmission security with less than half of the battery power consumption required by the fully encrypted transmission scheme.

Application programming interfaces (APIs) continually evolve to meet ever-changing user needs, and documentation provides an authoritative reference for their usage. However, API documentation is commonly outdated because nearly all of the associated updates are performed manually. Such outdated documentation, especially with regard to API names, causes major software development issues. In this paper, we propose a method for automatically updating outdated API names in API documentation. Our insight is that API updates in documentation can be derived from API implementation changes between code revisions. To evaluate the proposed method, we applied it to four open source projects. Our evaluation results show that our method, FreshDoc, detects outdated API names in API documentation with 48 percent higher accuracy than the existing state-of-the-art methods do. Moreover, when we checked the updates suggested by FreshDoc against the developers' manual updates in the revised documentation, FreshDoc detected 82 percent of the outdated names. When we reported 40 outdated API names found by FreshDoc via issue tracking systems, developers accepted 75 percent of the suggestions. These evaluation results indicate that FreshDoc can be used as a practical method for the detection and updating of API names in the associated documentation.

Software products developed with the clone-and-own approach pose difficulties in maintenance. Migrating to software product line can solve this problem. This paper proposes an approach to recover software product line architecture (PLA) from a family of products developed with the clone-and-own approach. The proposed approach decomposes all source code of the family of products and analyses cloned copy classes, cloned modification classes and product-specific classes. From the results, it recovers a PLA. For determining common and variable classes, the proposed approach uses Harmonized Total Constant Commonality Indices of packages or classes of a product line (HTCCIPL). We apply our approach to recover the PLA of the Apo-Games developed with the clone-and-own approach. The results show that our approach recovers the Apo-Games PLA with a set of guidelines that can assist product line engineers in making decisions on commonality and variability of architectural elements of a PLA.

For software testing, it is well known that the architecture of a software system can be utilized to enhance testability, fault detection and error locating. However, how much and what effects architecture-based software testing has on software testing have been rarely studied. Thus, this paper undertakes case study investigation of the effects of architecture-based software testing specifically with respect to fault detection and error locating. Through comparing the outcomes with the conventional testing approaches that are not based on test architectures, we confirm the effectiveness of architecture-based software testing with respect to fault detection and error locating. The case studies show that using test architecture can improve fault detection rate by 44.1%–88.5% and reduce error locating time by 3%–65.2%, compared to the conventional testing that does not rely on test architecture. With regard to error locating, the scope of relevant components or statements was narrowed by leveraging test architecture for approximately 77% of the detected faults. We also show that architecture-based testing could provide a means of defining an exact oracle or oracles with range values. This study shows by way of case studies the extent to which architecture-based software testing can facilitate detecting certain types of faults and locating the errors that cause such faults. In addition, we discuss the contributing factors of architecture-based software testing which enable such enhancement in fault detection and error locating.

Regression testing for software product line (SPL) is challenging and can be expensive because it must ensure that all the products of a product family are correct whenever changes are made. SPL regression testing can be made efficient by selecting only the test cases that are relevant to the changes. In the past, some approaches for SPL test case selection have been proposed. However, they require requirements specification, architecture and/or traceabilities for test cases that are well managed for selecting test cases for a retest. In this paper, we propose an automated method of source code-based regression test selection for SPLs that selects regression tests, based on the commonality and variability of a product family while leaving out the test cases not affected by the changes to the source code. Preliminary evaluation of our method using five product lines shows that our method reduces without missing any fault-revealing test cases the number of test cases for a retest by 22.4%, 13.4% and 20.4%, on average, compared to, respectively, the retest-all method, the random selection method and the complete selection method.

LG Electronics Mobile Communications division developed the Variable part Auto Configuration and Management System (VACMS) to improve its current smartphone application development process. However, the effects of the new process using the VACMS have not been assessed yet. In this study, we compare the current process and the new process through a case study. The assessment results show that using the new process the development effort is reduced to 32.5% of that of the current process and the reuse rate becomes 2.34 times higher in Lines of Code.

One of the reasons behind the tremendous success of deep learning theory and applications in the recent days is advances in distributed and parallel high performance computing (HPC). This paper proposes a new distributed deep learning platform, named ShmCaffe, which utilizes remote shared memory for communication overhead reduction in massive deep neural network training parameter sharing. ShmCaffe is designed based on Soft Memory Box (SMB), a virtual shared memory framework. In the SMB framework, the remote shared memory is used as a shared buffer for asynchronous massive parameter sharing among many distributed deep learning processes. Moreover, a hybrid method that combines asynchronous and synchronous parameter sharing methods is also discussed in this paper for improving scalability. As a result, ShmCaffe is 10.1 times faster than Caffe and 2.8 times faster than Caffe-MPI for deep neural network training when Inception_v1 is trained with 16 GPUs. We verify the convergence of the Inception_v1 model training using ShmCaffe-A and ShmCaffe-H by varying the number of workers. Furthermore, we evaluate scalability of ShmCaffe by analyzing the computation and communication times per one iteration of deep learning training in four convolutional neural network (CNN) models.

Software extensibility, the capability of adding new functions to a software system, is established based on software architecture. Therefore, developers need to evaluate the capability when designing software architecture. To support the evaluation, researchers have proposed metrics based on quality models or scenarios. However, those metrics are vague or subjective, depending on specific systems and evaluators. We propose the extensibility metric for software architecture (EMSA), which represents the degree of extensibility of a software system based on its architecture. To reduce the subjectivity of the metric, we first identify a typical task of adding new functions to a software system. Second, we define the metrics based on the characteristics of software architecture and its changes and finally combine them into a single metric. The originality of EMSA comes from defining metrics based on software architecture and extensibility tasks and integrating them into one. Furthermore, we made an effort to translate the degree into effort estimation expressed as person-hours. To evaluate EMSA, we conducted two types of user studies, obtaining measurements in both a laboratory and a real-world project. The results show that the EMSA estimation is reasonably accurate [6.6% MMRE and 100% PRED(25%)], even in a real-world project (93.2% accuracy and 8.5% standard deviation).

It has been recognized by many researchers that the notion of test architecture should be utilized for software testing to cope with the task of testing complicated software, as it can support test architecture design and test case generation based on test architecture as well as efficient fault detection and error locating. However, in the current software testing theory and practice, the notion of test architecture and how it can be utilized for software testing are not well understood. To redress this situation, this paper provides foundational concepts and principles of architecture-based software testing to help utilize test architecture for software testing. Case study experiments are conducted to show how the concepts and principles of architecture-based software testing work and the effects that can be obtained by using architecture-based software testing.

Everything can be mobile, from end-hosts to applications. The need for mobility management is rising rapidly due to the increasing number of mobile devices and the advent of new types of mobile object, such as Internet of Things devices, connected vehicles, wearable devices, and virtual machines. In order to support various types of mobility, we propose an integrated and distributed mobility management approach, called Mobility of Everything (MoE). The MoE approach uses an object ID whose value is used to determine a specific edge switch that an object is connected with. In addition, the approach distributes binding information of an object ID and an IP address of edge switch throughout the network. We implement our approach on both an emulation environment and a testbed with software switches. Our evaluation results demonstrate that the MoE approach achieves seamless and scalable handover of end-hosts and applications.

Pairwise testing is an effective combinatorial test case generation approach in which test cases are developed to execute all possible pairwise combinations of system inputs. It can help reduce the number of test cases and save testing time yet still effective in finding defects. However, it is very difficult for practitioners to effectively apply pairwise testing in the real world because of the lack of suitable techniques and guidelines. To redress this situation, this paper conducts a case study of applying pairwise testing to system data derived from real-valued variable inputs. In order to apply pairwise testing to this case study, this paper develops a test procedure and a novel partitioning method to test derived data as a naïve application of the conventional pairwise testing that would produce a huge number of test cases. A comparative evaluation shows that the pairwise testing of the proposed approach is more effective than the random testing with a 12–20% higher fault detection ratio. Based on our experience, guidelines for applying pairwise testing in practice are also presented. Copyright © 2014 John Wiley & Sons, Ltd.

Modern automotive software components are often first developed by different suppliers and then integrated under limited resources by a manufacturer. The integration of software components under various resource configurations is prone to timing errors because the components are resources independently designed by the supplier and viewed by the manufacturer as black boxes during the integration stage, so that imposing resource constraints/requirements on their behavior is a challenge. This paper introduces an engineering awareness environment for the analysis of automotive systems with respect to two perspectives: 1) time-aware design models that correspond to the supplier perspective; and 2) resource-aware design models imposed by the manufacturer during integration. To this end, first we propose two timed behavioral models, a time-constrained model (TcM) and a resource-constrained model (RcM) that are extended from a functional model (FM). A timing analysis of applications can hence be conducted incrementally by adopting the separation of concerns principle coming from the model-driven architectures (MDAs). Second, given a basic application component description of AUTomotive Open System Architecture with timing properties, we specify how to define the behavior of the basic components as process terms using a process algebra, algebra of communicating shared resources with value passing (ACSR-VP), in order to exploit the description capability of the language for both timing aspects and resource-constrained aspects of a system. As a result, a timed behavioral model of a system can be seamlessly refined by various resource configurations, and both platform-independent and platform-dependent timing properties of real-time systems can be analyzed in a consistent and efficient manner.

Most of the current variability resolution tools are based on feature model. However, due to the lack of binding representation in feature model, most of them rely on other build systems for variability resolution to produce product implementations. The disconnection incurs redundant efforts by requiring developers to make or manage two separate artifacts, a variability model and an instantiation script. As a solution for this problem, we previously proposed a software binding application tool, SBAT, which supports build systems and is based on the orthogonal variability description language (OVDL) that simply and strictly defines syntaxes for variability modeling and variability resolution. By using this tool, developers can reduce efforts in writing and managing a script for variability modeling and variability resolution. In this paper, we suggest enhanced version of SBAT that adopts the new improved version of OVDL and conduct a practical case study to demonstrate the efforts reduction effect in writing and modifying scripts that can be achieved when using SBAT.

Recommendation systems are intended to increase developer productivity by recommending files to edit. These systems mine association rules in software revision histories. However, mining coarse-grained rules using only edit histories produces recommendations with low accuracy, and can only produce recommendations after a developer edits a file. In this work, we explore the use of finer-grained association rules, based on the insight that view histories help characterize the contexts of files to edit. To leverage this additional context and fine-grained association rules, we have developed MI, a recommendation system extending ROSE, an existing edit-based recommendation system. We then conducted a comparative simulation of ROSE and MI using the interaction histories stored in the Eclipse Bugzilla system. The simulation demonstrates that MI predicts the files to edit with significantly higher recommendation accuracy than ROSE (about 63 over 35 percent), and makes recommendations earlier, often before developers begin editing. Our results clearly demonstrate the value of considering both views and edits in systems to recommend files to edit, and results in more accurate, earlier, and more flexible recommendations.

In the mobile software ecosystem, a method that finds out the applications that are compatible with the device of an end user is called application-device matching. In the current mobile software environment, the device fragmentation causes substantial degree of inaccuracy in matching applications with devices as the traditional platform-centric method handles only the features of platform vendors without considering the unique feature set of a certain device, such as device-manufacturer's features, resulting in a low accuracy in matching applications and devices. This paper proposes a new matching method that is device-centric, which achieves high accuracy in application-device matching by grouping features of existing devices and then using it as criteria of application-device matching. To demonstrate the performance of our method, we conduct a case study with 22 devices and 10 applications in the Google Android mobile software ecosystem. The result of case study shows our proposed method shows a higher accuracy.

Traceability enables the developer to keep track of changes in software development artifacts. Compared to that of single product development, traceability management in software product line development is much more complicated as it has to deal with traceability of individual products through the commonality and variability of the families of products. However, the existing traceability research treated traceability for families of products in an ad-hoc way and did not adequately address the relationship between traceability of domain engineering artifacts and that of application engineering artifacts. In this paper, we develop a formal representation that represents traceability between features and requirements at platform level. Also we present a procedure for constructing platform traceability from the trace abilities of a family of products. The proposed traceability representation and construction can be used as a basis for automated management of software product line trace abilities and for traceability representation and construction between artifacts of other stages of software product line.

Testing in software product line is difficult because variability mechanisms, which is an integral part of software product line development, decrease observability and controllability. To cope with this difficulty, this paper proposes adopting test architecture for software product line testing as a way to enhance observability and controllability.

This paper proposes a novel cross-layer packet prioritization scheme that overcomes the limitations of conventional video prioritization schemes for IPTV system. In the conventional schemes, the Extend profile or frame unit is used for prioritization and these incur limited uses of the video prioritization schemes or unreliable transmission of the P-frame and B-frame headers. In order to overcome these limitations, the proposed scheme uses the MPEG-2 system information and the H.264/AVC NAL header information to prioritize the important video packets including the P-frame and B-frame headers. The experimental results using a testbed demonstrated that the proposed scheme has a significant performance enhancement over the conventional video prioritization schemes in terms of packet utilization ratio for video streaming, direct frame loss ratio, and PSNR.

Software architecture allows us to make many decisions about a software system and analyze it even before it has been implemented, so as to make planned development possible. Similarly, architecture-based software evolution planning makes planned evolution possible by allowing us to make many decisions about the evolution of a software system and to analyze its evolution at the level of architecture design before software evolution is realized. In this paper, we develop a framework for architecture-based software evolution planning. It is done by defining various foundational terms and concepts, providing a taxonomy of software evolution plans, and then showing how to calculate values for various types of plans. By identifying and defining constituent foundational concepts, this conceptual framework makes precise the notion of "architecture-based software planning". By developing a value-calculation framework for software evolution plans, it also provides a basis for concrete methods for designing and evaluating evolution plans.

Software traceability is the ability to provide trace information on requirements, design, and implementation of a system. It helps stakeholders understand the many associations of software artifacts created during a software development project. End-to-end traceability refers to linkage of all artifacts in the entire lifecycle of a software development project. Its goal is to provide stakeholders of the software development with trace information in order to analyze impacts due to changes in a software system. Compared to that of a single product, the end-to-end traceability of software product line is more complicated because Software Product Line Development (SPLD) requires two separate but intimately related phases of domain engineering and application engineering. Various SPLD traceability approaches have been proposed in the past. However, thus far no research work on SPLD traceability has focused on SPLD end-to-end traceability. This paper defines SPLD end-to-end traceability and evaluates the existing SPLD traceability approaches from SPLD end-to-end traceability perspectives. We surveyed studies on SPLD traceability methods, traceability mechanisms used in major SPLD approaches, and software traceability survey papers. We compared the existing SPLD traceability approaches based on Systematic Literature Review (SLR). Through the survey, we found that none of the SPLD traceability studies fully supports SPLD end-to-end traceability, and there are unexplored research areas of SPLD end-to-end traceability in the existing SPLD traceability studies. The contribution of this paper is that it presents future research directions that give research guidelines for each unexplored research area in SPLD end-to-end traceability. Finally, based on the research directions, this paper suggests future research opportunities for SPLD end-to-end traceability.

Recently, several graphical tools have been proposed to help developers avoid becoming disoriented when working with large software projects. These tools visualize the locations that developers have visited, allowing them to quickly recall where they have already visited. However, developers also spend a significant amount of time exploring source locations to visit, which is a task that is not currently supported by existing tools. In this work, we propose a graphical code recommender NavClus, which helps developers find relevant, unexplored source locations to visit. NavClus operates by mining a developer's daily interaction traces, comparing the developer's current working context with previously seen contexts, and then predicting relevant source locations to visit. These locations are displayed graphically along with the already explored locations in a class diagram. As a result, with NavClus developers can quickly find, reach, and focus on source locations relevant to their working contexts. http://www.youtube.com/watch?v=rbrc5ERyWjQ.

A recent proliferation of mobile devices led to immense deployment of WLAN access points (APs). IEEE 802.11 mobile devices periodically perform active background scanning to discover available APs in the vicinity. However, this periodic active scanning imposes unnecessary overhead in a static WLAN environment. This paper addresses this scanning overhead issue of mobile devices in IEEE 802.11 WLANs and proposes a smart scanning method using a motion sensor. Our scheme scans channels only if the signal strength from the associated AP becomes below a specified threshold and a mobile device is moving. The smart scanning suppresses unnecessary periodic background scans. We implemented the smart scanning in a commercial smartphone and evaluated its performance in a real indoor WLAN environment. The experimental and simulation results show that the smart scanning can significantly reduce the scanning overhead, the number of unnecessary handoffs and force disconnections.

More and more mobile devices, such as smartphones and pad/tab devices, are being used in IEEE 802.11 Wireless LANs (or Wi-Fi). However, mobile users are currently unsatisfied with using Wi-Fi on the move due to large handoff delay. In order to perform fast handoff, this paper proposes a new scheme using a geomagnetic sensor (or a digital compass) embedded in mobile devices. The proposed scheme predicts the direction of movement of a Mobile Station (MS) from the currently associated Access Point (AP) and performs active scanning with a reduced number of channels. The proposed scheme was implemented in Android smartphones and their performance was evaluated in a real indoor WLAN environment. Our test results show that the proposed scheme reduces handoff delay compared to conventional handoff and selective scanning scheme. In addition, the proposed scheme does not require modification to existing APs, which makes it very practical for using real-time multimedia services on current mobile devices.

Software product line (SPL) testing consists of two separate but closely related test engineering activities: domain testing and application testing. Various software product line testing approaches have been developed over the last decade, and surveys have been conducted on them. However, thus far none of them deeply addressed the questions of what researches have been conducted in order to overcome the challenges posed by the two separate testing activities and their relationships. Thus, this paper surveys the current software product line testing approaches by defining a reference SPL testing processes and identifying, based on them, key research perspectives that are important in SPL testing. Through this survey, we identify the researches that addressed the challenges and also derive open research opportunities from each perspective.

When performing software evolution tasks, programmers spend a significant amount of time exploring the code base to find methods, fields or classes that are relevant to the task at hand. We propose a new clustering approach called NavClus to recommend collections of code relevant to tasks. By gradually aggregating navigation sequences from programmers' interaction history, NavClus clusters pieces of code that are contextually related. The resulting clusters become the basis for NavClus to recommend collections of code that are likely to be relevant to the programmer's given task. We compare NavClus and TeamTracks, the state of the art code recommender for sharing navigation data among programmers. The results show that NavClus recommends pieces of code relevant to tasks considerably better than TeamTracks.

Variable length messages have been in use for a long time for efficient delivery of information. As there are many different ways, with varying complexity, to utilize message length variability, it is crucial to thoroughly test the capability of the parsers of such messages to ensure that they correctly handle the variability. However, testing techniques for message length variability were developed only in fragments in the past and therefore test developers who are faced with the task of testing variable length messages are left with little guidance or few techniques for handling them systematically. This paper develops an approach for systematic test cases generation for testing the parsers of variable length messages. To do so, we develop taxonomy of message length variabilities, and derive test requirement patterns for them using the taxonomy. Then test requirements for particular protocols can be derived from the patterns. A case study is conducted to show that the proposed taxonomy and the test requirement patterns are effective in deriving test cases for actual protocols. The results showed significant improvement over the conventional approach. It revealed many missed requirements that were not identified with the test requirements developed using the conventional intuition-based approach.

Representing commonality and variability in the software product line architectures requires extension of the existing representation mechanisms (RMs). Various RMs including Orthogonal Variability Model (OVM) or extensions of the UML notation have been proposed by the well-known software product line (SPL) engineering methods. However, there is no research that analyzes to what extent they can express commonality and variability. This paper conducts an analysis of two representative RMs for the SPL architecture. To that end, first, it surveys various SPL engineering methods and identifies the two common types of RMs: the orthogonal RM type and the integrated RM type. Then it selects a well-known specific RM for each type: the mechanism of Pohl et al. and the KobrA mechanism. Then for analysis of the RMs various perspectives are derived from the concepts in Orthogonal Variability Description Mechanism [4]. Finally, the RM of Pohl et al. and the KobrA method are analyzed from these analysis perspectives. We believe that these results of the analysis provide essential guidance for improving existing RMs for SPL architecture or for defining new RMs for SPL architecture.

Although synthesis was considered an important and challenging approach to construction of a program or a program model in software development, most of research on synthesis has been devoted to the construction of state machine models or variations of them. Recently, as process modeling through languages like UML Activity Diagram and BPMN appears as a new paradigm of software development, the ability to synthesize models in such languages from requirements would tremendously increase the scope of automatic software development. This paper presents transformation rules for synthesis of UML Activity Diagrams from scenario-based specifications modeled as UML Sequence Diagrams. To that end, we first identify various control flow patterns of Sequence Diagrams and define rules for mapping them to corresponding parts of Activity Diagram. In order to make precise such mapping labeling rules are introduced for the patterns. Also we provide a synthesis algorithm for construction of a UML Activity Diagram from scenarios.

In software development, it is important to mediate various concerns coming from user experience (UX) designers and application developers. In Agile User-Centered Design (Agile-UCD), there is a special role called specialist who is dedicated to implement application features as well as to monitor user experiences. However, the specialist normally has difficulty in linking user tasks to be accessed via a user interface (UI) into application feature entities. In addition, the specialist may also have some unsettled usability risks that might result in the failure of meeting certain usability criteria and passing acceptance tests. To alleviate these difficulties of the specialists in Agile-UCD, we propose a usability-pattern-based requirement-analysis method. This method uses standardized and common representations of requirements specification to bridge the gap between user tasks and related application features of a UI. It also provides a guideline to allow the specialist to reduce usability risks in an early stage by reflecting usability factors of UI design patterns to an application design. A case study has been conducted to show how users can effectively specify user tasks and application features on UI workflows. It also shows how easy and practical it is to understand the common representations as well as to apply to usability patterns.

In this paper, we reflect upon the past five years of the KAIST-Carnegie Mellon MSE (Master of Software Engineering) collaboration, and look ahead to the ways in which we can improve in the years to come. With the understanding that the major component of the program lies in its curriculum, our insights focus mainly in the areas of curriculum improvement and evolution. As a means of achieving this goal, two surveys were conducted, one addressing reflections by the program's participating faculty and graduates, and a second investigating various reference curriculums. Based upon the results of both surveys, an improved curriculum structure is proposed, one that identifies and introduces special track options that the authors propose might better serve the needs and demands of Korean industry.

During the past decade a number of methods and techniques for software product line scoping have been developed. Although their basic goal is the same, when it comes to details it is often hard to see what they have in common, where they differ and what their strengths and weaknesses are. This makes it difficult for the user to decide when and how to use them because these methods and techniques sometimes describe the same concepts and activities with different terminologies and, more often than not, by that the activities and tasks defined in them do not exactly match with each other and their inputs/outcomes are not clearly defined. In this paper, we compare and analyze the mainstream approaches to software product line scoping, deduce their essential components and develop them into a unified approach that can be easily referred to and utilized by the user companies planning to launch product lines.

For software with nontrivial size and complexity, it is not feasible to manually perform architecture reconstruction. Therefore it is essential for the software architecture miner who is mining architecture from the existing software to have a well-defined software architecture reconstruction process that helps incorporate as much tool use as possible at the appropriate steps of architecture reconstruction. There are some existing software architecture reconstruction frameworks but they do not provide guidelines on how to systematically utilize tools to produce architecture views for a reconstruction purpose. In this paper, we propose a framework for tool-based software architecture reconstruction. This framework consists of a generic process for software architecture reconstruction and the steps to derive from it a concrete tool-based process to be used for actual architecture reconstruction. The architecture miner can use this framework to analyze source code for modifying source code as well as to reconstruct software architecture from source code.

TActical Digital Information Links (TADILs) are communication infrastructure for military co-operations among air, sea, ground weapon systems/forces. To support such co-operations, real-time message translation and reliability assessment of translated messages used for TADILs are essential for effective situation awareness and interoperability of real-time coordination of weapon systems. In this paper, we propose a technique for assessing of VMF/Link-16 messages.

During software development process, software artifacts are produced. Consistency among these artifacts should be verified to ensure error-free product. In software product line development, consistency becomes more important because commonalities and variabilities increase the complexity of relationship among artifacts. In this paper, we present a formal approach to verification of consistency between feature model and component and connector view of software architecture. By utilizing prototype verification system (PVS), we introduce our model of feature description and architecture description, and illustrate the consistency verification approach using a digital watch product line example.

Describing architecture variabilities explicitly and precisely is important in the software product line approach for software development since it helps product derivation as well as modeling and managing the variabilities. The SAE AADL is an industry standard architecture analysis and design language for the automotive community, which originally was not intended to be used for software product line. In this paper, we propose EAADL a software product line architecture description language for the automotive domain that extends the SAE AADL. By incorporating orthogonal variability model into it, EAADL offers traceability with requirement engineering as well as the implementation process that is essential in software product line engineering.

If we can analyze software qualities during the design phase of development without waiting until the implementation is completed and tested, the total development cost and time will be significantly saved. Therefore in the past many design analysis methods have been proposed but either they are hard-to-learn and use or, in the case of simulation-based analysis, functionality concerns and quality concerns were intermingled in the design as well as in the implementation thereby making development and maintenance more complicated. In this paper, we propose a simulation-based design phase analysis method based on aspect-oriented programming. In our method, quality aspects remain separate from functionality aspect in the design model and the implementation code for simulation is automatically obtained by injecting quality requirements into the skeleton code generated from the design level functionality model. Our method has advantages over the conventional approach in reducing both the development cost and the maintenance costly

In this paper, a systematic approach of developing detail OO designs from component and connector architectures (CCAs) is proposed. In this approach, an intermediate model between the architecture model and the detail design model specified with class diagrams or sequence diagrams is introduced to narrow the wide gap between the two abstraction levels. Once a CCA is designed, candidate classes and their relationships are identified per each architectural element. In order to show the efficacy of this approach, we apply it to an industry software development project and verify that quality attributes supported by the CCA are equally maintained by the detail design.

It is commonly agreed that architecture design is essential for development of complicated software and that depending on viewpoints software architecture can be captured in various views. Among them, the logical view is the earliest and foremost view that software developers should consider because it shapes the later phase of architecture design and the subsequent development. In this paper, we present an architecture description language for logical architecture and its associated design method. The main characteristic of the language and the design method are that they support recursive top-down design so that logical architectures for software systems of any scale and complexity can be designed. We apply them to a realistic system and show their efficacy.

In this paper, we propose a new mechanism for supporting seamless QoS guarantees in mobile Internet, called selective establishment of pseudo reservations (SEP). SEP addresses the issues of the conventional approaches such as excessive reservation requirements due to establishment of multiple advance reservations. It significantly reduces the number of required advance reservations by employing a movement detection scheme using link-layer functionalities. SEP requires fewer functional and structural changes in the current Internet components and protocols since all enhanced features are integrated into leaf base stations (BSs). Experimental results show that SEP outperforms the conventional approaches such as HMRSVP in reservation session loss and completion rates as the offered load in the network becomes high and the average number of handoffs increases during a reservation session.

This paper presents an automatic test generation and minimization method for testing interoperability of communication protocols such as the asynchronous transfer mode/broadband integrated services digital network (ATM/B-ISDN) signaling protocol and the transmission control protocol (TCP). The method is based on a technique of composing finite-state machines (FSMs). Traditionally, the generation of inputs utilizing FSM was mostly based on sequential test scripting languages and often done manually. Each input is processed on a one-at-a-time basis, which did not allow generating complex scenarios of simultaneous inputs on several interfaces of the system under test (SUT). In practice, there exists the possibility that additional inputs have to be sent to the SUT, while the previous input is still being processed, and/or multiple inputs need to be sent to different interfaces of the SUT at the same time. Our method generates interoperability test cases dealing with these more complex situations. Moreover, it minimizes the number of increased test cases due to the multiple stimuli without jeopardizing transition coverage. Experimental results have shown that compared with the conventional methods, our test generation method generates more interoperability test cases resulting in higher transition coverage (26% higher for TCP and 12% higher for ATM signaling protocol). Also, our test minimization method reduces the interoperability test cases by about 94% in the case of the ATM signaling protocol with the same transition coverage.