Design of an architecture for a software system affects not only the system's functional and/or non-functional properties but also the development processes such as coding, verification, maintenance, and so forth. Thus, technologies for supporting architectural design are extremely important to develop and maintain software of high quality. Architecture documentation of a system is also important, in particular when the system has a long life and is expected to keep its value in a required level over time. That is, documentation of an architecture becomes a convenient vehicle to convey traceability information between the architecture and other software configuration items such as system's requirement specification, design, program code, and so forth. In this paper we have surveyed the importance of software architecture design and architecture documentation in the context of software development with high quality. On architecture documentation we describe and explain the notions of architecture styles, patterns, concerns, views, and so forth. The relationships among these notions are explained as well. Moreover we present a literature review on the tools and technologies for architectural decision support, documenting design rationale, traceability and knowledge management.
Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure. Not only researchers but also practitioners need to know past instances of refactoring performed in a software development project. So far, a number of techniques have been proposed on the automatic detection of refactoring instances. Those techniques have been presented in various international conferences and journals, and it is difficult for researchers and practitioners to grasp the current status of studies on refactoring detection techniques. In this survey paper, we introduce refactoring detection techniques, especially in techniques based on change history analysis. At first, we give the definition and the categorization of refactoring detection in this paper, and then introduce refactoring detection techniques based on change history analysis. Finally, we discuss possible future research directions on refactoring detection.
This paper presents a survey on techniques to record and utilize developers' operations on integrated development environments (IDEs). Especially, we let techniques treating fine-grained code changes be targets of this survey for reference in software evolution research. We created a three-tiered model to represent the relationships among IDEs, recording techniques, and application techniques. This paper also presents common features of the techniques and their details.
Boolean SATisfiability problem (hereafter SAT) is the problem of deciding whether there exists an assignment to variables in a given propositional formula that makes the formula true. SAT is a computationally difficult problem as it is a classical NP-complete problem, but development of practically fast algorithms and hardware speed-ups enable SAT solvers to be used in variety of real applications. In this paper, we survey applications of SAT algorithms into broader problem classes, and technical interplays between SAT research and other research fields around those problem classes.
Although code completion is inevitable for effective code editing on integrated development environments, existing code completion tools can be improved. A previous study noted that developers sometimes perform ineffective repetitions of the same code completion operations. Hence, this paper introduces a statement, “A more recently inserted code completion candidate should be given a higher rank among previously inserted items in the candidate list.” To confirm this statement, this paper examines the following three points. First, an experiment using operation histories is presented to reconfirm that developers more frequently repeat recent code completion operations. Second, a tool called RCC Candidate Sorter is presented. It alters the sorting algorithm of the default Eclipse code completion tool to prioritize candidates inserted by recent code completion. Finally, an experiment is conducted to evaluate the performance of the tool. The experimental result shows that it outperforms an existing method.
In this paper, we propose a method to produce suggestions of declassifiers placement for correcting type errors in information flow analysis. Though the declassification is a useful method to resolve illegal information flow, it can be a difficult and time-consuming task to manually place declassifiers. By our method, developers only need to select a declassifiers placement from suggestions for correcting errors. We proved that produced suggestions can resolve type errors and at least one suggestion can be produced, and implemented our proposed method as a prototype tool.
Usability is a crucial characteristic for Web applications. A user often re-inputs values because of mistakes or changes of mind during operation. Therefore, an Input Save Function (ISF) is useful to temporarily save a user's inputs. Whether an ISF can be implemented properly into an application depends on the results of analysis and design phases where CRUD (create, read, update, delete) timing of inputs, screen transitions, security and so on are determined. However, a method to aid in the design and analysis of ISFs is not presently available. In this paper, we propose a method to evaluate Web application usability based on the number of input items and input value lengths which are affected strongly by the ISF used. To achieve this purpose, methods to express screen transitions and user operation scenarios in UML are also proposed. The effectiveness of our method is demonstrated by using an actual e-commerce website.
Kobayashi et al. recently proposed a method for verification of higher-order tree transducers called HMTTs. An HMTT can be considered as a higher-order, functional tree-processing program. The goal of the HMTT verification is to check whether a given HMTT satisfies a given input/output specifications. Kobayashi et al.'s algorithm abstracts tree data using automata that represents input/output specifications and reduces an HMTT verification problem to a higher-order model checking problem. Their method cannot, however, determine whether a given HMTT verification problem actually has a counterexample when a corresponding higher-order model-checking problem has a counterexample. We propose a method of generating a counterexample of an HMTT verification problem from a counterexample of a corresponding higher-order model-checking problem. We also propose a method of refining an abstraction by splitting the states of automata when counterexamples do not exist. We have implemented the method and report the effectiveness of the method.
Rewriting induction (Reddy, 1989) is proposed as an automated theorem proving method on term rewriting systems. In general, rewriting induction does not work well for the term rewriting systems with tail recursion. On the other hand, context moving and splitting (Giesl, 2000) are proposed as program transformation techniques intended to facilitate automated verification for functional programs. These techniques transform tail recursive programs into simple recursive programs suitable for automated verification. In this paper, we prove that the correctness of these techniques for term rewriting systems, and show that the combination of rewriting induction and these techniques are useful in proving inductive theorems on term rewriting systems with tail recursion.
Code reading is important in several situations, including reusing existing programs and developing a program by several persons. In this paper, we report on our prototype implementation of a code-reading assistance tool for a functional programming language. Our tool is based on an observation that name, such as variable names, is the basic ingredient of the data-flow, which represents computations in functional programs. Our tool provides the following two functionalities by using dependencies between names calculated by a compiler: it can find definitions of names from their uses, and vice versa; it can visualize dependencies of source files based on dependencies of variables and functions in them and thereby helps us intuitively understand resources that each module uses.
The present paper proposes and tests a new method for evaluating educational effect of collaborative education. Education Network for Practical Information Technologies (enPiT) provides a nationwide collaborative graduate education in information science aiming to elevate practical skills. There are two problems in assessing educational effect of a collaborative education program aiming to raise practical skills. First, students' practical skills are not determinable with questionnaires assessing the level of expertise. Second, it would be impractical to use common index for graduate students from various curriculums. The authors combined questionnaire to assess learning experience and behavior characteristics of the participants to provide a common criteria to assess practical skills of graduate students from various curriculums.
A coding pattern is a sequence of method calls and control structures, which appears repeatedly in source code. In this paper, we have extracted coding patterns of each version of ten Java programs, and then explored the number of versions in which the coding patterns appear. This paper reports the characteristics of coding patterns over versions. While learning from coding patterns is expected to help developers to perform appropriate modifications and enhancements for the software, many coding patterns are unstable as similar to the result of clone genealogy research.
We analyze effect of review and patch development experience to patch review process in OSS. We use log data from version control system (git and Subversion) and code review system (Rietveld) for the analysis.As a result, both of review and patch development experience showed strong negative correlation with times of review. Further, we added bug (issue) tracking system log data and analyzed with above data as additional analysis. The analysis showed that the experiences did not show correlation with finding bugs in review process.
Sequence diagrams are often used in the modular design of softwares. However, it is difficult to verify UML diagrams automatically. In this work, we develop a verification tool of sequence diagrams named SDVerifier. It converts sequence diagrams to processes in CSP, so that existing model checking tool can verify them. One of the main contributions in this work is that counter examples found in the model checking can be translated back to sequence diagrams for supporting to correct their inconsistency. We implemented the tool and conducted experiments with real world case studies.
The lazy functional programming language Haskell has attracted much attention in recent years. The Glasgow Haskell Compiler (GHC) is a state-of-the-art and de facto standard compiler and runtime system for Haskell. Much of the literature on Haskell has been devoted to GHC and many new mechanism have been introduced into GHC. However, since the implementation of the current GHC is huge and complicated, it is hard to introduce a new mechanism into GHC. In such a situation, our prior work on thunks, which are internal objects to enable lazy evaluation, also incorporated our thunk recycling into GHC and succeeded in reducing memory allocations. The method transforms a program into the program that enables thunk recycling by reusing and updating an already-allocated thunk. Although the essence of thunk recycling has already been published in our paper, it does not cover our overall implementation in GHC, a large and complicated software. In this paper, we present the entire sophisticated implementation of thunk recycling in GHC, explaining various design decisions and implementation techniques and report experimental results of our techniques. Furthermore, we have improved our implementation by using additional techniques based on our knowledge of GHC. As a result, we have reduced the overhead of our method successfully. The knowledge of the implementation obtained from our experience which used GHC for the base of a programming language research is also described. In particular, the fact that GHC is written by Haskell contributes to the extendibility of its implementation.