The formal method, or the method for writing and verifying formal specifications, with the CafeOBJ language system is described in a series of six tutorials. The CafeOBJ language is a most advanced formal specification language which extents the OBJ language, and behavioral, rewriting, and parameterized specifications can be written in it. The CafeOBJ language system can simulate equational reasoning by executing equations as rewrite rules, and be used as an interactive verification system. This first tutorial presents an overview of the CafeOBJ formal method by using an example of “mutual exclusion protocol with a waiting queue” without getting into details of the language and the verification technique. In the following tutorials, the language and its semantics (2nd tutorial), equational reasoning and term rewriting systems (3rd tutorial) are presented, and the CafeOBJ's verification method with proof scores which only uses reductions (4th tutorial) is explained. Furthermore, CafeOBJ's verifications of an authentication protocol (5th tutorial) and a communication protocol (6th tutorial) are also presented, and several verification techniques are explained.
CafeOBJ algebraic specification language features flexible mix-fix syntax, powerful typing system with sub-types, and sophisticated module composition system featuring various kinds of imports, parameterised modules, views for instantiating the parameters, etc. CafeOBJ specifications denote algebras. The algebra is a universal modeling framework including useful models like abstract data types and abstract machines, and allows us to describe and verify formal specifications in a unified framework. In this paper, the syntax and semantics of CafeOBJ algebraic specification language are explained. The use of CafeOBJ processor also is explained briefly by examples of parsing, executing, and verifying specification.
We present an educational compiler, MinCaml, implemented in 2000 lines of ML. The target language is a strict, impure, implicitly typed, higher-order functional language. The compiler produces as fast code as Objective Caml and GCC do for several application programs including a ray tracer.
We supply a binary to build a Japanese TEX environment on Cygwin, which is a UNIX-like environment for Windows. We intend our new binary to be another choice against a famous binary for the native Windows system, to be installed easily, and to be used comfortably by Cygwin users. We choose the following sources for the standard Japanese TEX environment: an ongoing source distribution ‘ptetex’ for TEX processors and a DVI viewer, and the stable version 7.07 for Ghostscript. Since required sources and patches to construct a well-customized Ghostscript are scattered, we gather them into an archive and supply it, too. We believe anyone can inherit our project. It's because we have little customization by asking the upstream developers to repair some issues, and we open our operations. In this paper, we introduce guidelines on this project and report our activities.
LMNtal is a language model based on hierarchical graph rewriting that allows the representation and the manipulation of connectivity expressed using links and hierarchy expressed using membranes. The model allows concise description of programs involving dynamic data structures and multiset processing. Since LMNtal features fine-grained concurrency whose atomic operation is the application of a rewrite rule, how to implement it correctly and efficiently is far from obvious. This motivated us to implement LMNtal using Java and establish implementation techniques that are both correct and reasonably efficient. Our implementation consists of a compiler into intermediate code, an interpreter of the intermediate code, and a translator from the intermediate code to Java source code. It also provides a variety of useful features including foreignlanguage interface. The cruxes of the implementation techniques include the handling of links that cross membranes and the asynchronous execution of rewrite rules belonging to different membranes. This paper describes the design and implementation of our publicly available LMNtal system, focusing on technical issues raised in the course of the development. Those issues include the representation of hierarchical graph structures, intermediate code, and safe asynchronous execution of multiple tasks.
We propose a new type inference algorithm for polymorphic programming languages based on the idea of delaying type substitution until type variables are referenced. The resulting algorithm is expected to be practically more efficient by avoiding repeated and redundant application of type substitutions and scanning large type terms. We establish the soundness of the algorithm. The algorithm has been implemented for the full set of Standard ML type system. Our preliminary benchmark results show the expected performance.
There are many catalogs of software patterns available on the World Wide Web and literature; however, conventional document search systems are not appropriate for retrieving objective patterns from a number of collected patterns because these systems are not specific to software patterns (e.g., these systems show many pattern documents directly as a search result on a user's query). To solve this problem, we propose a search system for software patterns. Our system is based on both of inter-pattern link analysis and linkbased importance calculation method, called “pattern rank”. As a result of experimental evaluations for 131 pattern documents, it is found that our system is useful for retrieving patterns that are related to users' intension/requirement by calculating an appropriate importance for each pattern.
We propose “thread resumption barriers” to avoid a long pause time of program execution at the beginning of each garbage collection cycle in multi-threaded environments. Traditional snapshot garbage collectors stop all threads and scan their stacks at the beginning of each garbage collection cycle. Therefore, when there are many threads, the program pauses for a long time at the beginning. In this paper, we propose a garbage collection scheme which scans only the stack of the current thread at the beginning and later scans other stacks one at a time. In order to prevent a thread from running with its stack unscanned, when an “unscanned” thread is about to resume, its stack is scanned by the thread resumption barrier. Although Azatchi et al. have also proposed a garbage collection which scans stacks one at a time, we can easily determine when the next garbage collection cycle should be triggered in our scheme. We implemented and evaluated this garbage collection scheme. The results of performance measurements show that the program pause time can be reduced to a practical range even with a large number of threads.