Topic
Observer pattern
About: Observer pattern is a research topic. Over the lifetime, 193 publications have been published within this topic receiving 3899 citations.
Papers published on a yearly basis
Papers
Book•
1 Jan 2001
TL;DR: In this paper, the authors present an approach to handling new requirements in object-oriented software development by using UML and UML-based patterns, such as the Facade Pattern, the Decorator Pattern and the Bridge Pattern.
Abstract: Preface. From Object Orientation to Patterns to True Object Orientation. From Artificial Intellegence to Patterns to True Object Orientation. I. AN INTRODUCTION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT. 1. The Object-Oriented Paradigm. Before The Object-Oriented Paradigm: Functional Decomposition. The Problem of Requirements. Dealing With Changes: With Functional Decomposition. Dealing with Changing RequirementS. The Object-Oriented Paradigm. Special Object Methods. Summary. 2. The UML - The Unified Modeling Language. Overview. What is the UML? Why Use the UML? The Class Diagram. Interaction Diagrams. Summary. II. THE LIMITATIONS OF TRADITIONAL OBJECT-ORIENTED DESIGN. 3. A Problem that Cries Out for Flexible Code. Overview. Extracting Information from a CAD/CAM System. Understand the Vocabulary. Describe the Problem. The Essential Challenges and Approaches. Summary. 4. A Standard Object-Oriented Solution. Overview. Solving With Special Cases. Summary. Supplement: C++ Code Examples. III. DESIGN PATTERNS. 5. An Introduction to Design Patterns. Overview. Design Patterns Arose from Architecture and Anthropology. Moving from Architectural to Software Design Patterns. Why Study Design Patterns. Other Advantages to Studying Design Patterns. Summary. 6. The Facade Pattern. Overview. Introducing the Facade Pattern. Learning the Facade Pattern. Field Notes: The Facade Pattern. Relating the Facade Pattern to the CAD/CAM Problem. Summary. 7. The Adapter Pattern. Overview. Introducing the Adapter Pattern. Learning the Adapter Pattern. Field Notes: The Adapter Pattern. Relating the Adapter Pattern to the CAD/CAM Problem. Summary. Supplement: C++ Code Examples 8. Expanding Our Horizons. Overview. Objects the Old Way and the New Way. Encapsulation the Old Way and the New Way. Find What is Varying and Encapsulate It. Commonality / Variability and Abstract Classes. Summary. 9. The Bridge Pattern. Overview. Introducing the Bridge Pattern. An Observation about Using Design Patterns. Learning the Bridge Pattern: An Example. The Bridge Pattern In Retrospect. Field Notes: Using the Bridge Pattern. Summary. 10. The Abstract Factory Pattern. Overview. Introducing the Abstract Factory Pattern. Learning the Abstract Factory Pattern: An Example. Learning the Abstract Factory: Implementing It. Field Notes: The Abstract Factory. Relating the Abstract Factory Pattern to the CAD/CAM Problem. Summary. Supplement: C++ Code Examples. IV. PUTTING IT ALL TOGETHER: THINKING IN PATTERNS. 11. How Do Experts Design? Section Overview. Overview. Building by Adding Distinctions. Summary. 12. Solving the CAD/CAM Problem with Patterns. Overview. Review of the CAD/CAM Problem. Thinking in Patterns. Thinking in Patterns: Step 1. Thinking in Patterns: Step 2A. Thinking in Patterns: Step 2B. Thinking in Patterns: Step 2D (Facade). Thinking in Patterns: Step 2D (Adapter). Thinking in Patterns: Step 2D (Abstract Factory). Thinking in Patterns: Step 3. Comparison with the Previous Solution. Summary. 13. The Principles and Strategies of Design Patterns. Overview. The Open-Closed Principle. The Principle of Designing from Context. The Principle of Containing Variation. Summary. V. HANDLING VARIATIONS WITH DESIGN PATTERNS. 14. The Strategy Pattern. Overview. An Approach to Handling New Requirements. Initial Requirements of the Case Study. Handling New Requirements. The Strategy Pattern. Field Notes: Using the Strategy Pattern. Summary. 15. The Decorator Pattern. Overview. A Little More Detail. The Decorator Pattern. Applying the Decorator Pattern to the Case Study. Another Example: Input / Output. Field Notes: Using the Decorator Pattern. Summary. Supplement: C++ Code Examples. 16. The Singleton Pattern and the Double-Checked Locking Pattern. Overview . Introducing the Singleton Pattern. Applying the Singleton Pattern to the Case Study. A Variant: The Double-Checked Locking Pattern. Field Notes: Using the Singleton and Double-Checked Locking Patterns. Summary. Supplement: C++ Code Examples. 17. The Observer Pattern. Overview. Categories of Patterns. More Requirements for the Case Study. The Observer Pattern. Applying the Observer to the Case Study. Field Notes: Using the Observer Pattern. Summary. Supplement : C++ Code Examples. 18. The Template Method Pattern. Overview. More Requirements for the Case Study. The Template Method Pattern. Applying the Template Method to the Case Study. Field Notes: Using the Template Method Pattern. Summary. 19. The Factory Method Pattern. Overview. More Requirements for the Case Study. The Factory Method Pattern. Field Notes: Using the Factory Method Pattern. Summary. 20. The Analysis Matrix. Overview. In the Real World: Variations. Case Study in Variation: An International E-Tail System. Field Notes. Summary. VI. ENDINGS AND BEGINNINGS. 21. Design Patterns Reviewed From Our New Perspective of Object-Oriented Design. Overview. A Summary of Object-Oriented Principles. How Design Patterns Encapsulate Implementations. Commonality / Variability Analysis and Design Patterns. Decomposing a Problem Domain Into Responsibilities. Relationships Within a Pattern. Patterns and Contextual Design. Field Notes. Summary. 22. Bibliography. Design Patterns Explained: The Web Site Companion. Recommended Reading on Design Patterns and Object Orientation. Recommended Reading for Java Programmers. Recommended Reading for C++ Programmers. Recommended Reading for Cobol Programmers. Recommended Reading on eXtreme Programming. Recommended Reading on General Programming. Personal Favorites. Index.
220 citations
Book•
27 Feb 2004
TL;DR: In this article, the authors present a UML profile for Scheduling Model-Based Projects (SBM) and UML Profile for Schedulability, Performance, and Time (RT UML).
Abstract: Figure List. About the Author. Foreword to the Third Edition. Foreword to the Previous Editions. Preface to the Third Edition. Preface to the Second Edition. Preface to the First Edition. Acknowledgments. 1. Introduction to the World of Real-Time and Embedded Systems. What Is Special about Real-Time Systems? Time, Performance, and Quality of Service. Systems Engineering vs. Software Engineering. What Do We Mean by Architecture? The Rapid Object-Oriented Process for Embedded Systems (ROPES) Process. MDA and Platform-Independent Models. Scheduling Model-Based Projects. Model Organization Principles. Working with Model-Based Projects. Looking Ahead. Exercises. References. 2. Object Orientation with UML 2.0-Structural Aspects. Object Orientation with UML. Small Things: Objects, Classes, and Interfaces. Relations. Big Things: Packages, Components, and Subsystems. Advanced: UML Metamodel of Structural Elements (for the Advanced Modeler). Additional Notations and Semantics. Looking Ahead. Exercises. References. 3. Object Orientation with UML 2.0-Dynamic Aspects. Behavior and the UML. Types of Behavior. Behavior Primitives: Actions and Activities. Behavior and the Single Object. Interactions. Summary. Exercises. References. 4. UML Profile for Schedulability, Performance, and Time. UML Profiles. "RT UML" Profile. Looking Ahead. Exercises. References. 5. Requirements Analysis of Real-Time Systems. Requirements. Use Cases. Detailing the Use Cases. Looking Ahead. Exercises. References. 6. Analysis: Object Domain Analysis. The Object Discovery Process. Connecting the Object Model with the Use Case Model. Key Strategies for Object Identification. Identify Object Associations. Object Attributes. Discovering Candidate Classes. Class Diagrams. Looking Ahead. Exercises. References. 7. Analysis: Defining Object Behavior. Object Behavior. Defining Object State Behavior. Interactions. Defining Operations. Looking Ahead. Exercises. References. 8. Architectural Design. Overview of Design. What Is Architectural Design? Software Meets Hardware: Deployment Architecture in UML. Concurrency and Resource Design. Looking Ahead. Exercises. References. 9. Mechanistic Design. What Is Mechanistic Design? Mechanistic Design Patterns. The Observer Pattern. The Proxy Pattern. Reliable Transaction Pattern. Smart Pointer Pattern. Guarded Call Pattern. Container Pattern. The Rendezvous Pattern. Looking Ahead. Exercises. References. 10. Detailed Design. What Is Detailed Design? Data Structure. Associations. Operations. Visibility. Algorithms. Exceptions. Summary. Exercises. References. 11. Special Topic: C4ISR Architecture and the UML. Introduction. What is C4ISR? Required Products of C4ISR. Supporting Products. Summary. Acknowledgments. References. Appendix: Notational Summary. Index.
160 citations
TL;DR: This work proposes to formalize the pattern relationships in a pattern language grammar and to annotate the grammar with effects on quality goals to support the selection of patterns based on desired quality attributes and systematic design decisions based on patterns.
Abstract: Software patterns provide reusable solutions to recurring design problems in a particular context. The software architect or designer must find the relevant patterns and pattern languages that need to be considered, and select the appropriate patterns, as well as the best order to apply them. If the patterns and pattern languages are written by multiple pattern authors, it might be necessary to identify interdependencies and overlaps between these patterns and pattern languages first. Out of the possible multitude of patterns and pattern combinations that might provide a solution to a particular design problem, one fitting solution must be selected. This can only be mastered with a sufficient expertise for both the relevant patterns and the domain in which they are applied. To remedy these issues we provide an approach to support the selection of patterns based on desired quality attributes and systematic design decisions based on patterns. We propose to formalize the pattern relationships in a pattern language grammar and to annotate the grammar with effects on quality goals. In a second step, complex design decisions are analyzed further using the design spaces covered by a set of related software patterns. This approach helps to systematically find and categorize the appropriate software patterns—possibly even from different sources. As a case study of our approach, we analyze patterns from a pattern language for distributed object middleware. Copyright © 2006 John Wiley & Sons, Ltd.
83 citations
29 Sep 2013
TL;DR: Concern-Oriented Software Design, a modelling technique that focuses on concerns as units of reuse, is proposed, which presents the concern models of variations of the Observer design pattern, which internally depends on the Association concern to link observers and subjects.
Abstract: There exist many solutions to solve a given design problem, and it is difficult to capture the essence of a solution and make it reusable for future designs. Furthermore, many variations of a given solution may exist, and choosing the best alternative depends on application-specific high-level goals and non-functional requirements. This paper proposes Concern-Oriented Software Design, a modelling technique that focuses on concerns as units of reuse. A concern groups related models serving the same purpose, and provides three interfaces to facilitate reuse. The variation interface presents the design alternatives and their impact on non-functional requirements. The customization interface of the selected alternative details how to adapt the generic solution to a specific context. Finally, the usage interface specifies the provided behaviour. We illustrate our approach by presenting the concern models of variations of the Observer design pattern, which internally depends on the Association concern to link observers and subjects.
82 citations
13 Jul 2011
TL;DR: This paper aims at smoothing the learning curve of pattern writing by proposing a step-by-step guide that enables you to write a pattern in a simple but complete format to enable you to submit your pattern to a pattern conference.
Abstract: Pattern writing is a creative, iterative process. For new pattern authors, however, it is often not obvious where to start and how to proceed. Although well-written patterns typically follow a strict format, the number of available formats push first-time authors right at the start to choose a specific format without knowing its advantages and liabilities. Furthermore, new pattern authors are often not aware that the order in which a pattern is published typically is not the best order in which to write the pattern.Done the right way, writing a pattern often creates unforeseen insight into a domain one was sure to know very well. The pattern structure encourages you to think more deeply about the actual problem that the pattern solves and what consequences arise by applying the solution. And by following an iterative approach you gain new insights in each cycle.This paper aims at smoothing the learning curve of pattern writing by proposing a step-by-step guide that enables you to write a pattern in a simple but complete format. The goal is to enable you to submit your pattern to a pattern conference.The paper is divided into two parts. Part I is a warming-up. It presents the transcript of a conversation about a pattern and shows how knowledge of a fascinating solution slowly transforms into a pattern. Part II contains the actual step-by-step guide how to write a pattern.
66 citations
Related Topics (5)
Performance Metrics
| Year | Papers |
|---|---|
| 2021 | 1 |
| 2020 | 1 |
| 2019 | 1 |
| 2018 | 3 |
| 2017 | 6 |
| 2016 | 9 |