|
|
Theses2011
Alexander Wilfred John Bradley.
Supporting Software History Exploration.
Master's thesis,
April 2011.
Software developers often confront questions such as "Why was the code
implemented this way"? To answer such questions, developers make use
of information in a software system's bug and source repositories. In
this thesis, we consider two user interfaces for helping a developer
to explore information from such repositories. One user interface,
from Holmes and Begel's Deep Intellisense tool, exposes historical
information across several integrated views, favouring exploration
from a single code element to all of that element's historical
information. The second user interface, in a tool called Rationalizer
that we introduce in this thesis, integrates historical information
into the source code editor, favouring exploration from a particular
code line to its immediate history. We introduce a model to express
how software repository information is connected and use this model to
compare the two interfaces. Through a laboratory study, we found that
our model can help to predict which interface is helpful for two
particular kinds of historical questions. We also found deficiencies
in the interfaces that hindered users in the exploration of historical
information. These results can help inform tool developers who are
presenting historical information from software repositories, whether
that information is retrieved directly from the repository or derived
through software history mining.
Thomas Fritz.
Developer-Centric Models: Easing Access to Relevant Information in a Software Development Environment.
PhD thesis,
April 2011.
During the development of a software system, large amounts of new
information, such as source code, work items and documentation, are
produced continuously. As a developer works, one of his major
activities is to consult portions of this information pertinent to his
work to answer the questions he has about the system and its
development. Current development environments are centered around
models of the artifacts used in development, rather than of the people
who perform the work, making it difficult and sometimes infeasible for
the developer to satisfy his information needs. We introduce two
developer-centric models, the degree-of-knowledge (DOK) model and the
information fragments model, which support developers in accessing the
small portions of information needed to answer the questions they
have. The degree-of-knowledge model computes automatically, for each
source code element in the development environment, a real value that
represents a developer's knowledge of that element based on a
developer's authorship and interaction data. We present evidence that
shows that both authorship and interaction information are important
in characterizing a developer's knowledge of code. We report on the
usage of our model in case studies on expert finding, knowledge
transfer and identifying changes of interest. We show that our model
improves upon an existing expertise finding approach and can
accurately identify changes for which a developer should likely be
aware. Finally, we discuss the robustness of the model across multiple
development sites and teams. The information fragment model automates
the composition of different kinds of information and allows
developers to easily choose how to display the composed
information. We show that the model supports answering 78 questions
that involve the integration of information siloed by existing
programming environments. We identified these questions from
interviews with developers. We also describe how 18 professional
developers were able to use a prototype tool based on our model to
successfully and quickly answer 94% of eight of the 78 questions posed
in a case study. The separation of composition and presentation
supported by the model, allowed the developers to answer the questions
according to their personal preferences.
Brett Allen Cannon.
Minimizing Resource Access and Management Disparities Between Desktop and Web Applications.
PhD thesis,
January 2011.
Client applications, including both traditional desktop applications
and modern Web applications, typically access and manage resources in
order to perform their intended work. Unfortunately both approaches
lack something the other has when it comes to resource access and
management. Desktop applications typically do not provide enough
security for resources to prevent malicious abuse of them. While
operating systems provide access-control lists, they do not help
facilitate enforcing the Principle of Least Privilege to minimize
insecure resource access. Web applications, while they operate in a
sandboxed environment which provides the necessary resource access
restrictions, do not have a rich API for data storage
management. While HTML5 provides two primitive APIs for a developer to
use to manage stored data, neither approach allows for storing data in
an object-oriented manner that a developer is used to. This thesis
addresses the question of "can these two shortcomings in resource
access and management be overcome in order to lessen the technological
gap between desktop applications and Web applications?" For desktop
applications an approach using aspect-oriented software design has
been created which adds enforcement of the Principle of Least
Privilege by using I/O to dynamically choose what resource permissions
to grant the application. I show that this approach can tie into Java
applications with rich user interaction and I/O to control resource
access while providing a way for third-parties to provide the security
code for auditing purposes. For Web applications, a library has been
designed which introduces automatic object persistence to JavaScript
without requiring any modifications of the browser. I show that my
library is able to persist a thousand objects without a
user-perceptible impact on application performance, all while having
minimal requirements placed upon the developer to use the library.
2010
Ryan M. Golbeck.
VM Supported AspectJ.
PhD thesis,
November 2010.
Traditional AspectJ implementations use a VM-external implementation
approach based on JBC instrumentation. These approaches pose an
inherent penalty in both steady state performance as well as startup
or recompilation performance. We present a map of the design space for
AspectJ implementations with potential advantages and disadvantages to
evaluate the coverage of the space by related work to identify
unexplored possibilities. We propose an architecture for AspectJ
implementations which supports both VM-internal and VM-external
implementations. VM-internal implementations of our architecture fit
naturally into existing JVMs, are straight forward to implement and
support all known AspectJ optimizations as well as maintaining
efficient startup performance. However, because our architecture also
supports VM-external implementations, it is both backward and forward
compatible. Additionally, we present a suite of benchmarks designed to
evaluate AspectJ implementations. This suite contains macro and micro
benchmarks designed to measure the steady state, startup, and overall
performance of an implementation. To demonstrate the viability of our
architecture, we present one primary implementation, ajvm, in the
Jikes Research Virtual Machine (RVM), and several secondary partial
implementations in the Jikes RVM and a second JVM, J9. We use our
proposed benchmark suite to produce an analysis that confirms our
claims that VM-integrated AspectJ implementations can support known
and proposed steady state and startup optimizations. Furthermore, they
overcome inherent performance penalties associated with VM-external
implementations.
2009
Steven Xinyue Gao.
FireInsight: Understanding JavaScript Behaviors in Web Pages by Visually Exploring the Browser.
Master's thesis,
December 2009.
JavaScript is one of the most important and prevalent programming
languages today. It is the language of the web browser and it has seen
a surge in active development since the rise of the Ajax approach for
developing highly interactive web applications. Often misunderstood as
a simple scripting language, JavaScript is in fact powerful and
expressive. As web applications have grown in sophistication, so have
their user interfaces, which are predominately implemented as
client-side JavaScript. This growth in complexity has resulted in a
vast array of JavaScript frameworks, best practices and design
patterns. Since JavaScript applications involve creating user
interfaces, adopting a visual development approach would seem a
natural choice to help manage complexity and improve program
understanding. One possible approach is to allow the developer to
visually relate semantically meaningful elements on a web page to the
actual JavaScript source code that implements its behavior. This can
be accomplished by leveraging context information during JavaScript
execution. Additionally, control-flow graphs are dynamically generated
to help the developer understand how a series of function calls might
be related based on events triggered in the user interface. Inspired
by work from Li and Wohlstadter, we implement the above approach by
creating a program called FireInsight. It integrates with the Mozilla
Firefox web browser and the Firebug development tool. We use an HTTP
proxy to instrument JavaScript source code with our own analysis
code. We analyze this approach and evaluate its effectiveness by
applying FireInsight to an open-source web application called Java Pet
Store 2.0.
Jingwen Ou.
Computing Degree-of-Knowledge Values for a Developer's Workspace.
Master's thesis,
May 2009.
Previous research in computer science shows that software developers
are typically deluged by an enormous volume of information
daily. Improving the effectiveness of developers to filter this
information may yield significant productivity improvements. To combat
this overload, we introduce an indicator, called degree-of-knowledge
(DOK), which is a real value indicating how much knowledge a developer
has with a source code element. A developer's DOK values for a source
code base can be computed automatically from authorship data mined
from the source revision systems and from interaction data collected
as the developer works. This indicator may help reduce information
overload by, for instance, filtering the source code to only show the
elements for which a developer has high knowledge. We describe our
implementation of an efficient framework for computing DOK values in a
development environment.
Muhammad Immad Naseer.
Interpreter Implementation of Advice Weaving.
Master's thesis,
April 2009.
Implementing advice weaving using code rewriting can cause performance
problems during application startup and incremental development. We
present an interpreter based (non-rewriting) approach using a simple
table and cache structure for matching pointcuts against dynamic join
points together with a simple mechanism for calling the matched
advice. An implementation in the JikesRVM, an open source research
virtual machine, shows the approach is straightforward to
implement. Internal micro-benchmarks show dynamic join point execution
overhead of approximately 28% in the common case where no advice is
applicable. Comparative micro-benchmarks with ajc load time weaving
show startup time reductions equivalent to the interpreted execution
of 100-117 million unadvised dynamic join points. The cache and table
structures could be used during later (i.e. JIT time) per-method
rewrite based weaving to reduce pointcut matching overhead. We
conclude that it is worthwhile to develop and evaluate a complete
in-VM hybrid implementation, comprising both non-rewriting and
rewriting based advice weaving.
Petcharat Viriyakattiyaporn.
An Active Help System to Improve Program Navigation.
Master's thesis,
April 2009.
Software development environments have evolved to make it easy for
third parties to integrate a variety of tools into the
environment. Previous research has shown that developers often do not
use or know all of the tools available in development environments
that they regularly use. The most common solution to alleviate this
problem is to provide a means to search through passive help
documents. However, this approach requires a developer to be able to
express her desires in a form understood by a search engine. To
overcome this limitation, we propose using an active help system to
automatically recommend to a developer tools that are appropriate to
the developer’s current goal. We introduce an active help system to
recommend navigation tools because previous research has shown a
substantial amount of effort expended by a developer on a software
evolution task is related to navigation. Our approach infers which
structurally related pieces of information are of interest to a
developer and determines when the navigation performed by the
developer between the related information is suboptimal. In suboptimal
navigation situations, our approach recommends a tool that would
enable more efficient navigation. Our approach was implemented as a
prototypical active help system, called Spy glass, in IBM’s Rational
Team Concert development environment. To investigate whether and under
what conditions Spyglass helps or hinders a developer in navigation,
two empirical studies were conducted: a longitudinal user study in an
undergraduate software engineering course and a laboratory user study
comparing Spyglass to a passive tutorial. The longitudinal study
provided feedback to improve the user interface of Spyglass and
provided evidence that the developers who were novice to the
development environment liked the idea of having an active help system
in the environment. The laboratory study confirmed that Spyglass can
help developers navigate between code elements more efficiently. The
developers in the laboratory study also confirmed their desire for a
system like Spyglass. The laboratory study also revealed that Spyglass
requires improvements to its accuracy.
2008200720062005200420032002
Gene S. Lee.
Interaction-based simulation.
PhD thesis,
July 2002.
200119991997
Elisa Ladan Anahita Baniassad.
Conceptual modules: expressing desired structure for software reengineering.
Master's thesis,
December 1997.
|