·        Component-Based Software Development

·        COTS Software Incorporation

·        Incremental Transformation and Analysis

·        Model Consistency Checking and Fixing

·        Model Simulation and Execution

·        Model Traceability

·        Model Transformation

·        Product Families and Product Lines

·        Requirement Engineering

·        Refinement from Software Requirements to Architecture

·        Self-Aware, Self-Adaptive, and Self-Healing Software Systems

·        Architecture and Design Recovery (reverse engineering)

·        Software Architecture and UML

·        Software Engineering Education

My past research work has been diverse. I started off with the quantitative analysis of requirements negotiation dynamics in collaboration with Barry Boehm. There we analyzed the differences in requirements negotiations among 37 projects spanning two years of library application development. My Ph.D. thesis was a shift towards consistency checking among diagrammatic design notations such as the Unified Modeling Language (UML). I contributed a transformation-centric approach to consistency checking that bridged among the abstraction, generality, and behaviorism of the different diagrammatic languages. This work lead to interesting collaborations with Philippe Kruchten, Nenad Medvidovic and Cristina Gacek on class diagram simplification, architectural modeling, and component-based software development (systems-of-systems).

At Teknowledge Corporation, I co-developed an architectural style for self-healing systems with Dave Wile. This work resulted in an execution infrastructure for so-called self-healing, self-adaptive systems – systems that maintain a particular level of healthiness or quality of service (QoS).  This infrastructure was driven by a reflective model of the operation of a target system – whose health is to be maintained – to determine what aspects can be changed to effect repair. Around the same time, I developed an infrastructure for incorporating commercial-off the shelf software (COTS) into software systems. Reusing COTS software has become highly desirable as it can significantly reduce development cost and effort, while maintaining overall software product quality and increasing product acceptance. However, this activity brings with it a range of complexities we are currently ill equipped to handle. The framework we developed was integrated with three major modeling tools, including IBM Rational Rose, and was subsequently applied to a number of domains. One of the most interesting applications was its use in the embedded systems domain by Boeing Company. They wanted to use a standardized modeling tool to describe its Boldstroke avionics product-line model – an architectural model that integrates software and hardware components. We provided the infrastructure to capture this model, visualize it, and export it to analysis tools (e.g., timing analysis together with Raj Rajkumar at CMU).

I have been involved with the development of a real-time, collaborative agent system. At the core of this system was a scheduling problem where agents had to decide on how to best use a given set of sensors to track an unknown number of targets. The sensors and targets were embedded devices we had to interface with. Each agent only had access to one sensor but multiple sensors were requires for successful tracking. The challenge of the project was thus on collaboratively deciding how to schedule the use of the sensors based on the local knowledge of each collaborative agent. The visualization and debugging work done in this project became a precursor to a later project on the development of an ontology-driven visualization and debugging infrastructure for unmanned air vehicles (UAV). This recent effort, called HURT (Heterogeneous Urban RSTA Teams), is a complex undertaking as it integrates user management, platform modeling, and planning & control. UAVs were provided by Northrop-Grumman and Georgia Tech. Our role was (and is) the integration of these embedded devices into a real-time system for autonomously (re)assigning UAVs to missions and monitoring their progress (together with Bob Balzer and Neil Goldman).

Around the same time, I also co-developed an intrusion detection and error prevention mechanism with Dave Wile. The approach was based on the scenario-guided differencing of statechart models. The goal of differencing is to validate whether a software implementation (source code) conforms to its specification (design and architecture). To date, conformance between a design and its implementation (source code) is ensured mostly through static analysis. This has limitations and we thus developed a dynamic approach to conformance analysis that identifies differences between the implementation and specification during the system’s execution (run-time). Differences between the system execution and the model (simulation) point to an error or instruction. Either way, we recover from these errors by re-constituting the affected software components to a previous, healthy state as suggested by the model. This project required the development of a simulatable modeling language to support the differencing. A modeling language mixes graphical and textual descriptions but is not unlike a programming language. Yet, the emphasis of a modeling language is on capturing a particular (set of) concern(s). In our case, we developed a modeling language for simulating certain behaviors of dynamic systems that were typical for mobile systems where components come and go and the environment is in a continuous state of flux.

While my work emphasized on systems-of-systems development (software, hardware, embedded) and language/infrastructure development, I still continued research on software modeling. Recently, I have developed automated techniques (with Sven Johann and Wuwei Shen) to support incremental transformation and analyses with vast performance benefits over traditional, batch techniques. I also co-developed CBSP with Paul Grünbacher and Nenad Medvidovic, an approach for the refinement of software requirements into an architecture satisfying those requirements. And, I developed an approach to trace analysis that automatically discovers dependencies (mappings) among separately captured modeling perspectives in a software project (e.g., mappings among requirements, architecture, design, and code).

I have been successful in finding, solving, and publishing a wide variety of research problems. The above list merely summarizes some of my work. It is meant to provide an overview as to the breath of projects I worked on in the past. Yet, many of these projects are ongoing projects and there are new research opportunities opening up in every project I work on. I intend to continue my research work in the many diverse areas I have worked on in the past. At the core of my research is modeling. I believe in modeling and model-based problem solving. And I believe that it can hold the key in seamlessly integrating systems-of-systems that involve software, hardware, embedded devices, middleware (networks), commercial-off-the shelf components, and legacy systems. I also believe in the development of new modeling languages to independently explore (describe and solve) development concerns.