The distributed and unreliable nature of wireless sensor networks, as well as severe resource, bandwidth and energy constraints on the sensor nodes, make constructing practical and reliable systems out of them, a significant challenge. My research centers around developing programming tools and techniques to simplify the process of building reliable and efficient applications for sensor networks, and analyzing their correctness.

Past Projects

I have been involved in the development of Pleiades, a high-level programming language for sensor networks. Pleiades promotes a centralized model of programming, pushing the non-functional high-level concerns of fault tolerance, reliability and energy efficiency, to the language compiler and runtime. This allows the programmer to focus on the global application functionality rather than the individual sensor nodes, simplifying her task.

I have also worked on designing tools to understand and analyze the correctness of applications written for sensor networks on programming platforms currently in popular use, like TinyOS and SOS, both at compile-time as well as at run-time.

The tool FSMGen that I developed, derives user-understandable state machines for TinyOS applications and system components, using various program analysis techniques. It helps the programmer understand and verify the functionality of her program statically, without it being executed, by generating state machines as high-level representations of components.

I have contributed to the development of Hermes, a software framework for interposition, which allows the programmers to inspect and control the functionality of their application at run-time by interposing its interactions with the rest of the system. This interposition is transparent to the program itself, and allows the programmer to observe, understand and verify the behavior of her application at run-time.

Current Research

Sensor network programs are complicated and prone to errors due to the programmer having to handle a number of concerns (like failure recovery, energy efficiency etc.)which do not directly affect functionality, within application code. I am currently working on an approach to programming sensor networks, which provides a complete separation of concerns, that is, various non-functional concerns are untangled from the application logic as well as from each other, while still allowing the programmer to retain control over their handling. Not only would this approach make sensor network programs easy to write and understand, it would enable code reuse across applications, and also expose trade-offs among concerns to make the programs more easily adaptable to varying environments and performance requirements.