In annotating real-life large, noisy and domain-specific images for digitising infrastructure, substantial human effort persists despite past advancements. This research provides practical and interpretable scores for human annotators, enabling flexible annotation strategies, improving automation and reducing the effort required to create and correct image labels. The authors present the CRAAC solution: Consistency Regularised Active learning and Automatic Corrections, which builds on Mask R-CNN with three additional modules: consistency regularisation, scoring modules for active learning and automatic corrections. Experiments on our pavement image dataset, recorded with a low silhouette score of 0.146 and qualitative annotation inconsistencies, reduce the human effort of mouse clicks by 5-11% and improve the quality metrics of mAP and AR by approx. 40% from the original Mask R-CNN. The automatic correction further reduces the performance variation.

The rise of self-sovereign identity (SSI) technology plays a critical role in addressing the limitations of conventional digital identity management systems. This paper focuses on the credential layer within the SSI technology stack, presenting a comprehensive solution to challenges related to usability, inefficient encryption and decryption processes, and verifiable credential management in existing SSI frameworks. To tackle these issues, the proposed approach introduces a user-friendly private key generation method, a rule table-based encryption and decryption technique, and a verifiable credential management system using smart contracts. In a usability evaluation involving 58 participants, 74.1% rated the proposed approach as user-friendly. Performance evaluations demonstrated that the rule table-based encryption method is between 10.37 and 171.51 times faster than existing encryption techniques. Similarly, the decryption process showed significant improvements, achieving performance that is 16.94 to 58.68 times faster than traditional methods. Security analyses were also conducted, highlighting the resilience against brute-force attacks and unauthorized access. The impact of this research extends beyond addressing current limitations, offering a robust and efficient framework that enhances the usability, security, and performance of SSI systems. By advancing the credential layer, this work paves the way for broader adoption of SSI technology across diverse applications, contributing to the evolution of decentralized identity management solutions. • A decentralized identity management system for Web 3.0 is proposed. • A method for enhancing user autonomy in Web 3.0 is proposed. • A decentralized trust network-based DIM for Web 3.0 is proposed.

The evolution of the metaverse necessitates inventive solutions that can uphold data security. In this paper, we present a novel approach that seamlessly integrates blockchain and substitution cipher techniques to enhance the security landscape of the metaverse. The proposed approach encompasses the generation of the rule table for substitution encryption and decryption, as well as a methodology for data encryption and decryption utilizing the rule table. Furthermore, we conducted a comprehensive evaluation of the proposed approach’s security robustness, especially focusing on its resistance against potential security attacks, including the brute-force attack. Moreover, a series of performance experiments were meticulously conducted to comprehensively gauge the effectiveness and efficiency of the proposed technique. The findings revealed that the proposed approach outperforms asymmetric key algorithms in terms of encryption elapsed time. Additionally, the decryption process of the proposed approach is notably faster than both symmetric and asymmetric key algorithms. The results of security analysis and performance evaluations underscore the viability and efficiency of the proposed approach, positioning it as a promising solution for secure and swift data management within the metaverse environment.

Abstract This study is an attempt to evaluate the compliance problem regarding the current status of the establishment of agreed‐upon interfaces for tokens, which are the most important type of applications of the Ethereum blockchain. The authors analysed the existing application programming interface standard interface called Ethereum Request for Comment 20 (ERC‐20), proposed functional ERC‐20 specifications, and evaluated the real‐world token smart contracts that have been deployed and used for transactions on a blockchain. For the evaluation, the authors developed an automatic tool with a test suite based on the proposed functional specifications. The authors' experiment revealed that no top‐100 market capitalization token smart contracts turned out to agree perfectly based on the functional specifications. In addition, the authors found the de facto standard behaviour deduced through testing with the functional specifications and suggested a possible countermeasure for the compliance problem in dealing with multiple tokens together.

Paper-based digital microfluidic biochips (P-DMFBs) have recently attracted great attention for its low-cost, in-place, and fast fabrication. This technology is essential for agile bio-assay development and deployment. P-DMFBs print electrodes and associate control lines on paper to control droplets and complete bio-assays. However, P-DMFBs have following issues: 1) control line interference may cause unwanted droplet movements, 2) avoiding control interference degrades assay performance and routability, 3) single layer fabrication limits routability, and 4) expensive ink cost limits low-cost benefits of P-DMFBs. To solve above issues, this work proposes an interference-free design methodology to design P-DMFBs with fast assay speed, better routability, and compact printing area. The contributions are as follows: First, we categorize control interference into soft and hard. Second, we identify only soft interference happens and propose to remove soft control interference constraints. Third, we propose an interference-free design methodology. Finally, we propose a cost-efficient ILP-based fluidic design module. Experimental results show proposed method outperforms prior work [14] across all bio-assay benchmarks. Compared to previous work, our cost-optimized designs use only 47%~78% area, gain 3.6%~16.2% more routing resources, and achieve 0.97x~1.5x shorter assay completion time. Our performance-optimized designs can accelerate assay speed by 1.05x~1.65x using 81%~96% printed area.

Summary A log statement is one of the key tactics for a developer to record and monitor important run‐time behaviors of our system in a development phase and a maintenance phase. It composes of a message for stating log contents, and a log level (eg,debugorwarn) to denote the severity of a message and controlling its visibility at run time. In spite of its usefulness, a developer does not tend to deeply consider which log level is appropriate in writing source code, which causes the system to be unmaintainable. To address this issue, this paper proposes an automatic approach to validating the appropriateness of the log level in consideration of the semantic and syntactic features and recommending a proper alternative log level. We first build the semantic feature vector to quantify the semantic similarity among application log messages using the word vector space, and the syntactic feature vector to capture the application context that surrounds the log statement. Based on the feature vectors and machine learning techniques, the log level is automatically validated, and an alternative log level is recommended if the log level is invalid. For the evaluation, we collected 22 open‐source projects from three application domains, and obtained the 77% of precision and 75% of recall in validating the log levels. Also, our approach showed 6% higher accuracy than that of the developer group who has 7 to 8 years of work experience, and 72% of the developers accepted our recommendation.

Class cohesion is a design quality that has a great impact on posterior development and maintenance of object-oriented systems. There have been much works on measuring class cohesion based on internal class relationships such as method-attribute referencing and internal method invocations. However, object-oriented systems involve many external class relationships carrying a functional context which should be also taken into account in measuring class cohesion. However, the existing works using internal relationships cannot measure cohesion of classes involving many external relationships. In this paper, we present a novel metric for measuring class cohesion based on both internal and external class relationships through an iterative process. We evaluate the metric by applying it to five applications — ArgoUML, jEdit, JHotDraw, JMeter, and Refactor, and validate the metric theoretically and statistically. The theoretical validation shows that the metric exhibits the required properties for cohesion metrics and the statistical validation shows that the metric captures a new aspect of class cohesion that has not been addressed by the existing works.

A log statement is used to record important runtime behavior of software systems for diverse reasons, which is inevitable to develop most of the software systems. However, developers do not tend to deeply consider an appropriate log level in their source code. In order to address the issues, this paper proposes an automatic approach to validating log levels in Java in consideration of the syntactic as well as semantic features. We first build up the Word2Vec model and generate semantic and syntactic log feature vectors, then train the machine learning classifiers to automatically validate the log levels. For the evaluation, we collected six open source projects of the message-oriented middleware domain, and obtained the 88% precision and the 87% recall respectively.

Cohesion significantly impacts on posterior development and maintenance. A well-designed module should be coherent with a single responsibility and less propagative for changes to other modules. In object-oriented development, classes are often modularized based on their relationships to localize change impact. There has been much work on grouping classes using direct class interactions and similarity of lexical information of classes. However, there has been little attention to indirect class relationships which are significant in defining functional semantics in object-oriented systems. In this paper, we present an approach for grouping classes using both direct and indirect class relationships. In the approach, we define a set of metrics for measuring couplings based on indirect class relationships and use them to group classes with the aim of localizing the impact of changes. We evaluate the approach using three applications - JHotDraw, JMeter, and ArgoUML and compare the results with existing work. The evaluation shows that the proposed approach reduces 17.2% and 22.2% of the number of packages that are affected by changes over the existing works.

A business process is a collection of activities to create more business values and its continuous improvement aligned with business goals is essential to survive in fast changing business environment. However, it is quite challenging to find out whether a change of business processes positively affects business goals or not, if there are problems in the changing, what the reasons of the problems are, what solutions exist for the problems and which solutions should be selected. Big data analytics along with a goal-orientation which helps find out insights from a large volume of data in a goal concept opens up a new way for an effective business process reengineering. In this paper, we suggest a novel modeling framework which consists of a conceptual modeling language, a process and a tool for effective business processes reengineering using big data analytics and a goal-oriented approach. The modeling language defines important concepts for business process reengineering with metamodels and shows the concepts with complementary views: Business Goal-Process-Big Analytics Alignment View, Transformational Insight View and Big Analytics Query View. Analyzers hypothesize problems and solutions of business processes by using the modeling language, and the problems and solutions will be validated by the results of Big Analytics Queries which supports not only standard SQL operation, but also analytics operation such as prediction. The queries are run in an execution engine of our tool on top of Spark which is one of big data processing frameworks. In a goal-oriented spirit, all concepts not only business goals and business processes, but also big analytics queries are considered as goals, and alternatives are explored and selections are made among the alternatives using trade-off analysis. To illustrate and validate our approach, we use an automobile logistics example, then compare previous work.

Summary In recent years, software development environments have changed from being driven by professional developers to being driven by technical end users. One of the key issues in end‐user‐driven software development environments is how to guarantee the quality of the software artifacts. Measuring the quality of developed software requires the correct specification of a quality range the software is expected to meet. However, technical end users are non‐professionals in engineering techniques for software requirements, and training a developer to be an expert in requirements engineering in a short period of time is difficult. This paper proposes a new software development life cycle based on reutilizing previously evaluated software requirements assets from completed projects. End‐User Requirements Engineering with Collaborative Animation, a tool that was developed to support the proposed software development life cycle, is described and demonstrated by application to three projects. The results from real cases are used as the basis for a discussion on the efficiency enhancement of requirements work, an increased rate of reusing legacy software requirements assets, and an improvement in the technical end user's individual competency level using the End‐User Requirements Engineering with Collaborative Animation. Copyright © 2017 John Wiley & Sons, Ltd.

Completeness in software requirements specification is one of the key factors for successful software development. For specifying software requirements, scenario-based approach is broadly used, comprising a basic flow regarding the successful use of the system, and alternative flows describing abnormal or less frequent interactions of the system. However, alternative flows tend to be frequently missed in many cases, because of the relative lower significance rather than the basic flow, which eventually have an influence on achieving the completeness of software requirements. In order to address the issue, we propose an approach for automatically recommending alternative flows from a basic flow by extracting the essential use case patterns based on the occurrence patterns of the agents and measuring the verb similarity between the main verbs of each scenario. In order to validate our approach, we apply it to three industrial case studies, and show comprehensiveness of the suggested alternative flows and synergic effectiveness for inexperienced developers.

Abstract Software process improvement (SPI) begins with process assessment based on a process reference model such as CMMI. Process improvement action items in SPI are determined according to the identified strengths and weaknesses of the current practice. Therefore, given that a list of assessment findings has been identified, it is important to analyze correlations of findings and identify relevant findings for building improvement items. However, correlation analysis requires expertise and considerable efforts, which makes it difficult for practitioners to perform it in process improvement projects. In this work, we present a CMMI‐based method for identifying correlations of findings and building improvement packages using graph clustering techniques. We evaluate the method using industrial data. Copyright © 2015 John Wiley & Sons, Ltd.

Using deprecated APIs often results in security vulnerability or performance degradation. Thus, invocations to deprecated APIs should be immediately replaced by alternative APIs. To resolve deprecated APIs, most developers rely on API documents provided by service API libraries. However, the documents often do not have sufficient information. This makes many deprecated API usages remain unresolved, which leads programs to vulnerable states. This paper reports a result of studying document quality for deprecated APIs. We first collected 260 deprecated APIs of eight Java libraries as well as the corresponding API documents. These documents were manually investigated to figure out whether it provides alternative APIs, rationales, or examples. Then, we examined 2,126 API usages in 249 client applications and figured out whether those were resolved in the subsequent versions. This study revealed that 1) 3.6 APIs was deprecated and 3.6 deprecated APIs are removed from the library a month on average, 2) only 61% of API documents provided alternative APIs while rationale and examples were rarely documented, and 3) 62% of deprecate API usages in client applications were resolved if the corresponding API documents provided alternative APIs while 49% were resolved when the documents provided no alternative APIs. Based on these results, we draw future directions to encourage resolving deprecated APIs.

The concept of adaptation and self-adaptation of systems, in particular at runtime has caught the attention of the research community at large, both inside the area of SPL as well as outside SPL in areas like models-at-runtime, selfadaptive systems, ubiquitous computing, etc.

In emerging domains such as ubiquitous computing, service robotics, unmanned space & water exploration, or medical and life-support devices, software is becoming increasingly complex with extensive variation in both requirements and resource constraints. Developers face growing pressure to deliver high-quality software with additional functionality on tight schedules ever more economically.

A design pattern addresses a recurring design problem by providing a proven solution for reuse in software development. However, due to the informal nature of prevailing pattern descriptions, it is difficult to reuse design patterns in practice. There has been much work on tool support for pattern reuse. However, the existing work focuses on only the solution domain of a pattern, leaving largely the problem domain unaddressed which is an important aspect in determining pattern applicability. Also, the existing work uses non-standardized techniques, which makes it difficult to adopt. In this work, we present a novel approach for applying design patterns using Query/View/Transformation (QVT), a de-facto standard for model transformation. In the approach, we make use of both the problem domain and solution domain of a design pattern for checking pattern applicability and verifying pattern conformance. The domains are defined at the metamodel level and mapped each other for a base to define QVT transformation. We demonstrate the approach using the Visitor design pattern applied to an open source drawing tool.

Software process assessment methods such as SCAMPI and ISO 15504-2 provide an assessment framework for evaluating the current practice of software development organizations. Strengths, weaknesses, and recommendations are core results of process assessment to be used as a basis for process improvement. While the existing models provide concrete methods for identifying strengths and weaknesses of process, they lack detailed approaches to building recommendations, which are crucial in developing strategic improvement plans. This makes it difficult for the assessment team to develop constructive recommendations, which has consequently negative impact on the quality of process improvement. To address this, we present a systematic method for developing recommendations based on a capability-based reference model (e.g., CMMI, SPICE). The presented method is evaluated using real assessment data from industry and the results show the potential of the method.

In emerging domains such as ubiquitous computing, service robotics, unmanned space and water exploration, and medical and life-support devices, software is becoming increasingly complex with extensive variation in both requirements and resource constraints. Developers face growing pressure to deliver high-quality software with additional functionality, on tight deadlines, and more economically.

Service Systems are increasingly being utilized to keep pace with the changing environment and business requirements. Moreover, service requirement management is very significant for service workflow design. Managing requirement is one of the core activities in developing service systems. To identify proper requirements, business requirements and business change factors should be correctly analyzed since the ultimate aim which is to meet the needs of its stakeholders. Therefore, appropriate service requirements should be elicited from both the service providers and service consumers. In this paper, we propose a service requirements identification method using KANO Model and AHP for superior service workflow design.

In emerging domains such as ubiquitous computing, service robotics, unmanned space and water exploration, and medical and life-support devices, software is becoming increasingly complex with extensive variation in both requirements and resource constraints. Developers face growing pressure to deliver high-quality software with additional functionality, on tight deadlines, and more economically. In addition, modern computing and network environments demand a higher degree of adaptability from their software systems. Computing environments, user requirements, and interface mechanisms between software and hardware devices such as sensors can change dynamically during runtime. Because it's impossible to foresee all the functionality or variability an SPL requires, there is a need for dynamic SPLs that produce software capable of adapting to fluctuations in user needs and evolving resource constraints. DSPLs bind variation points at runtime, initially when software is launched, to adapt to the current environment, as well as during operation to adapt to changes in the environment. Although traditional SPL engineering recognizes that variation points are bound at different stages of development, and possibly also at runtime, it typically binds variation points before delivery of the software. In contrast, DSPL engineers typically aren't concerned with pre-runtime variation points. However, they recognize that in practice mixed approaches might be viable, where some variation points related to the environment's static properties are bound before runtime and others related to the dynamic properties are bound at runtime. In DSPLs, monitoring the current situation and controlling the adaptation are thus central tasks. The user, the application, or generic middleware can perform these tasks manually or automatically. Although dynamic software product lines build on the central ideas of SPLs, there are also differences. For example, the focus on understanding the market and letting the SPL drive variability analysis is less relevant to DSPLs, whose primary goal is to adapt to variations in individual needs and situations rather than market forces. In summary, a DSPL has many, if not all, of the following properties:• dynamic variability configuration and binding at runtime, • changes binding several times during its lifetime, • variation points change during runtime: variation point addition (by extending one variation point), • deals with unexpected changes (in some limited way), • deals with changes by users, such as functional or quality requirements, • context awareness (optional) and situation awareness, • autonomic or self-adaptive properties (optional), • automatic decision making (optional), and• individual environment/context situation instead of a "market." Given these characteristics, DSPLs benefits from research in several related areas. For example, situation monitoring and adaptive decision making are also characteristics of autonomic computing, and the DSPL approach can be seen as one among several to building self-adapting/managing/healing systems. In addition, dynamically reconfigurable architectures provide mechanisms to rebind variation points at runtime, while multiagent systems, which focus on the use of agents and communities of agents, are particularly useful for evolving systems such as DSPLs [1].

Many popular software systems automatically report failures back to the vendors, allowing developers to focus on the most pressing problems. However, it takes a certain period of time to assess which failures occur most frequently. In an empirical investigation of the Firefox and Thunderbird crash report databases, we found that only 10 to 20 crashes account for the large majority of crash reports; predicting these “top crashes” thus could dramatically increase software quality. By training a machine learner on the features of top crashes of past releases, we can effectively predict the top crashes well before a new release. This allows for quick resolution of the most important crashes, leading to improved user experience and better allocation of maintenance efforts.

In this paper, we present a prototype tool that supports the systematic development of software architectures driven by quality requirements using architectural tactics. The tool allows one to configure architectural tactics based on quality requirements and compose the configured tactics to produce an initial architecture for the system. We demonstrate the tool for developing an architecture for a resource profiling system in the web environment and validate the results using a set of metrics.

Recently, industries need more effective software engineering education for undergraduate students as software plays an increasingly important role in consumer products. Specifically, the manufacturing industry emphasizes overall experience with software development processes from requirements to implementation in embedded software development. This paper proposes an educational toolkit focusing on architecture design methodology for embedded software and reports experience with teaching software engineering by using the toolkit. The toolkit has several tools that support methodology education. The toolkit consists of three perspectives: people, process, and technology. Each perspective represents a set of tools which can support educational activities. Particularly, the toolkit introduces LEGO MindStorms NXT as a robotic system to provide experiences with embedded software development, and visible and tangible course materials. We have conducted a case study based on the toolkit in undergraduate-level classes. The case study shows the toolkit can be successfully applied in undergraduate-level software engineering education.

Recently, organizations face various business challenges because of rapidly changing user needs and expectations. SOA (Service-Oriented Architecture) is a promising technique for adequately handling them in organizations. In developing SOA based systems, service identification is one of the core activities, having a broad influence on the systems. To identify proper services, business goals and business change factors should be analyzed because the ultimate aim of SOA is to achieve business goals and business agility in turbulent business environment. To tackle this, we propose a service identification method based on goal-scenario modeling and a conceptual framework to elicit possible business changes. Traceability among business goals, business changes and identified services are also constructed in this approach. We applied our approach into the HRS (Hotel Reservation System) domain to demonstrate its feasibility.

Service-Oriented Architecture (SOA) is emerging as an effective solution to deal with rapid changes in the business environment. To handle fast-paced changes, organizations need to be able to assess the quality of its products prior to implementation. However, literature and industry has yet to explore the techniques for evaluating design quality of SOA artifacts. To address this need, this paper presents a hierarchical quality assessment model for early assessment of SOA system quality. By defining desirable quality attributes and tracing necessary metrics required to measure them, the approach establishes an assessment model for identification of metrics at different abstraction levels. Using the model, design problems can be detected and resolved before they work into the implemented system where they are more difficult to resolve. The model is validated against an empirical study on an existing SOA system to evaluate the quality impact from explicit and implicit changes to its requirements.

In this paper, we propose an Internet management scheme that includes rate adjustment algorithm. This algorithm is designed by adaptive online approach to resolve conflicting QoS criteria while ensuring efficient network performance. Our online scheme exhibits dynamic adaptability to the current traffic conditions in multimedia networks. The results of a simulation study demonstrate the excellent performance of our proposed scheme under widely varying diverse traffic loads.

Numerous studies have shown that a software projectpsilas cost, schedule and defect density escalate as the rate of requirements change increases. Yet none of these studies have explored the effects of not making requirements changes in response to changes in user needs. This paper explains why a project incurs just as much, if not more, risk when requirements changes are suppressed.

This paper presents an approach for embodying nonfunctional requirements (NFRs) into software architecture using architectural tactics. Architectural tactics are reusable architectural building blocks, providing general architectural solutions for commonly occurring issues related to quality attributes. In this approach, architectural tactics are represented as feature models, and their semantics is defined using the role-based metamodeling language (RBML) which is a UML-based pattern specification notation. Given a set of NFRs, architectural tactics are elected and composed. The composed tactic is then used to instantiate an initial architecture for the application where the NFRs are embodied. A stock trading system is used to demonstrate the approach.

In emerging domains such as ubiquitous computing, service robotics, unmanned space and water exploration, and medical and life-support devices, software is becoming increasingly complex with extensive variation in both requirements and resource constraints. Developers face growing pressure to deliver high-quality software with additional functionality, on tight deadlines, and more economically.

Home service robots increasingly need to provide diverse and complex services such as cooking, sweeping and dishwashing. These services inevitably require a number of software functions simultaneously. For example, the cooking service requires an arm manipulation function to grasp dishes, an navigation function to move around, an object recognition function to find foods, an speech recognition function to understand user requirements, and etc. However, when the services and software functions are executed simultaneously in a robot without run-time software management, those may cause malfunction due to resource contention. In this paper, we describe the situation that causes resource contention and formulate architecture-based adaptation in robot software systems. Based on the formulation we proposed an approach to dynamic robot software management that effectively uses robot computing resources.

In order to provide services more reliably, intelligent service robots need to consider various factors, such as their surrounding environments, user's changing requirements, and constrained resources. Most of the intelligent service robots are controlled based on a task-based control system, which generates a task plan that consists of a sequence of actions, and executes the actions by invoking the corresponding functions. However, this task-based control system did not seriously consider resource factors even though intelligent service robots have limited resources (limited computational power, memory space, and network bandwidth). If we consider these factors during the task generation time, the complexity of the plan may become unmanageable. Therefore, in this paper, we propose a mechanism for robots to efficiently use their resources on-demand. We define reusable software-architectures corresponding to each action of a task plan, and provide a way of using the limited resources by minimizing redundant software components. We conducted an experiment of this mechanism for an infotainment robot. The experiment shows the effectiveness of our mechanism.

The research field of Intelligent Service Robots, which has become more and more popular over the last years, covers a wide range of applications from climbing machines for cleaning large storefronts to robotic assistance for disabled or elderly people. When developing service robot software, it is a challenging problem to design the robot architecture by carefully considering user needs and requirements, implement robot application components based on the architecture, and integrate these components in a systematic and comprehensive way for maintainability and reusability. Furthermore, it becomes more difficult to communicate among development teams and with others when many engineers from different teams participate in developing the service robot. To solve these problems, we applied the COMET design method, which uses the industry-standard UML notation, to developing the software of an intelligent service robot for the elderly, called T-Rot, under development at Center for Intelligent Robotics (CIR). In this paper, we discuss our experiences with the project in which we successfully addressed these problems and developed the autonomous navigation system of the robot with the COMET/UML method.

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.

Identifying and representing variant requirements among products in a product family are crucial activities for a successful software reuse. The variant requirements should be not only identified based on the business goal, which drives marketing plan, product plan, and differences among products, but also represented as familiar notations in order to support developing a particular product in the product family. Thus, our proposal is to identify the variant requirements through goals and scenarios, and represent them as variable use cases for a product family. Especially, for identification of the variant requirements, we propose four abstraction levels of requirements in the product family, and goal and scenario modeling. For representation of them, variable use case model is suggested, and also the use case transfer rules are proposed so as to bridge the gap between the identification and representation activity. The paper illustrates the application of the approach within a supporting tool, namely DREAM (Domain REquirements Analysis Method) using the ATM example.

Product line development has proven a successful approach to achieve strategic and large-grained reuse and hence time-to-market and productivity. A key to successful software product lines is to identify and analyze the right functionality for reusable implementation, and thus perform detailed requirements analysis for product lines to exploit commonality and variability (C&V) within a family of related systems. In this paper, we describe the goal and scenario driven approach for developing software product lines, which elicits product line requirements and analyzes C&V in products of a product line, as well as supports developing a particular product in the product line. We also discuss our ultimate goal that is to develop a dynamic software product line, which can produce new products at runtime by dynamic reconfiguration of the product line based on goals and scenarios.

Software systems are operating in an environment that is not well defined or predictable. Therefore, the software systems should be robustly performed to meet various user requirements in the complex and often hostile environment. The problem is significant in robot applications. The robot has to serve without human's interrupt without trouble caused by unexpected situations. Thus, this paper at first presents a self adaptive approach for software robustness and proposes the research framework for self adaptive robot.

A feature-oriented approach has been used extensively for commonality and variability (C&V) analysis in software product lines (SPL). However, this feature-oriented approach contains no proposal to systematically identify features and provide the rationale for both the features and C&V. Therefore, we propose a domain analysis method for the SPL based on scenarios, goals and features in order to overcome some of the deficiencies and limitations of the feature-oriented approach. In particular, we present a domain requirements model (DRM) that integrates features with both goals and scenarios. Using this DRM, we also propose a domain requirements modeling method. At the end, this approach is applied to a home integration system (HIS) and then is also evaluated. Our approach makes it possible to systematically identify features and provide the rationale for both the features and C&V. Thus, the approach provides a systematic and concrete domain analysis method for the SPL.

This paper presents a goal based modeling method for an agent-oriented software system. In modeling research for agent-oriented software, problems often emerged in that the properties of an agent system were not efficiently reflected in the development phase (analysis, design, etc.), because the techniques based on the other software paradigm are adopted to develop agent-oriented software. The result of analysis differs depending on which paradigm is used. An agent is goal-oriented, which necessitates a shift in paradigm. Therefore, the modeling method for an agent system should start from the concept of goal.

Due to the increased applications of agents, agent-oriented software becomes large and complex. To support systematic developments of such software, the agent-oriented software development methodology needs to be developed. This paper focuses on the modeling phase of agent-oriented software development. For agent-oriented software modeling, the Agent Elicitation method, Intra and Inter Agent modeling method are proposed. Agent Elicitation shows how to extract agents from classes in the real world. Modeling methods of agent's characteristics-Goal, Belief, Plan and Capability-are proposed for Intra Agent modeling. Methods of agent's mobility and communication in multiagent systems are proposed for Inter Agent modeling.

This paper summarizes an approach to software systems requirements management, called "engineering baselines" that has been developed to address those challenges. There are three primacy dimensions of those requirements management challenges as addressed by the engineering baseline approach: 1) machine processing of system text, especially the requirements statements; 2) correlation between requirements and all other system elements, including hardware components, code modules, test cases, user manuals, and design specifications; and 3) change consideration and control. There are three principal features of the engineering baseline approach: structuring statements into separate, autonomous, stand-alone statements called system elements; numbering with a unique system number to each system element, maintaining history of changes; and correlating all system elements using their unique system numbers.

A new paradigm for use in system development is described: engineering baselines. This new paradigm enables controlled visibility and traceability into the complete development effort. One of the primary features of the engineering baseline paradigm is its comprehensiveness and feasibility: its simplicity and usability by everyone involved at all levels. It is recognized that no matter how good an approach may be otherwise, unless it is one that all engineers can readily apply, on-the-spot at their desks or benches, if on balance falls short of the need. Engineering baselines have three principal unique features that sustain both its comprehensiveness and feasibility: (1) establishment of all system descriptions in plain ASCII files for universal machine processing, with each system element as a standalone entity bulleted descriptions concatenated with the lead in information, for example; (2) application of three types of numbers: a unique system number for all system elements, an engineering tag to establish links among system elements, and change set numbers; (3) use of plain ASCII two-column index files for all paired link among system elements. The basic ASCII files, the three number types and the two-column ASCII index files enable the tracking and linking [and reuse] by any and all engineers, as well as in speciality database-oriented applications of all system elements, including system specifications, designs, test cases hardware components, software code, work breakdown structures, development milestones, and user documentation.