Advertisement

Amplifying the Benefits of Design Patterns: From Specification Through Implementation

  • Jason O. Hallstrom
  • Neelam Soundarajan
  • Benjamin Tyler
Part of the Lecture Notes in Computer Science book series (LNCS, volume 3922)

Abstract

The benefits of design patterns are well-established. We argue that these benefits can be further amplified across the system lifecycle. We present two contributions. First, we describe an approach to complementing existing informal pattern descriptions with precise pattern specifications. Our specification language captures the properties common across all applications of a pattern, while accommodating the variation that occurs across those applications. Second, we describe an approach to monitoring a system’s runtime behavior to determine whether the appropriate pattern specifications are respected. The monitoring code is generated automatically from the pattern specifications underlying the system’s design. We conclude with a discussion of how our contributions are beneficial across the software lifecycle.

Keywords

Design Pattern Monitor Generation Call Sequence Pattern Instance Runtime Overhead 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

References

  1. 1.
    Gamma, E., et al.: Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Reading (1995)Google Scholar
  2. 2.
    Buschmann, F., et al.: Pattern-Oriented Software Architecture: A System of Patterns. John Wiley & Sons, Inc., Chichester (1996)Google Scholar
  3. 3.
    Schmidt, D., et al.: Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects. John Wiley & Sons, Inc., Chichester (1996)Google Scholar
  4. 4.
    Kiczales, G., et al.: An overview of AspectJ. In: Knudsen, J.L. (ed.) ECOOP 2001. LNCS, vol. 2072, pp. 327–353. Springer, Heidelberg (2001)CrossRefGoogle Scholar
  5. 5.
    Eden, A.: Formal specification of object-oriented design. In: CSME-MDE (2001)Google Scholar
  6. 6.
    Mikkonen, T.: Formalizing design patterns. In: ICSE, pp. 115–124. IEEE, Los Alamitos (1998)Google Scholar
  7. 7.
    Helm, R., et al.: Contracts: Specifying behavioral compositions in object-oriented systems. In: OOPSLA/ECOOP, pp. 169–180. ACM, New York (1990)CrossRefGoogle Scholar
  8. 8.
    Soundarajan, N., Hallstrom, J.: Responsibilities and rewards: Specifying design patterns. In: ICSE, pp. 666–675 (2004)Google Scholar
  9. 9.
    Soundarajan, N., et al.: Specifying and monitoring design pattern contracts. In: SAVCBS/ICSE, pp. 87–94 (2004)Google Scholar
  10. 10.
    Tyler, B., et al.: Automated generation of monitors for pattern contracts. In: Biham, E., Youssef, A.M. (eds.) SAC 2006. LNCS, vol. 4356, Springer, Heidelberg (2007)Google Scholar
  11. 11.
    Meyer, B.: Object-Oriented Software Construction. Prentice Hall, Englewood Cliffs (1988)Google Scholar
  12. 12.
    Rosenblum, D.: A practical approach to programming with assertions. IEEE TSE 21, 19–31 (1995)Google Scholar
  13. 13.
    Burdy, L., et al.: An overview of JML tools and applications. STTT (to appear, 2005)Google Scholar
  14. 14.
    Lippert, M., Lopes, C.: A study on exception detection and handling using aspect-oriented programming. In: ICSE, pp. 418–427 (2000)Google Scholar
  15. 15.
    Gibbs, T., Malloy, B.: Weaving aspects into C++ applications for validation of temporal invariants. In: CSMR, pp. 249–258 (2003)Google Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2006

Authors and Affiliations

  • Jason O. Hallstrom
    • 1
  • Neelam Soundarajan
    • 2
  • Benjamin Tyler
    • 2
  1. 1.Department of Computer ScienceClemson UniversityUSA
  2. 2.Department of Computer Science and EngineeringOhio State UniversityUSA

Personalised recommendations