Celina Gibbs

C-CLR: a tool for navigating highly configurable system software

In order to accommodate the spectrum of configuration options currently required for competitive system infrastructures, many systems leverage heavy usage of C preprocessor controlled conditional compilation. In herent costs associated with this heavy preprocessor usage include both the impaired readability of the base system, and the reduced reusability of the configuration code. Our proposed solution, C-CLR, allows developers to sift through views of a system based on configuration options. Configuration-specific views improve readability of the system as a whole by including only relevant code. They also support reusability by aiding aspect mining through easy navigation to relevant configuration options, and automated identification of equivalent blocks of code within conditionally compiled segments.

Sustainable system infrastructure and big bang evolution: can aspects keep pace?

Realistically, many rapidly evolving systems eventually require extensive restructuring in order to effectively support further evolution. Not surprisingly, these overhauls reverberate throughout the system. Though several studies have shown the benefits of aspect-oriented programming (AOP) from the point of view of the modularization and evolution of crosscutting concerns, the question remains as to how well aspects fare when the code that is crosscut undergoes extensive restructuring. That is, when evolution is a big bang, can aspects keep pace? The case study presented here considers several categories of aspects – design invariants, dynamic analysis tools, and domain specific design patterns – and shows the concrete ways in which aspects had positive, negative and neutral impact during the restructuring of the memory management subsystem of a virtual machine. Compared with best efforts in a hierarchical decomposition coupled with a preprocessor, aspects fared better than the original implementation in two out of four aspects, and no worse in the remaining two aspects.

Disentangling virtual machine architecture

Virtual machine (VM) implementations are made of intricately intertwined subsystems, interacting largely through implicit dependencies. As the degree of crosscutting present in VMs is very high, VM implementations exhibit significant internal complexity. This study proposes an architecture approach for VMs that regards a VM as a composite of service modules coordinated through explicit bidirectional interfaces. Aspect-oriented programming techniques are used to establish these interfaces, to coordinate module interaction, and to declaratively express concrete VM architectures. A VM architecture description language is presented in a case study, illustrating the application of the proposed architectural principles.

Aspect mining in the presence of the C preprocessor

In systems software, the C preprocessor is heavily used to manage variability and improve efficiency. It is the primary tool to model crosscutting concerns in a very fine-grained way, but leads to extremely tangled and scattered preprocessor code. In this paper, we explore the process of aspect mining and extraction in the context of preprocessor-driven systems. Our aim is to identify both opportunities (extracting conditional compilation into advice) and pitfalls (mining on unpreprocessed code) in migrating preprocessor code to aspects. We distill five trade-offs which give a first impression about the usefulness of replacing the preprocessor by aspects. Preprocessor-driven systems prove to be a real challenge for aspect mining, but they could become on the other hand one of the most promising applications of AOP.

Aspects of Memory Management

With the constant demand for system change and upgrades comes the need to simplify and ensure accuracy in this process. As structural boundaries decay, non-local modifications compound the costs of system evolution and adaptation. Aspect-Oriented Programming (AOP) aims to improve structural boundaries for concerns that are inherently crosscutting - no single hierarchical decomposition can localize both the crosscutting concern and the concerns it crosscuts. This paper provides a case study of three crosscutting concerns within a rapidly evolving memory management subsystem of a JVM. The study shows how aspects can be structured as a natural locus of control, and how this new modularity provides leverage for system evolution and adaptation. Demonstrated benefits include enhanced extensibility for a dynamic analysis tool, centralized configurability for a subsystem-wide synchronization mechanism, and increased verifiability for a domain-specific design pattern.

Mind the gap!: bridging the dichotomy of design and implementation

This paper presents a revamping of a sparse linear algebra design pattern, targeting parallelization within scientific and engineering applications. A proof of concept implementation is developed to compare actual software practices and optimizations with those described in the original design pattern. The case study reveals that the design pattern did not tightly coincide with the design decisions in the implementation. The proposed revised pattern takes these decisions into account more explicitly, refining the structural representation of the pattern to make it more accessible to scientific developers attempting to achieve the benefits of pallelization now available in commodity systems.

ICE: circumventing meltdown with an advanced binary analysis framework

In this paper we propose ICE, an Integrated Comprehension Environment, designed to facilitate advanced binary analysis through an extensible framework. ICE makes extensive use of modules and a flexible intermediate representation to enable seamless integration of instruction set architectures, platforms, and analysis techniques.

Understanding abstraction: a means of leveling the playing field in CS1?

Given the wide ranging treatment of IT in high schools, future generations of CS1 students are bound to arrive with dramatically different levels of exposure to programming constructs. Though exposure to language mechanisms is not the take-away point from CS1, this appears to create an uneven playing field in our introductory courses. The premise of our work is that by focusing on abstraction, students connect with opportunities to engage in creative and analytical processes, potentially achieving more intellectual satisfaction--even from simple formative exercises in a first assignment. Our results show that of the 75 students in the study, on average 91% reported success with the implementation exercises in the assignment. However, when asked to reflect on their implementations at a higher level of abstraction, only 69% communicated solutions in ways that meaningfully generalized the specific task at hand. Further, success in abstracting their solution appeared to be less tightly linked with previous programming experience, and instead is most strongly related to the propensity to experiment with their own code.

Living with the Law: Can Automation give us Moore with Less?

Multi-core programming presents developers with a dramatic paradigm shift. Whereas sequential programming largely allowed the decoupling of source from underlying architecture, it is now impossible to develop new patterns and abstractions in isolation from issues of modern hardware utilization. Synchronization and coordination are now manifested at all levels of the software stack, and developers currently lack the essential tools to even partially automate reasoning techniques and system configuration management. As a first stage to addressing this problem, this paper proposes a framework for a tool suite designed to partially automate the acquisition and management of static system visualization in a feedback loop with dynamic execution properties. This model enables developers to find a best fit system configuration, potentially reconciling resource contention and utilization tensions that are critical to multi-core platforms. The application of a prototype of this suite, Deja View, demonstrates how tool support can aid reasoning about causally related sets of changes across system artifacts.

MADAPT: managed aspects for dynamic adaptation based on profiling techniques

An increasingly significant cost associated with dynamically adaptive middleware is the complexity of managing the code responsible for adaptive behaviour. It is not surprising that, due to the fine-grained nature of trace-data collection and the subtle adaptation that can result, more flexible systems are typically more complex to manage. This paper makes the case for using aspect-oriented programming (AOP) [6] as a means to achieve adaptive middleware based on fine-grained, customizable, profiling techniques. A feasibility-study combining Java Management Extensions (JMX) [3] and AOP shows the effectiveness of the synergy between the management support for application services offered by JMX, and the structured support for crosscutting concerns offered by AOP.