Multi-Language Edit-and-Continue for the Masses

We present an Edit-and-Continue implementation that allows regular source files to be treated like interactively updatable, compiled scripts, coupling the speed of compiled native machine code, with the ability to make changes without restarting. Our implementa-tion is based on the Microsoft .NET Framework and allows applications written in any .NET language to be dynamically updatable. Our solution works with the standard version of the Microsoft Common Language Runtime, and does not require a custom compiler or runtime. Because no application changes are needed, it is transparent to the application developer. The runtime overhead of our implementation is low enough to support updating real-time applications (e.g., interactive 3D graphics applications)

Multi-Language Edit-and-Continue for the Masses

We present an Edit-and-Continue implementation that allows regular source files to be treated like interactively updatable, compiled scripts, coupling the speed of compiled native machine code, with the ability to make changes without restarting. Our implementa-tion is based on the Microsoft .NET Framework and allows applications written in any .NET language to be dynamically updatable. Our solution works with the standard version of the Microsoft Common Language Runtime, and does not require a custom compiler or runtime. Because no application changes are needed, it is transparent to the application developer. The runtime overhead of our implementation is low enough to support updating real-time applications (e.g., interactive 3D graphics applications)

Debugging Woven Code

The ability to debug woven programs is critical to the adoption of Aspect Oriented Programming (AOP). Nevertheless, many AOP systems lack adequate support for debugging, making it difficult to diagnose faults and understand the program's structure and control flow. We discuss why debugging aspect behavior is hard and how harvesting results from related research on debugging optimized code can make the problem more tractable. We also specify general debugging criteria that we feel all AOP systems should support. We present a novel solution to the problem of debugging aspect-enabled programs. Our Wicca system is the first dynamic AOP system to support full source-level debugging of woven code. It introduces a new weaving strategy that combines source weaving with online byte-code patching. Changes to the aspect rules, or base or aspect source code are rewoven and recompiled on-the-fly. We present the results of an experiment that show how these features provide the programmer with a powerful interactive debugging experience with relatively little overhead

Whitepaper: The Value of Improving the Separation of Concerns

Microsoft's enterprise customers are demanding better ways to modularize their software systems. They look to the Java community, where these needs are being met with language enhancements, improved developer tools and middleware, and better runtime support. We present a business case for why Microsoft should give priority to supporting better modularization techniques, also known as advanced separation of concerns (ASOC), for the .NET platform, and we provide a roadmap for how to do so

An empirical assessment of the crosscutting concern problem

Modularity is essential for creating evolvable software. Traditional programming languages limit the level of modularity that can be achieved because they provide only one way to structure the program, e.g., as a hierarchy of types. Regardless of how a program is structured, some features, requirements, or other types of concerns of the program cannot be modularized; that is, they cut across the program's structure. These so-called crosscutting concerns result in programs that are difficult to understand and reason about, to divide into manageable pieces, to reuse, and to evolve. In this dissertation, we assess the impact of crosscutting concerns on software quality. Little is known about the impact because determining the concerns of a program and how they are implemented is difficult, existing metrics for quantifying crosscutting are inadequate, and empirical evidence is lacking. To locate the source code that implements a concern, i.e., concern location, we present a new technique called prune dependency analysis, which can be combined with existing concern location techniques to dramatically improve accuracy. We developed CERBERUS, a potent hybrid technique for locating concerns that combines information retrieval, execution tracing, and prune dependency analysis . Our experiments show that prune dependency analysis can boost the recall of information-retrieval-based concern location by 155% and execution tracing by 104%. In addition, we show that our combined technique outperformed other techniques when run individually or in pairs. After using our techniques to locate all the code that implements a concern, our novel concern metrics quantify the amount of crosscutting that exists. We assessed the crosscutting concern problem by performing rigorous empirical studies of five medium-sized programs. We found a moderate to strong statistically significant correlation between the amount of crosscutting and the number of defects. That is, the more a concern crosscuts the program, the more likely it is to have defects. We also found that the crosscutting concern problem was prevalent: 86% of the concerns we analyzed were crosscutting, concerns were implemented by 6 classes on average, and classes implement 10 concerns on average

Experimentation, Languages, Performance

We present an Edit-and-Continue implementation that allows regular source files to be treated like interactively updatable, compiled scripts, coupling the speed of compiled native machine code, with the ability to make changes without restarting. Our implementation is based on the Microsoft.NET Framework and allows applications written in any.NET language to be dynamically updatable. Our solution works with the standard version of the Microsoft Common Language Runtime, and does not require a custom compiler or runtime. Because no application changes are needed, it is transparent to the application developer. The runtime overhead of our implementation is low enough to support updating real-time applications (e.g., interactive 3D graphics applications)

Statement annotations for fine-grained advising

AspectJ-like languages are currently ineffective at modularizing heterogeneous concerns that are tightly coupled to the source code of the base program, such as logging, invariants, error handling, and optimization. This leads to complicated and fragile pointcuts and large numbers of highly-repetitive and incomprehensible aspects. We propose statement annotations as a robust mechanism for exposing the join points needed by heterogeneous concerns and for enabling declarative fine-grained advising. We propose an extension to Java to support statement annotations and AspectJ’s pointcut language to match them. This allows us to implement heterogeneous concerns using a combination of simple and robust aspects and explicit and local annotations. We illustrate this using a logging aspect that logs messages at specific locations in the source code. Statement annotations also simplify advising specific object instances, local variables, and statements. We demonstrate this using an aspect that traces method calls made to specific object instances and calls made from specific call sites. Keywords statement annotations, byte code annotations, fragile pointcut problem, logging problem, statement-level join points, instance-local advising 1

Identifying, Assigning, and Quantifying Crosscutting Concerns

Crosscutting concerns degrade software quality. Before we can modularize the crosscutting concerns in our programs to increase software quality, we must first be able to find them. Unfortunately, accurately locating the code related to a concern is difficult, and without proper metrics, determining how much the concern is crosscutting is impossible. We propose a systematic methodology for identifying which code is related to which concern, and a suite of metrics for quantifying the amount of crosscutting code. Our concern identification and assignment guidelines resolve some of the ambiguity issues encountered by other researchers. We applied this approach to systematically identify all the requirement concerns in a 13,531 line program. We found that 95 % of the concerns were crosscutting—indicating a significant potential for improving modularity—and that our metrics were better able to determine which concerns would benefit the most from reengineering

My Own Private Kiosk: Privacy-Preserving Public Displays

Ubiquitous, high-resolution, large public displays offer an attractive complement to wearable displays. Unfortunately, the inherently public nature of these public displays makes them unsuitable for displaying sensitive information. We present EyeGuide, a wearable system that allows the user to obtain information quickly from a public display without sacrificing privacy. To this end, EyeGuide employs a lightweight head-worn eyetracker for hands-free object selection and an earphone for private communication