Papers - NITTA Naoya
-
A Method to Comprehend Feature Dependencies Based on Semi-Static Structures Reviewed International journal
Narumasa Kande and Naoya Nitta
Proceedings of IEEE 37th International Conference on Software Maintenance and Evolution (ICSME 2021) 2021.10
Joint Work
Authorship：Last author, Corresponding author
To understand why features of existing software can depend on each other is important for correct addition of a new feature to the software. Although some work has been done to detect feature dependency, it is not clear how effective such existing approaches are when they are applied to feature dependency comprehension because they are aimed at detection of runtime dependency between features. Therefore in this paper, we present an extraction method of source code that can be used to comprehend feature dependency. The method can extract a wider range of source code than existing techniques of feature dependency detection by using delta extraction. We conducted a controlled experiment with 20 professional programmers and confirmed that the difference of the extracted range has a positive effect on feature dependency comprehension. To figure out an internal mechanism to enable feature dependency, we also defined semi-static parts of object graphs that can be used to make features depend on each other. Finally, we confirmed that semistatic structures are actually used in feature dependencies in three open source programs and can be effectively extracted by
our method. -
Delta extraction: An abstraction technique to comprehend why two objects could be related Reviewed International journal
IEEE 31st International Conference on Software Maintenance and Evolution (ICSME 2015) 61 - 70 2015.9
-
Identifying Mandatory Code for Framework Use via a Single Application Trace Reviewed
Naoya Nitta, Izuru Kume, Yasuhiro Takemura
The 28th European Conference on Object-Oriented Programming (ECOOP 2014) 593 - 617 2014.8
Joint Work
Authorship：Lead author
Application frameworks allow application developers to effectively reuse both designs and implementations which frequently appear in their intended domains. However, when using a framework with large scale APIs, its usage to implement an application-specific behavior tends to be complicated. Thus, in practice, application developers use existing sample application code as references for their development, but the task to locate the parts which are related to their application usually becomes a burden. To address this problem, in this paper, we characterize the problem as a kind of dynamic flow analysis problem, and based on the characterization, we present a method to automatically identify the mandatory code for the framework use using only a single sample application's trace. We have conducted case studies with several real-world frameworks to validate our method and the results indicate that the method is suitable to extract the mandatory framework usage.
-
Towards a Dynamic Visualization of Complex Reverse-Engineered Object Collaboration Reviewed
Aki Hongo and Naoya Nitta
2021.12
Authorship：Last author
-
Revealing Implicit Correspondence between Bytecode Instructions and Expressions Determined by Java Compilers Reviewed
Izuru Kume, Masahide Nakamura, Naoya Nitta
Proc. of the 25th Australasian Software Engineering Conference (ASWEC) 126 - 130 2018.11
Joint Work
-
Constraints Based Approach to Interactive Feature Location Reviewed
Daiki Fujioka, Naoya Nitta
Proceedings - 2017 IEEE International Conference on Software Maintenance and Evolution, ICSME 2017 499 - 503 2017.11
Joint Work
Publisher：Institute of Electrical and Electronics Engineers Inc.
Feature location is a maintenance task to identify the implementation of a feature within the source code. To automate or support the task, extensive studies have been conducted on feature location techniques. In this paper, we focus on certain static and dynamic constraints regarding feature additions to object-oriented programs, and construct an interactive feature location procedure based on the constraints. We manually conducted a case study for several features of a real-world program on the assumption that the user always correctly answers the questions asked by the procedure. The results show that over 75% of the feature's implementation could be efficiently covered by the procedure with relatively small number of execution traces.
-
Experiences of debugger-based architecture comprehension Reviewed
Naoya Nitta
18th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD 2017) 2017.6
Single Work
Architecture comprehension is crucial for appropriately maintaining, evolving and reusing large scale software. However, in an actual software development, architecture descriptions are often insufficient, obsoleted or at worst missing, and most of the maintenance tasks are performed without sufficient understanding of the architecture. While many techniques to extract architectural information from existing source code have been proposed to support architecture comprehension, debuggers are still powerful for more exact comprehension of architectures. However, a debugger-based comprehension task usually becomes complicated and cumbersome. In this paper, we study debugger-based manual comprehension processes of real-world architectures. Through the case studies, we found that manual comprehension processes are basically driven by backward tracking of runtime flow of multiple non-primitive objects and such tracking task is cumbersome and time-consuming when only a debugger is available. We expect that the experiences of the case studies will be beneficial to exploring a dynamic analysis approach which can support exact comprehension of architectures.
-
A Formal Approach for Guiding Architectural Design with Data Constraints Reviewed
Naoya Nitta
The 15th IEEE/ACIS International Conference on Computer and Information Science (ICIS 2016) 2016.6
Single Work
Authorship：Lead author
The data managed in a software system is often controlled to behave dependently. Basically, dependent parts of the data can be controlled through their internal connections. However in a real-world system, dependencies among the data and its required behaviors are generally complex and designing its internal structure and control mechanism to satisfy all requirements becomes challenging. To cope with the problem, in this paper, we present a formal approach to guide an architecture design process so that given execution scenarios can be satisfied through iterative refinement of constraints among the data. For case studies, we applied our approach to a customer management system and a 3D game framework, and confirmed that a valid architectural design guide can be obtained.
-
Composite Refactoring for Decoupling Multiple Classes Reviewed
Yusuke Takahashi, Naoya Nitta
IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016) 594 - 598 2016.3
Joint Work
Abstract:
An architecture level change of existing software requires tedious, error-prone and time-consuming tasks. However, current Integrated Development Environments (IDEs) do not support such high-level refactorings. In this paper, we present a scalable but simple composite refactoring for decoupling multiple classes. In addition, we introduce several primitive refactorings as components of the composite refactoring. The details of the results of applying our composite refactoring to an actual architectural change are also reported in this paper. -
A Case Study of Dynamic Analysis to Locate Unexpected Side Effects Inside of Frameworks Reviewed
Izuru Kume, Masahide Nakamura , Naoya Nitta, Etsuya Shibayama
International Journal of Software Innovation (IJSI) 3 ( 3 ) 26 - 40 2015
Joint Work
Recently many frameworks are deployed without proper documents to explain their correct usage. In the absence of proper documents, application developers often write code to call a framework API in a wrong way. Such a wrong API call tends to bring about a failure after its complex chain of infection inside of a framework. The complexity and the lack of implementation knowledge about a framework make it difficult for application developers to debug this kind of failure. In the preceding study the authors focused on unexpected side effects that are caused by wrong API calls and bring about failures, and developed a dynamic analysis technique to detect such side effects. In this paper, the authors introduce a case study to find a wrong API call using our technique.
-
Toward a Dynamic Analysis technique to Locate Framework Misuses That Cause Unexpected Side Effects Reviewed
Izuru Kume, Masahide Nakamura, Naoya Nitta, Etsuya Shibayama
The 15th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD 2014) 2014.6
Joint Work
Recently many frameworks are used in software development without proper documentation, and are misused by application developers in calling framework APIs. Debugging a failure caused by a wrong API call is difficult and requires a proper supporting technique. In our preceding study we developed a dynamic analysis technique to detect possibly unexpected side effects that cause failures. In this paper, we introduce a case study to identify a wrong API call using this technique.
-
A Dynamic Analysis Technique to Extract Symptoms That Suggest Side Effects in Framework Applications Reviewed
Izuru Kume, Naoya Nitta, Masahide Nakamura, Etsuya Shibayama
The 29th ACM Symposium on Applied Computing (SAC2014) 1176 - 1178 2014.3
Joint Work
Program debugging forces time consuming tasks to locate defects on maintainers. Many existing supporting methods assume that maintainers can identify erroneous values and objects' states at run-time. However, such assumptions do not always hold in real program debugging. In this paper, we propose a dynamic analysis technique to extract symptoms which suggest a framework misuse in the process to update a state of an object. Symptoms help maintainers by showing which state updates are likely to be unexpected, even if maintainers can not decide if the updated states are correct or not. We developed a prototype tool to extract symptoms. We evaluate our method by applying it to a bug in a practical framework application developed by a third party.
-
複数クラスを横断する情報隠蔽のためのリファクタリングフレームワークの適用事例
高橋 祐介, 新田 直也
甲南大学紀要知能情報学編 7 ( 2 ) 153 - 171 2014
Joint Work
-
フレームワークアプリケーションを対象としたプログラム修復支援手法の適用事例
森岡 友樹, 新田 直也
甲南大学紀要知能情報学編 7 ( 2 ) 173 - 190 2014
Single Work
-
A Method for Early Detection of Mismatches between Framework Architecture and Execution Scenarios Reviewed
Naoya Nitta, Izuru Kume, Yasuhiro Takemura
The 20th Asia-Pacific Software Engineering Conference (APSEC 2013) 2013.12
Joint Work
Authorship：Lead author
Abstract:
Recently, application frameworks are widely used to facilitate software development. However in a real-world application development, potential mismatches between a selected framework and the application's specification often remain undetected until late in the development process. Especially if an architecture level mismatch between them is left unresolved, then enormous implementation level effort to suppress the mismatch and/or modification of the framework's internal implementation would be needed. To avoid the problems, we present a method to detect architectural mismatch between a selected framework and the execution scenarios of the application to develop before its implementation process. In this paper, we have evaluated two 3D game frameworks using our method for a case study, and have identified several problems to implement a certain game application. -
A Feature Model of Framework Applications Reviewed
Izuru Kume, Masahide Nakamura, Naoya Nitta, Etsuya Shibayama
The 14th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD 2013) 511 - 516 2013.7
Joint Work
Learning how to use application frameworks effectively becomes important in their widespread use in software development. Learning frameworks is often difficult because of lack of their documentation and their complexity. In order to help framework learning, we propose a behavioral model, called feature component model, which abstracts internal behaviors of framework applications in terms of their behavioral characteristics such as inversion of controls. We apply our behavioral model to an example misuse of a practical framework developed by a third party in order to show its practical usefulness.
DOI： 10.1109/SNPD.2013.14
-
プログラム解析技術を用いた大規模ソフトウェアの開発作業支援の試み Invited
新田 直也
甲南大学紀要 知能情報学部編 6 ( 6 ) 199 - 210 2013
Single Work
Authorship：Lead author
-
Work in progress: Analysis of the relationship between teaching contents and motivation in programming education Reviewed
Hidekuni Tsukamoto, Yasuhiro Takemura, Hideo Nagumo, Naoya Nitta
The 42th ASEE/IEEE Frontiers in Education Conference (FIE 2012) 2012.10
Joint Work
In this research the motivational levels of the students in a social welfare department while learning computer programming were analyzed relative to the contents that were taught in each lesson. The introductory programming course was game-based, and Java language was used with Eclipse as the Integrated Development Environment (IDE). The lessons were designed in such a way that as the students finished more and more assignments they were nearing completion of the Tetris game. The motivation levels were measured using a questionnaire based on the ARCS motivation model, which has four factors: Attention, Relevance, Confidence, and Satisfaction. As a result, it was found that the motivation of the students changes according to the lesson content.
-
Change of Students' Motivation in an Introductory Programming Course for Non-computing Majors Reviewed
Hidekuni Tsukamoto, Hideo Nagumo, Yasuhiro Takemura, Naoya Nitta
The IEEE 12th International Conference on Advanced Learning Technologies (ICALT) 124 - 125 2012.7
Joint Work
Abstract:
In this research, the motivational aspects of the students while learning introductory programming was monitored and analyzed. The students were in the social welfare department, and the programming language used was Java and Processing. Monitoring students' motivation throughout the course was found to be important because, by doing so, the weak points in the syllabus could be found and modified. It was also found to be important to devise topics relevant to the students, and to adjust the level of difficulty of the assignments so that the students can feel confident studying. -
Development of a 3D game engine Radish and its application to architecture comparisons Reviewed
4 ( 1 ) 1 - 12 2010.3
Joint Work
Authorship：Lead author