AOAsia/Pacific 2014: 9th International Workshop on Advanced Modularization Techniques

one-day workshop co-located with FSE 2014, November 16, Hong Kong, China


  • 9:20- 9:30: Welcome
  • 9:30-10:30: Invited Talk

    • Why Modularity Matters: Achieving Modular Reasoning about Concurrent Programs and its Implications

      Hridesh Rajan

      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

    • Toward Understanding How Developers Recognize Features in Source Code from Descriptions

      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.

    • Uncertainty-aware Architectural Interface

      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.

    • Crossver: a Code Transformation Language for Crosscutting Changes

      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.

  • 12:30-14:00: Lunch

  • 14:00-15:30: Short talks, discussions and closing

    • Toward a Dynamic Slice-based Metric to Evaluate the Usefulness of Partial Execution Trace

      Takashi Ishio

    • 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

      Jianjun Zhao