Shintaro Hosoai

Abstraction-aware verifying compiler for yet another MDD

This paper rethinks both modularity and compilation in the light of abstraction between design and implementation. We propose a new compilation approach called abstraction-aware verifying compiler, in which abstraction is the target of compilation. Both a design model and its code are inputted as the first-class software modules to the compiler.

iArch - An IDE for supporting abstraction-aware design traceability

Abstraction has been an important issue in software engineering. However, it is not easy to design an architec- ture reflecting the intention of developers and implement the result of a design as a program while preserving an adequate abstraction level. To deal with this problem, we provide iArch, an IDE (Integrated Development Environment) for supporting abstraction-aware traceability between design and code. The iArch IDE is based on Archface, an architectural interface mechanism exposing a set of architectural points that should be shared between design and code. An abstraction level is determined by selecting architectural points.

iArch: an IDE for supporting fluid abstraction

Abstraction plays an important role in software development. Although it is preferable to firmly separate design from its implementation, this separation is not easy because an abstraction level tends to change during the progress of software development. It is not avoidable to fluidly go back and forth between design and implementation. An abstraction level of a design specification may change as a result of reconsidering the balance between design and code - which concern should be described in design and which concern should be written in code. The iArch IDE (Integrated Development Environment) supports the notion of fluid abstraction, a design approach in which an appropriate abstraction level can be captured by the convergence of fluid moving between design and implementation.

Project Report: Toward the Realization of Highly Reliable Embedded Systems

Our society depend on embedded and ubiquitous computingand the reliability of embedded software becomesmore and more important. We have conducted a five yearsproject with industries to develop software for realizinghighly reliable embedded systems. We have tackled reliabilityissues from the following aspects. 1)Design environment:we have developed a UML design verification tool thatapply model checking techniques to improve the designquality of application software. 2)Operating environment:we have developed operating system supports that realizemultiple execution of real-time operating systems andalso developed operating systems with enhanced resourcemanagement. Both technologies contribute the realizationof robust run-time environment. 3) Real-time environment:we have developed real-time garbage collection techniquesfor Jave. They prevent the suspension of applications thatviolates the correct behavior of real-time applications. Also,they reduce the effort of application programmers to avoidgarbage-collection during important execution timing. Wehave obtained fruitful results from these three researchthemes, and some of them are actually used in industries.Furthermore, we have integrated the results to make synergeticeffect of them. In order to demonstrate the effectiveness,we have conduct an experiment. In this paper, we introducethe project and its results.

Poster: Multidisciplinary Skill Assessment for Embedded Software Development Education via a Robot Contest

This article introduces a multidisciplinary skill assessment for learning embedded software development. In the industry, software engineers and mechanical engineers have to communicate with each other, and hence, these engineers need to have multidisciplinary skills. For learning such skills, we need to give an occasion to work with different field students. To this end, we have been organizing a robot contest with embedded software development education. One of the goals of the contest is to inculcate multidisciplinary skills. However, we have not clarified the contribution. Thus, we construct a multidisciplinary skill assessment map based on the experiences gained through these contests. The map consists of (1) integration skill, (2) performing skill, and (3) cross-understanding skill.

System Product Line Engineering for Small Appliances with Driver Derivation

Advances in device technology have promoted the development of small appliances such as wearable devices, IoT equipment, and small home electronics equipment. Considering a product family of such device/equipment, each product in the family may have different hardware (micro controller unit, devices such as sensors and actuators, and different configurations). Software for such equipment tends to be compact and handles the devices directly via drivers. However, software engineers are not familiar with driver development and this causes development bottleneck. Therefore, in order to develop products efficiently, derivations of software and hardware are not enough, i.e., the systematic derivation of drivers is indispensable. In this paper, we propose a system product line development method for small appliances in which drivers are systematically derived. In this method, hardware features and software features are managed in terms of feature models, and system products are derived by specifying features of hardware and software. Based on these, drivers are systematically derived. This paper proposes 1) an extension of the UML/MARTE model that can represent hardware information that is necessary for driver generation, and 2) a systematic driver derivation method based on variability management and model-driven engineering techniques. We evaluate the method using an example of a motion tracking system product family

Poster: Conquering Uncertainty in Java Programming

Uncertainty in programming is one of the challenging issues to be tackled, because it is error-prone for many programmers to temporally avoid uncertain concerns only using simple language constructs such as comments and conditional statements. This paper proposes ucJava, a new Java programming environment for conquering uncertainty. Our environment provides a modular programming style for uncertainty and supports test-driven development taking uncertainty into consideration.

Sketch-based gradual model-driven development

This paper proposes an abstraction-aware reverse engineering method in which a developer just makes a mark on an important code region as if he or she draws a quick sketch on the program list. A support tool called iArch slices a program from marked program points and generates an abstract design model faithful to the intention of the developer. The developer can modify the design model and re-generate the code again while preserving the abstraction level and the traceability. Archface, an interface mechanism between design and code, plays an important role in abstraction-aware traceability check. If the developer wants to obtain a more concrete design model from the code, he or she only has to make additional marks on the program list. We can gradually transition to model-driven development style.

Uncertainty-aware architectural interface

In most software development projects, design models tend to contain uncertainty, because all of the design concerns cannot be captured at the early development phase. It is preferable to be able to check consistency or traceability among design models and programs even if they contain uncertain concerns. To deal with this problem, we propose the notion of uncertainty-aware Archface, an interface mechanism exposing a set of architectural points that should be shared between design and code. We can explicitly describe uncertainty in design models or programs by specifying uncertain architectural points.