Formal Description of Object-Oriented Design Patterns. Back, R., Mikhajlov, L., & Sekerinski, E. December, 1996. ![Formal Description of Object-Oriented Design Patterns [link]](https://bibbase.org/img/filetypes/link.svg "link")
Paper abstract bibtex This paper addresses the issue of specifying Object-Oriented Design Patterns [1] formally. Object-Oriented Design Patterns document an expertise in the field of OO Design. They describe simple and elegant solutions to concrete problems. Usually the patterns are presented informally, thus many subtle issues remain unclear and underspecified. In particular, relations among the participants of the patterns are rather obscure. We use the formal semantics and the notation of the object-oriented programming and specification language developed in [2]. The advantage of this approach is the uniform way of presenting all stages of development starting with an abstract specification of general system architecture and ending with a concrete executable program. This allows for specifying patterns and custom designs following them in the same terms and simplifies reasoning about their interrelations. A characteristic feature of the used formalism is the distinction between classes and object types. This entitles us to be precise about the relationship among entities participating in a pattern. For example, very often the conformance of the class interfaces (i.e. object types) is insufficient to precisely specify a pattern. In this case we can require that classes are in the refinement relation [3]. Most of the patterns promote clear and extendable design. It means that the program following a pattern will be easily extendable along some axes and very rigid along the others. With the informal specifications such issues are not immediately apparent. The described approach allows for indicating clearly hot spots [4]. (i.e places intended for future extensions) and frozen spots. This is achieved using a mechanism of parameterization of classes with types, values and other classes available in the formalism. References [1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Design Patterns. ADDISON-WESLEY, ( May 1994). [2] Emil Sekerinski A Type-Theoretic Basis for an Object-Oriented Refinement Calculus. Dept. of Computer Science, Abo Akademi, Turku, Finland [3] R.J.R. Back Correctness Preserving Program Refinements:Proof Theory and Applications vol. 131 of Mathematical Center Tracts. Amsterdam: Mathematical Center 1980 [4] Wolfgang Pree Design Patterns for Object-Oriented Software Development ADDISON-WESLEY,1994.
@misc{BackMikhailovSekerinski96FormalDesignPatterns,
address = {Oslo, Norway},
title = {Formal {Description} of {Object}-{Oriented} {Design} {Patterns}},
url = {https://web.archive.org/web/19970606115810/http://www.ifi.uio.no:80/~nwpt96/},
abstract = {This paper addresses the issue of specifying Object-Oriented Design Patterns [1] formally. Object-Oriented Design Patterns document an expertise in the field of OO Design. They describe simple and elegant solutions to concrete problems. Usually the patterns are presented informally, thus many subtle issues remain unclear and underspecified. In particular, relations among the participants of the patterns are rather obscure. We use the formal semantics and the notation of the object-oriented programming and specification language developed in [2]. The advantage of this approach is the uniform way of presenting all stages of development starting with an abstract specification of general system architecture and ending with a concrete executable program. This allows for specifying patterns and custom designs following them in the same terms and simplifies reasoning about their interrelations. A characteristic feature of the used formalism is the distinction between classes and object types. This entitles us to be precise about the relationship among entities participating in a pattern. For example, very often the conformance of the class interfaces (i.e. object types) is insufficient to precisely specify a pattern. In this case we can require that classes are in the refinement relation [3]. Most of the patterns promote clear and extendable design. It means that the program following a pattern will be easily extendable along some axes and very rigid along the others. With the informal specifications such issues are not immediately apparent. The described approach allows for indicating clearly hot spots [4]. (i.e places intended for future extensions) and frozen spots. This is achieved using a mechanism of parameterization of classes with types, values and other classes available in the formalism. References [1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Design Patterns. ADDISON-WESLEY, ( May 1994). [2] Emil Sekerinski A Type-Theoretic Basis for an Object-Oriented Refinement Calculus. Dept. of Computer Science, Abo Akademi, Turku, Finland [3] R.J.R. Back Correctness Preserving Program Refinements:Proof Theory and Applications vol. 131 of Mathematical Center Tracts. Amsterdam: Mathematical Center 1980 [4] Wolfgang Pree Design Patterns for Object-Oriented Software Development ADDISON-WESLEY,1994.},
author = {Back, Ralph and Mikhajlov, Leonid and Sekerinski, Emil},
month = dec,
year = {1996},
}
Downloads: 0
{"_id":"7dCgeHK4tiJ3MMZ87","bibbaseid":"back-mikhajlov-sekerinski-formaldescriptionofobjectorienteddesignpatterns-1996","author_short":["Back, R.","Mikhajlov, L.","Sekerinski, E."],"bibdata":{"bibtype":"misc","type":"misc","address":"Oslo, Norway","title":"Formal Description of Object-Oriented Design Patterns","url":"https://web.archive.org/web/19970606115810/http://www.ifi.uio.no:80/~nwpt96/","abstract":"This paper addresses the issue of specifying Object-Oriented Design Patterns [1] formally. Object-Oriented Design Patterns document an expertise in the field of OO Design. They describe simple and elegant solutions to concrete problems. Usually the patterns are presented informally, thus many subtle issues remain unclear and underspecified. In particular, relations among the participants of the patterns are rather obscure. We use the formal semantics and the notation of the object-oriented programming and specification language developed in [2]. The advantage of this approach is the uniform way of presenting all stages of development starting with an abstract specification of general system architecture and ending with a concrete executable program. This allows for specifying patterns and custom designs following them in the same terms and simplifies reasoning about their interrelations. A characteristic feature of the used formalism is the distinction between classes and object types. This entitles us to be precise about the relationship among entities participating in a pattern. For example, very often the conformance of the class interfaces (i.e. object types) is insufficient to precisely specify a pattern. In this case we can require that classes are in the refinement relation [3]. Most of the patterns promote clear and extendable design. It means that the program following a pattern will be easily extendable along some axes and very rigid along the others. With the informal specifications such issues are not immediately apparent. The described approach allows for indicating clearly hot spots [4]. (i.e places intended for future extensions) and frozen spots. This is achieved using a mechanism of parameterization of classes with types, values and other classes available in the formalism. References [1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Design Patterns. ADDISON-WESLEY, ( May 1994). [2] Emil Sekerinski A Type-Theoretic Basis for an Object-Oriented Refinement Calculus. Dept. of Computer Science, Abo Akademi, Turku, Finland [3] R.J.R. Back Correctness Preserving Program Refinements:Proof Theory and Applications vol. 131 of Mathematical Center Tracts. Amsterdam: Mathematical Center 1980 [4] Wolfgang Pree Design Patterns for Object-Oriented Software Development ADDISON-WESLEY,1994.","author":[{"propositions":[],"lastnames":["Back"],"firstnames":["Ralph"],"suffixes":[]},{"propositions":[],"lastnames":["Mikhajlov"],"firstnames":["Leonid"],"suffixes":[]},{"propositions":[],"lastnames":["Sekerinski"],"firstnames":["Emil"],"suffixes":[]}],"month":"December","year":"1996","bibtex":"@misc{BackMikhailovSekerinski96FormalDesignPatterns,\n\taddress = {Oslo, Norway},\n\ttitle = {Formal {Description} of {Object}-{Oriented} {Design} {Patterns}},\n\turl = {https://web.archive.org/web/19970606115810/http://www.ifi.uio.no:80/~nwpt96/},\n\tabstract = {This paper addresses the issue of specifying Object-Oriented Design Patterns [1] formally. Object-Oriented Design Patterns document an expertise in the field of OO Design. They describe simple and elegant solutions to concrete problems. Usually the patterns are presented informally, thus many subtle issues remain unclear and underspecified. In particular, relations among the participants of the patterns are rather obscure. We use the formal semantics and the notation of the object-oriented programming and specification language developed in [2]. The advantage of this approach is the uniform way of presenting all stages of development starting with an abstract specification of general system architecture and ending with a concrete executable program. This allows for specifying patterns and custom designs following them in the same terms and simplifies reasoning about their interrelations. A characteristic feature of the used formalism is the distinction between classes and object types. This entitles us to be precise about the relationship among entities participating in a pattern. For example, very often the conformance of the class interfaces (i.e. object types) is insufficient to precisely specify a pattern. In this case we can require that classes are in the refinement relation [3]. Most of the patterns promote clear and extendable design. It means that the program following a pattern will be easily extendable along some axes and very rigid along the others. With the informal specifications such issues are not immediately apparent. The described approach allows for indicating clearly hot spots [4]. (i.e places intended for future extensions) and frozen spots. This is achieved using a mechanism of parameterization of classes with types, values and other classes available in the formalism. References [1] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Design Patterns. ADDISON-WESLEY, ( May 1994). [2] Emil Sekerinski A Type-Theoretic Basis for an Object-Oriented Refinement Calculus. Dept. of Computer Science, Abo Akademi, Turku, Finland [3] R.J.R. Back Correctness Preserving Program Refinements:Proof Theory and Applications vol. 131 of Mathematical Center Tracts. Amsterdam: Mathematical Center 1980 [4] Wolfgang Pree Design Patterns for Object-Oriented Software Development ADDISON-WESLEY,1994.},\n\tauthor = {Back, Ralph and Mikhajlov, Leonid and Sekerinski, Emil},\n\tmonth = dec,\n\tyear = {1996},\n}\n\n","author_short":["Back, R.","Mikhajlov, L.","Sekerinski, E."],"key":"BackMikhailovSekerinski96FormalDesignPatterns","id":"BackMikhailovSekerinski96FormalDesignPatterns","bibbaseid":"back-mikhajlov-sekerinski-formaldescriptionofobjectorienteddesignpatterns-1996","role":"author","urls":{"Paper":"https://web.archive.org/web/19970606115810/http://www.ifi.uio.no:80/~nwpt96/"},"metadata":{"authorlinks":{}}},"bibtype":"misc","biburl":"https://api.krunk.cn/emil/bib.php","dataSources":["HEdahWqKBpmSGmDwq","MF5eGzpJnqf6bSAoG","ienufKdnmJs49AsjR","So4gmSWFmbQRNEuFs","ezsmw4w22u9JFLNYJ","CvQYP6Tmpapx74Mgr","RWydLHbBJqgdeh5jr"],"keywords":[],"search_terms":["formal","description","object","oriented","design","patterns","back","mikhajlov","sekerinski"],"title":"Formal Description of Object-Oriented Design Patterns","year":1996}