Naoya Nitta

Work in progress: Analysis of the relationship between teaching contents and motivation in programming education

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.

A Case Study of Dynamic Analysis to Locate Unexpected Side Effects Inside of Frameworks

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. A Case Study of Dynamic Analysis to Locate Unexpected Side Effects Inside of Frameworks

Identifying Mandatory Code for Framework Use via a Single Application Trace

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 applications 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.

A Method for Early Detection of Mismatches between Framework Architecture and Execution Scenarios

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 applications 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 frameworks 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.

Experiences of debugger-based architecture comprehension

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.

Constraints Based Approach to Interactive Feature Location

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 features implementation could be efficiently covered by the procedure with relatively small number of execution traces.

Composite Refactoring for Decoupling Multiple Classes

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 formal approach for guiding architecture design with data constraints

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.

Toward a dynamic analysis technique to locate framework misuses that cause unexpected side effects

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 Feature Model of Framework Applications

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.