Kyushu University Academic Staff Educational and Research Activities Database
List of Papers
Naoyasu Ubayashi Last modified date:2021.06.02

Professor / Advanced Software Engineering / Department of Advanced Information Technology / Faculty of Information Science and Electrical Engineering


Papers
1. Ryujiro Nishinaka, Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, How Fast and Effectively Can Code Change History Enrich Stack Overflow?, 2020 IEEE International Conference on Software Quality, Reliability & Security (QRS 2020), 467-478, 2020.12.
2. Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, When and Why Do Software Developers Face Uncertainty?, 2019 IEEE International Conference on Software Quality, Reliability & Security (QRS 2019), 288-299, 2019.07.
3. Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, Modular Programming and Reasoning for Living with Uncertainty (Extended Version)(Selected Paper from ICSOFT 2018), Software Technologies, Communications in Computer and Information Science (CCIS) 1077, Springer, 220-244, 2019.07.
4. Naoyasu Ubayashi, Watanabe Takuya, Yasutaka Kamei, Ryosuke Sato, Git-based Integrated Uncertainty Manager, 41st International Conference on Software Engineering (ICSE 2019), Companion Volume, 95-98, 2019.05.
5. Thong Hoang, Hoa Khanh Dam, Yasutaka Kamei, David Lo, and Naoyasu Ubayashi, DeepJIT: An End-To-End Deep Learning Framework for Just-In-Time Defect Prediction, 16h International Conference on Mining Software Repositories (MSR 2019), 34-45, 2019.05.
6. Katsuhisa Maruyama, Naoyasu Ubayashi, Message from the APSEC 2018 General Co-Chairs, 25th Asia-Pacific Software Engineering Conference, APSEC 2018 , 10.1109/APSEC.2018.00005, 2018-December, xvi, 2019.05.
7. Lionel Montrieux, Naoyasu Ubayashi, Tianqi Zhao, Zhi Jin, Zhenjiang Hu, Bidirectional transformations for self-adaptive systems, Engineering adaptive software systems Communications of nii shonan meetings, 10.1007/978-981-13-2185-6_4, 95-114, 2019.01, Bidirectional transformations are a synchronisation mechanism between documents, a source, and a view. A bidirectional transformation is a pair of functions, one that extracts a view from a source and the other that updates a source according to changes made to the view. Bidirectional programming is a recent technique that helps developers to easily write bidirectional transformations and ensure that they satisfy properties of interest. In this chapter, we argue that bidirectional transformations and bidirectional programming are useful techniques in the context of self-adaptive systems.We present four applications of bidirectional transformation for construction of adaptive systems: abstraction, separation of concerns, rule-based adaptation, and uncertainty-aware programming..
8. Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, Modular Programming and Reasoning for Living with Uncertainty, Software Technologies - 13th International Conference, ICSOFT 2018, Revised Selected Papers, 10.1007/978-3-030-29157-0_10, 220-244, 2019.01, Embracing uncertainty in software development is one of the crucial research topics in software engineering. In most projects, we have to deal with uncertain concerns by using informal ways such as documents, mailing lists, or issue tracking systems. This task is tedious and error-prone. Especially, uncertainty in programming is one of the challenging issues to be tackled, because it is difficult to verify the correctness of a program when there are uncertain user requirements, unfixed design choices, and alternative algorithms. If uncertainty can be dealt with modularly, we can add or delete uncertain concerns to/from code whenever they arise or are fixed to certain concerns. This paper proposes a new programming and reasoning style based on Modularity for Uncertainty. The iArch-U IDE (Integrated Development Environment) is developed to support uncertainty-aware software development. The combined usage of a type checker and a model checker in iArch-U plays an important role in verifying whether or not some important properties are guaranteed even if uncertainty remains in a program. Our model checker is based on LTSA (Labelled Transition System Analyzer) and is implemented as an Eclipse plug-in. Agile methods embrace change to accept changeable user requirements. On the other hand, our approach embraces uncertainty to support exploratory software development..
9. Introduction to ICSE 2018..
10. Yasutaka Kamei, Takahiro Matsumoto, Kazuhiro Yamashita, Naoyasu Ubayashi, Takashi Iwasaki, Shuich Takayama, Studying the Cost and Effectiveness of OSS Quality Assessment Models: An Experience Report of Fujitsu QNET, IEICE Transactions on Information and Systems, E101-D, 11, 2744-2753, 2018.11.
11. Junji Shimagaki, Yasutaka Kamei, Abram Hindle, Naoyasu Ubayashi, Automatic Topic Classification of Test Cases Using Text Mining at an Android Smartphone Vendor Company, 12th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM 2018), 32:1-32:10, 2018.10.
12. Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, iArch-U/MC: An Uncertainty-Aware Model Checker for Embracing Known Unknowns, 13th International Conference on Software Technologies (ICSOFT 2018), 176-184, 2018.07.
13. Naoyasu Ubayashi, Hokuto Muraoka, Daiki Muramoto, Yasutaka Kamei, Ryosuke Sato, Exploring Uncertainty in GitHub OSS Projects---When and How Do Developers Face Uncertainty?---, 40th International Conference on Software Engineering (ICSE 2018), poster, 272-273, 2018.05.
14. Naoyasu Ubayashi, Yasutaka Kamei, Ryosuke Sato, Can Abstraction Be Taught? Refactoring-based Abstraction Learning, 6th International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2018), 429-437, 2018.01.
15. MLSE Kick-off Symposium Participation Report.
16. Introduction to the Special Issue on Practical IT Education.
17. Keisuke Watanabe, Naoyasu Ubayashi, Takuya Fukamachi, Shunya Nakamura, Hokuto Muraoka, Yasutaka Kamei, IArch-U
Interface-Centric Integrated Uncertainty-Aware Development Environment, 9th IEEE/ACM International Workshop on Modelling in Software Engineering, MiSE 2017 , 10.1109/MiSE.2017.7, 40-46, 2017.06, Uncertainty can appear in all aspects of software development: Uncertainty in requirements analysis, design decisions, implementation and testing. If uncertainty can be dealt with modularly, we can add or delete uncertain concerns to/from models, code and tests whenever these concerns arise or are fixed to certain concerns. To deal with this problem, we developed iArch-U, an IDE (Integrated Development Environment) for managing uncertainty modularly in all phases in software development. In this paper, we introduce an overview of iArch-U. The iArch-U IDE is open source software and can be downloaded from GitHub..
18. Keisuke Watanabe, Takuya Fukamachi, Naoyasu Ubayashi, Yasutaka Kamei, Automated A/B Testing with Declarative Variability Expressions, 10th IEEE International Conference on Software Testing, Verification and Validation Workshops, ICSTW 2017 , 10.1109/ICSTW.2017.72, 387-388, 2017.04, A/B testing is the experiment strategy, which is often used on web or mobile application development. In A/B testing, a developer has to implement multiple variations of application, assign each variation to a subset of the entire user population randomly, and analyze log data to decide which variation should be used as a final product. Therefore, it is challenging to keep the application code clean in A/B testing, because defining variations of software or assigning user to each variation needs the modification of code. In fact there are some existing tools to approach this problem. Considering such a context of A/B testing research, we propose the solution based on the interface Archface-U and AOP (Aspect Oriented Programming) which aims to minimize the complication of code in A/B testing..
19. Pawin Suthipornopas, Pattara Leelaprute, Akito Monden, Hidetake Uwano, Yasutaka Kamei, Naoyasu Ubayashi, Kenji Araki, Kingo Yamada, Ken-ichi Matsumoto, Industry Application of Software Development Task Measurement System: TaskPit, IEICE Transactions on Information and Systems, E100-D, 3, 462-472, 2017.03.
20. Report on ER 2016.
21. Introduction to the Forum Special Issue on Practical IT Education.
22. Automated A/B Testing with Declarative Variability Expressions.
23. The Field of Embedded Systems.
24. Yasutaka Kamei, Takafumi Fukushima, Shane McIntosh, Kazuhiro Yamashita, Naoyasu Ubayashi, Ahmed E. Hassan, Studying just-in-time defect prediction using cross-project models, Empirical Software Engineering, 21, 5, 2072-2106, 2016.10.
25. Junji Shimagaki, Yasutaka Kamei, Shane McIntosh, David Pursehouse, Naoyasu Ubayashi, Why are Commits being Reverted? A Comparative Study of Industrial and Open Source Projects, 32nd IEEE International Conference on Software Maintenance and Evolution (ICSME 2016), 301-311, 2016.10.
26. Keisuke Miura, Shane McIntosh, Yasutaka Kamei, Ahmed E. Hassan, Naoyasu Ubayashi, The Impact of Task Granularity on Co-evolution Analyses, 10th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM 2016), 47:1-47:10, 2016.09.
27. Kazuhiro Yamashita, Changyun Huang, Meiyappan Nagappan, Yasutaka Kamei, Audris Mockus, Ahmed E. Hassan, Naoyasu Ubayashi, Thresholds for Size and Complexity Metrics: A Case Study from the Perspective of Defect Density, 2016 IEEE International Conference on Software Quality, Reliability & Security (QRS 2016), 191-201, 2016.08.
28. Kwabena Ebo Bennin, Koji Toda, Yasutaka Kamei, Jacky Keung, Akito Monden, Naoyasu Ubayashi, Empirical Evaluation of Cross-Release Effort-Aware Defect Prediction Models, 2016 IEEE International Conference on Software Quality, Reliability & Security (QRS 2016), 214-221, 2016.08.
29. Kwabena Ebo Bennin, Jacky Keung, Akito Monden, Yasutaka Kamei, Naoyasu Ubayashi, Investigating the Effects of Balanced Training and Testing Data Sets on Effort-Aware Fault Prediction Models, 40th IEEE Computer Society International Conference on Computers, Software & Applications (COMPSAC 2016), 154-163, 2016.06.
30. Junji Shimagaki, Yasutaka Kamei, Shane McIntosh, Ahmed E. Hassan, Naoyasu Ubayashi, A Study of the Quality-Impacting Practices of Modern Code Review at Sony Mobile, 38th International Conference on Software Engineering (ICSE 2016), Software Engineering in Practic (SEIP) Track, 212-221, ICSE (Companion Volume) , 2016.05.
31. Bodin Chinthanet, Passakorn Phannachitta, Yasutaka Kamei, Pattara Leelaprute, Arnon Rungsawang, Naoyasu Ubayashi, Kenichi Matsumoto, A review and comparison of methods for determining the best analogies in analogy-based software effort estimation, 31st ACM/SIGAPP Symposium on Applied Computing (SAC 2016), Software Engineering (SE) Track, poster, 1554-1557, 2016.04.
32. Kazuhiro Yamashita, Yasutaka Kamei, Shane McIntosh, Ahmed E. Hassan, Naoyasu Ubayashi, Magnet or Sticky? Measuring Project Characteristics from the Perspective of Developer Attraction and Retention, Journal of Information Processing, 24, 2, 1-10, 2016.03.
33. Yasutaka Kamei, Everton Maldonado, Emad Shihab, Naoyasu Ubayashi, Using analytics to quantify the interest of self-admitted technical debt, Joint of the 4th International Workshop on Quantitative Approaches to Software Quality, QuASoQ 2016 and 1st International Workshop on Technical Debt Analytics, TDA 2016 CEUR Workshop Proceedings, 1771, 68-71, 2016.01, Technical debt refers to the phenomena of taking a shortcut to achieve short term development gain at the cost of increased maintenance effort in the future. The concept of debt, in particular, the cost of debt has not been widely studied. Therefore, the goal of this paper is to determine ways to measure the 'interest' on the debt and use these measures to see how much of the technical debt incurs positive interest, i.e., debt that indeed costs more to pay off in the future. To measure interest, we use the LOC and Fan-In measures. We perform a case study on the Apache JMeter project and find that approximately 42-44% of the technical debt incurs positive interest..
34. Measuring Difficulty of Program Comprehension based on Brain Activation.
35. Kazuhiro Yamashita, Shane McIntosh, Yasutaka Kamei, Ahmed E. Hassan, Naoyasu Ubayashi, Revisiting the applicability of the pareto principle to core development teams in open source software projects, 14th International Workshop on Principles of Software Evolution, IWPSE 2015 , 10.1145/2804360.2804366, 46-55, 2015.08, It is often observed that the majority of the development work of an Open Source Software (OSS) project is contributed by a core team, i.e., a small subset of the pool of active developers. In fact, recent work has found that core development teams follow the Pareto principle-roughly 80% of the code contributions are produced by 20% of the active developers. However, those findings are based on samples of between one and nine studied systems. In this paper, we revisit prior studies about core developers using 2,496 projects hosted on GitHub. We find that even when we vary the heuristic for detecting core developers, and when we control for system size, team size, and project age: (1) the Pareto principle does not seem to apply for 40%-87% of GitHub projects; and (2) more than 88% of GitHub projects have fewer than 16 core developers. Moreover, we find that when we control for the quantity of contributions, bug fixing accounts for a similar proportion of the contributions of both core (18%-20%) and non-core developers (21%-22%). Our findings suggest that the Pareto principle is not compatible with the core teams of many GitHub projects. In fact, several of the studied GitHub projects are susceptible to the bus factor, where the impact of a core developer leaving would be quite harmful..
36. Takuya Fukamachi, Naoyasu Ubayashi, Shintaro Hosoai, Yasutaka Kamei, Conquering Uncertainty in Java Programming, 37th International Conference on Software Engineering (ICSE 2015), poster, 823-824, 2015.05.
37. Takuya Fukamachi, Naoyasu Ubayashi, Shintaro Hosoai, Yasutaka Kamei, Modularity for uncertainty, 7th International Workshop on Modeling in Software Engineering, MiSE 2015 , 10.1109/MiSE.2015.9, 7-12, 2015.05, Uncertainty can appear in all aspects of software development: uncertainty in requirements analysis, design decisions, implementation, and testing. As the research on uncertainty is so young, there are many issues to be tackled. Modularity for Uncertainty is one of them. If uncertainty can be dealt with modularly, we can add or delete uncertain concerns to/from models, code, and tests whenever these concerns arise or are fixed to certain concerns. To deal with this challenging issue, we propose a modularization mechanism for uncertainty. Agile methods embrace change to accept changeable user requirements. On the other hand, our approach embraces uncertainty to support exploratory development. This paper sets out a focused research agenda for uncertainty in terms of the new modularity vision..
38. Changyun Huang, Ataru Osaka, Yasutaka Kamei, Naoyasu Ubayashi, Automated DSL Construction Based on Software Product Lines, 3rd International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2015), 247-254, 2015.02.
39. Peiyuan Li, Naoyasu Ubayashi, Di Ai, Yu Ning Li, Shintaro Hosoai, Yasutaka Kamei, Sketch-Based gradual model-driven development, International Workshop on Innovative Software Development Methodologies and Practices, InnoSWDev 2014 , 10.1145/2666581.2666595, 100-105, 2014.11, 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..
40. Naoyasu Ubayashi, Di Ai, Peiyuan Li, Yu Ning Li, Shintaro Hosoai, Yasutaka Kamei, Uncertainty-aware architectural interface, 9th International Workshop on Advanced Modularization Techniques, AOAsia 2014 , 10.1145/2666358.2666579, 4-6, 2014.11, 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..
41. Akinori Ihara, Yasutaka Kamei, Masao Ohira, Ahmed E. Hassan, Naoyasu Ubayashi, Kenichi Matsumoto, Early Identification of Future Committers in Open Source Software Projects, 14th International Conference on Quality Software (QSIC 2014), 47-56, 2014.10.
42. Naoyasu Ubayashi, Di Ai, Peiyuan Li, Yu Ning Li, Shintaro Hosoai, Yasutaka Kamei, Abstraction-aware Verifying Compiler for Yet Another MDD, 29th International Conference on Automated Software Engineering (ASE 2014), 557-562, 2014.09.
43. Kazuhiro Yamashita, Shane McIntosh, Yasutaka Kamei, Naoyasu Ubayashi, Magnet or Sticky?: An OSS Project-by-Project Typology, 11th International Working Conference on Mining Software Repositories (MSR 2014), 344-347, 2014.06.
44. Takafumi Fukushima, Yasutaka Kamei, Shane McIntosh, Kazuhiro Yamashita, Naoyasu Ubayashi, An Empirical Study of Just-In-Time Defect Prediction Using Cross-Project Models, 11th International Working Conference on Mining Software Repositories (MSR 2014), 172-181, 2014.06.
45. Di Ai, Naoyasu Ubayashi, Peiyuan Li, Daisuke Yamamoto, Yu Ning Li, Shintaro Hosoai, Yasutaka Kamei, An IDE for Supporting Fluid Abstraction, 13th International Conference on Modularity (Modularity'14), Demonstrations, 13-16, 2014.04.
46. Di Ai, Naoyasu Ubayashi, Peiyuan Li, Shintaro Hosoai, Yasutaka Kamei, iArch: An IDE for Supporting Abstraction-aware Design Traceability, 2nd International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2014), 442-447, 2014.01.
47. Naoyasu Ubayashi, Shin Nakajima, Masayuki Hirayama, Context-dependent Product Line Engineering with Lightweight Formal Approaches (SPLC 2010 Revised Selected Paper), Science of Computer Programming, 2331-2346, 78(12), 2013.12, This paper proposes a new style of product line engineering methods. It focuses on constructing embedded systems that take into account the contexts such as the external physical environments. In current product line development projects, Feature Analysis is mainly conducted from the viewpoint of system configurations: how hardware and software components are configured to constitute a system. In most cases, contexts are not considered explicitly. As a result, unexpected and unfavorable behavior might emerge in a system if a developer does not recognize any possible conflicting combinations between the system and contexts. To deal with this problem, this paper provides the notion of a context-dependent product line, which is composed of the system and context lines. The former is obtained by analyzing a family of systems. The latter is obtained by analyzing features of contexts associated to the systems. The system and context lines contain reusable core assets. The configuration of selected system components and contexts can be formally checked at the specification level. In this paper, we show a development process that includes the creation of both product line assets as well as context assets.
.
48. Naoyasu Ubayashi, Yasutaka Kamei, Design module
A modularity vision beyond code: Not only program code but also a design model is a module, 2013 5th International Workshop on Modeling in Software Engineering, MiSE 2013 , 10.1109/MiSE.2013.6595295, 44-50, 2013.12, We propose a new modularity vision to integrate design modeling with programming. A system consists of not only program code but also design models. However, design models such as UML diagrams have been treated as not modules but complementary documents. This paper provides a novel idea that treats a design model as a first-class software module termed design module. A system cannot be complied without design modules. A developer has to create and modify not only program modules but also design modules. To realize design modules, we introduce Archface, an architectural interface mechanism. Archface exposes architectural points shared between design and code. Archface plays a role as a design interface for a design module and as a program interface for a program module. Arch-face type system automatically checks the consistency between design and code. Our approach can integrate research on design modeling with research on programming in terms of modularity. Additional costs are not needed to introduce design modules, because Archface descriptions can be generated from a model editor and Archface is just an extension of the notion of program interfaces. That is, we can substitute Archface for traditional program interfaces..
49. Masateru Tsunoda, Koji Toda, Kyohei Fushida, Yasutaka Kamei, Meiyappan Nagappan, Naoyasu Ubayashi, Revisiting software development effort estimation based on early phase development activities, 10th International Working Conference on Mining Software Repositories, MSR 2013 , 10.1109/MSR.2013.6624059, 429-438, 2013.12, Many research projects on software estimation use software size as a major explanatory variable. However, practitioners sometimes use the ratio of effort for early phase activities such as planning and requirement analysis, to the effort for the whole development phase of the software in order to estimate effort. In this paper, we focus on effort estimation based on the effort for early phase activities. The goal of the research is to examine the relationship of early phase effort and software size with software development effort. To achieve the goal, we built effort estimation models using early phase effort as an explanatory variable, and compared the estimation accuracies of these models to the effort estimation models based on software size. In addition, we built estimation models using both early phase effort and software size. In our experiment, we used ISBSG dataset, which was collected from software development companies, and regarded planning phase effort and requirement analysis effort as early phase effort. The result of the experiment showed that when both software size and sum of planning and requirement analysis phase effort were used as explanatory variables, the estimation accuracy was most improved (Average Balanced Relative Error was improved to 75.4% from 148.4%). Based on the result, we recommend that both early phase effort and software size be used as explanatory variables, because that combination showed the high accuracy, and did not have multicollinearity issues..
50. Changyun Huang, Yasutaka Kamei, Kazuhiro Yamashita, Naoyasu Ubayashi, Using alloy to support feature-based DSL construction for mining software repositories, 17th International Software Product Line Conference Co-located Workshops, SPLC 2013 , 10.1145/2499777.2500714, 86-89, 2013.12, The Mining Software Repositories (MSR) field reveals knowledge for software development by analyzing data stored in repositories such as source control and bug trace systems. In order to reveal the knowledge, MSR researchers need to perform complicated procedures iteratively. To help the complex work of MSR practitioners, we study the construction of domain specific languages (DSLs) for MSR. We have conducted feature-oriented domain analysis (FODA) on MSR and developed a DSL based on the feature model. In this paper, we expand our previous work and propose to construct not a single DSL but a DSL family. A DSL family consists of a series of DSLs with commonality in their domain but suitable to specific applications of MSR. To readily construct these DSLs, we use Alloy to encode the feature model. Our encoding includes not only the DSL features and their relations but also some composition rules that can be used to generate the syntax of DSLs. Based on this, we can automatically derive the language elements to construct DSLs suitable to specific purposes of MSR..
51. Changyun Huang, Kazuhiro Yamashita, Yasutaka Kamei, Kenji Hisazumi, Naoyasu Ubayashi, Domain analysis for mining software repositories
Towards feature-based DSL construction, 2013 4th International Workshop on Product LinE Approaches in Software Engineering, PLEASE 2013 , 10.1109/PLEASE.2013.6608663, 41-44, 2013.10, The mining software repositories (MSR) analyze data stored in software repositories and discover meaningful information to support software development. However, MSR is complex due to conducting large scale data collection with various repositories. To help practitioners perform MSR analysis, one possible way is to apply the approaches of software product line (SPL) to the MSR domain to understand variability and commonality for the domain, and to construct domain specific languages (DSLs) because DSLs have high readability to reduce the complexity of the procedure of MSR. In this paper, we construct a SQL-based DSL to support MSR and provide a systematic approach to conduct Feature-Oriented Domain Analysis (FODA) for MSR towards the construction of the DSL. We provide the syntax of the DSL and explain how to locate language elements of the DSL to the four-layer structure used in FODA..
52. Naoyasu Ubayashi, Ai Di, Yasutaka Kamei, Archface4COP
Architectural interface for context-oriented programming, 5th International Workshop on Context-Oriented Programming, COP 2013 , 10.1145/2489793.2489794, 2013.08, Context-awareness plays an important role in developing flexible and evolvable applications such as self-* systems (e.g., self-adaptive, self-healing, and self-management systems). However, it is not easy to design and implement such a context-aware system, because its software architecture is dynamically changed. That is, software components constituting a system and their connection structure can be dynamically changed. As a result, it is hard to check whether or not a design model is correctly implemented and its context-dependent behavior is faithful to the design. To deal with this problem, we introduce Archface4COP, an architectural interface mechanism for COP (Context-Oriented Programming). Archface4COP exposes architectural points shared between UML-based design models and code written in COP languages. Architectural points represent COP-specific events such as layer in, layer out, layered message send, and layered message receive. These points are important to represent an abstract structure of software architecture focusing on context-awareness. We can verify whether or not a design model and its code can co-evolve each other by checking an Archface4COP interface..
53. Yasutaka Kamei, Emad Shihab, Bram Adams, Ahmed E. Hassan, Audris Mockus, Anand Sinha, Naoyasu Ubayashi, A Large-Scale Empirical Study of Just-In-Time Quality Assurance, IEEE Transactions on Software Engineering, 39, 6, 757-773, 2013.06.
54. Masateru Tsunoda, Koji Toda, Kyohei Fushida, Yasutaka Kamei, Meiyappan Nagappan, Naoyasu Ubayashi , Revisiting Software Development Effort Estimation Based on Early Phase Development Activities, International Working Conference on Mining Software Repositories (MSR 2013), 2013.05.
55. Hidehiko Masuhara, Shigeru Chiba, Naoyasu Ubayashi, Jörg Kienzle, Elisa Baniassad, David H. Lorenz, MODULARITY:aosd.13 - Chairs' welcome, 12th Annual International Conference on Aspect-Oriented Software Development, AOSD 2013 , iii-iv, 2013.04.
56. Naoyasu Ubayashi, Yasutaka Kamei, UML-based Design and Verification Method for Developing Dependable Context-aware Systems, 1st International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2013), pp.89-94, 2013.02.
57. Naoyasu Ubayashi, Yasutaka Kamei, UML4COP
UML-based DSML for context-aware systems, SPLASH 2012 DSM 2012 - Proceedings of the 2012 ACM Workshop on Domain-Specific Modeling, 10.1145/2420918.2420928, 33-38, 2012.12, Context-awareness plays an important role in developing flexible and adaptive systems. However, it is not easy to design and implement such a context-aware system, because its system configuration can be dynamically changed. This paper proposes UML4COP, a UML-based design method for COP (Context-Oriented Programming). UML4COP is a DSML (Domain-Specific Modeling Language) for designing context-aware systems. In UML4COP, each context is modeled separately and a system design model at a certain period of time is composed by merging associated contexts..
58. Naoyasu Ubayashi, Yasutaka Kamei, Verifiable architectural interface for supporting model-driven development with adequate abstraction level, 2012 4th International Workshop on Modeling in Software Engineering, MiSE 2012 , 10.1109/MISE.2012.6226008, 15-21, 2012.08, It is not easy to design software architecture reflecting the intention of developers and implement the result of design as a program while preserving the architectural correctness and adequate abstraction level. Archface, an architectural interface mechanism, plays a role as an ADL at the design phase and as a programming interface at the implementation phase. Design and code can co-evolve with Archface at the center of the development process. This paper proposes a verifiable architectural interface that can check the traceability between design and code. For this checking, we use an SMT (Satisfiability Modulo Theories) solver, a tool for deciding the satisfiability of logical formulas. Adopting our approach, we can construct MDD tools supporting adequate abstraction level when they generate code, recover a design model from code, and check the traceability between a design model and its code..
59. Rina Nagano, Hiroki Nakamura, Yasutaka Kamei, Bram Adams, Kenji Hisazumi, Naoyasu Ubayashi, Akira Fukuda, Using the GPGPU for Scaling Up Mining Software Repositories, 34th International Conference on Software Engineering (ICSE 2012), poster, 1435-1436, 2012.06.
60. Naoyasu Ubayashi, Yasutaka Kamei, An Extensible Aspect-oriented Modeling Environment for Constructing Domain-Specific Languages, IEICE Transactions on Information and Systems, E95-D, 4, 942-958, 2012.04.
61. Naoyasu Ubayashi, Yasutaka Kamei, Stepwise Context Boundary Exploration Using Guide Words, CAiSE Forum 2011 (Selected Extended Papers), 218-233, 2012.04.
62. Naoyasu Ubayashi, Yasutaka Kamei, Architectural Point Mapping for Design Traceability, 11th Workshop on Foundations of Aspect-Oriented Languages (FOAL 2012) (Workshop at AOSD 2012), 39-43, 2012.03.
63. Akinori Ihara, Yasutaka Kamei, Akito Monden, Masao Ohira, Jacky Wai Keung, Naoyasu Ubayashi, Ken Ichi Matsumoto, An investigation on software bug-fix prediction for open source software projects - A case study on the eclipse project, 19th Asia-Pacific Software Engineering Conference, APSEC 2012 APSECW 2012 - Proceedings of the 19th Asia-Pacific Software Engineering Conference Workshops, 10.1109/APSEC.2012.86, 2, 112-119, 2012, Open source software projects (OSS) receive a large number of bug reports from various contributors and developers alike, where many planned to be fixed by OSS developers. Given the next release cycle information, OSS users can be more effective and flexible in planning and to fix the bugs that are not to be fixed in the next release. It is therefore vital for OSS users to learn which bugs the OSS developers will fix, unfortunately such information may not be readily available, nor there is a prediction framework exists to serve such an important purpose. In this study, we would like to answer the question 'Will this bug be fixed by the next release?', this is addressed by building a bug fixing prediction model based on the characteristics of a bug-related metric and by incorporating the progress of bug fixing measures such as status, period and developer metrics to provide aggregated information for the OSS users. The proposed model calculates the deviance of each variable to analyze the most important metrics, and it has been experimented using a case study with Eclipse platform. Result shows a bug fixing prediction model using both base metrics and state metrics provide significantly better performance in precision (139%) and recall (114\%) than the standard model using only base metrics..
64. Hiroki Nakamura, Rina Nagano, Kenji Hisazumi, Yasutaka Kamei, Naoyasu Ubayashi, Akira Fukuda, QORAL
An external domain-specific language for mining software repositories, 2012 4th International Workshop on Empirical Software Engineering in Practice, IWESEP 2012 Proceedings - 2012 4th International Workshop on Empirical Software Engineering in Practice, IWESEP 2012, 10.1109/IWESEP.2012.20, 23-29, 2012, The mining software repositories (MSR) field integrates and analyzes data stored in repositories such as source control and bug repositories to provide support to practitioners. In order to provide useful information to practitioners, MSR researchers need to perform tasks iteratively, these tasks include extracting data from repositories, transforming them into specific data formats, and loading them into the statistical analysis tool. These tasks require a significant amount of man hours to implement and execute according to the requirements of the researchers. This paper proposes an external domain-specific language (DSL) called QORAL to facilitate the performance of multiple iterations and environment development. The results from a questionnaire used to evaluate QORAL indicate that it is easy to understand and modify source code..
65. Shizuka Uchio, Naoyasu Ubayashi, Yasutaka Kamei, SMT-based Debugging Support for Context-oriented Programming, Computer Software, 29, 3, 108-114, 2012, COP (Context-Oriented Programming) languages such as ContextJ* enable programmers to describe the context-aware behavior elegantly. The primary system behavior can be separated from the context-aware behavior. On the other hand, unfortunately, it becomes difficult to debug the programs due to the complexity of COP execution and the dependence between objects and contexts. To deal with this problem, this paper proposes CJAdviser, SMT-based debugging support for ContextJ*. In CJAdviser, the execution trace of a ContextJ* program is converted to a context dependence graph that can be analyzed by the SMT solver Yices. Using CJAdviser, we can check a variety of object-context dependencies..
66. Shizuka Uchio, Naoyasu Ubayashi, Yasutaka Kamei, CJAdviser
SMT-based debugging support for ContextJ, 3rd International Workshop on Context-Oriented Programming, COP'11 - Co-located with the 25th European Conference on Object-Oriented Programming, ECOOP 2011 , 10.1145/2068736.2068743, 2011.12, Context-awareness plays an important role in developing flexible and adaptive software. However, it is not easy to write context-aware programs because context cannot be treated as a module in the traditional programming languages. COP (Context-Oriented Programming) languages such as ContextJ * enable programmers to describe the context-aware behavior elegantly. The primary system behavior can be separated from the context-aware behavior. On the other hand, unfortunately, it becomes difficult to debug the programs due to the complexity of COP execution and the dependence between objects and contexts. To deal with this problem, this paper proposes CJAdviser, SMT-based debugging support for ContextJ*. In CJAdviser, the execution trace of a ContextJ* program is converted to a context dependence graph that can be analyzed by the SMT (Satisfiability Modulo Theories) solver Yices. Using CJAdviser, we can check a variety of object-context dependencies such as "Do two objects A and B exist in the Context X at the same time?". In CJAdviser, SMT is applied to not static analysis but dynamic analysis because many context-aware properties are determined at run time..
67. Ryosuke Nakashiro, Yasutaka Kamei, Naoyasu Ubayashi, Shin Nakajima, and Akihito Iwai, Translation Pattern of BPEL Process into Promela Code, Joint Conference of the 21th International Workshop on Software Measurement (IWSM) and the 6th International Conference on Software Process and Product Measurement (Mensura) (IWSM/MENSURA 2011), 2011.11.
68. Yasutaka Kamei, Hiroki Sato, Akito Monden, Shinji Kawaguchi, Hidetake Uwano, Masataka Nagura, Ken-Ichi Matsumoto, and Naoyasu Ubayashi, An Empirical Study of Fault Prediction with Code Clone Metrics, Joint Conference of the 21th International Workshop on Software Measurement (IWSM) and the 6th International Conference on Software Process and Product Measurement (Mensura) (IWSM/MENSURA 2011), 2011.11.
69. Naoyasu Ubayashi, Yasutaka Kamei, Masayuki Hirayama, and Tetsuo Tamai, A Context Analysis Method for Embedded Systems ---Exploring a Requirement Boundary between a System and Its Context, 19th IEEE International Requirements Engineering Conference (RE 2011), pp.143-152, 2011.08, 高信頼な組み込みシステムを開発するには,システムに求められる機能だけでなく,それが動作する環境 (外部環境) についても要求分析を行う必要がある.しかし,考慮すべき外部環境は一般的に広範囲にわたるため,アドホック的な分析ではフレーム問題に陥ってしまう.本論文では,ガイドワードを用いて要求境界を決定する方法を提案している.更に,形式仕様記述言語 VDM とその支援ツールを用いて要求境界の妥当性を検査する方法,外部環境モデルから要求境界を考慮した設計モデルを自動生成する方法を提示している..
70. Masaru Shiozuka, Naoyasu Ubayashi, and Yasutaka Kamei, Debug Concern Navigator, 23rd International Conference on Software Engineering and Knowledge Engineering (SEKE 2011), 2011.07.
71. Shizuka Uchio, Naoyasu Ubayashi, and Yasutaka Kamei, CJAdviser: SMT-based Debugging Support for ContextJ*, 3rd Workshop on Context-Oriented Programming (COP 2011) (Workshop at ECOOP 2011), 2011.07.
72. Naoyasu Ubayashi and Yasutaka Kamei, Stepwise Context Boundary Exploration Using Guide Words, 23rd International Conference on Advanced Information Systems Engineering (CAiSE 2011 Forum), 2011.06.
73. Keiji Hokamura, Naoyasu Ubayashi, Shin Nakajima, and Akihito Iwai, Reusable Aspect Components for Web Applications, IEEE TENCON 2010, 2010.11.
74. Naoyasu Ubayashi, Shin Nakajima, and Masayuki Hirayama, Context-dependent Product Line Practice for Constructing Reliable Embedded Systems, 14th International Software Product Line Conference (SPLC 2010), pp.1-15, 2010.09.
75. Naoyasu Ubayashi, A Modularity Assessment Framework for Context-dependent Formal Specifications, 4th Workshop on Assessment of Contemporary Modularization Techniques(ACoM 2010) (Workshop at SPLC 2010), pp.13-14, 2010.09.
76. Takako Nakatani, Shozo Hori, Naoyasu Ubayashi, Keiichi Katamine, and Masaaki Hashimoto, A Case Study of Requirements Elicitation Process with Changes, IEICE Transactions on Information and Systems, E93-D, no.8, pp.2182-2189, 2010.08.
77. Shin Nakajima, Keiji Hokamura, and Naoyasu Ubayashi, Aspect-Oriented Development of PHP-based Web Applications, 4th IEEE International Workshop on Quality Oriented Reuse of Software(QUORS 2010) (Workshop at COMPSAC 2010), 2010.07.
78. Naoyasu Ubayashi, Jun Nomura, and Tetsuo Tamai, Archface: A Contract Place Where Architectural Design and Code Meet Together, 32nd ACM/IEEE International Conference on Software Engineering (ICSE 2010), pp.75-84, 2010.05, ソフトウェアアーキテクチャに関する研究は,ソフトウェア工学において重要な研究分野の一つである.本論文では,アーキテクチャ設計とその実装の間の溝を埋めるためのインタ
フェース機構 Archface を提案している.Archface を導入することにより,アーキテクチャ設計の本質をインタフェース内にカプセル化することが可能になる.Archface は Component-and-Connector アーキテクチャを記述支援の対象とし,プログラムの実装に際してはインタフェース中に記述されたアーキテクチャ制約に従うことをプログラマに強制する.そのため,設計の意図を正しく実装に反映できる..
79. Shozo Hori, Takako Nakatani, Keiichi Katamine, Naoyasu Ubayashi, and Masaaki Hashimoto, Project Management Patterns to Prevent Schedule Delay Caused by Requirements Changes, IEICE Transactions on Information and Systems, vol E93-D no.4, pp.745-753, vol E93-D, no.4, pp.745-753, 2010.04.
80. Shozo Hori, Takako Nakatani, Keiichi Katamine, Naoyasu Ubayashi, and Masaaki Hashimoto, A Discussion on a Framework of Project Management Patterns to Prevent Schedule Delay Caused by Requirements Elicitation, IADIS Information Systems Conference (IS 2010), 2010.03.
81. Naoyasu Ubayashi, A modularity assessment framework for context-dependent formal specifications, 14th International Software Product Line Conference, SPLC 2010 SPLC 2010 - Proceedings of the 14th International Software Product Line Conference, 13-14, 2010, Context-awareness is one of the important characteristics for developing dynamic and flexible systems. To develop reliable context-aware systems based on product lines, it is necessary to take into account not only system configurations but also any possible contexts. However, in most cases, contexts are not considered systematically. As a result, unexpected and unfavorable behavior might emerge in a system if a developer does not recognize any possible conflicting combinations between the system and its contexts. Lightweight formal approaches such as VDMTools and Alloy are effective for detecting this kind of conflicts. Because system and context specifications described in these formal methods can be considered as assets, modularity in these specifications is one of the crucial issues. This paper proposes an assessment framework for selecting appropriate formal approaches in terms of the modularity..
82. Shin Nakajima, Keiji Hokamura, Naoyasu Ubayashi, Aspect-oriented development of PHP-based web applications, 34th Annual IEEE International Computer Software and Applications Conference Workshops, COMPSACW 2010 Proceedings - 34th Annual IEEE International Computer Software and Applications Conference Workshops, COMPSACW 2010, 10.1109/COMPSACW.2010.17, 37-44, 2010, Web applications, which are sometimes developed incrementally and iteratively, may result in program codes that are poorly organized. The notion of aspect can theoretically be introduced for better modularization, but trials occasionally fail because homogeneous aspects alone are not adequate. The approach taken here is to introduce feature analysis and to radically use heterogeneous aspects to implement identified application features. This paper discusses our demonstration of the idea with an example case where Web applications were developed by using AOWP, which is a new AOP framework for PHP programs..
83. Shozo Hori, Takako Nakatani, Keiichi Katamine, Naoyasu Ubayashi, Masaaki Hashimoto, Project management patterns to prevent schedule delay caused by requirement elicitation, IEICE Transactions on Information and Systems, 10.1587/transinf.E93.D.745, E93-D, 4, 745-753, 2010, We propose PM(Project Management) patterns to prevent schedule delays caused by changes in requirements on empirical studies. Changes or late elicitation of requirements during the design, coding and test processes are one of the most serious risks, which may delay project schedules. However, changes and late elicitation of requirements are usually accepted during development processes. Therefore, the PM methods for preventing schedule delays caused by changes and late elicitation of requirements during development processes are an important area of study. In this study, we examined the actual conditions of various projects which succeeded in preventing schedule delays resulting from changes and late elicitation of requirements during development processes. We were able to extract various typical PM techniques for preventing these schedule delays. The techniques, known as "PM patterns", were also applied to other projects. The patterns were arranged on a two-dimensional framework. We discuss a framework of PM patterns aimed at solving the problems caused by changes in requirements..
84. Keiji Hokamura, Ryoto Naruse, Masaru Shiozuka, Naoyasu Ubayashi, Shin Nakajima, Akihito Iwai, AOWP
Web-specific AOP framework for PHP, 24th IEEE/ACM International Conference on Automated Software Engineering, ASE2009 ASE2009 - 24th IEEE/ACM International Conference on Automated Software Engineering, 10.1109/ASE.2009.45, 683-685, 2009.12, Aspect-oriented programming (AOP) is a technique for modularizing crosscutting concerns (CCCs). A variety of CCCs can be found in typical Web applications. Most CCCs are scattered over Web-specific events such as page requests. AOWP, a PHP-based AOP framework, provides Web-specific aspect instantiations for dealing with session management and pointcut & advice mechanisms for capturing Web-specific events. CCCs in Web applications can be clearly modularized by introducing AOWP..
85. Shin Nakajima, Naoyasu Ubayashi, Alloy
MModel-oriented specification language with automated analysis tool, Computer Software, 26, 3, 78-83, 2009.11.
86. Naoyasu Ubayashi, Hidenori Akatoki, Jun Nomura, Pointcut-based architectural interface for bridging a gap between design and implementation, Workshop on AOP and Meta-Data for Software Evolution, RAM-SE'09 Proceedings of the Workshop on AOP and Meta-Data for Software Evolution, RAM-SE'09, 10.1145/1562860.1562865, 2009.11, This paper proposes archface, a pointcut-based interface mechanism for bridging a gap between architectural design and its implementation. Archface, which encapsulates the essence of architectural design, is not only an architecture description language (ADL) but also a programming-level interface. Archface is based on the component-and-connector architecture, one of the most popular architectural styles. Archface is effective for software evolution because the trace-ability between design and its implementation can be realized by enforcing architectural constraints specified in arch-face on the program implementation. This traceability is bidirectional. In the modern software development, not only object orientation (OO) but also aspect orientation (AO) plays an important role in the architectural design because dealing with crosscutting concerns becomes crucial for designing reliable and maintainable software. In archface, AO can be easily introduced into architecture descriptions only with the component-and-connector mechanism. We do not have to distinguish AO from traditional OO-based design modeling approaches. Archface integrates not only design modeling with its implementation but also AO with OO..
87. Naoyasu Ubayashi, Genya Otsubo, Kazuhide Noda, and Jun Yoshida, An Extensible Aspect-oriented Modeling Environment, 21st International Conference on Advanced Information Systems (CAiSE 2009), 2009.06.
88. Shouzo Hori, Takako Nakatani, Keiichi Katamine, Naoyasu Ubayashi, Masaaki Hashimoto, Project management patterns to prevent schedule delay caused by requirements changes
Empirical study on a successful project, ICSOFT 2009 - 4th International Conference on Software and Data Technologies ICSOFT 2009 - 4th International Conference on Software and Data Technologies, Proceedings, 1, 115-120, 2009, We propose PM (Project Management) patterns in order to prevent schedule delays caused by requirements changes on empirical studies. Changes or late elicitation of requirements during the design, coding and test processes are one of the most serious risks, which may delay the project schedules. However, changes and late elicitation of requirements are sometimes inevitably accepted during the development processes. Therefore, the PM method for preventing schedule delays caused by changes and late elicitation of requirements during the development processes should be studied. In this study, we examined the actual conditions of a project. The project succeeded in preventing schedule delays, though it did accept changes and late elicitation of requirements during the development processes. As a result, we were able to extract various typical PM techniques for preventing schedule delays caused by requirements elicitation. The techniques were also applied to other projects. Thus, we call them "PM patterns". Moreover, we've arranged the patterns on a two-dimensional framework. The first dimension is a set of nine knowledge areas of PM such as scope, time and cost management. The second dimension is a group of PM processes such as planning, executing and controlling processes. We also break down the project goal, in this case, the redevelopment of systems for future modifiability, into issues such as keeping lead time and educating engineers, and arrange them on the framework. Then, we discuss the relationship between the project goal and PM patterns on the framework..
89. Shin Nakajima, Naoyasu Ubayashi, Keiji Hokamura, Runtime monitoring of cross-cutting policy, 2009 ICSE Workshop on Aspect-Oriented Requirements Engineering and Architecture Design, EA 2009 Proceedings of the 2009 ICSE Workshop on Aspect-Oriented Requirements Engineering and Architecture Design, EA 2009, 10.1109/EA.2009.5071579, 20-24, 2009, In open systems, certain unfavorable situations due to unanticipated user behavior may be seen, which results in a violation of cross-cutting policy. This paper proposes a runtime monitoring method to check such problems. Since there is a large gap, a certain link is needed between the policy and runtime execution method. We employ a two-step checking approach; an offline symptom checking and a runtime monitoring. The ingredient to tie the two steps is a Linear-time Temporal Logic formula for the cross-cutting policy to look at..
90. Naoyasu Ubayashi, Toshiki Seto, Hirotoshi Kanagawa, Susumu Taniguchi, Jun Yoshida, Takeshi Sumi, Masayuki Hirayama, A context analysis method for constructing reliable embedded systems, 30th International Conference on Software Engineering, ICSE 2008 Co-located Workshops - 2008 International Workshop on Models in Software Engineering, MiSE'08 30th International Conference on Software Engineering, ICSE 2008 Co-located Workshops - Proceedings of the 2008 International Workshop on Models in Software Engineering, MiSE'08, 10.1145/1370731.1370745, 57-62, 2008.12, This paper proposes a context-dependent requirements analysis method called CAMEmb (Context Analysis Method for Embedded systems) consisting of UML-based context modeling and formal verification support. In CAMEmb, a context model is constructed from initial system requirements by using a UML Profile for Context Analysis. This context model clarifies the relations among hardware components and contexts. After that, the context model is verified in order to check whether a target system behaves correctly under the expected contexts..
91. Keiji Hokamura, Shin Nakajima, Naoyasu Ubayashi, Akihito Iwai, Aspect-oriented programming for web controller layer, 15th Asia-Pacific Software Engineering Conference, APSEC 2008 , 10.1109/APSEC.2008.69, 529-536, 2008.12, We propose a new domain-specific aspect-oriented programming (AOP) mechanism for Web application development. A variety of crosscutting concerns such as access control and performance tuning are found in typical Web applications, but it is not easy to concisely modularize the concerns as aspects in current AOP languages because they do not provide pointcut mechanisms for directly handling events in the Web controller layer. To deal with this problem, we propose a Web-specific AOP mechanism called AOWP and a PHP-based AOWP framework. Using this framework, a programmer can easily address Web-specific crosscutting concerns triggered by Web-specific events, including page requests, page transitions, and session management events..
92. Naoyasu Ubayashi, Yuki Sato, Akihiro Sakai, Tetsuo Tamai, Alloy-based lightweight verification for aspect-oriented architecture, 6th ACIS International Conference on Software Engineering Research, Management and Applications, SERA 2008 Proceedings - 6th ACIS International Conference on Software Engineering Research, Management and Applications, SERA 2008, 10.1109/SERA.2008.12, 171-178, 2008.10, ccJava, a new kind of class-based AOP language, provides the weaving-interface mechanism in which the weaving can be realized by the component-and-connector architecture. The interface description constructs in ccJava can be considered a kind of architecture description language that takes into account the weaving. This paper provides a lightweight verification approach using Alloy, a structural modeling language based on relational logic. Using Alloy, we can verify whether the weaving based on the component-and- connector architecture satisfies some kinds of properties-whether advice-types are specified correctly, whether a pointcut selects join points correctly, and so on. By enforcing the architecture verified by Alloy to the class implementation, we can construct a reliable system..
93. Naoyasu Ubayashi, Jinji Piao, Suguru Shinotsuka, Tetsuo Tamai, Contract-based verification for aspect-oriented refactoring, 1st International Conference on Software Testing, Verification and Validation, ICST 2008 Proceedings of the 1st International Conference on Software Testing, Verification and Validation, ICST 2008, 10.1109/ICST.2008.36, 180-189, 2008.09, Refactoring is a method for improving a program's structure without changing its external behavior. Refactoring is a promising approach to assist reliable and safe software evolution. However, in aspect-oriented programming (AOP), it is not necessarily easy for a programmer to understand the overall behavior of a woven program because the weaving modifies the behavior. Unexpected bugs can be embedded in a program if the programmer does not modify the program carefully. In order to deal with this problem, we propose the notion of RbC (Refactoring by Contract), a technique to verify refactoring based on contracts. Contracts in RbC consist of preconditions, postconditions, and invariants. A precondition states under which conditions refactoring can be applied. A postcondition states what condition should be verified after refactoring has been accomplished, and an invariant states what conditions refactoring should preserve. After introducing RbC, we check whether refactoring preserves behavior and whether it actually improves internal structure. A contract is described in COW (COntract Writing language), a language for describing a predicate based on first-order logic. COW provides a set of primitive predicates that represent program structure and behavior. Adopting our approach, software evolution in AOP becomes reliable and safe..
94. Keiichi Katamine, Yasufumi Shinyashiki, Toshiro Mise, Masaaki Hashimoto, Naoyasu Ubayashi, Takako Nakatani, A conceptual model for analysis method of extracting unexpected obstacles of embedded systems, Knowledge-Based Software Engineering. Proceedings of the Eighth Joint Conference on Knowledge-Based Software Engineering, 10.3233/978-1-58603-900-4-22, 22-31, 2008.01, This paper proposes a conceptual model for analysis method of extracting unexpected obstacles in order to improve the quality of embedded systems. Although embedded software has become increasingly large in scale and complexity, companies are requiring the software to be developed with in shorter periods of time. This trend in the industry has resulted in the oversight of unexpected obstacles and consequently has affected the quality of embedded software. In order to prevent the oversight of unexpected obstacles, we have already proposed two methods for requirements analysis: the Embedded Systems Improving Method (ESIM) using an Analysis Matrix, and a method that uses an Information Flow Diagram (IFD). However, these analysis methods have been developed separately. This paper proposes the conceptual model including both methods, and clarifies abstraction mechanisms of expert engineers for extracting unexpected obstacles of embedded systems. It also describes a case study and discussion of the domain model..
95. Keiichi Ishibashi, Masaaki Hashimoto, Keiichi Katamine, Ryoma Shiratsuchi, Keita Asaine, Takako Nakatani, Naoyasu Ubayashi, Yoshihiro Akiyama, A discussion on domain modeling in an example of motivation-based human resource management, Knowledge-Based Software Engineering. Proceedings of the Eighth Joint Conference on Knowledge-Based Software Engineering, 10.3233/978-1-58603-900-4-32, 32-41, 2008.01, This paper proposes a domain model comprising a static model, dynamic model and scenario generation method for providing a foundation for motivation-based human resource management. One of the main concerns of managers when establishing a management method in an organization, is the individual members' motivation for the method. It is, however, difficult to manage the members' motivation, because the human resource is very complicated. We therefore, propose a domain model by applying Lawler's motivation model. Using this model, we analyze an actual example of successfully establishing CCPM (Critical Chain Project Management) in a company. We discuss primarily the stability of states, motivation, understanding of individuals' roles and their relationship..
96. Takako Nakatani, Shouzo Hori, Naoyasu Ubayashi, Keiichi Katamine, Masaaki Hashimoto, A case study
Requirements elicitation processes throughout a project, 16th IEEE International Requirements Engineering Conference, RE'08 Proceedings of the 16th IEEE International Requirements Engineering Conference, RE'08, 10.1109/RE.2008.46, 241-246, 2008, Requirements changes sometimes cause a project to fail. A lot of projects now follow incremental development processes so that new requirements and requirements changes can be incorporated as soon as possible. These processes are called integrated requirements processes which integrate requirements processes with other development processes. We have investigated the requirements processes of a project from beginning to end, both quantitatively and qualitatively. Our focus is to clarify the types of requirements based on the components contained within a certain portion of the software architecture. Each type reveals its typical requirements processes through its rationale. The case studied is a system to manage the orders and services of a restaurant. In this paper, we introduce the case and describe the types of requirements processes. Then we discuss the reasons why we could not elicit all the requirements in the early development processes..
97. Naoyasu Ubayashi, Genya Otsubo, Kazuhide Noda, Jun Yoshida, Tetsuo Tamai, AspectM
UML-based extensible AOM language, ASE 2008 - 23rd IEEE/ACM International Conference on Automated Software Engineering ASE 2008 - 23rd IEEE/ACM International Conference on Automated Software Engineering, Proceedings, 10.1109/ASE.2008.91, 501-502, 2008, AspectM, a UML-based aspect-oriented modeling (AOM) language, provides not only basic modeling constructs but also an extension mechanism called metamodel access protocol (MMAP) that allows a modeler to extend the AspectM metamodel. MMAP enables a modeler to construct domain-specific AOM languages at relatively low cost. In this paper, we show the overview of an AspectM support tool consisting of a reflective model editor and a verifying model weaver..
98. Naoyasu Ubayashi, Akihiro Sakai, and Tetsuo Tamai, An Aspect-oriented Weaving Mechanism Based on Component and Connector Architecture, 22nd IEEE/ACM International Conference on Automated Software Engineering (ASE 2007), 2007.11.
99. Naoyasu Ubayashi, Shin Nakajima, Context-aware feature-oriented modeling with an aspect extension of VDM, 2007 ACM Symposium on Applied Computing Proceedings of the 2007 ACM Symposium on Applied Computing, 10.1145/1244002.1244277, 1269-1274, 2007.01, Separation of concerns is important to reduce the complexity of software design. This paper examines a software development method starting with the feature-oriented modeling method to have VDM-based formal design. In order to overcome the problem that a feature may be scattered over the VDM design description, the notion of the aspect is adapted to propose Aspect VDM. The identified features are concisely represented in Aspect VDM to demonstrate modular descriptions of cross-cutting concerns in VDM..
100. Naoyasu Ubayashi, Shinji Sano, Genya Otsubo, A reflective aspect-oriented model editor based on metamodel extension, ICSE 2007 Workshops: International Workshop on Modeling in Software Engineering, MISE'07 Proceedings - ICSE 2007 Workshops International Workshop on Modeling in Software Engineering, MISE'07, 10.1109/MISE.2007.3, 12-17, 2007, AspectM, an aspect-oriented modeling language, provides not only basic modeling constructs but also an extension mechanism called metamodel access protocol (MMAP) that allows a modeler to modify the metamodel. MMAP consists of metamodel extension points, extension operations, and primitive predicates for defining pointcut designators. In this paper, a reflective model editor for supporting MMAP is proposed. A new modeling construct can be introduced by extending the metamodel. This mechanism, a kind of edit-time structural reflection, enables a modeler to represent domain-specific crosscutting concerns..
101. Yasufumi Shinyashiki, Toshiro Mise, Masaaki Hashimoto, Keiichi Katamine, Naoyasu Ubayashi, Takako Nakatani, A suggestion for analysis of unexpected obstacles in embedded system, Symposium on Human Interface 2007 Human Interface and the Management of Information Methods, Techniques and Tools in Information Design - Symposium on Human Interface 2007. Held as Part of HCI International 2007, Proceedings, 10.1007/978-3-540-73345-4_86, 755-768, 2007, In order to improve the quality of embedded software by finding obstacles unanticipated by software specifications, this paper describes a requirement analysis method based on an Information Flow Diagram and experiments using this method, with discussion. Recently, embedded software has become more large-scale and complicated while the development cycle of the software has typically been shortened. This industry trend compromises the quality of embedded software. In order to improve the quality of the software, unexpected obstacles must be carefully analyzed in me specification and design phases. We propose a diagram-based analysis method to answer this need, and have performed an experiment using the analysis method with an actual product. The results of the experiment made it clear that 1) Novice engineers can construct an Information Flow Diagram under the lead of expert engineers; and 2) The methods by which experts lead novice engineers in the analysis of unexpected obstacles require further refinement..
102. Suguru Shinotsuka, Naoyasu Ubayashi, Hideaki Shinomi, Tetsuo Tamai, Contract-based impact analysis for weaving classes and aspects, Computer Software, 24, 2, 133-149, 2007, Aspect-oriented programming (AOP) has the good characteristic called obliviousness that enables a programmer to design a class without considering crosscutting concerns. On the other hand, it is not necessarily easy for the programmer to know the overall behavior of a woven program because weaving modifies the behavior of a method denned in a class. Unexpected errors might be embedded in the woven program. To tackle this problem, we propose WbC (Weaving by Contract), a technique for verifying the correctness of weaving based on contracts. Contracts in WbC consist of pre-conditions, post-conditions, and invariants of weaving. By introducing WbC, we can specify how a program should behave before and after weaving. We also provide a language called COW (COntracl Writing language) for supporting WbC. In COW, a programmer describes contracts by predicate logic that represents the behavior of a program as a property of control and data flow. WbC can restrict weaving to keep the intention of the programmer..
103. Yasufumi Shinyashiki, Masaaki Hashimoto, Naoyasu Ubayashi, Toshiro Mise, Keiichi Katamine, Takako Nakatani, Enhancing the ESIM (Embedded Systems Improving Method) by combining information flow diagram with analysis matrix for efficient analysis of unexpected obstacles in embedded software, 14th Asia Pacific Software Engineering Conference, ASPCE 2007 Proceedings - 14th Asia-Pacific Software Engineering Conference, APSEC 2007, 10.1109/APSEC.2007.49, 326-333, 2007, In order to improve the quality of embedded software, this paper proposes an enhancement to the ESIM (Embedded Systems Improving Method) by combining an IFD (Information Flow Diagram) with an Analysis Matrix to analyze unexpected obstacles in the software. These obstacles are difficult to predict in the software specification. Recently, embedded systems have become larger and more complicated. Theoretically therefore, the development cycle of these systems should be longer. On the contrary, in practice the cycle has been shortened. This trend in industry has resulted in the oversight of unexpected obstacles, and consequently affected the quality of embedded software. In order to prevent the oversight of unexpected obstacles, we have already proposed two methods for requirements analysis: the ESIM using an Analysis Matrix and a method that uses an IFD. In order to improve the efficiency of unexpected obstacle analysis at reasonable cost, we now enhance the ESIM by combining an IFD with an Analysis Matrix. The enhancement is studied from the following three viewpoints. First, a conceptual model comprising both the Analysis Matrix and IFD is defined. Then, a requirements analysis procedure is proposed, that uses both the Analysis Matrix and IFD, and assigns each specific role to either an expert or non-expert engineer. Finally, to confirm the effectiveness of this enhancement, we carry out a description experiment using an IFD..
104. Tetsuo Tamai, Naoyasu Ubayashi, Ryoichi Ichiyama, Objects as actors assuming roles in the environment, 5th Workshop on Software Engineering for Large-Scale Multi-Agent Systems, SELMAS 2006 Software Engineering for Multi-Agent Systems V - Research Issues and Practical Applications, 10.1007/978-3-540-73131-3_11, 185-203, 2007, To achieve the goal of realizing object adaptation to environments, a new role-based model Epsilon and a language EpsilonJ are proposed. In Epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. Objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. Environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observable as behaviors. Environments encapsulating collaboration are independent reuse components to be deployed separately from objects. In this paper, the Epsilon model and the language are explained with some examples. The effectiveness of the model is illustrated by a case study on the problem of integrated systems. Implementation of the language is also reported..
105. Naoyasu Ubayashi, Tetsuo Tamai, Shinji Sano, Yusaku Maeno, Satoshi Murakami, Metamodel access protocols for extensible aspect-oriented modeling, 18th International Conference on Software Engineering and Knowledge Engineering, SEKE 2006 18th International Conference on Software Engineering and Knowledge Engineering, SEKE 2006, 4-10, 2006.12, Aspect orientation is important not only at the programming-level but also at the modeling-level We previously proposed an aspect-oriented modeling language called AspectM for managing modeling-level aspects Although AspectM provides basic modeling facilities for a modeler, the language constructs cannot be extended In this paper, we propose a mechanism called metamodel access protocol (MMAP) that allows an application modeler to access and modify the AspectM metamodel MMAP consists of metamodel extension points, extension operations, and primitive predicates for defining pointcut designators MMAP enables a modeler to represent application-specific crosscutting concerns..
106. Kouhei Sakurai, Hidehiko Masuhara, Naoyasu Ubayashi, Saeko Matuura, Seiichi Komiya, Design and implementation of an aspect instantiation mechanism, Transactions on Aspect-Oriented Software Development I, 259-292, 2006.01, This paper describes the design and implementation of association aspects, which are a linguistic mechanism for the AspectJ language that concisely associates aspect instances to object groups by extending the per-object aspects in AspectJ. This mechanism allows an aspect instance to be associated to a group of objects, and by providing a new pointcut primitive to specify aspect instances as execution context of advice. With association aspects, we can straightforwardly implement crosscutting concerns that have stateful behavior related to a particular group of objects. The new pointcut primitive can more flexibly specify aspect instances when compared against previous implicit mechanisms. We implemented a compiler for association aspects by modifying the AspectJ compiler, which reduces the size of data structures for keeping associations. Our benchmark tests confirm that the overheads of association aspects are reasonably small when compared against functionally equivalent aspects in pure AspectJ that manually manage associations. The expressiveness of association aspects is demonstrated through development of an integrated development environment with and without association aspects..
107. Toshiro Mise, Masaaki Hashimoto, Keiichi Katamine, Yasufumi Shinyashiki, Naoyasu Ubayashi, Takako Nakatani, An analysis method with failure scenario matrix for specifying unexpected obstacles in embedded systems, 12th Asia-Pacific Software Engineering Conference, APSEC'05 Proceedings - 12th Asia-Pacific Software Engineering Conference, APSEC'05, 10.1109/APSEC.2005.30, 447-454, 2005.12, This paper describes an analysis method with failure scenario matrix for specifying unexpected obstacles in order to improve the quality of embedded systems. Although embedded software has become increasingly large in scale and complexity, companies are requiring the software to be developed within shorter periods of time. Therefore, the quality of the software is bound to suffer. This problem is one of the most serious concerns in a coming age of ubiquitous embedded systems. In order to improve the quality, it is very important to specify the forbidden behavior of embedded systems. The forbidden behavior of unexpected obstacles is analyzed by using a matrix and scenarios. This paper provides a detailed description of the analysis method used, in particular the cause, phenomenon, and goal in the scenario, relating them to each other by using a matrix..
108. Naoyasu Ubayashi, Tetsuo Tamai, Shinji Sano, Yusaku Maeno, Satoshi Murakami, Model compiler construction based on aspect-oriented mechanisms, 4th International Conference on Generative Programming and Component Engineering, GPCE 2005 Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 10.1007/11561347_9, 109-124, 2005.12, Model-driven architecture (MDA) aims at automating software design processes. Design models are divided into platform-independent models (PIMs) and platform-specific models (PSMs). A model compiler transforms the former models into the latter automatically. We can regard PIMs as a new kind of reusable software component because they can be reused even if a platform is changed. However, a generated PSM is useless if it does not satisfy system limitations such as memory usage and real-time constraints. It is necessary to allow a modeler to customize transformation rules because model modifications for dealing with these limitations may be specific to an application. However, current model compilers do not provide the modeler sufficient customization methods. In order to tackle this problem, we propose a method for constructing an extensible model compiler based on aspect orientation, a mechanism that modularizes crosscutting concerns. Aspect orientation is useful for platform descriptions because it crosscuts many model elements. A modeler can extend model transformation rules by defining new aspects in the process of modeling. In this paper, an aspect-oriented modeling language called AspectM (Aspect for Modeling) for supporting modeling-level aspects is introduced. Using AspectM, a modeler can describe not only crosscutting concerns related to platforms but also other kinds of crosscutting concerns. We believe that MDA is one of the applications of aspect-oriented mechanisms. The contribution of this paper is to show that a model compiler can actually be constructed based on aspect-oriented mechanisms..
109. Naoyasu Ubayashi, Tetsuo Tamai, Shinji Sano, Yusaku Maeno, Satoshi Murakami, Model evolution with aspect-oriented mechanisms, 8th International Workshop on Principles of Software Evolution, IWPSE 2005 Proceedings - Eighth International Workshop on Principles of Software Evolution, IWPSE 2005, 10.1109/IWPSE.2005.24, 187-194, 2005.12, Model-based development is a software development method in which models are created before source code is written. Although the method is effective, we have to modify models when we face evolution such as change of platforms. These modifications crosscut over many places in the models, and tend to cause unexpected errors. In order to tackle this problem, we propose a method for model evolution using model transformations based on aspect orientation, a mechanism that modularizes crosscurting concerns. A modeler can extend model transformation rules by defining new aspects in the process of modeling. In this paper, we demonstrate the effectiveness of aspect orientation in terms of model evolution..
110. Naoyasu Ubayashi, Genki Moriyama, Hidehiko Masuhara, and Tetsuo Tamai, A Parameterized Interpreter for Modeling Different AOP Mechanisms, 20th IEEE/ACM International Conference on Automated Software Engineering (ASE 2005), 2005.11.
111. Masayuki Hirayama, Yoshikazu Ueda, Toshiaki Aoki, Harumi Watanabe, Mikio Aoyama, Shin Nakajima, Atsushi Sawada, Naoyasu Ubayashi, Shigeyuki Ohara, Shinji Kohno, Kazutoshi Wakabayashi, Shigeru Hitomi, Suji Yamamoto, Naoki Tamura, Special section on software engineering for embedded systems, IEICE Transactions on Information and Systems, 10.1093/ietisy/e88-d.6.1103, E88-D, 6, 1103-1104, 2005.06.
112. Tetsuo Tamai, Naoyasu Ubayashi, and Ryoichi Ichiyama, An Adaptive Object Model with Dynamic Role Binding, 27th IEEE/ACM International Conference on Software Engineering (ICSE 2005), 2005.05.
113. Naoyasu Ubayashi, Tetsuo Tamai, Concern management for constructing model compilers, 2005 Workshop on Modeling and Analysis of Concerns in Software, MACS 2005 Proceedings of the 2005 Workshop on Modeling and Analysis of Concerns in Software, MACS 2005, 10.1145/1083125.1083137, 2005.05, Model-driven architecture (MDA) aims at automating soft- ware design processes. A model compiler transforms platform- independent models into platform-specific models automatically. In order to construct an effective model compiler, we need to take account of not only platform concerns but also other kinds of model transformation concerns including optimization, real-Time constraints, and deployment. However, current model compilers do not provide a mechanism for managing these multiple concerns. We propose a method for constructing an extensible model compiler based on aspect- orientation. A modeler can manage multiple concerns and extend model transformation rules by defining new aspects in the process of modeling. In this paper, an aspect-oriented modeling language called AspectM is introduced for managing modeling-level aspects..
114. Kouhei Sakurai, Hidehiko Masuhara, Naoyasu Ubayashi, Saeko Matsuura, and Seiichi Komiya, Association Aspects, 3rd International Conference on Aspect-Oriented Software Development (AOSD 2004), 2004.03.
115. Naoyasu Ubayashi and Tetsuo Tamai, Aspect-Oriented Programming with Model Checking, 1st International Conference on Aspect-Oriented Software Development (AOSD 2002), 2002.04.
116. Ubayashi Naoyasu, Tamai Tetsuo, Modeling collaborations among objects that change their roles dynamically and its modularization mechanism, Systems and Computers in Japan, 10.1002/scj.1127, 33, 5, 51-63, 2002.01, For the representation of the collaborative operations among objects (computational entities), many of the techniques proposed at present treat the collaborative operations only as the concept in analysis and design stages; moreover, the roles carried by the respective objects have the problem of being fixed from the beginning to the end. Based on the environment-adaptive computation model "ε computation" proposed by the authors, in this paper we will study from the language side a description method for the case of collaborative operations in which the group of objects changes their roles dynamically along with the progress of computation. Furthermore, we will present a method for defining the collaborative operations among objects as general collaboration protocol components and reuse them again. ε computation is a model in which the field where the group of objects operates collaboratively is considered as an environment for the individual objects; the object can change its roles and collaboration forms with other objects dynamically by entering the environment or leaving the environment..
117. Naoyasu Ubayashi, Tetsuo Tamai, An evolutionary mobile agent system based on role concepts, Computer Software, 18, 1, 217-221, 2001.12.
118. Naoyasu Ubayashi, Tetsuo Tamai, Separation of concerns in mobile agent applications, 3rd International Conference on Metalevel Architectures and Separation of Crosscutting Concerns, REFLECTION 2001 Metalevel Architectures and Separation of Crosscutting Concerns - 3rd International Conference, REFLECTION 2001, Proceedings, 10.1007/3-540-45429-2_7, 89-109, 2001, Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is dificult to understand collaborations among agents and travels of individual agents as a whole because mobility/collaboration functions tend to be intertwined in the code; it is dificult to define behaviors of agents explicitly because they are influenced by their external context dynamically. Many aspects of mobility/collaboration strategies including traveling, coordination constraints, synchronization constraints and security-checking strategies should be considered when mobile agent applications are constructed. In this paper, the concept of RoleEP(Role Based Evolutionary Programming) is proposed in order to alleviate these problems. In RoleEP, a field where a group of agents roam around hosts and collaborate with each other is regarded as an environment and mobility/collaboration functions that an agent should assume in an environment are defined as roles. An object becomes an agent by binding itself to a role that is defined in an environment, and acquires mobility/collaboration functions dynamically. RoleEP provides a mechanism for separating concerns about mobility/collaboration into environments and a systematic evolutionary programming style. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically..
119. Naoyasu Ubayashi, Tetsuo Tamai, RoleEP
Role based evolutionary programming for cooperative mobile agent applications, International Symposium on Principles of Software Evolution, ISPSE 2000, 10.1109/ISPSE.2000.913244, 232-240, 2000.01, Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is difficult to understand collaborations among agents as a whole; it is difficult to define behaviors of agents because they are influenced by their external context dynamically. So, in general, constructions of cooperative distributed applications based on mobile agent systems are considered as very hard and difficult works. In this paper, the concept of RoleEP (Role Based Evolutionary Programming) is proposed in order to alleviate these problems. RoleEP provides a systematic evolutionary programming style. In RoleEP, a field where a group of agents collaborate with each other is regarded as an environment and a function that an agent assumes in an environment is defined as a role. Descriptions only concerning to collaborations among agents can be abstracted by environments. An object becomes an agent by binding itself with a role that is defined in an environment, and acquires functions needed for collaborating with other agents that exist in the same environment. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically..
120. Naoyasu Ubayashi, Tetsuo Tamai, An evolutional cooperative computation based on adaptation to environment, 6th Asia Pacific Software Engineering Conference, APSEC 1999, 10.1109/APSEC.1999.809620, 334-341, 1999.01, A framework in which a group of objects collaborating with each other evolve their functions dynamically is presented in this paper. We call the framework evolutional cooperative computation and present an environment-adaptive computation model for its foundation. Then, a programming language Epsilon/0, which supports the computation model and has the reflection mechanism, is presented. In this paper, the concept of environments that give objects collaboration fields is introduced. An object evolves itself and changes relations among other objects by adapting itself to environments or seceding from environments..
121. Naoyasu Ubayashi, Atsuo Ohki, Yasushi Kuno, A parallel computation model and programming language for the description of collaboration among objects, Systems and Computers in Japan, 10.1002/(sici)1520-684x(199705)28:5<33::aid-scj4>3.0.co;2-p, 28, 5, 33-43, 1997.05, Several parallel computation models including the Actor Model have been proposed. Since these models have only primitive constructs for parallel computation, it is not easy to build a model in terms of what kind of roles objects in the real world play and how they collaborate with each other. When we create a parallel system model with such frameworks, it is difficult to understand the system behavior as a whole. To solve this problem, we propose a new model, the Producer Model, and its description language Produce/1. In the Producer Model, parallel objects collaborate with each other under the coordination of producer objects. In the Actor Model, objects build network topologies and send messages to each other. On the other hand, in the Producer Model, we distinguish these two kinds of computations, through the execution of the former by producer objects, and of the latter by actor objects. By reading procedures of producer objects, we can understand collaboration among objects easily..