Got a question?
Got a question or comment? Contact us at
(515) 294-6168 or email@example.com.
Active Research Projects
Writing correct and efficient concurrent programs still remains a challenge.
Explicit concurrency is difficult, error prone, and creates code which is
hard to maintain and debug. This type of concurrency also treats modular
program design and concurrency as separate goals, where modularity often
suffers. To solve these problems, we are designing a new language that we
call Panini. Panini's goals are to reconcile the modularity goals promoted
by good software design practices with the concurrency goals of exposing
potential concurrency between the execution of components.
Since modularity is improved and concurrency is implicit in Panini, programs
are easy to reason about and maintain. Furthermore, races and deadlocks are
avoided entirely yielding programs with a guaranteed sequential semantics.
Ultra-large-scale software repositories (e.g., SourceForge, GitHub, Google
Code) contain an enormous corpus of software and related information about
software projects. Systematic extraction of relevant data from these
repositories and analysis of such data for testing hypotheses is hard, and best
left for mining software repository (MSR) experts. The goal of Boa, a
domain-specific language and infrastructure, is to ease testing MSR-related
A software is created to satisfy user needs (also called concerns).
These concerns may change often and unanticipatedly.
On a concern change, the parts of the software called modules,
responsible for that concern must also be revised.
A module revision incurs costs and may introduce new errors.
It is thus desirable to minimize module revisions.
Some concerns, called crosscutting concerns e.g. security,
fault tolerance, accountability, etc; have systemic effect.
If many modules are responsible for such a concern,
a change in it could trigger costly and error-prone
systemic module revisions.
We are designing the Ptolemy language to help avert
these systemic revisions.
[IEEE Software '06],
As multi-core processors are becoming common, vendors are
starting to explore trade offs between the die size and the number of
cores on a die, leading to heterogeneity among cores on a
single chip. For efficient utilization of these processors,
application threads must be assigned to cores such that
the resource needs of a thread closely matches resource
availability at the assigned core.
Current methods of thread-to-core assignment often require an
application's execution trace to determine it's runtime properties.
These traces are obtained by running the application on some
representative input. A problem is that developing these
representative input sets is time consuming, and requires
expertise that the user of a general-purpose processor
may not have. In this project, we are designing, implementing
and evaluating automatic thread-to-core assignment techniques for
heterogeneous multi-core processors that will
enhance the utilization of these processors.
The Slede project is looking at specification language design
and supporting verification mechanisms for specifying and verifying
cryptographic protocols for sensor networks. Applications of sensor networks are
numerous from military to environmental research. By providing
mechanisms to find cryptographic errors in the security protocols
for sensor networks this research program is improving the
reliability of these networks, making a direct impact on all
areas where these networks are utilized.
[ESEC/FSE '07 - DS],
[FSE '06 - Poster paper]
Past Research Projects
Eos is a unified aspect-oriented extension for C# on Microsoft® .NET Framework.
Eos unifies aspects and objects as classpects. The unified language model improves
the conceptual integrity of the language design and the compositionality of aspect modules
to better support hierarchical advising structures.
[ICSE '04 - DS],
The Frances project produces tools for teaching topics related to
code generation and mapping high-level languages to low-level langages.
is designed to help teach code generation and assembly language.
is designed to help teach computer architecture, assembly language, and how
high-level code actually executes on a system.
The Nu (pronounced new) project is exploring intermediate
language design and corresponding virtual machine extensions to
better support new features of aspect-oriented languages. The
potential impacts of this project include better compatibility
with the existing tool chain, better run-time performance, cross
AO language compatibility, improved pointcut expressivity, efficient
run-time weaving support, etc.
The key notion in service-oriented architecture is
decoupling clients and providers of a service based
on an abstract service description, which is used by
the service broker to point clients to a suitable
service implementation. A client then sends service
requests directly to the service implementation.
A problem with the current architecture is that it
does not provide trustworthy means for clients to
specify, service brokers to verify, and service
implementations to prove that certain desired
non-functional properties are satisfied during service
request processing. An example of such non-functional
property is access and persistence restrictions on the
data received as part of the service requests. In this
project, we are developing an extension of the
service-oriented architecture that provides these
facilities. We are also developing a prototype
implementation of this architecture that demonstrate
the potential practical value of the proposed
architecture in real-world software applications.
[IEEE SOC '08],
Comprehending software is hard. As system complexity
and size increases, existing approaches for program
comprehension become less usable. Ironically, the need
for these approaches increases with the size of the system.
In the Osiris project, we are looking at approaches and tools
generation of concerns models from source code for better
comprehension of large software systems.