Search

The Internet of Things uses low-power wireless communication for wireless connectivity and efficient energy. Low-power wireless communication is applied to IoT for wireless connection and efficient energy consumption in various areas such as wearable devices, smart homes, and power plants in order to send and receive data and control the environment. Security is becoming more important because the Internet of Things controls real physical systems. For the security of the Internet of Things, the encryption key is important to identify and authenticate devices that are trusted. The static encryption key method used for devices is likely to be calculated in reverse through the value of the key and is vulnerable to exploitation attacks. This requires the application of dynamic encryption keys that generate keys periodically. However, in the case of low-power wireless communication, the asynchronous communication method and the packet loss make it difficult to apply existing dynamic encryption key technologies. In this paper, we proposed dynamic encryption key method that applies the mechanism of the block chain to solve these problems. Based on the history of sensor data between devices, encryption keys are dynamically generated. The proposed method is to generate the same encryption key between devices with only one step of asynchronous communication considering packet loss. The proposed method is also validated in terms of availability and security in the Internet of Things low-power wireless communication.

Among various consensus algorithms, the Byzantine Fault Tolerance (BFT)-based consensus algorithms are broadly used for private blockchain. However, as BFT-based consensus algorithms are structured for all participants to take part in a consensus process, a scalability issue becomes more noticeable. In this approach, we introduce a consensus coordinator to execute a conditionally BFT-based consensus algorithm by classifying transactions. Transactions are divided into equal and unequal transactions. Moreover, unequal transactions are divided again and classified as common and trouble transactions. After that, a consensus algorithm is only executed for trouble transactions, and BFT-based consensus algorithms can achieve scalability. For evaluating our approach, we carried out three experiments in response to three research questions. By applying our approach to PBFT, we obtained 4.75 times better performance than using only PBFT. In the other experiment, we applied our approach to IBFT of Hyperledger Besu, and our result shows a 61.81% performance improvement. In all experiments depending on the change of the number of blockchain nodes, we obtained the better performance than original BFT-based consensus algorithms, thus, we can conclude that our approach improved the scalability of original BFT-based consensus algorithms. We also showed a correlation between performance and trouble transactions associated with transaction issue intervals and the number of blockchain nodes.

Completeness is one of the key attributes for a high-quality software requirements specification. Although incomplete requirements frequently occur in the requirements specification, it is rarely discovered. This turns out to be one of the major causes of software project failure. In order to handle this issue, this paper proposes an automatic approach to recommending omitted steps in a use case-based requirements specification. First, we automatically extract diverse scenario patterns by using the verb clustering algorithm and scenario flow graphs. Based on the scenario patterns, our approach detects omitted steps of user’s scenarios by the pattern matching algorithm and automatically recommends appropriate steps for the omitted parts. For validation of our approach, we have developed tool support, named ScenarioAmigo, and collected 231 use case specifications composing of 1874 scenario steps from 12 academic or proprietary projects. We first carried out the preliminary study to decide appropriate thresholds and weights. Then, we conducted three experiments as a quantitative performance evaluation. First, the cross-validation for the collected scenarios shows the 76% precision and 80% recall. Second, the comparison of recall of ScenarioAmigo to that of human experts obtained the 20% higher score. As the last experiment, we compared the result of ScenarioAmigo and human experts in terms of severity of each scenario and found that our approach could recommend normal as well as important scenarios, compared to the human experts.

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.

Software requirement analysis is necessary for successful software development project. Specially, incomplete requirement is the most influential causes of software project failure. Incomplete requirement can bring late delay and over budget because of the misunderstanding and ambiguous criteria for project validation. Software requirement patterns can help writing more complete requirement. These can be a reference model and standards when author writing or validating software requirement. Furthermore, when a novice writes the software scenario, the requirement patterns can be one of the guideline. In this paper proposes an automatic approach to identifying software scenario patterns from various software scenarios. In this paper, we gathered 83 scenarios from eight industrial systems, and show how to extract 54 scenario patterns and how to find omitted action of the scenario using extracted patterns for the feasibility of the approach.

Software requirements completeness is the one of the key elements for successful software development. Incomplete requirements can cause one to misunderstand requirements and eventually build a wrong system as a developer interprets them in an ad-hoc manner. In order to handle this issue, the use case pattern is suggested, which is a set of commonly discovered scenarios in the use case specification. However, identifying the use case pattern is not systematic and comprehensive without providing any algorithmic or statistical rationale. This paper proposes an automatic approach to identifying the use case flow pattern from various use case specification. In this paper, we gathered 83 use case specifications from eight industrial systems, and presented two use case flow patterns identified from the use case specification.

An alternative scenario in use case specification indicates abnormal or less frequent behaviors in a software system. It has an influence on not only customer's satisfaction but also software quality. However, alternative scenarios are frequently missed because of the author's mistake or lack of experiences. In order to tackle this issue, this paper proposes a use case pattern based approach to recommending alternative scenarios. We adopt six essential use case patterns and extend them to identify the pattern type from ordinary natural language based scenario. We propose four-step approach using the word similarity tech- nique to find out the use case patterns of the basic scenarios.

User requirements for mobile software are maturing along with the industry, with request for quality attributes growing in diversity. The quality of context-awareness, recommending appropriate services based on user contexts, have become of particular importance. Satisfying new user demands requires mobile software developers to transit to writing adaptive software. Unfortunately, up to now this transition has not been very successful, and developers have been limited to making trial attempts with adaptation frameworks, mainly due to insufficient understanding and experience with adaptive software. This paper presents a guideline for identifying context awareness factors in mobile software and proposes a pattern-based model refactoring method to facilitate efficient transformation from traditional to adaptive software.

Following the advancements in convergent devices, the trend of rapid increase in software complexity and the contrastingly shortened software product lifecycle have introduced new challenges to which the transformation from legacy single-core based system to multi-core based system have emerged. Unfortunately, software development process which provides adequate support for multi-core parallelization has not been around to keep up with the speed of advancements in multi-core based hardware systems. In this paper, to address this need, we propose a development process supporting transformation of existing single-core based software to a multi-core equivalent, and discuss the overall cost-saving potential in introducing automation tools for supporting applicable activities within the proposed process.

This paper presents an approach to transforming a source code using the old API into that with the updated API. The source code is described in the code model at first, and it is transformed into the target code model by applying transformation rules. The rules are described in OCL (Object Constraints Language). In this paper, we exemplified a depreciated method in JDK in order to demonstrate our approach.

In constructing software architecture, domain architecture is broadly adopted because it handles common functional requirements (FRs) and non-functional requirements (NFRs) and suggests both fundamental software structure and architectural strategy. In spite of the usefulness of the domain architecture, an approach to building domain architecture is carried out in an ad hoc manner. This paper presents an approach to building domain architecture by using domain requirements and architectural tactics. At first, application requirements are classified into domain FRs and NFRs, application specific FRs and NFRs. Then, domain components are derived from domain FRs, and architectural tactics are selected by using a quantitative approach to handle domain NFRs. Finally, domain architecture is produced after composing domain components and architectural tactic semantics. As all components are specified at UML meta-model level, it contains a feature that automatically instantiates application architectures in our proposed tool. This paper illustrates our approach by building the domain architecture of job candidate management to show feasibility of our approach.