Projects

OCommand: A Domain Specific Language for Type Safe Shell Programming in OCaml

We propose a domain-speci c language (DSL), called OCommand, for executing shell commands from within OCaml programs in a type safe way. OCommand takes a command speci cation consisting of types of output columns from the command and effects of command options on the types of the columns, and generates an OCaml module that contains a command-executing function and a set of… Continue Reading OCommand: A Domain Specific Language for Type Safe Shell Programming in OCaml

Proof of Soundness of Concurrent Separation Logic for GPGPU in Coq

We design a concurrent separation logic for GPGPU, namely GPUCSL, and prove its soundness by using Coq. GPUCSL is based on a CSL proposed by Blom et al., which is for automatic verification of GPGPU kernels, but employs different inference rules because the rules in Blom’s CSL are not standard. For example, Blom’s CSL does not have a… Continue Reading Proof of Soundness of Concurrent Separation Logic for GPGPU in Coq

Pyrlang: A High Performance Erlang Virtual Machine Based on RPython

We are building an Erlang virtual machine with a JIT (Just-In-Time) compiler by using RPython. RPython was originally developed for building PyPy (a high performance python virtual machine with JIT compiler). With meta-tracing JIT technique, one can use RPython to build arbitrary virtual machine with a JIT compiler. We also use this technique to build… Continue Reading Pyrlang: A High Performance Erlang Virtual Machine Based on RPython

A per-type Instantiation Mechanism for Generic Aspects

We propose a per-type instantiation mechanism for generic aspects. Generic pointcuts that specify join points of different return types are proposed, but when a return type of a piece of around advice is not generic, generic pointcuts cannot be used in the advice. Although we can declare generic aspects in AspectJ 5, generic aspects must be… Continue Reading A per-type Instantiation Mechanism for Generic Aspects

AOP for implicit conversion

Projects Publications Tomoyuki Aotani and Hidehiko Masuhara, “A Join Point Model for Implicit Conversion”, In Proceedings of the 5th Asian Workshop on Aspect-Oriented Softawer Development (AOAsia 5), Auckland, New Zealand, 17 November 2009. Position paper.

Aspect Sand Box

The Aspect SandBox (ASB) project is developing a suite of simple interpreters for a range of AOP systems. Our goal is to help clarify the semantics of AOP systems, and support the development of formal models that truly capture AOP semantics. The ASB interpreters can also be used for teaching. People Chris Dutchyn Gregor Kiczales Hidehiko… Continue Reading Aspect Sand Box

AspectKlava

This project explores practical ways of integrating program analysis techniques into aspect specification and execution, aimed at an AOP system that is both flexible and powerful to enforce a number of challenge security policies (e.g. policies regarding the restriction of data usage). It involves design and implementation of a tuple space based AOP language AspectKE*… Continue Reading AspectKlava

Aspectual Caml (A'Caml): an AOP extension to functional language Caml

We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in AspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed… Continue Reading Aspectual Caml (A’Caml): an AOP extension to functional language Caml

Aspectual Haskell

Aspectual Haskell is an aspect-oriented programming (AOP) language based on a purely functional language Haskell with AOP mechanisms similar to those in AspectJ language. In this project, we focus on the design and implementation issues of AOP mechanisms that give us insights into the interaction between AOP features and common features in purely functional languages.… Continue Reading Aspectual Haskell

Association Aspects

Association Aspects are an extension to aspects in AspectJ for representing crosscutting concerns among objects. With our extended compiler, you can freely create aspect instances of aspects, associate them to groups of objects, and let aspect instances run advice upon events in the objects associated to. Member Kouhei Sakurai Hidehiko Masuhara Naoyasu Ubayashi (Kyushu Institute… Continue Reading Association Aspects

BCS: BYTECODE SPECIALIZATION

BCS is a run-time program specialization technique for Java bytecode. It enables the programmer to dynamically generate programs that are optimized by using run-time information. Publications ●Hidehiko Masuhara and Akinori Yonezawa, “A Portable Approach to Dynamic Optimization in Run-time Specialization”,                                                                                       In Journal of New Generation Computing, Volume 20, Number 1, November 2001. (28 pages) ○A4… Continue Reading BCS: BYTECODE SPECIALIZATION

Context-Oriented Programming in Java

Context-oriented programming aims at modularization of context-depdent concerns by providing a few language constructs such as dynamically activable and first-class layers, and partial methods. This project investigates context-oriented programming as an extension to Java. It involves with design and implementation of the languages ContextJ and JCop, and case studies with practical application programs. This is… Continue Reading Context-Oriented Programming in Java

Dflow : dataflow pointcut for aspect-oriented programming languages

This project is to introduce an extended pointcut into aspect-oriented languages. Designing intuitively clear syntax and semantics, devising efficient implementation, and validating in real applications are the subjects. People Kazunori Kawauchi Hidehiko Masuhara Publications Kazunori Kawauchi and Hidehiko Masuhara Dataflow Pointcut in Aspect-Oriented Lnaguage, In Journal of The Japan Society for Software Science and Technology,… Continue Reading Dflow : dataflow pointcut for aspect-oriented programming languages

Event-based Context-Oriented Programming

We propose event-based context-oriented programming, and design and implement EventCJ, an event-based extension to ContextJ. Its design stems from our observation that, in many context-aware applications, context changes are triggered by external events. Thus, in addition to the current COP language mechanisms, namely the one to activate/deactivate layers in accordance with a flow of control… Continue Reading Event-based Context-Oriented Programming

Foundations of Context-Oriented Programming

Although there have been quite a few context-oriented programming (COP) languages, little is known their nature. We examine language mechanisms in COP languages by building formalizations of simplified context-oriented languages, and by designing minimalistic COP languages that can subsume other language mechanisms like objects, inheritance, traits, features, and so forth. People Robert Hirschfeld Atsushi IgarashiContinue Reading Foundations of Context-Oriented Programming

ITD Interfaces

Although the mechanism of Inter-Type Declarations (ITDs) is one of the key mechanisms in aspect-oriented programming, it disables separate compilation of aspect-oriented programs. We propose ITD interfaces, which are contracts between classes and aspects. An ITD interface has introduced method declarations, which do not provide bodies of the methods and require an aspect that specifies… Continue Reading ITD Interfaces

ObjCache: Profile-based Object Caching

This project is to transform object-oriented programs into faster ones by using a profiler. Efficient profiling and automatic transforming are the subjects. People Takahiro Kamio Hidehiko Masuhara Publication Takahiro Kamio and Hidehiko Masuhara, “A Value Profiler for Assisting Object-Oriented Program Specialization”, In Proceedings of Workshop on New Approaches to Software Construction (WNASC 2004), September 2004.… Continue Reading ObjCache: Profile-based Object Caching

Pit: Point-in-time Join Point Model for Aspect-Oriented Programming Languages

We propose a new join point model for aspect-oriented programming (AOP) languages. In most AOP languages including AspectJ, a join point is a time interval of an action in execution. While those languages are widely accepted, they have problems in aspects reusability, and awkwardness when designing advanced features such as tracematches. Our proposed join point… Continue Reading Pit: Point-in-time Join Point Model for Aspect-Oriented Programming Languages

SCoPE - Static Conditional Pointcut Evaluator for AspectJ

SCoPE is an extended AspectJ compiler that optimizes conditional pointcuts (i.e. if pointcuts). With SCoPE compiler, you can write expressive pointcuts within standard AspectJ language without runtime overheads. With SCoPE compiler, the following advice declaration, which adds extra behavior to calls to methods with only lower case characters, runs without runtime overheads: before(): call(* *)… Continue Reading SCoPE – Static Conditional Pointcut Evaluator for AspectJ

Selene: a source code recommendation tool

Selene is a source code recommendation tool that spontaneously displays code fragments relevant to a program being edited in the Eclipse IDE. Its key features are: Spontaneous recommendation: Selene displays several number of code fragments automatically. Search is triggered by certain edit operations of the user on an Eclipse editor pane, and the fragments are… Continue Reading Selene: a source code recommendation tool

Test-based Pointcuts

Test-based Pointcut is a new lanugage construct for aspect-oriented programmming that turns unit test cases into interface of crosscutting concerns. Test-based pointcuts are less fragile with respect to program changes. Test-based pointcuts can discriminate execution histories without requiring to specify detailed execution steps. Member Kouhei Sakurai Hidehiko Masuhara Publication Kouhei Sakurai , Hidehiko Masuhara ,… Continue Reading Test-based Pointcuts

Traceglasses : A Trace-Based Debugger

Traceglasses : A Trace-Based Debugger Menu Top Research Projects Test-based Pointcuts Association Aspects Traceglasses Traversal Assert Contact Mail sakurai_at_ec.t.kanazawa-u.ac.jp Affiliation Computer Science Laboratory at Kanazawa University PPP Research Group at University of Tokyo Komiya Lab. at Shibaura-Institute of Technology [ Japanese ] Overview Download Trying with an example traceglasses-pta License Publications Links Overview Traceglasses is… Continue Reading Traceglasses : A Trace-Based Debugger

Type Relaxed Weaving

Around advice in AspectJ language can change runtime arguments to method invocations (and other kinds of operations) and return values from the invocations (ibid.). While this is very powerful, there is severe restriction in terms of types, which prevents aspects to change values even if it is safe to do. This project aims at relaxing… Continue Reading Type Relaxed Weaving

Typed Pointcut Lanugage

Publications Tomoyuki Aotani and Hidehiko Masuhara, “Towards a Type System for Detecting Never-Matching Pointucut Compositions”, Workshop on Foundations of Aspect-Oriented Languages (FOAL), Vancouver, Canada, 2007. foal07aotani.pdf