Isao Sasano

Lightweight fusion by fixed point promotion

This paper proposes a lightweight fusion method for general recursive function definitions. Compared with existing proposals, our method has several significant practical features: it works for general recursive functions on general algebraic data types; it does not produce extra runtime overhea (except for possible code size increase due to the success of fusion); and it is readily incorporated in standard inlining optimization. This is achieved by extending the ordinary inlining process with a new fusion law that transforms a term of the form f o (fixgλx.E) to a new fixed point term fixhλx.E′ by promoting the function f through the fixed point operator. This is a sound syntactic transformation rule that is not sensitive to the types of f and g. This property makes our method applicable to wide range of functions including those with multi-parameters in both curried and uncurried forms. Although this method does not guarantee any form of completeness, it fuses typical examples discussed in the literature and others that involve accumulating parameters, either in the tt foldl-like specific forms or in general recursive forms, without any additional machinery. In order to substantiate our claim, we have implemented our method in a compiler. Although it is preliminary, it demonstrates practical feasibility of this method.

Make it practical: a generic linear-time algorithm for solving maximum-weightsum problems

In this paper we propose a new method for deriving a practical linear-time algorithm from the specification of a maximum-weightsum problem: From the elements of a data structure x, find a subset which satisfies a certain property p and whose weightsum is maximum. Previously proposed methods for automatically generating linear-time algorithms are theoretically appealing, but the algorithms generated are hardly useful in practice due to a huge constant factor for space and time. The key points of our approach are to express the property p by a recursive boolean function over the structure x rather than a usual logical predicate and to apply program transformation techniques to reduce the constant factor. We present an optimization theorem, give a calculational strategy for applying the theorem, and demonstrate the effectiveness of our approach through several nontrivial examples which would be difficult to deal with when using the methods previously available.

Toward bidirectionalization of ATL with GRoundTram

ATL is a language for describing model transformations currently in uni-direction. In our previous work we have shown that transformations of graph structures given in some form can be bidirectionalized and have implemented a system called GRoundTram system for bidirectional graph transformations. We say a transformation t is bidirectionalized when we obtain a backward transformation t′ so that the pair (t, t′) of transformations satisfies certain well-behavedness properties. Bidirectional model transformation is used to reflect the changes in the target model back to the source model, and vice versa. In this paper, as a first step toward realizing practical bidirectional model transformations, we present bidirectionalization of core part of the ATL by encoding it in the UnQL language, which is used as a transformation language in the GRound-Tram system. We give the algorithm for the encoding, based on which we have implemented the system for bidirectionalizing the core ATL in OCaml language.

Generation of efficient programs for solving maximum multi-marking problems

Program generation has seen an important role in a wide range of software development processes, where effective calculation rules are critical. In this paper, we propose a more general calculation rule for generation of efficient programs for solving maximum marking problems. Easy to use and implement, our new rule gives a significant extension of the rule proposed by Sasano et al., allowing multiple kinds of marks as well as more general description of the property of acceptable markings. We illustrate its effectiveness using several interesting problems.

Maximum marking problems with accumulative weight functions

We present a new derivation of efficient algorithms for a class of optimization problems called maximum marking problems. We extend the class of weight functions used in the specification to allow for weight functions with accumulation, which is particularly useful when the weight of each element depends on adjacent elements. This extension of weight functions enables us to treat more interesting optimization problems such as a variant of the maximum segment sum problem and the fair bonus distribution problem. The complexity of the derived algorithm is linear with respect to the size of the input data.

An approach to completing variable names for implicitly typed functional languages

This paper presents an approach to completing variable names when writing programs in implicitly typed functional languages. As a first step toward developing practical systems, we considered a simple case: up to the cursor position the program text is given completely. With this assumption we specify a variable completion problem for an implicitly typed core functional language with let-polymorphism and show an algorithm for solving the problem. Based on the algorithm we have implemented a variable name completion system for the language as an Emacs-mode.

Detecting code clones with gaps by function applications

Code clones are pairs or groups of code segments which are identical or similar to each other. Generally the existence of code clones is considered to make it cumbersome to maintain the source code, so that various kinds of code clone detection tools have been developed. Simple ones divide the source code into a sequence of lines or tokens and find identical or similar sub-sequences. Differences among code clones, called gaps, may prevent clones from being detected or may make clones to be detected with being fragmented. In order to cope with gaps, various tools have been developed by using abstract syntax trees, comparing some metrics, or using program dependency graphs. In this paper we present a novel algorithm for detecting clones by focusing on gaps by function applications. Based on the algorithm we have implemented a tool for detecting code clones on programs written in Standard ML.

A Tool for Visualizing Buffer Overflow with Detecting Return Address Overwriting

Buffer overflow is a serious problem when the software is run as a server on the internet. Especially when the return addresses are overwritten intentionally, the control flow may be changed as the attacker intends. Although there have been proposed several ways to protect attacks that utilize the buffer overflow, the number of the errors owing to the buffer overflow have been increasing gradually. This paper presents a tool that visualizes the buffer overflow when executing programs in C language, especially when the return addresses are overwritten. The functionality is mainly targeted at beginners of C programming who do not recognize the attacks, which we expect makes the number of errors decrease in the future.

Toward modular implementation of practical identifier completion on incomplete program text

Identifier completion is a widely-used functionality in IDEs like Eclipse and editors like Emacs and vi. In this paper we present how to implement identifier completion for a core of functional languages with a focus on coping with incomplete program text based on error recovery in LR parsing. We believe the present work is a first step toward building practical identifier completion in IDEs for functional languages in modular way by reusing the code in compilers. We also give a specification of the identifier completion and argue that our solution conforms to it.