I have broad interests in systems spanning applications, system software, networking, and architecture. Current interests include: 1) Cloud/Grid applications, system software, and architecture; 2) Computer Architecture for Exascale computers; and 3) Programming models and tools for post-Moore’s Law computing substrates.

Developing and ensuring the reliability and security of software systems by developing innovative software architectures, languages, and tools.

I am interested in Programming Languages and Software Engineering, more specifically, in techniques for building reliable computer systems. My work draws from, combines and contributes to methods the areas of Model Checking, Program Analysis and Automated Deduction. In particular, I have worked on Software Model Checking, the design and implementation of languages and tools for building robust Distributed Systems, and analyses for multithreaded systems software. More recent interests include advanced refinement type systems for statically verifying sophisticated
program invariants (with low programmer overhead) and techniques to analyze information flow and other security properties in modern web applications.

My research typically involves both theory (“proving theorems”) and practice (“building tools”.) In addition to the topics above, I am happy to explore related ideas for potential projects.

The goal of the Galois project is to develop programming notations, compilers and runtime systems for programming multicore processors. We focus on irregular algorithms, which are algorithms in which the key data structures are sparse graphs, trees, sets, etc. This class of algorithms is very general, and includes mesh generation, refinement and partitioning algorithms, SAT solvers, machine learning algorithms, n-body methods etc. Our work has appeared recently in top conferences like PLDI 2011, POPL 2011, OOPSLA 2010, and ASPLOS 2011. Our group has six PhD students and three post-docs, and we are always looking for new talent!

My research focuses on programming languages, with applications to software engineering and security. The general goal of my research is to help developers rapidly construct software that is reliable, maintainable, and secure. In the past, I have done research on points-to analysis; type qualifiers; foreign function interfaces; data race detection; network protocol implementations; modularity for C; and ownership systems, among others. Currently, I am working on several research directions, including studying typing scripting languages, working on program synthesis, and studying security on Android.

All of my work involves both theory and practical implementations of software tools.

In addition to the topics above, I would be happy to explore related ideas for projects.

I have a broad interest in almost all disciplines of Computer Science, and have shifted my focus several times during my research career. My major of B.S., M.S., and Ph.D are all in control theory, but I spent most of my Ph.D time on the application of control theory to computer systems, especially deadlock avoidance in multithreaded software. I become a compiler and program analysis specialist after this exercise. My work at HP Labs was initially around the application of control theory to business process management systems. We focused on Service-Oriented Architecture and studied the service composition problem in great length. Lately I am working on Intelligent Transportation Systems. We are interested in building an IT platform that can collect and analyze large-scale sensor input in realtime from various sources, e.g., GPS probes, loop detectors, and close-circuit cameras.

In my research, I investigate and develop compiler technology in order to automate domain-specific performance and parallelization transformations that are currently applied by hand or not at all. My current and previous research can generally be categorized into performance improving program transformations for regular and irregular applications and domain-specific analysis and program transformation. The ultimate goal is to raise the level of abstraction for scientists who develop computational simulations of physical phenomena while enabling powerful interfaces for performance programmers that enable the orthogonal mapping such simulations to parallel systems. See http://www.cs.colostate.edu/~mstrout for more information about the research we are doing.

At Colorado State University in the High Performance Computing research group, a CI Fellow would have the opportunity to create and direct research and help supervise students. We have active collaborations with the BioChemistry, Math, and Statistics departments hear at CSU. We also are actively collaborating with researchers at Argonne National Laboratory, Berkeley, Cray, LBL, and Intel. I look forward to hearing from interested candidates.

My research group focuses on developing automatic analyses of programs to support software testing (recently focusing on web applications), software developer search of source code during maintenance (concern location), optimization for improved performance for parallel architectures, debugging, program understanding and other software developer tools. We use machine learning, data mining, and manual analysis of thousands of large software systems to guide the development of our analyses, and evaluate our techniques through solid experimental study, human subjects when appropriate, and statistical analyses. The research group involves collaborations with professors within the university as well as collaborators at other universities. The research lab includes PhD, master’s and very good undergraduate student researchers.

My overarching research goal is to use program analysis to ensure software quality of real-world applications, even at industrial scale. My current focus is on the use of tightly coupled static and dynamic program analyses for object-oriented systems. My most recent project focused on performance diagnosis of framework-based systems. We are currently exploring applications of these analyses to problems of security and debugging. We are interested in validating behavioral properties of multi-language applications (e.g., Java and Javascript). There are interesting open research questions about the analysis paradigm being explored such as “In what sense is our dataflow solution ‘safe’?” and “How can we add precision to such analyses?”

The research in our group (PROLANGS@VT) is characterized by problem definition and algorithm design followed by extensive empirical validation. We emphasize finding techniques effective and practical for real applications. Background in program analysis is desirable. Person must be self-motivated and willing to take the initiative in research. Primary responsibility to strengthen research group and help with research supervision of grad students and undergrad students under REU support.

Formal Methods / High Performance Computing / Software Engineering / Concurrency

Our main interests are to develop scalable formal analysis methods for high-performance computing systems.
Of particular interest are formal dynamic analysis methods for MPI, shared memory threads, and CUDA/OpenCL, as well as hybrid codes using more than one API. Efficient test generation in these domains as well as coverage enhancing analysis methods are of interest. The Center for Parallel Computing at Utah (http://www.parallel.utah.edu) provides ample opportunities for collaboration including new faculty hire in formal analysis of concurrency.

My interests span programming languages, runtime systems, and operating systems, with a particular focus on systems that transparently improve reliability, security, and performance.

* Reliability and Security

I am interested in systems that transparently improve the reliability and security of deployed systems. Examples of this work include systems that can survive bugs, or even repair themselves by fixing bugs automatically. One of these projects, DieHard, was the direct inspiration for Windows 7′s Fault-Tolerant Heap. Other related projects include Exterminator, Archipelago, and DieHarder. Ongoing work includes systems to protect applications from security attacks with low overhead, and high-performance information flow tracking (“tainting”) to track / prevent information leakage.

* Concurrency

I am interested in systems that improve the performance or correctness of concurrent applications running on multi-CPU / multicore computers. Examples of this work include Hoard, a scalable memory manager that is in use in a number of large commercial settings (e.g., British Telecom, Credit Suisse, Royal Bank of Canada, Cisco…), and Grace, a system that automatically eliminates concurrency errors like race conditions and deadlocks.

The following are my current projects:
1. Formal verification of embedded firmware (NSF funded)
2. Formal foundations of execution models for exascale computing (DARPA funded)
3. Analytics and activity-based intelligence (DARPA funded)
4. New paradigms in machine learning and complex event processing with applications to oil industry and agriculture (funded by BP and the State of Louisiana)

Recently completed projects:
1. Program synthesis and service-based systems (ONR and NRL funded)
2. Reliable middleware (NRL funded)

My main research interests are in the areas of
- High-performance processors
- Memory hierarchy, prefetching, cache coherence
- Multi-cores and multiprocessors
- Power and temperature management
- Compiler and architecture co-design

I am working at the interface of control engineering and computer systems. Within control engineering, I work on modeling, control, and diagnosis of discrete event systems, a class of dynamic systems with discrete state spaces and event-driven dynamics. Finite-state automata and Petri nets are two popular modeling formalisms used in discrete event systems. My interests overlap with the emerging area of Cyber-Physical Systems (CPS).

Recently, we have applied discrete control techniques to address the problem of deadlock avoidance in concurrent software. Specifically, we model multithreaded C programs using Petri nets and then synthesize control logic that is used to instrument the program; the instrumented program is guaranteed to be deadlock-free. We also have a project on synthesis of safe control strategies for collision avoidance in intelligent transportation systems. Please consult the “Research” section of my website for further details.

I am interested in exploring applications of discrete control theory to computer systems, including but not restricted to concurrent software and security, as well as control problems in CPS, with a post-doctoral researcher.

My current research interests are in incremental analysis and modular analysis for concurrent programs.

In Incremental analysis the differences between closely related program (system) versions serve as the basis for reducing the cost of checking functional correctness and achieving desired coverage of the program. Analyses based on program differences are attractive and have considerable potential benefits since most systems are developed follow an evolutionary process. Functional requirements of a system evolve and change over time. The program sources are changed to match the change in the functional elements. The program is also changed when a fault (bug) is detected and fixed in the program. The challenge with effectively using incremental analysis, however, lies in determining precisely which program execution behaviors are affected by the program changes. We are looking at using data and control flow analysis to conservatively estimate the impact of the change and use symbolic execution to precisely generate program behaviors “affected” by the change.

information integration, query-evaluation algorithms, temporal reasoning,
automata-theoretic algorithms, firmware validation, protocol synthesis, constraint satisfaction, discrete techniques in robotic motion planning

My research focuses on the interaction between the architecture and software of computer systems and underlying hardware implementation challenges. These challenges include power, reliability, and variability issues across embedded and high-performance computing systems. A basic tenet of my research is that architecture design must be cognizant of these implementation issues, and that multi-layer solutions spanning circuits, architecture, and software can provide significant advantages.

The primary focus of my research is the computer-aided verification and validation of computer systems, including concurrent and distributed systems; security, network and wireless protocols; software systems; biological systems; and safety-critical and embedded systems. Current research projects include the use of Hybrid Automata to Model and Analyze Cardiac-Cell Networks; a Process Algebra for Mobile Ad Hoc Network Protocols; Probabilistic Model Checking of Security Protocols; and Runtime Monitoring of Software Systems with Controllable Overhead.

It is now widely recognized that current commercial many-core systems are simply not good enough: most programmers can’t handle them. Therefore, alternatives must be developed. Anticipating this problem over a decade ago, the Explicit Multi-Threading (XMT) framework has been under development at the University of Maryland. XMT is a general-purpose many-core computing platform with the vision of a 1000-core chip that is easy to program but does not compromise on performance.

XMT is built to support the PRAM theory of parallel algorithm, which is second in its wealth only to the serial algorithms. Since four decades of parallel computing research provided no real alternative to the PRAM, the XMT project sought to draft specifications for the general-purpose many-core desktop of the future, by first inventing hardware and software support for the abstractions developed by PRAM algorithmics — a task deemed impossible by architecture researchers prior to the accomplishments of the XMT project.

A 2010 status report of XMT appears in U. Vishkin, Using simple abstraction for reinventing computing for parallelism, CACM, January 2011. Order of magnitude speedups, dramatic advantages on teachability from middle school to graduate courses have been demonstrated. And favorable student ranking for achieving speedups relative to standard platforms have been demonstrated.

So far, XMT has spanned applications, parallel algorithms, compilers, HW/SW and education of parallelism. Research opportunities building on this promising foundation include now also CS education, bioinformatics, machine learning and other applications, security, OS, and SW architectures.

There is so much more to the potential of many-core parallel computing than the horizons of commercial hardware offer!

I direct the UCSD Center for Dark Silicon, which is dedicated to maximizing the amount of computation we can get out of a single square centimeter of silicon. Dark Silicon refers to factors that prevent us from using this resource at its full potential. There are three causes to dark silicon: a) power limitations because of poor CMOS scaling, b) overly large software engineering costs for parallelizing programs for multicore chips, and c) lack of parallel application domains.

My research attacks each of these problems by 1) reinventing processor design to make use of dark silicon, 2) utilizing existing cores better through better parallel software engineering tools and 3) finding new parallel application classes to put cores to work.

I co-direct the GreenDroid Mobile Applications Processor pojects, which employs Conservation Cores, automatically-generated energy saving coprocessors to fight dark silicon and is part of the Arsenal Project. It has been featured in MIT Technology Review, EE Times, and slashdot.org.

I direct the Kremlin project, which has developed a tool that, given a serial program, tells you which regions to parallelize. It’s like gprof, but for parallelization. It uses a novel dynamic analysis called hierarchical critical path analysis. It’s appeared in PLDI, PPoPP and HOTPAR. We have some more novel extensions for GPUs that we are working on.

I also direct the effort that developed the San Diego Vision Benchmark suite, and an effort to adapt manycore processors for Cloud computing.

Please see my web page cited above.

My group focuses on verification of embedded and cyber-physical systems, studying the question “how can we build computerized controllers for physical systems that are guaranteed to meet their design goals?” These questions are of crucial importance in many areas, including automotive, aeronautics, railway, mobile robotics, factory automation, and medical devices. After all, our society cannot afford to have these systems malfunction. In our research, we have developed powerful logic-based verification techniques that help producing reliable complex systems, e.g., in aeronautical, railway, and automotive applications. We have developed KeYmaera, the first theorem prover for hybrid systems. We also developed the first verification technique for distributed hybrid systems, which combine the challenges of hybrid systems with those of distributed systems. We have further developed the first logic and compositional verification technique for stochastic hybrid systems. My grou p also works on statistical model checking techniques. There are plenty of exciting challenges ahead in these and related directions of research.

Real-time software, specifically: embedded software, cyber-physical systems, models of computation, code generation and optimization, domain-specific languages, architectures for real-time computing, and schedulability analysis.

Formal methods in general and software security in particular, including: ad hoc network and mobile application security; fine-grained confidentiality/integrity policies integrated with access control; program analysis, verification, and transformation; correctness by construction, refinement and refactoring; methodology for formal specification of system components.

Several ongoing projects on programming language designs for improving modularity, concurrency, and verifiability that range from language theory to rigorous empirical evaluation of programming language designs to code generation and optimization to program verification. A broad range of expertise is available in our research group in both programming languages/compilers/virtual machines and in software engineering.

We have broad interests in the general area of programming languages and compilers, formal methods, language-based security, program verification, operating system verification, proof assistants, automated theorem proving, and software engineering. Members of our research group are working on building certified OS kernels and compilers, developing new programming languages for writing certified programs, and designing new program logics for reasoning about general safety, liveness, and information flow properties.

design, implementation, and evaluation of advanced transactional programming features from hardware through language and benchmarks; automatic generation of compiler back-ends from machine and IR descriptions; automatic generation of corresponding efficient cycle-accurate simulators; proving properties of data abstractions as related to transactional programming; the chaotic nature of computer systems performance and application of chaos theory; machine learning in systems problems, particularly in compilers and virtual machines; virtual machines / managed run-time systems for parallel languages on many-core platforms

My research interests lie in two primary areas: design of high performance, but energy efficient computer systems and compilation for heterogeneous multicore systems. Traditionally, high performance and energy efficiency have been competing goals and designers have to select one of these objectives. The CCCP group focuses on achieving both by improving the fundamental efficiency of computation through customization of hardware to the target application domain and the use of flexible accelerators to accelerate small portions of accelerators. Under investigation are low-power graphics processing units, flexible single instruction multiple data accelerators, and compute engines for control-intensive code.

The second area of focus is compilers for heterogeneous multicore systems. We are currently focusing on the streaming model and an implicitly streaming model that extracts stream program behavior from C/C++ code. The compiler automatically customizes the streaming computation for graphics processing units, SIMD accelerators, and multicore systems. Compiler-generated CUDA from a streaming specification is machine independent and can outperform hand optimized CUDA on many applications.

GUI for molecular modeling software and highly parallel computation with GPUs for materials modeling

Several interesting and ongoing projects ranging from programming language theory to computer architecture, mostly aimed at making multicore programming easier and better defined. Also interested in doing more work on better support for web applications, particularly on the client side (within the browser).

My research interests are languages and systems. Lately, I have been focusing on stream processing and on programming tools that compose different languages (such as Java and C).

My key research interests are: making it simpler to write, debug and deploy parallel programs to address the concurrency challenge; develop energy-aware programming models; exploring systems software for non-volatile main memory. Sample research projects include making multiprocessor systems deterministic, dynamic concurrency bug avoidance, debugging, concurrency exceptions for failstop behavior of race condition, energy-aware programming models, etc.

Seeking postdoc for computer security research. Research webpage at http://security.ece.cmu.edu, professional webpage at http://www.ece.cmu.edu/~dbrumley

My research focuses on problems in programming languages, data management, and security. Some specific topics of interest include semantics, type systems, bidirectional languages, provenance, data synchronization, and mechanized proof. Most recently, I have been working on a domain-specific network programming language.

My current research focuses on exploring the concept of “behavioral coverage”. The idea is that your favorite verification and validation technique, whether it is testing, static analysis, symbolic execution or some variant or combination of those, produces information about how a program’s behavior conforms, or fails to conform, to expectations. We are interested in developing methods that allow such techniques to “characterize” the portion of a program’s behavior that has been shown to conform to expectations. Moreover, we seek to encode those characterizations in a form that allows the combination of information from a variety of techniques. The resulting combined characterization can be used to target additional V&V or provide developers with a semantic basis for having confidence in system correctness. This project offers an excellent opportunity to collaborate with experts in testing, static analysis, verification, and runtime monitoring and move towards a vision of V&V that breaks out of the silos of individual techniques to provide a holistic characterization of behavioral coverage.

My group works to improve the reliability of software systems, especially embedded systems, using techniques such as random testing, theorem proving, and model checking.

Because of the inherently dynamic personality of next-generation multicore, manycore, and cloud platforms, new techniques to specify, test, exercise, and implement robust software systems on these platforms are required. The central issues here concern scalability and safety: how do we specify, optimize,verify, and implement software systems that adapt seamlessly, efficiently, and safely to changes in the underlying platform? We envision programming models that emphasize concurrency and distribution over localization, and decouple the question of how to structure a highly-parallel or distributed computation from the question of how the resources required to execute it are acquired and managed.

In this context, my research interests explore high-level concurrency and distribution abstractions (including formal semantics, specification, and verification), their implementation (including static and dynamic analysis, and associated runtime support), and low-level abstractions such as weak-memory consistency and associated compilation techniques.

There are many outstanding challenges that must be overcome in this general space. Of these numerous challenges, my research focuses specifically on programming languages, software models, abstractions, and implementation
techniques for these environments. Since an application’s activity may be highly concurrent and possibly distributed, and thus less easily monitored or controlled, new software models comprising programming language design, compiler and runtime implementation, and lower-level architecture-specific protocols are required to ensure robustness, safety, and efficiency.

A central question underlying much of my research is how we can craf robust software systems in the presence of unreliablity, injected from both the underlying architecture and the application itself, without comprising efficiency and scalability.

Thus, effectively dealing with future computing environments requires a symbiotic treatment of software design ranging from language definition and semantics, to software engineering principles related to testing and protocol definition and inference, to compiler and runtime implementation, down to architecture-specific models such as weak-memory consistency. Each of these components contribute
to the realization of a software architecture focused on supporting scalable, robust, and long-lived applications. My research addresses these issues along the dimensions outlined, with specific interests biased towards principled language and system design, and implementation.

In the past I have focused on high performance computers. I and my colleagues developed some of the first prototype computers that exceeded 200 MHz. However, in the past decade I have focussed on various aspects of low power computing. My research group developed the “Intelligent Energy Management” system used in many ARM cores. I was a co-inventor on the original razor patents, a circuit technology that is being deployed in many next generation low power cores to combat the growing effects of variation that occurs in smaller technology nodes. My research group has developed a series of ultra-low power signal processors targeted at mobile wireless baseband processing. They evolved into a commercial prototype developed by ARM, which led to a commercial spinoff, Cognovo. They will commercialize the processor and provide wireless software stack.
My group were among the first to propose replacing DRAM with non-volatile memory to reduce memory power, cost and footprint. His group has also been active in exploring new server architectures that combine “near threshold” technology and 3D chip stacking to drastically reduce system power consumption. They recently complete the tape-out of a 128-core multiprocessor that integrated the cores, caches and DRAM into a single 3D stack. The fabrication run was funded by a DARPA grant.
Finally, my group is exploring ways to build low power compact interconnect fabrics. We recently completed a compact 128 x 128 crossbar architecture that can sustain a bi-section bandwidth of about 1.3 terabits / second while consuming less than 130 mW.

My chief research focus is programmer productivity. I develop theoretical and practical techniques and tools for helping people to create, understand, and modify software systems; I perform significant experiments at scale; and I distribute tools to programmers and researchers. My research spans software engineering, programming language design, type theory, static and dynamic program analysis, testing, security, and development environments. My results often stem from cross-fertilization between traditionally separate research areas: experimental vs. theoretical, syntactic vs. semantic, static vs. dynamic, exact vs. inferred, proven vs. statistically likely. Overall, I am to make it easier — and more fun — for programmers to build robust, reliable, secure, and correct software.

I briefly mention several current research thrusts. More details are available at my webpage, http://www.cs.washington.edu/homes/mernst/.

Programming language design and type systems: My research focuses on bringing new capabilities to real languages in a backward-compatible way (which is critical for evaluation and adoption), and building implementations to assess their utility. This pragmatic approach promises to aid both today’s and tomorrow’s programmers, and makes results more likely to have practical impact. The work includes type systems, type inference, and frameworks.

Security: My research addresses three distinct practical problems: measuring unintended disclosure of private data, creating exploits for unknown security vulnerabilities, and fixing bugs that underlie zero-day exploits.

Debugging: Dynamic analysis is complementary to static analysis: although dynamic analysis is often unsound, it can also be more precise, scalable, and applicable to legacy programs. My work applies dynamic analysis, with good effect, to problems that in the past have only been addressed statically, such as type inference and refactoring. It is also useful for reproducing crashes and for reducing false positives in bug-finding tools.

Testing: A common theme in my research is exploiting impoverished test suites. Users seem willing to write small test suites or to supply a few sample executions, but they are reluctant or unable to write more comprehensive or more focused test suites. My research automates these and other testing tasks. The research spans test generation, test selection, test classification, and test execution.

My group’s research is aimed at various aspects of parallel computing, with a major goal of improving programmer productivity while retaining high efficiency and scalability. We aim at both high-end clusters and supercomputers, as well as parallel desktops, although our research in recent years has focused on large-scale supercomputers. We also make a point of working in collaborations with real science/engineering applications, with the belief that that is the only way of arriving at abstractions and technical ideas that will have a long-lasting impact on the state of the art. NAMD, a widely used parallel program for iomolecular simulations, is one of our early successes; it was developed in collaboration with Prof Klaus Schulten’s biophysics group at Illinois. (Recent applications include OpenAtom for nanotechnology/materials, and ChaNGa for astronomy. A major focus, and foundational theme, in our work is adaptive runtime systems, which inspects the execution, and automates resource management, and tunes the execution by a variety of means. This has been embodied in Charm++ parallel programming system. More recent efforts have aimed at higher level languages, with the idea that “incomplete” but elegant languages can combine together to form an effective toolbox for parallel programming.

We are part of the team that is working towards making the Blue Waters multi-petaFLOP/s system at UIUC (which will have 300,000+ cores) productive. Please visit the group website for additional information.

The polyhedral model is a formalism for reasoning about compute-and data-intensive kernels that take up a huge part of most programs. Such computations arise in many applications in signal and image processing, scientific and engineering simulations, dense linear algebra, bio-informatics, numerical analysis, etc. In fact, most of four of the Berkeley “dwarfs” or motifs can be described very succinctly in the polyhedral model.

In the new era of multi- and many-core, programmer productivity is just as critical as performance (if not more so). The polyhedral model provides a framework for both, optimally compiling high-level equational programs to parallel architectures, and also improving programmer productivity.

I am seeking a postdoctoral researcher to work in this broad area. The specific topic can be determined based on mutual interest, and may range from low level (e.g., FPGA platforms) through discrete nonlinear optimization, program transformation systems to semantics of equational programs.

Cloud Resource Management and Virtualization; P2P and Peer-Assisted Content Distribution; Economics-Inspired and Game-Theoretic Approaches to Resource Management in Distributed Systems and Networks; Formal Specification and Verification of Cyber-Physical Systems; Compile-Time and Run-Time Support for Embedded Real-Time Systems.

I am broadly interested in formal, automated methods for program verification and synthesis, in particular abstract interpretation and model checking. I am also broadly interested in languages, models, and systems for parallel programming.

I am seeking a postdoctoral researcher to work with me on Cauchy, a long-term project aiming to build an “analytical calculus of computation”: a system of mechanized reasoning that can verify whether a program satisfies “analytic” properties like continuity and smoothness, and compute derivatives, discontinuities, limits, and other analytic attributes of programs. The practical motivation of the project is to develop a new class of program analyses for an era where computing is intertwined with sensor-derived perceptions of the physical world, and correctness is a continuum rather than a boolean fact. For example, we may now require that the program be “robust” to small amounts of uncertainty in its inputs—i.e., that small perturbations to an input state only lead to small changes to the output state. A way to formalize this statement would be to define a metric space over the states of the program, and ask that the program encode a continuous function over this space. Alternately, we may consider the Lipschitz constant of the program as a measure of its robustness. To tune program parameters, we may want to use classical root-finding techniques, which may only work on an analytic approximation of the program. To argue that a program converges, we may want to compute limits on its outputs as time elapses to infinity. Common to the above scenarios is the need for some form of analytic reasoning about programs.

The scope of Cauchy includes the theoretical foundations of such reasoning, ways to automate it using state-of-the-art constraint-solvers and numerical optimizers, and its applications in program verification, synthesis, optimization, and approximation. From evidence so far, Cauchy opens a new playground for research on reasoning about programs. It also raises the possibility of a fruitful union of program semantics and verification with control theory, numerical analysis, machine learning, and computer algebra.

- Scalable, QoS-aware, Energy-Efficient Multi-core Memory Systems
- Scalable, QoS-aware, and Energy-Efficient Interconnection Networks
- Asymmetric Multi-core Systems
- Enabling and Exploiting Emerging Memory Technologies
- Architectural Support for Safe Languages
- Architectural Support for Virtualization and Multi-Core Operating Systems
- Resource Management

Other projects are also possible. Feel free to contact me for more information.

My main research focus is on Software and Systems Security. It is driven by practical problems, and emphasizes building real systems. It draws on principles and techniques from programming languages and compilers, algorithms and operating systems to address problems such as:

* Binary analysis and instrumentation for security applications
* Principled and proactive defenses against malware and untrusted code
* Source-code analysis/transformation to mitigate software vulnerabilities (memory errors, SQL injection, XSS, …)
* Attack isolation and recovery; Self-healing systems
* High-performance intrusion detection (network and host-based)

Please visit Secure Systems Laboratory (http://seclab.cs.sunysb.edu/) for a detailed description.

Programming models, languages and compilers for efficient parallel execution.

My research interests center on tools and techniques for building, understanding, and ensuring reliable computational systems. Much of my work centers on finding novel ways of interacting with the programmer to design more precise and practical program analyses to produce more effective programming systems.

The Xisa project is an instance of this approach that infers precise properties of complex data structure manipulations. The novelty of Xisa is that it extracts both the necessary invariants and reasoning rules from executable assertions. This approach allows the developer to focus the analysis to the properties of interest and without using a separate formalism for testing and static analysis.

Another project called Mix looks at an incremental combination of analyses with different precision, such as type checking with symbolic execution. The observation is that with user interaction, an analysis need not prove all the desired properties at once.

Have you ever felt a compiler/analysis tool misunderstood what you meant in your program? The Gradual Programming project examines this disconnect between the intent of a software developer and the meaning of the program according to the language semantics. In the end, we envision a programming system where the developer and tools interact to agree upon the precise meaning of a program.

High-performance and energy-efficient cache designs for large-scale multicore architectures; architecture and runtime support for emerging memory technologies; architecture and runtime support for novel parallel programming models (deterministic parallelism, disciplined parallelism); architectural and runtime support, and programming models for variable-fidelity computing; cross-layer reliable systems, where the reliability goal is achieved through the cooperation of all the abstraction layers, from circuits to architecture to the operating system; programming models, runtime environments and memory hierarchy designs for heterogeneous multicores; programming models, and runtime and architecture support for energy-aware computing; impact of memristors on architecture, memory hierarchy and systems software; novel database management systems for emerging multicore architectures and memory technologies

1. Designing efficient algorithms for networking, security, and database applications. My current focus is on efficient packet processing algorithms used on core Internet devices such as routers and IDS/IPSes.

2. Designing efficient privacy preserving protocols for practical problems. My current focus is on privacy and integrity preserving queries.

More information is on my homepage http://www.cse.msu.edu/~alexliu/

My interests are in model checking programs, probabilistic systems, and hybrid systems. I am also interested in the core areas of logic and automata theory.

My group works on modelling molecular systems that process information
through sensing, computing, and motion; our focus has been on
catalytic DNA systems, such as logic gates, circuits, and nanorobots.
We are interested in both formal and quantitative models. We
collaborate with experimentalists at UNM and other institutions. We
are also interested in programming languages (design and
implementation, molecular or not, especially of functional languages),
algebraic aspects of fluid mixing, and sensor array data analysis.

I have two main projects going on: (1) Sourcerer, and infrastructure for collecting, indexing and analyzing large amounts of open source code with the goals of gaining empirical insights into how people write programs and developing innovative software engineering tools that leverage this large amount of existing code; (2) OpenSim, an open source platform for massive multiuser online virtual environments designed to be the next generation 3D web. I am interested in mentoring CI Fellows for work of mutual interest in any of these projects. The first is at the border of information retrieval and software engineering; the second is primarily middleware for interoperability in the 3D web.

The goal of my research is to find ways to help programmers create correct, reliable, and secure software. To address these issues, I work on methods to manipulate programs and analyze their properties. Often these have taken the form of frameworks that apply to general classes of problems.

Much of my current focus is on methods to analyze machine code (a.k.a. “binaries” or “stripped executables”), but I am also interested in other challenging program-analysis problems, such as analysis of concurrent programs and programs that use linked data structures.

Static analysis of complex software systems, with the goal of optimizing, securing and parallelizing such systems.

Right now, my group is working on a range of projects, including accelerating classical static analysis with GPUs, automatic parallelization of functional programs, deep shape analysis of object-oriented programs and software understanding tools for legacy code.

We’re also making foundational thrusts aimed at improving the speed and precision of static analyzers in general.

I’d be happy to mentor CIFellows with interests in or a near any of these topics. Please contact if interested!

Bioinformatics: Ontologies and Protein Structure Prediction
Assistive Technologies: non-visual access to the web and to complex data
Declarative Languages: logic programming and constraint programming
Parallel Processing: parallel execution of search problems
Knowledge Representation: planning, action languages, multi-agent systems

My interests span most of “systems”, broadly construed, with a unifying theme of parallelism and concurrency. With the rise of multicore processors, this theme has become central to nearly every aspect of system design. Building on past work in synchronization and microarchitecture, the group here at Rochester has played a leading role in the development of transactional memory. We’re also working on concurrent programming models and language design (for both mainstream and scripting languages), heterogeneous and multicore architecture, and distributed systems with multicore nodes. As the author of a major programming languages text, I’m also deeply interested in how to integrate concurrency into the undergraduate curriculum.

Current research topics include: compilation using many-core CPUs (including GPUs), high-ILP microarchitectures, parallel libraries for biomedical imaging, hardware/software reliability, virtualization performance, architectural features for security, and intrusion detection and taint analysis.

My group is interested in how to program the behavior of information-based molecular systems. We focus on theory and lab experiments involving synthetic DNA devices that self-assemble, compute, and move. We are interested in models of computation appropriate for molecular systems; molecular programs for tasks such as how to grow a complex molecular structure or how to detect a complex molecular environment; compilers for automatically producing low-level specifications (such as DNA sequences) from high level descriptions of the desired system behavior; and theoretical analysis of resource complexity and fault-tolerance in molecular programs.

My current research interests are in two broad areas: the automatic analysis of software (either static or dynamic) for verification or bug finding, and in programming highly parallel machines, in particular programming heterogeneous machines with complex memory hierarchies.

Olin provides a unique opportunity to explore contextualized computing/engineering education with a strong design component. My research interests are broad within AI (most recently semantic web/web 2.0 but also including cognitive robotics, HCI, knowledge representation and reasoning, programming languages). I spent ten years on the faculty at MIT before leaving to help found Olin; I would like to share what I’ve learned in both of these contexts. A CI Fellow working with me would have the opportunity to pursue both a research agenda and explorations into curricular/pedagogic innovations, working in a close-knit and collegial community with regular conversation about learning, contextualization, usability. Current and new projects focus on the role of sketching/drawing, mobile devices/social networks, support for aging and/or cognitively challenged populations, and computational thinking/small footprint curricula; collaborations through Olin’s new Initiative for Innovation in Engineering Education would also be encouraged.

High performance computing, MPI, generic programming, C++, scientific computing, numerical analysis, parallel programming, large-scale systems, computational photography

My research interests include automatic performance analysis, which includes identification and tuning of performance bottleneck. My current focus is on developing analysis and tooling for Java enterprise applications running on multi-core systems.

The most pressing and urgent problem in software development is the creation of software on which we can rely to perform as intended. Given how ubiquitous software is in every field of human endeavor, this is one of the most important problems facing mankind. My research focuses on the development of software systems for distributed and high assurance applications. Part of this work relates to the formal specification of software properties. Formal specifications can be used by a variety of software tools for creating and verifying software. These tools include model checkers, theorem provers, runtime monitors, and program synthesis systems. Formal specifications can be used to identify conflicting requirements, manage change in requirements (pre- and post-deployment), and detect errors during software execution.

I am engaged in the application of software engineering technology to real world problems, namely the development of application software for use by scientists and engineers. The goals of the development of this set of applications are two-fold: first, it is my intent to provide software support to important research, research that might not be possible without the availability of reliable, trustworthy software. As such, much of the work is multidisciplinary. Second, the development of production software provides numerous examples against which to test the cost-effectiveness of industrial software engineering approaches. Ideas on improving the reliability and reducing the cost of software abound; however, few are used in practice, in part because their efficacy remains undemonstrated. By applying techniques and practices to real-world software projects, we are testing the applicability and cost-effectiveness of these techniques and training a cohort of software engineers who can make reasoned decisions about these techniques in industrial practice.

Most prominent of this work is the development of the software currently in use by the space scientists in the analysis of data from the NASA Cassini mission to Saturn. Software developed for this mission aids in mission planning and rapid opportunity analysis as well as image analysis from the ISS, CIRS, and VIMS instruments on Cassini. The research group has investigated and developed a number of software refactorings that are used to migrate procedural IDL code to object-oriented IDL code.

Other applications under development include the PROSPEC property specification tool, which guides domain experts in the development of formal specifications for use by formal software analysis tools. Aligned with this is the development of a framework for model-checker based testing of formal specifications and the development of mechanisms for the generation of specifications in LTL. The PROSPEC work includes porting the software to the Eclipse platform and providing visual feedback for validation of the resulting specifications.

In the fall of 2008, I began working with Craig Tweedie of the Systems Ecology Laboratory in the Department of Biology at UTEP. This work will result in a system that allows climate researchers to access data from a network of sensors. A novel part of this system is the automated data quality flagging that identifies anomalous data on upload

My work at Google focuses on improving the programmability and performance of web applications delivered over the internet. Recent years have seen an explosion in size and scope of web applications to the extent that they are now straining the capabilities of today’s web execution frameworks. I am investigating the evolution of these frameworks to better handle greater client-side compute requirements, scalability, programmability, and security.

I seek to develop programming systems, i.e., languages, libraries, compilers, and development tools and environments, that are (a) natural and easy to use, (b) efficient to run (particularly over very large data and many machines), and (c) actually used in practice by real developers getting real work done. Some of my recent work at Google includes libraries and run-time systems supporting easy yet efficient massively data-parallel pipeline computations, and data synchronization infrastructure for easier development and deployment of web-based applications.

I am interested in innovative research which spans compiler/architecture boundary
particularly alternative forms of parallelism, including memory-level and instruction level parallelism. Current research projects include a new program representation which permits unrestricted code motion, compiler algorithms for optimizations on this representation as well as new micro-architecture designs capable of directly executing this representation. The representation has its roots in data-flow, demand driven and instruction-level parallelism. I am also interested in domain specif?c languages particularly automatic generation of micro-architecture simulators.

The focus of our research consists of the development of locality analysis for single- and multi-threaded applications to enable the prediction of the resource requirements of those applications. Our research will apply new memory locality models to manage the cache and bandwidth requirements for single–threaded applications, and to manage remote memory access caching in addition to on-chip cache requirements for multi-threaded applications. Specifically, our research will examine locality models for predicting the memory behavior of single-threaded scientific applications and multi-threaded Partitioned Global Address Space (PGAS) applications written in Unified Parallel C (UPC).

The investigation of an open source distributed cloud computing platform (AppScale) and its support infrastructure to identify new techniques that make it easier for a broad population of users to design, develop, debug, and deploy creative and scalable applications on remote resources.

Please see my home page and publications.

My current research interests include:
* Software model checking: Using symbolic or explicit state model checking techniques to verify (or falsify) software systems.
* String analysis: Automata-based symbolic analysis for detecting and preventing vulnerabilities that relate to string manipulation.
* Analysis and verification of web software: Application of automated verification techniques to interactive web applications and web services.
* Design for verification: Investigating new ways of constructing software to facilitate effective automated verification.

Analyzing Web software:

Our team works on a project called BEAM for static analysis of software. It is centered around compiler emulation, data-flow analysis, theorem proving, pointer analysis, inter-procedural analysis. Today the tool is used inside IBM for defect detection.
In the immediate future we would like to push more into parallelization issues, security, specification mining and taking advantage of dynamic analysis.
In the distant future I am also interested in the general issues of software robustness and usability.

I use
* modal logics, which model knowledge and quotation,
* delimited continuations, which liberate control flow, and
* polymorphic type systems, which propagate static assurances,
to
* unify linguistic side effects,
* support natural metaprogramming, and
* build theories of mind with bounded rationality.

My current research interests are in developing domain specific programming models for multicore in Recognition, Analysis and Reasoning (RAR) application domain. I am also interested in optimizing performance of data access in parallel computing and multicore processing.

I am currently coordinating research program to explore the opportunities of benefiting from a structured Network on chip organization in NEC chip architectures. My main research interests include the development of methodologies and tools for electronic system level design. I focus, in particular, on design and synthesis of reusable platforms, networks on chip and hardware/software integration challenges.

Programming Models and Productivity, Hardware Accelerators, and Manycore Processors.

PROJECT 1 is developing tooling and analysis techniques to enable
performance optimization in support of large commercial workloads in
the massive multicore era in which systems have hundreds or thousands
of processor cores. PROJECT 1 involves working with large-scale,
commercial applications with an eye towards dramatic improvements in
the performance of critical enterprise software deployments. This
project would benefit from postdocs whose research focuses on such
issues and who have experience with deployment and performance
analysis of multi-tier web applications, and more particularly
experience with Java programming, scripting (Javascript, Awk, Perl),
Java EE, database setup and tuning.

PROJECT 2 also focuses on future system architectures with large
numbers of multicore processors, but with a particular focus on how
such systems incorporate solid state disk / memory. PROJECT 2 is
analyzing how software can best take advantage of SSD and multicore
advances and what algorithms and architectures are best suited to
these systems — with approaches again focused on critical enterprise
workloads. This project would benefit from postdocs whose research
focuses on such issues and who have experience in storage systems and
disk modeling and with good knowledge of system benchmarking,
performance modelling, flash memory design, and interfaces such as
Sata and PCIe.

Currently, my main focus is on realizing Claytronics, a form of
programmable matter. Programmable matter is an ensemble of computing
elements which can be programmed to work together to produce changes
in the physical properties of the ensemble. I am interested in
post-doctoral fellows who have broad interests. Particular projects
in the upcoming year: (1) realizing claytronics hardware (cm-scale
modular robots, mm-scale MEMS based robots, and bio-based units), (2)
Programming massively distributed systems (programmable matter, sensor
networks, etc.) using declarative approaches, (3) Ensemble based
applications (E.g., distributed planning, dynamic motion, etc.)

broadly interested in programming languages, software engineering, and computer security, with a particular focus on techniques and tools for improving software reliability & security, and programmer productivity.

My research focuses on using 3D stacking to improve reliability in high performance processors. My research group also works on data center efficiency improvement issues primarily from the ICT infrastructure view point. I also work on energy efficient sensor management for body area networks for continuous and real time health monitoring.

Prior to my teaching career, I worked in industrial research labs for 6 years; first at the Intel Microprocessor Research Labs as a senior researcher for five years and then at the Nokia Research Center Palo Alto as a visiting research faculty for eight months. At Nokia my research focused on mobile platform services. At Intel my research focused on computer systems architecture spanning the entire computer system design space; from new silicon technologies at that hardware level to systems software analysis of server workloads.

The FASTlab (Fundamental Algorithmic and Statistical Tools Laboratory), consisting of 19 people including 11 PhD students, works on the problem of how to perform machine learning/data mining/statistics on massive datasets, and related problems in scientific computing and applied mathematics. We employ a multi-disciplinary array of techniques from machine learning, nonparametric statistics, convex optimization, linear algebra, discrete algorithms and data structures, computational geometry, computational physics, Monte Carlo methods, distributed/cloud computing, data visualization, programming language theory, and automated theorem proving. We have developed the current fastest algorithms for several of the most fundamental machine learning methods. We also develop new machine learning methods for difficult aspects of real-world data. Our work has enabled high-profile scientific results which have been featured in Science and Nature. We strive for first-of-a-kind analyses of massive datasets from domains such as cosmology, cancer diagnosis, spam blacklisting, and retail transactions.

Our main interests are in the formal specification, verification, and certification of software-based systems using static and dynamic analysis, model checking, and deductive methods. Our group has developed verification and reasoning systems such as PVS, SAL, Yices, and PCE (Probabilistic Consistency Engine). We have applied these systems to a number of sequential and distributed algorithms. We are also active participants in the Verified Software Initiative and the related VSTTE conference.

I’m interested in a broad array of topics related to programming languages, particularly functional
languages: their design, analysis and implementation. A few more specific topics would be garbage
collection, parallelism, and domain-specific languages. See my web-page for more details.

My primary research interest is in extensible programming languages and
environments, especially as realized through Scheme macros, and especially
as implemented and put to work in PLT Scheme. Current projects in my group
include generalizing DrScheme to more easily and automatically adapt to
different (i.e., non-S-expression) syntaxes, fitting an extensible type system
into the framework of macros, and developing a model of macro expansion
that retains the expressiveness of PLT Scheme while being easier to understand
and implement.

My research takes a broad approach to increasing programmer productivity by improving system performance, correctness, and ease of programming. This approach is not constrained by system boundaries, as I have done work in languages, compilers, and micro-architecture. In particular, I have designed new languages, introduced the notion of library-level analysis and optimization, invented new pointer analysis algorithms, and developed new micro-architectural techniques for improving branch prediction and memory system performance.

Jaakko Järvi is an assistant professor in the department of Computer Science and Engineering, and belongs to the Parasol lab (parasol.cs.tamu.edu). His current research interests includes a generic and declarative approach for programming user interfaces, with a goal of obsoleting most of the event handling code that is necessary and abundant in todays GUI frameworks. Besides user interfaces, he investigates how the approach extends to software construction in general.

My research interests are in various aspects of multithreaded shared memory programming including transactional memory. I am working on making shared memory programming simple while preserving functionality and performance. I am particularly interested in the semantics of atomic sections and their transactional implementations that improve runtime performance. To this end, I am examining interfaces that should be exposed to the user as well as tight coupling between the compiler, the runtime, and other development tools.

My goal is to simplify shared memory parallel programming, both by clarifying the basic rules governing programming with threads, and by improving the underlying facilities available to programmers. I recently led an effort to properly define shared memory semantics (i.e. define a concurrency memory model) for the C++0x draft standard. I’m trying to leverage that, and the related Java work that mostly preceded it, to address related but less well understood problems. These include issues related to the semantics for transactional memory, and simpler semantics for Java-like languages that currently attempt to give meaning to data races, but only with limited success. In the latter context, I have also recently become very interested in fast reliable data race detection, and variants of that problem.

Although a lot of my interest here is in getting the semantics right, the research questions tend to be closely tied to tricky implementation issues.

Real-world use of multi-core systems requires the development of distributed programming methods for inter-core communication. This fact is evidenced by the formation of the Multi-core association (MCA) and the development of the Multi-core Communications API (MCAPI, http://www.multicore-association.org) supported by more than 20 industrial member companies. MCAPI targets the transport layers within future multi-core SOC systems and is hoped to become the industry standard. Like the message passing interface (MPI) API for cluster computers, MCAPI is inherently complex leaving it vulnerable to ambiguity in specification, implementation, and slow adoption. To address these concerns, ensure the absence of nasty bugs, and guarantee conformance to product specifications and user expectations, we propose to employ formal specifications to characterize MCAPI; formal analysis methods to ensure that MCAPI applications are bug-free and conform to specifications; and field validation of our ideas with the help of Industrial Mentors who have expressed willingness to provide us driving examples, monitor our progress, and give feedback. The work explores technologies to improve design quality in complex APIs, facilitate multiprocessor programmability in future SOC products, and provide design verification in both hardware and software layers. In the first year we shall acquire a thorough understanding of MCAPI and other APIs such as MRAPI for resource interactions. With this understanding, we will develop a formal specification for MCAPI that can help answer putative (“what if”) queries about various scenarios of using the API. Since the uniqueness of MCAPI lies in its use of light-weight message passing in addition to shared memory consistency, understanding the formal semantics of MCAPI is crucially important. We expect this specification to help us garner valuable high level properties about MCAPI that can serve as incisive default correctness properties to verify on application codes that use MCAPI. In conjunction with the development of the formal specification, we will work on a verified golden execution model that can be used by developers to begin testing programs. The golden execution model will also serve as a reference solution for other implementations. The second year of the project is to develop dynamic execution methods that can efficiently verify MCAPI application codes directly (without model building) and also significantly reduce the number of program schedules to be examined using new partial order reduction methods. The dynamic verification engine will critically rely on the golden execution model for a runtime environment, and the partial order reduction will critically rely on the formal MCAPI specification to understand dependency relations in the API. The work in the third year of the project will be to enhance a user given test harnesses for MCAPI applications through symbolic methods thus removing the need for a closed test environment. A significant challenge to overcome in doing this generalization is how to propagate information across the API calls.

My main research areas are concurrent system verification, security and logic programming. The long-term goal of my research is to simplify the construction of large, high-assurance– i.e., reliable, robust and secure– systems. In the near-term, my research is focused on assuring the security and correctness of safety-critical systems: network and operating system components, and database agents. I am currently developing techniques and tools for automated analysis and verification of concurrent, infinite-state systems. I am also interested in the synthesis of embedded systems (e.g. sensor networks) from high level specifications, and the analysis of such systems. I develop and use logic programming techniques to support this work. One instance of this is the recent work on incremental evaluation of logic programs, which has been used for implementing incremental program analyzers in general, and an incremental technique for constructing attack graphs for networks of computers from vulnerability information. My research is currently supported by several NSF grants and an ONR grant.

My research interests are in programming languages, compilers, tools, and applications. I currently focus on high-assurance systems software development under the umbrella of the PSU HASP project. I’m especially interested in formal verification of runtime system components.

My research interests include low-level compiler optimizations, tools for
supporting the development and maintenance of compilers, program
performance evaluation tools, predicting execution time, computer architecture
and embedded systems. Much of my recent research has involved compiler and
architectural support for low-power embedded processors. More information
about my background and research can be found on my home page,

http://www.cs.fsu.edu/~whalley.

Interests from web site:
* Language mechanisms for abstraction (program generators, DSLs, modules and components, extensible languages, meta-programming, multi-paradigm programming)
* Languages and tools for systems (programming models for concurrency, language support for distributed computing, memory management and program locality)
* Program analysis and testing (automatic test generation, invariant inference, symbolic execution, pointer analysis).

See URL for more.

My main research focus is on developing compiler algorithms, runtime systems, and tools that enable programmers to use a high-level programming style and modern languages, and yet still achieve high performance on modern architectures. I am particularly interested in effectively using processor memory hierarchies, and in memory management.

I am very interested in future architectures and their compilers that are a better match to current and future technology limits and constraints. Explicit Dataflow Graph Execution (EDGE) is the approach we are pursuing.

See my publications page for a sample of our recent results:

http://www.cs.utexas.edu/users/mckinley/papers.html

Dr. Kleanthis Psarris is working on program analysis and compiler optimization techniques for high performance computing. As part of the PLATO (Programming Language Analysis, Translation and Optimization) project we developed state of the art program analysis techniques and compiler tools to accurately and efficiently detect data dependences in sequential programs and increase program parallelization. The results of our research produced higher speedups and better program execution performance for several scientific applications executed on multiprocessors.

Professor Edwards and his group explore automating the creation of software for embedded systems: application-specific computers hiding in a growing number of industrial and consumer systems. They have developed numerous compilation techniques for the Esterel synchronous language for real-time control and are also developing domain-specific languages for device drivers and communication protocols.

NLP/ML/AI: My group develops principled approaches to MODELING, TRAINING, and SEARCH for AI problems. Most often we work in scenarios that involve structured inference for natural language processing problems (notably parsing, morphology, and machine translation). I am also starting to think about adapting successful techniques to problems in visual scene analysis, web mining, etc.

PL/ALGORITHMS: I know a lot of interesting tricks for the above that are applicable across problems. Among other things, I am working to generalize these tricks within the design of a new declarative programming language, so that they don’t have to be repeatedly reinvented or recoded. The language is a clean hybrid of logic programming with functional programming. This is an ambitious project with a lot of scope for a creative PL/compilers person.

SOME RECENT PREOCCUPATIONS: Generally speaking, there is a tension between expressivity and tractability. There’s an art to constructing elegant expressive models (e.g., non-parametric Bayes) that really capture our deep understanding of the domain (e.g., linguistics). On the other hand, these models are usually intractable. Lately I’ve been trying intractable models whose components are tractable in isolation; the idea is to use generic approximate inference algorithms as the “outer loop,” but have them call specialized combinatorial algorithms to deal with pieces of the problem efficiently and exactly. I’m also thinking about LEARNING approximate search strategies that seek a desired balance between speed and accuracy on a given workload.

MENTORSHIP: I love to work with smart students and postdocs, and spend most of my day in meetings (and most of my night writing technical emails). I’m well-connected in the NLP and ML communities, my interests are broad, and my students have done very well.

We are investigating how a broad range of algorithms and data
structures map to GPUs, including algorithms and data structures for
which mappings are not immediately clear, such as sparse matrices and
directed graphs. We pursue this work based on larger workloads
containing these algorithms, and with two additional goals: (1)
Identify changes to GPU architectures that may make them more amenable
wider classes of algorithms; and (2) Identify changes to existing GPU
languages that may permit more natural expression of certain
constructs while still permitting an efficient mapping of those
constructs to the underlying hardware. We have already obtained very
large factor speedups compared to existing approaches on medical
imaging applications.

I am a Research Staff Member and the Manager of the Data-Intensive Systems and Analytics Group at the IBM T. J. Watson Research Center. I am also the Manager of the InfoSphere Streams Language and Developer Tools Team, Information Management, IBM Software Group (SWG). The combined Research and SWG team currently engages in the product development of System S — a software platform for large-scale, distributed stream processing — focusing on the SPADE language and compiler, the SPADE IDE, the Admin/Config/Install tools, and the SPADE adapters and toolkits. In addition, we explore various research issues in data-intensive systems and analytics — including programming language and model for stream processing; advanced analytic algorithms for stream applications; job management and scheduling, resource management and system optimization for large-scale distributed systems.

Design, specification and verification of concurrent software systems. Specification-based testing and concurrency analysis. Leveraging synchronization contracts for D4V (design for verification).