When adding a new feature to software, a large renovation which breaks the existing behavior is often required. Even in popular software project, such a renovation tends to fail halfway through and developers end up backing out their changes. Even worse, renovation failure discourages the developers who propose the plan, and causes a long-term lowering of productivity of the project. We present an analysis of renovation failure in open-source software projects and unveil the causes and measures. To prove that our measures are effective in practice, we have applied them to the rewrite of the cryptographic subsystem (approx. 4500 lines of code) of GNU Emacs, a famous text editor used all over the world.
Component system suitable for embedded systems and interface generator are presented. This component system adopts a static model which statically instantiates and connects components. The attributes of the components and interface codes for connecting components are statically generated and optimized by the generator. Hence, no instantiation overhead is introduced at runtime and runtime overhead of the interface code is minimized. A serial interface driver is demonstrated as a case study to evaluate the overhead and the software code size. The case study shows the effectiveness of our generator.
GETA (Generic Engine for Transposable Association) is a powerful and fully comprehensive search engine for huge corpora. The key design issues include: (1) it should be able to deal with huge corpora; (2) it can be incorporated into various applications; (3) a user can define new similarity measurement easily; (4) the result is totally ranked according to the given similarity, without any approximation; (5) the performance should be high. Furthermore, to maximize the availability, GETA requires only a huge sized memory and a modern operating system for its platform. In order to develop such an engine, we mainly wrote it in C. GETA compresses a target database to save the required memory, and it also compiles given similarity definitions into C code to achieve high performance. Today, GETA is adopted by various applications, including from academic use to commercial use. Some of them serve with a huge database that has several million records, showing GETA's scalability.
We report some features of Agate, a compiler for the dependently typed functional language of the Agda proof-assistant. Agate was developed as an experimental platform for the practice of dependently typed programming and extends the Agda language with I/O facilities and calls to Haskell functions. The first feature is the use of Higher-Order Abstract Syntax to translate terms of the Agda language into untyped λ-calculus encoded in Haskell. The second feature is the application of the Haskell class mechanism to embed typed Haskell terms in the universal type for untyped λ-calculus. This approach makes Agate very lightweight. The performance of a number of codes generated by Agate is evaluated.
Taking snapshots of live virtual machines is much easier than with real hardware, because a virtual machine's devices are simulated in software where it is easier to capture 100% of the necessary state. More so than for real machines, snapshot functionality has become fundamental for virtual machines. It is a necessary feature for administrators who use virtual machines to quickly balance the loads of servers in data centers, and developers who use snapshots to restore test environments to pristine state. This paper describes SBUML, a system that extends the User-Mode Linux (UML) virtual machine to provide snapshot functionality. SBUML snapshots are more portable than those of other virtual machines, such as Xen, that take on more restrictive host requirements. SBUML also integrates several alternative and complementary techniques for optimizing the storage and transfer of multiple, multi-gigabyte virtual machine states. This makes SBUML an ideal platform for researching design trade-offs that can make snapshot techniques practical for cutting-edge applications such as sustainable systems, model checking, software demonstrations, and others.
Web search APIs such as Google API and Yahoo API are often used for developingWeb applications. However, the number of Web pages obtained by using a Web API is limited and the full texts of these Web pages cannot be directly accessed by the APIs. These are serious problems for the developers. In order to solve the problems, we have developed an original search engine which are composed of open source softwares such as Heritrix, Apache Lucene and MySQL. Partitioning database and index, we have developed the search engine which has scalability to the sizes of database and index. We have confirmed that the speed performance of the developed search engine is not decreased by partitioning database and index.
As source codes of software are frequently modified in the projects, the codes evolve to become complex. Measurements of code complexity have been proposed such as module coupling and logical coupling. Module coupling is useful for clarifying complexity on a side view of product, logical coupling can suggest complexity on a side view of process. Therefore, we proposed a new metrics for software evolution. The metrics combines module coupling and logical coupling. A basic idea is that modules including strong module couplings should have strong logical couplings. If a gap between a set of modules including strong module couplings and a set of modules including strong logical couplings is large, the software complexity will become large. As a result of experiments in open source projects, we confirmed that the proposed metrics was useful for visualizing software evolution, and coupling maps were useful to investigate reasons of software evolution. In addition, although conventional metrics of complexity is often influenced by characteristics of software and individual development policy, the proposed metrics is often not influenced by such factor. Using hierarchical coupling maps, we confirmed that the proposed metrics is useful for analyzing weak points of large-scale software.
Life-like agents have the potential to make e-shopping sites on the Web more attractive and persuasive; our interest is to determine how multiple life-like agents should behave as a team to persuade customers. To know how the social relationships among two agents and a human user impacts the effectiveness of persuasion from the viewpoint of the balance theory, we develop a multi-agent persuasion system. In the system, the agents construct a social relationship to the user, and they then try to persuade him/her to select items that they recommend. An evaluation shows that a balanced relationship yields better performance than an imbalanced one.
Coalition formation is an important capability for automated negotiation among self-interested agents. In order for coalitions to be stable, a key question that must be answered is how the gains from cooperation are to be distributed. Coalitional game theory provides a number of solution concepts for this. However, recent research has revealed that these traditional solution concepts are vulnerable to various manipulations in open anonymous environments such as the Internet. To address this, previous work has developed a solution concept called the anonymity-proof core, which is robust against such manipulations. That work also developed a method for compactly representing the anonymity-proof core. However, the required computational and representational costs are still huge. In this paper, we develop a new solution concept which we call the anonymity-proof Shapley value. We show that the anonymity-proof Shapley value is characterized by certain simple axiomatic conditions, always exists, and is uniquely determined. The computational and representational costs of the anonymity-proof Shapley value are drastically smaller than those of existing anonymity-proof solution concepts.