Powered by
15th International Conference on Modularity (MODULARITY Companion 2016),
March 14–17, 2016,
Málaga, Spain
Language Modularity À La Mode (LaMOD 2016)
A Lightweight Optimization Technique for Data Types à la Carte
Hirotada Kiriyama, Tomoyuki Aotani, and
Hidehiko Masuhara
(Tokyo Institute of Technology, Japan)
Data types à la carte (DTC) is a technique for adding new variants to data types modularly. A drawback of DTC compared with simple variant types, which are commonly used to define data types in functional programming languages, is runtime inefficiency caused by the destruction of these values. In this paper, we propose a lightweight optimization technique for functions that destruct the values of DTC data types. It makes their execution as efficient as their non-DTC counterparts by just (1) deriving non-extensible algebraic data types isomorphic to ex- tensible data types defined in DTC fashion and (2) using them within the type annotations that specify concrete data types using the composition operator given in DTC. The approach is based on an insight on the functions: the functions never depend on any con- crete data types but merely constrain them. We implemented functions that take an extensible data type defined in DTC fashion and derive an isomorphic non-extensible algebraic data type using Template Haskell. Our experimental re- sults show that DTC functions using our approach run as efficiently as their non-DTC counterparts and avoid performance slow down even if the data types are extended multiple times.
@InProceedings{MODULARITY Companion16p86,
author = {Hirotada Kiriyama and Tomoyuki Aotani and Hidehiko Masuhara},
title = {A Lightweight Optimization Technique for Data Types à la Carte},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {86--90},
doi = {},
year = {2016},
}
Multi-level Debugging for Interpreter Developers
Bastian Kruck, Stefan Lehmann, Christoph Keßler, Jakob Reschke, Tim Felgentreff, Jens Lincke, and Robert Hirschfeld
(HPI, Germany)
Conventional debuggers require programmers to work on multiple levels of abstraction at once when inspecting call stacks or data. This demands considerable cognitive overhead and deep system knowledge of all implementation technologies involved. When developing an interpreter, programmers often create a dedicated debugger to have a higher-level perspective on the client-language; the resulting use of multiple debuggers at once leads to mental context switches and needs an elaborated method. We present an integrated debugging tool in which interpreter developers define and select the levels of abstraction on which they focus. Our debugger provides them with an abstraction-specialized view. We consider both host-language and guest-language levels, since either may be levels of interest in a debugging session. We show how this separation into host-language levels can ease the debugging of applications through filtering call stacks and specializing call stack representation on levels.
@InProceedings{MODULARITY Companion16p91,
author = {Bastian Kruck and Stefan Lehmann and Christoph Keßler and Jakob Reschke and Tim Felgentreff and Jens Lincke and Robert Hirschfeld},
title = {Multi-level Debugging for Interpreter Developers},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {91--93},
doi = {},
year = {2016},
}
Info
Toward Practical Language Oriented Modularity
Arik Hadas and David H. Lorenz
(Open University of Israel, Israel; Technion, Israel)
Language oriented modularity (LOM) implies the use
of multiple domain specific aspect languages (DSALs)
simultaneously. The complexity of implementing these DSALs
has significant implications on the practicality of LOM. In
this paper we describe a transformation-based approach
to DSAL implementation that reduces the overall cost of
implementing the weaving semantics and thus improves the
practicality of LOM.
@InProceedings{MODULARITY Companion16p94,
author = {Arik Hadas and David H. Lorenz},
title = {Toward Practical Language Oriented Modularity},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {94--98},
doi = {},
year = {2016},
}
Literal Inter-Language Use Case Driven Modularization
Michal Bystrický and Valentino Vranić
(Slovak University of Technology in Bratislava, Slovakia)
Use cases are a practically proven choice to concisely and precisely express what highly interactive systems do. Several attempts have been made to modularize code according to use cases. None of these approaches is able to gather all the code related to a use case in one module and to reflect its steps. However, to allow for code to be modularized according to use case flows and their steps, an instrumentation environment is necessary. In this paper, literal multi-language use case coding based on defragmentation is proposed. The approach aims at fully preserving use case flows in as comprehensible form as possible. The steps of use case flows appear directly in the code as comments. Despite being comments, the steps are active, which is achieved by a dedicated preprocessor and framework. The detailed step implementation gathers all the code fragments of each step each of which may be in a different programming language.
@InProceedings{MODULARITY Companion16p99,
author = {Michal Bystrický and Valentino Vranić},
title = {Literal Inter-Language Use Case Driven Modularization},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {99--103},
doi = {},
year = {2016},
}
Towards Improving Interface Modularity in Legacy Java Software through Automated Refactoring
Raffi Khatchadourian, Olivia Moore, and
Hidehiko Masuhara
(City University of New York, USA; Tokyo Institute of Technology, Japan)
The skeletal implementation pattern is a software design pattern consisting of defining an abstract class that provides a partial interface implementation. However, since Java allows only single class inheritance, if implementers decide to extend a skeletal implementation, they will not be allowed to extend any other class. Also, discovering the skeletal implementation may require a global analysis. Java 8 enhanced interfaces alleviate these problems by allowing interfaces to contain (default) method implementations, which implementers inherit. Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself. We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced interface feature for their legacy Java software.
@InProceedings{MODULARITY Companion16p104,
author = {Raffi Khatchadourian and Olivia Moore and Hidehiko Masuhara},
title = {Towards Improving Interface Modularity in Legacy Java Software through Automated Refactoring},
booktitle = {Proc.\ MODULARITY Companion},
publisher = {ACM},
pages = {104--106},
doi = {},
year = {2016},
}
Video
Info
proc time: 1.11