Jorge Ressia, Alexandre Bergel, and Oscar Nierstrasz. Object-Centric Debugging. In Proceeding of the 34rd international conference on Software engineering, ICSE ’12, 2012. Details.
Abstract
During the process of developing and maintaining a complex software system, developers pose detailed questions about the runtime behavior of the system. Source code views offer strictly limited insights, so developers often turn to tools like debuggers to inspect and interact with the running system. Unfortunately, traditional debuggers focus on the runtime stack as the key abstraction to support debugging operations, though the questions developers pose often have more to do with objects and their interactions. We propose object-centric debugging as an alternative approach to interacting with a running software system. We show how, by focusing on objects as the key abstraction, natural debugging operations can be defined to answer developer questions related to runtime behavior. We present a running prototype of an object-centric debugger, and demonstrate, with the help of a series of examples, how object-centric debugging offers more effective support for many typical developer tasks than a traditional stack-oriented debugger.
Andrea Quadri. Chameleon: Decoupling Instrumentation from Development Tools with Explicit Meta-Events. Master’s Thesis, University of Bern, January 2012. Details.
Abstract
Software instrumentation monitors the run-time behavior of a system to support a particular kind of analysis. The behavior of a system can be understood as a set of meta-level events that occur to achieve a goal. Instrumentation is often realized with the help of reflective mechanisms that reify these meta-events. Despite many advances, these approaches have a common drawback: the instrumentation of the base level is tightly coupled to the behavior of the development tools that required the instrumentation in the first place. This prevents development tools from leveraging the event abstractions used by other tools and forces them to respecify the events and their instrumentation. We propose to resolve this problem by modeling meta-events explicitly. Instrumentation is dedicated to generating meta-events, and is fully separated from analysis tools which selectively subscribe to these events by applying the observer pattern at the meta-level. We survey approaches to reflection to establish the key requirements for practical applications, and illustrate the limitations of these approaches. We introduce Chameleon, a prototype tool modeling the meta-level as explicit meta-events observable by development tools.
Amir Aryani, Fabrizio Perin, Mircea Lungu, Abdun Naser Mahmood, and Oscar Nierstrasz. Can We Predict Dependencies Using Domain information?. In Proceedings of the 18th Working Conference on Reverse Engineering (WCRE 2011), October 2011. Details.
Abstract
Software dependencies play a vital role in program comprehension, change impact analysis and other software maintenance activities. Traditionally, these activities are supported by source code analysis, however, the source code is sometimes inaccessible, and not all stakeholders have adequate knowledge to perform such analysis. For example, non-technical domain experts and consultants raise most maintenance requests, however, they cannot predict the cost and impact of the requested changes without the support of the developers. We propose a novel approach to predict software dependencies by exploiting coupling present in domain-level information. Our approach is independent of the software implementation, hence, it can be used to evaluate architectural dependencies without access to the source code or the database. We evaluate our approach with a case study on a large-scale enterprise system, in which we demonstrate how up to 68% of the source code dependencies and 77% of the database dependencies are predicted solely based on domain information.
Mircea Lungu, Romain Robbes, and Michele Lanza. Recovering Inter-Project Dependencies in Software Ecosystems. In ASE’10: Proceedings of the 25th IEEE/ACM International Conference on Automated Software Engineering, ACM Press, 2010. Details.
Abstract
In large software systems, knowing the dependencies be- tween modules or components is critical to assess the impact of changes. To recover the dependencies, fact extractors analyze the system as a whole and build the dependency graph, parsing the system down to the statement level. At the level of software ecosystems, which are collections of soft- ware projects, the dependencies that need to be recovered reside not only within the individual systems, but also be- tween the libraries, frameworks, and entire software systems that make up the complete ecosystem; scaling issues arise. In this paper we present and evaluate several variants of a lightweight and scalable approach to recover dependencies between the software projects of an ecosystem. We evaluate our recovery algorithms on the Squeak 3.10 Universe, an ecosystem containing more than 200 software projects.
Toon Verwaest, Camillo Bruni, Mircea Lungu, and Oscar Nierstrasz. Flexible object layouts: enabling lightweight language extensions by intercepting slot access. In Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications, OOPSLA ’11 p. 959—972, ACM, New York, NY, USA, 2011. Details.
Abstract
Programming idioms, design patterns and application libraries often introduce cumbersome and repetitive boilerplate code to a software system. Language extensions and external DSLs (domain specific languages) are sometimes introduced to reduce the need for boilerplate code, but they also complicate the system by introducing the need for language dialects and inter-language mediation. To address this, we propose to extend the structural reflective model of the language with object layouts, layout scopes and slots. Based on the new reflective language model we can 1) provide behavioral hooks to object layouts that are triggered when the fields of an object are accessed and 2) simplify the implementation of state-related language extensions such as stateful traits. By doing this we show how many idiomatic use cases that normally require boilerplate code can be more effectively supported. We present an implementation in Smalltalk, and illustrate its usage through a series of extended examples.
SCG