- 9:20- 9:30: Welcome
9:30-10:30: Invited Talk
Why Modularity Matters: Achieving Modular Reasoning about Concurrent Programs and its Implications
Abstract: Concurrent programming remains a longstanding challenge. Despite decades of research, support for compile-time verification of concurrency related safety properties in mainstream languages remains nonexistent. We believe that the root cause of these difficulties is the lack of true modularity, i.e. we cannot yet do modular reasoning about concurrent programs. Without modular reasoning humans and tools rely on global reasoning, which is often intractable due to interleavings of concurrent tasks that can lead to state explosion. Modular reasoning about concurrent programs is complicated by pervasive interference, i.e. the possibility of interferences happening between any two instructions of a task, oblivious interference, i.e. these interferences not giving out any information about the behaviors of potentially interfering concurrent tasks. Reasoning about a concurrent program would be easier if a programmer, modularly and statically knows precisely the program points at which the interference may happen, and has some insights into the behaviors of potentially interfering concurrent tasks at these points. This talk will discuss a programming model that we call capsule-oriented programming and its realization in the Panini programming language. This model is designed to enable modular reasoning about concurrent programs. The talk will also elaborate on the implications of this newfound property, some of which are already exploited in the design and implementation of Panini and others can be subject of future investigations. This is a collaborative work with my PhD students Mehdi Bagherzadeh, Eric Lin, and Ganesha Upadhayaya and has been supported by the US National Science Foundation.
10:30-11:00: Coffee break
11:00-12:30: Paper presentation
Shinpei Hayashi, Takashi Ishio, Hiroshi Kazato and Tsuyoshi Oshima
Abstract: A basic clue of feature location available to developers is a description of a feature written in a natural language. However, a description of a feature does not clearly specify the boundary of the feature, while developers tend to locate the feature precisely by excluding marginal modules that are likely outside of the boundary. This paper addresses a question: does a clearer description of a feature enable developers to recognize the same sets of modules as relevant to the feature? Based on the conducted experiment with subjects, we conclude that different descriptions lead to a different set of modules.
Takuya Fukamachi, Naoyasu Ubayashi, Di Ai, Peiyuan Li, Yu Ning Li, Shintaro Hosoai and Yasutaka Kamei
Abstract: In most software development projects, design models tend to contain uncertainty, because all of the design concerns cannot be captured at the early development phase. It is preferable to be able to check consistency or traceability among design models and programs even if they contain uncertain concerns. To deal with this problem, we propose the notion of uncertainty-aware Archface, an interface mechanism exposing a set of architectural points that should be shared between design and code. Introducing uncertain-aware Archface, we can explicitly describe uncertainty in design models or programs by specifying uncertain architectural points.
Kouhei Sakurai and Hidehiko Masuhara
Abstract: Software evolution sometimes requires changes of module interfaces, which in turn cause crosscutting changes, or modifications on clients of the modules spreading over a program. Such modifications on the client-side can be too complicated to be automated by a text replacement tool or a refactoring tool. We propose a code transformation language, called Crossver, for consistently updating code fragments in a program. Crossver offers a source-level pattern sublanguage to express complicated transformation conditions. The patterns are robust against variety among clients thanks to the dataflow-based pattern matcher. In the paper, we overview the design and core semantics of Crossver.
14:00-15:30: Short talks, discussions and closing
Toward a Dynamic Slice-based Metric to Evaluate the Usefulness of Partial Execution Trace
A language construct for fork/join and continuation-passing libraries
Hiroshi Yamaguchi and Shigeru Chiba
Bridging the gap between modularity and efficiency: compiling compositional data types in Haskell
Tomoyuki Aotani, Hirotada Kiriyama and Hidehiko Masuhara
Toward effective software reuse based on code search