My research interests are in the area of software architectures, programming language type systems and program analysis techniques. I work on practical solutions for real-world software engineering problems. My advisor, Professor Jonathan Aldrich, had proposed ArchJava, a language that integrates a Component-and-Connector (C&C) architectural specification into Java code, and AliasJava, an annotation system that extends Java to express how data is confined within, passed among, or shared between objects. We are currently working on the next generation of these languages to address some adoptability challenges. Our ultimate goal is to ensure the conformance of an implementation to a runtime architecture.

The following research threads are listed from most to least recent.

Static Checking of Architectural Structural Conformance

Publications

Compile-Time Extraction of the Execution Architecture

Research Goals

  • The ownership domains type system (AliasJava) can express abstract design intent with multiple public and private ownership domains per object and explicit domain links between domains
  • Design an analysis to obtain, at compile time, from a program with ownership domain annotations, a sound execution architecture of a system
  • Soundness means that the architecture does not fail to reveal relationships that exist at runtime
  • The execution architecture of a system has many applications such as reverse engineering, architectural analyses, checking for conformance, etc.

Research Summary

  • Implemented an analysis to obtain the Ownership Object Graph (OOG) from a program with ownership domain and alias annotations (using Java 1.5 annotations)
  • Evaluated the Ownership Object Graph (OOG) on an annotated version of JHotDraw (version 5.3), a 15,000-line Java program rich with design patterns and developed by experts in object-oriented design and programming (Erich Gamma et al.)
  • Evaluated the Ownership Object Graph (OOG) on an annotated version of HillClimber (part of the CIspace project), another 15,000-line Java program developed by undergraduates
  • See the summary of the Ownership Object Graph (OOG) case studies

Publications

  • Abi-Antoun, M. and Aldrich,  J. Compile-Time Views of Execution Structure Based on Ownership. In International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO), in conjunction with the European Conference on Object-Oriented Programming (ECOOP), 2007. [Paper (PDF)] [Presentation (PDF)]
  • Abi-Antoun, M. and Aldrich, J. A Static Analysis for Extracting Runtime Views from Annotated Object-Oriented Code (Demonstration). In Conference Companion of Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), 2006. [Paper (PDF)] [Presentation (PDF)]

Ownership Domains Type System: Tool Support and Case Studies

“Papers have been written enough, let us see systems!”
-- Reinhard Wilhelm

Research Goals

  • The Ownership domain (AliasJava) type system has had a publicly available open-source compiler for a few years, unlike some of the many ownership type systems which are only paper designs, have not released tool support, or have not been evaluated in substantial case studies on real code. Have we beaten iterators to death yet?
  • The Ownership domains annotation language was originally implemented as a language extension on the Barat research infrastructure
  • Re-implementing ownership domains using Java 1.5 annotations improves the adoptability of the ownership domains technique by mainstream Java developers:
    • Improves tool support since all the capabilities (e.g., refactoring) of the Eclipse environment become available to annotated programs;
    • Makes it easier to extend the annotation language in a backwards-compatible way to support additional features;
    • Allows developers to incrementally and partially specify annotations on large code bases while maintaining a running system.

Research Summary

  • Re-implemented the ownership domains type system as an annotation system using Java 1.5 annotations
  • Annotating third-party code (e.g., Java standard library) supported through external XML files (AliasXML)
  • Implemented a set of auxiliary tools to assist in annotating large programs (e.g., by automatically generating appropriate defaults for fields and method parameters)
  • Annotated JHotDraw, a 15,000-line Java framework, rich with design patterns that is also a significant example in the object-oriented programming community
  • Annotated HillClimber (part of the CIspace project), another 15,000-line Java program developed by undergraduates
  • Identified a number of expressiveness challenges that we plan on addressing in future work

Publications

  • Abi-Antoun, M. and Aldrich,  J. Ownership Domains in the Real World. In International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO), in conjunction with the European Conference on Object-Oriented Programming (ECOOP), 2007. [Paper (PDF)]  [Presentation (PDF)]
  • Abi-Antoun, M. and Aldrich, J. Bringing Ownership Domains to Mainstream Java (Demonstration). In Conference Companion of Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), 2006.  [Paper (PDF)] [Presentation (PDF)]
  • Abi-Antoun, M. and Aldrich, J. JavaD: Bringing Ownership Domains to Mainstream Java. Carnegie Mellon University Technical Report CMU-ISRI-06-110, 2006. [Report (PDF)].

Case Studies in Specifying Architectural Intent in Code

Research Goals

  • Apply ArchJava on a realistic legacy system to specify and enforce the architectural control flow
  • Apply AliasJava on a realistic legacy system to specify and enforce the architectural data sharing (using ownership domains, and aliasing annotations)
  • Describe the process, the lessons learned, as well as any perceived limitations with the tools, techniques and languages used

Research Summary

  • We have completed the largest ArchJava and AliasJava case studies to date (over 16,000 source lines of Java code)

Publications

  • Abi-Antoun, M., Aldrich, J., and Coelho, W. A Case Study in Re-engineering to Enforce Architectural Control Flow and Data Sharing. In Journal of Systems and Software, 80(2), pp. 240--264, 2007. [Preprint (PDF)] [Published Link]. [Note: this is an invited paper that expands the WICSA'05 paper to add AliasJava annotations to the ArchJava implementation.]
  • Abi-Antoun, M., and Coelho, W. A Case Study in Incremental Architecture-Based Re-engineering of a Legacy Application. In Proceedings of the 5th Working IEEE/IFIP Conference on Software Architecture (WICSA-5), 2005. [Paper (PDF)] [Presentation (PDF)]. [Note: This paper was selected as one of the "BEST papers at the WICSA 2005", and we were invited to write an extended version for the Journal of Systems and Software.]

Differencing and Merging of Architectural Views

“Never go to sea with two chronometers; take one or three”
-- Proverb

Research Goals

  • Initially support Component-and-Connector (C&C) Views
  • Identify or design new scalable algorithms
  • Implement a tool
  • Perform case studies to illustrate usefulness
  • Some possible scenarios:

    • Synchronization (differencing and merging) between a Conceptual (as-designed) and an Implementation (as-built) architecture

    • Differencing and merging between two versions of an architectural model

Research Summary

  • We have completed initial tool support to make an an architectural specification in Acme incrementally consistent with an ArchJava implementation. See walkthroughs here.

  • We still need to change the ArchJava infrastructure to support making incremental changes to an existing ArchJava implementation

    • Acme is a mature general purpose Architecture Description Language (ADL)

    • ArchJava is a language that specifies and enforces architecture directly within code and enabl

    • Main Contributions:

      • Initial generation of ArchJava starter code from an Acme model

      • Import of an Acme model from an existing ArchJava implementation

      • Synchronization between an existing Acme model and an existing ArchJava implementation

Publications

  • Abi-Antoun, M., Aldrich,  J., Nahas, N., Schmerl, B. and Garlan, D. Differencing and Merging of Architectural Views. In Proceedings of the 21st IEEE International Conference on Automated Software Engineering, 2006.  [Paper (PDF)] [Presentation (PDF)] [Presentation with animations (PowerPoint)][Aphyds Demo(AVI)][Aphyds Demo (MOV)][Duke's Bank Demo (AVI)][Duke's Bank Demo (MOV)]
  • Abi-Antoun, M., Aldrich,  J., Nahas, N., Schmerl, B. and Garlan, D. Differencing and Merging of Architectural Views. Carnegie Mellon University Technical Report CMU-ISRI-05-128, August 2005. [Report (PDF)] [Note: This is the most comprehensive description of the work to date. Last Revised March 2006.]
  • Abi-Antoun, M., Aldrich, J., Garlan, D., Schmerl, B. and Nahas, N. Semi-Automated Incremental Synchronization between Conceptual and Implementation Level Architectures (Position Paper). Proceedings of the 5th Working IEEE/IFIP Conference on Software Architecture (WICSA-5), 2005. [Paper (PDF)] [Presentation (PDF)]
  • Abi-Antoun, M., Aldrich,  J., Garlan, D., Schmerl, B., Nahas, N., and Tseng, T. Modeling and Implementing Software Architecture with Acme and ArchJava (Research Demonstration). In Proceedings of the International Conference on Software Engineering (ICSE'05), May 15-21, 2005, St. Louis, Missouri, USA. [Paper (PDF) ] [Presentation (PDF)]
  • Abi-Antoun, M., Aldrich, J., Garlan, D., Schmerl, B., Nahas, N., and Tseng, T. Improving System Dependability by Enforcing Architectural Intent. In Proceedings of the Workshop on Architecting Dependable Systems (WADS), 2005.  [Paper (PDF)] [Presentation (PDF)]