13 research outputs found
Controlling Plasmonic Chemistry Pathways through Specific Ion Effects
Plasmon-driven dehalogenation of brominated purines has been recently explored as a model system to understand fundamental aspects of plasmon-assisted chemical reactions. Here, it is shown that divalent Ca2+ ions strongly bridge the adsorption of bromoadenine (Br-Ade) to Ag surfaces. Such ion-mediated binding increases the molecule's adsorption energy leading to an overlap of the metal energy states and the molecular states, enabling the chemical interface damping (CID) of the plasmon modes of the Ag nanostructures (i.e., direct electron transfer from the metal to Br-Ade). Consequently, the conversion of Br-Ade to adenine almost doubles following the addition of Ca2+. These experimental results, supported by theoretical calculations of the local density of states of the Ag/Br-Ade complex, indicate a change of the charge transfer pathway driving the dehalogenation reaction, from Landau damping (in the lack of Ca2+ ions) to CID (after the addition of Ca2+). The results show that the surface dynamics of chemical species (including water molecules) play an essential role in charge transfer at plasmonic interfaces and cannot be ignored. It is envisioned that these results will help in designing more efficient nanoreactors, harnessing the full potential of plasmon-assisted chemistry
Towards object-aware development tools
Reasoning about object-oriented applications requires developers to answer contextual questions about their domain objects. Tailored development tools can support developers in this activity by providing relevant domain-specific information. Nonetheless, a high effort for extending development tools to handle domain-specific objects, together with diverging mechanisms for creating, sharing and discovering extensions, discourage developers to adapt their tools. To address this, we propose to enable contextual behavior in development tools by allowing domain objects to decide how they are handled in development tools. We show that combining this idea with mechanisms for specifying extensions using internal DSLs can significantly reduce the cost of tailoring development tools to specific domains
Moldable tools
Development tools are a prerequisite for crafting software. They offer the lenses through which developers perceive and reason about their software systems. Generic development tools, while having a wide range of applicability, ignore the contextual nature of software systems and do not allow developers to directly reason in terms of domain abstractions. Domain-specific development tools, tailored to particular application domains, can address this problem. While it has clear advantages, incorporating domain abstractions into development tools is a challenging activity. The wide range of domains and contextual tasks that development tools need to support leads to costly or ad hoc mechanisms to incorporate and discover domain abstractions. Inherently, this limits developers from taking advantage of domain-specific information during the development and maintenance of their systems.
To overcome this problem, we propose to embed domain abstractions into development tools through the design of moldable tools that support the inexpensive creation of domain-specific extensions capturing domain abstractions, and that automatically select extensions based on the domain model and the developer’s interaction with the domain model. This solution aims to reduce the cost of creating extensions. Towards this goal, it provides precise extension points together with internal DSLs for configuring common types of extensions. This solution facilitates automatic discovery by enabling extension creators to specify together with an extension an activation predicate that captures the context in which that extension is applicable.
We validate the moldable tools approach by applying it, in the context of objectoriented applications, to improve three development activities, namely: reasoning about run-time objects, searching for domain-specific artifacts, and reasoning about run-time behavior. For each activity we identify limitations of current tools, show how redesigning those tools following the moldable tools approach addresses the identified limitations, and discuss the cost for creating domain-specific extensions. We demonstrate that moldable tools address an existing need by analyzing the increase in domain-specific extensions after we integrated the moldable tools solving the aforementioned tasks with an IDE. We also show what kinds of custom environments developers can create by continuously adapting their development tools
Towards moldable development tools
Developers commonly ask detailed and domain-specific questions about the software systems they are developing and maintaining. Integrated development environments (IDEs) form an essential category of tools for developing software that should support software engineering decision making. Unfortunately, rigid and generic IDEs that focus on low-level programming tasks, that promote code rather than data, and that suppress customization, offer limited support for informed decision making during software development. We propose to improve decision making within IDEs by moving from generic to context-aware IDEs through moldable tools. In this paper, we promote the idea of moldable tools, illustrate it with concrete examples, and discuss future research directions
Pervasive Software Visualizations
A picture tells a thousand words. We all know that. Then why are our development tools showing mainly text with so much obstinacy? Even when visualizations do make it into our tools, they typically do not make it past the periphery. Something is deeply wrong. We argue that visualizations must become pervasive in software development, and to accommodate this goal, the integrated development environments must change significantly
A promising approach for debugging remote promises
Promises are synchronization constructs that hide the complexity of process synchronisation from the developer by providing a placeholder for the result of a potentially incomplete computation performed in a concurrent process. Promises evaluated by remote processes pose challenges for debugging when the remote computation raises an exception. Current debuggers are either unaware that there is a problem in the remote computation or give developers access only to the context of the remote process. This does not allow developers to interact at the same time with the process that launched the promise and the remote process that executed the promise's computation. To improve debugging of remote promises, in this paper we propose a debugger interface that presents a unified view of both the original and the remote process, by merging the call chains of the two processes at the point where the promise was created. We exemplify our approach, discuss challenges for making it practical, and illustrate through an initial prototype that it can improve debugging of exceptions in remote promises
GTInspector: A Moldable Domain-Aware Object Inspector
Understanding the run-time behaviour of object-oriented applications entails the comprehension of run-time objects. Traditional object inspectors favor generic views that focus on the low-level details of the state of single objects. While universally applicable, this generic approach does not take into account the varying needs of developers that could benefit from tailored views and exploration possibilities. GTInspector is a novel moldable object inspector that provides different high-level ways to visualize and explore objects, adapted to both the object and the current developer need
The Moldable Inspector
Object inspectors are an essential category of tools that allow developers to comprehend the run-time of object-oriented systems. Traditional object inspectors favor a generic view that focuses on the low-level details of the state of single objects. Based on 16 interviews with software developers and a follow-up survey with 62 respondents we identified a need for object inspectors that support different high-level ways to visualize and explore objects, depending on both the object and the current developer need. We propose the Moldable Inspector, a novel inspector model that enables developers to adapt the inspection workflow to suit their immediate needs by making the inspection context explicit, providing multiple interchangeable domain-specific views for each object, and supporting a workflow that groups together multiple levels of connected objects. We show that the Moldable Inspector can address multiple kinds of development needs involving a wide range of objects
Practical domain-specific debuggers using the Moldable Debugger framework
Understanding the run-time behavior of software systems can be a challenging activity. Debuggers are an essential category of tools used for this purpose as they give developers direct access to the running systems. Nevertheless, traditional debuggers rely on generic mechanisms to introspect and interact with the running systems, while developers reason about and formulate domain-specific questions using concepts and abstractions from their application domains. This mismatch creates an abstraction gap between the debugging needs and the debugging support leading to an inefficient and error-prone debugging effort, as developers need to recover concrete domain concepts using generic mechanisms. To reduce this gap, and increase the efficiency of the debugging process, we propose a framework for developing domain-specific debuggers, called the Moldable Debugger, that enables debugging at the level of the application domain. The Moldable Debugger is adapted to a domain by creating and combining domain-specific debugging operations with domain-specific debugging views, and adapts itself to a domain by selecting, at run time, appropriate debugging operations and views. To ensure the proposed model has practical applicability (i.e., can be used in practice to build real debuggers), we discuss, from both a performance and usability point of view, three implementation strategies. We further motivate the need for domain-specific debugging, identify a set of key requirements and show how our approach improves debugging by adapting the debugger to several domains
Exemplifying Moldable Development
Developing and evolving software requires developers to continuously make decisions about how to steer the design and implementation of their applications. To make informed decisions developers commonly formulate detailed and domain-specific questions about their software systems and use tools to explore available information and answer those questions. Development tools however focus on generic programming tasks while program comprehension and analysis tools typically are not tightly integrated with their development tools and environments. This has a negative effect on program comprehension as it increases the effort and the time needed to obtain an answer. To improve program comprehension we propose that developers build software using development tools tailored to their specific application domains, as this can directly answer domain-specific questions. We introduce moldable development as an approach for developing software in which developers evolve development tools together with their applications. In this paper we sketch the idea of moldable development and give examples to illustrate how it can be applied in practice. Through these examples we show that given a low cost for extending development tools, developers can create relevant and useful customizations to help them evolve their own applications