DOCSLIB.ORG

Example Calculator Design

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Example Calculator Design Example calculator design Dr. Onno van Roosmalen LATEX version: Pieter van den Hombergh Fontys Hogeschool voor Techniek en Logistiek September 25, 2017 Example calculator Content design ROO,HOM Command Consequences Interpreter Interpreter Example calculator design Prototype Pattern interpreter Example calculator design Calculator Prototype Description Design Rationales interpreter Interpreter Implementation Command Pattern Calculator Command Description Prototype Participants Command Structure Design Rationales Command Participants Factory Method Pattern Command Consequences Command Pattern Factory Method Description Prototype Pattern Prototype Description Command Description Interpreter with Factory Method Interpreter Implementation Command Structure Factory Method Participants Prototype Participants Factory Method Command Participants Factory Method Consequences Pattern Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 2/30 Example calculator Example Design design ROO,HOM Part 1 Interpreter Example calculator design interpreter Calculator Implement a command interpreter. Introduce a set of commands that are Design Rationales Command Pattern accepted during a command-interpreter session. The effect of each Command Description command can vary with the application. Command Structure Command Participants Two special command names are Quit and Undo. These must be accepted. Command Consequences Prototype Pattern Quit stops the session. Undo removes commands from the history of Prototype Description Interpreter Implementation executed commands in reverse chronological order. It notifies the user of Prototype Participants the name of the undone command. The number of executed commands is Factory Method Pattern thus decremented. Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 3/30 Example calculator Interpreter Design design ROO,HOM Command Interpreter -set Example calculator design InterpreterInterpreter + name interpreter { hashed } Calculator * Design Rationales ++ sessionsession ()() { ordered } * + clone() Command Pattern # getNewCommand () ++ executeexecute ()() Command Description -history Command Structure + undo () Command Participants Command Consequences Prototype Pattern Prototype Description Interpreter Implementation Prototype Participants Factory Method Quit Undo Pattern Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 4/30 Example calculator Interpreter Implementation design ROO,HOM p u b l i c class Interpreter f p r o t e c t e d Stack history = new Stack ( ) ; Interpreter p r o t e c t e d HashTable set = new HashTable (); Example calculator design p u b l i c void s e s s i o n ( ) f interpreter w h i l e ( t r u e ) f Calculator Command command = getNewCommand(); Design Rationales i f ( command i n s t a n c e o f Quit ) f Command Pattern r e t u r n ; g e l s e f Command Description command. execute (); Command Structure g Command Participants g Command Consequences g Prototype Pattern p r o t e c t e d Command getNewCommand() f Prototype Description String s = input.getString(); Interpreter Implementation w h i l e (! set.containsKey(s)) f Prototype Participants display.printError(”Not a v a l i d command; t r y a g a i n!”); Factory Method s = input.getString(); Pattern g r e t u r n ((Command)set .get(s)). clone (); Factory Method Description g Interpreter with Factory Method g Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 5/30 Undo Implementation a b s t r a c t class Command implements C l o n e a b l e f p u b l i c abstract void e x e c u t e ( ) ; p u b l i c abstract void undo ( ) ; g c l a s s Undo extends Command f p r o t e c t e d Stack history; p u b l i c Undo(Stack h) f h i s t o r y = h ; g p u b l i c void e x e c u t e ( ) f ((Command) history .top()).undo(); g p u b l i c void undo ( ) fg g Example calculator Calculator design ROO,HOM Part 2 Interpreter Example calculator design interpreter Calculator Using the interpreter, build a calculator with Reverse Polish Notation Design Rationales (RPN). It uses commands like Command Pattern Command Description accept “n” Command Structure Command Participants * Command Consequences / Prototype Pattern + Prototype Description Interpreter Implementation - Prototype Participants quit Factory Method undo Pattern Factory Method Description Interpreter with Factory The reverse polish notation uses the stack concept for prescribing the order Method Factory Method of executing the commands. Participants Factory Method The calculator commands must be “un-doable”. Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 7/30 Example calculator Calculator Design design ROO,HOM Command Interpreter history Stack execute() Example calculator design Interpreter * interpreter undo() Calculator Design Rationales Command Pattern valueStack Command Description Stack Command Structure Undo CalculatorCommand Command Participants Client execute() Command Consequences Prototype Pattern Prototype Description Calculator Interpreter Implementation Accept Prototype Participants Factory Method execute() Add Pattern Subtract Factory Method Description execute() Interpreter with Factory Method execute() Divide Factory Method <<create>> Participants Multiply Factory Method execute() Consequences execute() ROO,HOM/FHTenL Example calculator design September 25, 2017 8/30 Example calculator Calculator Implementation design ROO,HOM c l a s s C a l c u l a t o r extends Interpreter f Interpreter p u b l i c Calculator() f Example calculator design interpreter s e t . put (”quit”, new Quit ( ) ) ; Calculator s e t . put (”undo”, new Undo(history )); Design Rationales s e t . put (”+”, new Plus(history )); Command Pattern s e t . put (” −”, new Min(histroy) ); Command Description s e t . put (” ∗”, new Mul(history) ); Command Structure s e t . put (”/”, new Div(history) ); Command Participants s e t . put (”accept”, new Accept(history )); Command Consequences g Prototype Pattern g Prototype Description Interpreter Implementation Prototype Participants Factory Method Pattern Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 9/30 Example calculator Design Rationales design ROO,HOM Use specialization of abstract classes to avoid unnecessary coupling between Interpreter classes Example calculator design interpreter Obtain extendibility with regard the type of requested commands Calculator Design Rationales Obtain reusability of certain complex or carefully optimized algorithms Command Pattern Command Description Obtain a readable and communicable design through proper separation of Command Structure Command Participants concerns Command Consequences Prototype Pattern Prototype Description The essence of this can be captured in a design pattern Interpreter Implementation Prototype Participants Factory Method Pattern Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 10/30 Example calculator Command design ROO,HOM Classification: Behavioral Interpreter Example calculator design Intent: Encapsulate a request as an object, thereby letting you parametrise interpreter clients with different requests, queue or log requests, and support un-doable Calculator Design Rationales operations. Command Pattern Command Description Motivation: Sometimes it’s necessary to issue requests to objects without Command Structure knowing anything about the operation being requested or the receiver of the Command Participants request. Command Consequences Prototype Pattern E.g. user interface toolkits include objects that carry out a user request like Prototype Description Interpreter Implementation buttons Prototype Participants menus in response to user input. Factory Method The toolkit can’t implement the request explicitly because only applications Pattern Factory Method Description know what should be done on. Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 11/30 Example calculator Command design ROO,HOM Structure Interpreter Example calculator design interpreter Calculator Command Client Invoker Design Rationales Command Pattern Execute() Command Description Command Structure Command Participants Command Consequences Receiver receiver ConcreteCommand Prototype Pattern State Action() receiver.Action() Prototype Description Interpreter Implementation Execute() <<create>> Prototype Participants Factory Method Pattern Factory Method Description Interpreter with Factory Method Factory Method Participants Factory Method Consequences ROO,HOM/FHTenL Example calculator design September 25, 2017 12/30 Example calculator Two command instances in calculator design ROO,HOM Interpreter Example calculator design interpreter <<invoker>> Command Calculator Design Rationales Command Pattern <<Receiver>> <<Command>> Command Description Command Structure Command Command Participants history Execute() Interpreter Stack Command Consequences
Load more

Recommended publications
  • The Command Dispatcher Pattern Benoit Dupire and Eduardo B Fernandez {[email protected], [email protected]}
    The Command Dispatcher Pattern Benoit Dupire and Eduardo B Fernandez {[email protected], [email protected]} Department of Computer Science and Engineering. Florida Atlantic University Boca Raton, FL 33431 Can also be called: Command Evaluator Pattern. Intent This pattern increases the flexibility of applications by enabling their services to be changed, by adding, replacing or removing any command handlers at any point in time without having to modify, recompile or statically relink the application. By simulating the command-evaluation feature common in interpreted languages, this pattern supports the need for continual, incremental evolution of applications. Example Autonomous Underwater Vehicles (AUVs) are small, unmanned, untethered submersibles. There are numerous applications for AUVs, such as oceanographic surveys, operations in hazardous environments, underwater structure inspection and military operations. We implement the high level controller of this AUV as a Hierarchical Finite State Machine (Figure 1). A state of the Finite State Machine (FSM) represents a mode of the system, in which some tasks have to be executed, as described in the mission plan. The system takes transitions based on the results of these actions and the progression of the AUV. The system is programmed with high-level commands of the style "set depth 3" state1 state2 action 1.1 action 2.1 Figure 1: Simplified Finite State Machine for the AUV. The FSM must be able to fire any type of actions, without knowing anything about them. This problem is addressed by the Command Pattern [GOF95], which encapsulates an action as an object, thereby letting you parameterize clients with different actions.
    [Show full text]
  • Enterprise Development with Flex
    Enterprise Development with Flex Enterprise Development with Flex Yakov Fain, Victor Rasputnis, and Anatole Tartakovsky Beijing • Cambridge • Farnham • Köln • Sebastopol • Taipei • Tokyo Enterprise Development with Flex by Yakov Fain, Victor Rasputnis, and Anatole Tartakovsky Copyright © 2010 Yakov Fain, Victor Rasputnis, and Anatole Tartakovsky.. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/institutional sales department: (800) 998-9938 or [email protected]. Editor: Mary E. Treseler Indexer: Ellen Troutman Development Editor: Linda Laflamme Cover Designer: Karen Montgomery Production Editor: Adam Zaremba Interior Designer: David Futato Copyeditor: Nancy Kotary Illustrator: Robert Romano Proofreader: Sada Preisch Printing History: March 2010: First Edition. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly Media, Inc. Enterprise Development with Flex, the image of red-crested wood-quails, and related trade dress are trademarks of O’Reilly Media, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. While every precaution has been taken in the preparation of this book, the publisher and authors assume no responsibility for errors or omissions, or for damages resulting from the use of the information con- tained herein.
    [Show full text]
  • Behavioral Patterns
    Behavioral Patterns 101 What are Behavioral Patterns ! " Describe algorithms, assignment of responsibility, and interactions between objects (behavioral relationships) ! " Behavioral class patterns use inheritence to distribute behavior ! " Behavioral object patterns use composition ! " General example: ! " Model-view-controller in UI application ! " Iterating over a collection of objects ! " Comparable interface in Java !" 2003 - 2007 DevelopIntelligence List of Structural Patterns ! " Class scope pattern: ! " Interpreter ! " Template Method ! " Object scope patterns: ! " Chain of Responsibility ! " Command ! " Iterator ! " Mediator ! " Memento ! " Observer ! " State ! " Strategy ! " Visitor !" 2003 - 2007 DevelopIntelligence CoR Pattern Description ! " Intent: Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. ! " AKA: Handle/Body ! " Motivation: User Interfaces function as a result of user interactions, known as events. Events can be handled by a component, a container, or the operating system. In the end, the event handling should be decoupled from the component. ! " Applicability: ! " more than one object may handle a request, and the handler isn't known a priori. ! " Want to issue a request to one of several objects without specifying the receiver !" 2003 - 2007 DevelopIntelligence CoR Real World Example ! " The Chain of Responsibility pattern avoids coupling the sender of a request to the receiver, by giving more than one object a chance to handle the request. ! " Mechanical coin sorting banks use the Chain of Responsibility. Rather than having a separate slot for each coin denomination coupled with receptacle for the denomination, a single slot is used. When the coin is dropped, the coin is routed to the appropriate receptacle by the mechanical mechanisms within the bank.
    [Show full text]
  • Design Patterns in Ocaml
    Design Patterns in OCaml Antonio Vicente [email protected] Earl Wagner [email protected] Abstract The GOF Design Patterns book is an important piece of any professional programmer's library. These patterns are generally considered to be an indication of good design and development practices. By giving an implementation of these patterns in OCaml we expected to better understand the importance of OCaml's advanced language features and provide other developers with an implementation of these familiar concepts in order to reduce the effort required to learn this language. As in the case of Smalltalk and Scheme+GLOS, OCaml's higher order features allows for simple elegant implementation of some of the patterns while others were much harder due to the OCaml's restrictive type system. 1 Contents 1 Background and Motivation 3 2 Results and Evaluation 3 3 Lessons Learned and Conclusions 4 4 Creational Patterns 5 4.1 Abstract Factory . 5 4.2 Builder . 6 4.3 Factory Method . 6 4.4 Prototype . 7 4.5 Singleton . 8 5 Structural Patterns 8 5.1 Adapter . 8 5.2 Bridge . 8 5.3 Composite . 8 5.4 Decorator . 9 5.5 Facade . 10 5.6 Flyweight . 10 5.7 Proxy . 10 6 Behavior Patterns 11 6.1 Chain of Responsibility . 11 6.2 Command . 12 6.3 Interpreter . 13 6.4 Iterator . 13 6.5 Mediator . 13 6.6 Memento . 13 6.7 Observer . 13 6.8 State . 14 6.9 Strategy . 15 6.10 Template Method . 15 6.11 Visitor . 15 7 References 18 2 1 Background and Motivation Throughout this course we have seen many examples of methodologies and tools that can be used to reduce the burden of working in a software project.
    [Show full text]
  • Design Pattern Implementation in Java and Aspectj
    Design Pattern Implementation in Java and AspectJ Jan Hannemann Gregor Kiczales University of British Columbia University of British Columbia 201-2366 Main Mall 201-2366 Main Mall Vancouver B.C. V6T 1Z4 Vancouver B.C. V6T 1Z4 jan [at] cs.ubc.ca gregor [at] cs.ubc.ca ABSTRACT successor in the chain. The event handling mechanism crosscuts the Handlers. AspectJ implementations of the GoF design patterns show modularity improvements in 17 of 23 cases. These improvements When the GoF patterns were first identified, the sample are manifested in terms of better code locality, reusability, implementations were geared to the current state of the art in composability, and (un)pluggability. object-oriented languages. Other work [19, 22] has shown that implementation language affects pattern implementation, so it seems The degree of improvement in implementation modularity varies, natural to explore the effect of aspect-oriented programming with the greatest improvement coming when the pattern solution techniques [11] on the implementation of the GoF patterns. structure involves crosscutting of some form, including one object As an initial experiment we chose to develop and compare Java playing multiple roles, many objects playing one role, or an object [27] and AspectJ [25] implementations of the 23 GoF patterns. playing roles in multiple pattern instances. AspectJ is a seamless aspect-oriented extension to Java, which means that programming in AspectJ is effectively programming in Categories and Subject Descriptors Java plus aspects. D.2.11 [Software Engineering]: Software Architectures – By focusing on the GoF patterns, we are keeping the purpose, patterns, information hiding, and languages; D.3.3 intent, and applicability of 23 well-known patterns, and only allowing [Programming Languages]: Language Constructs and Features – the solution structure and solution implementation to change.
    [Show full text]
  • Java Design Patterns I
    Java Design Patterns i Java Design Patterns Java Design Patterns ii Contents 1 Introduction to Design Patterns 1 1.1 Introduction......................................................1 1.2 What are Design Patterns...............................................1 1.3 Why use them.....................................................2 1.4 How to select and use one...............................................2 1.5 Categorization of patterns...............................................3 1.5.1 Creational patterns..............................................3 1.5.2 Structural patterns..............................................3 1.5.3 Behavior patterns...............................................3 2 Adapter Design Pattern 5 2.1 Adapter Pattern....................................................5 2.2 An Adapter to rescue.................................................6 2.3 Solution to the problem................................................7 2.4 Class Adapter..................................................... 11 2.5 When to use Adapter Pattern............................................. 12 2.6 Download the Source Code.............................................. 12 3 Facade Design Pattern 13 3.1 Introduction...................................................... 13 3.2 What is the Facade Pattern.............................................. 13 3.3 Solution to the problem................................................ 14 3.4 Use of the Facade Pattern............................................... 16 3.5 Download the Source Code.............................................
    [Show full text]
  • Design Patterns
    Principles of Software Construction: Objects, Design, and Concurrency Introduction to Design Patterns Charlie Garrod Chris Timperley 17-214 1 Administrivia • Homework 1 feedback in your GitHub repository • Homework 2 due tonight 11:59 p.m. • Homework 3 available tomorrow • Optional reading due today: Effective Java Items 18, 19, and 20 – Required reading due next Tuesday: UML & Patterns Ch 9 and 10 17-214 2 Key concepts from Tuesday 17-214 3 Delegation vs. inheritance summary • Inheritance can improve modeling flexibility • Usually, favor composition/delegation over inheritance – Inheritance violates information hiding – Delegation supports information hiding • Design and document for inheritance, or prohibit it – Document requirements for overriding any method 17-214 4 Continued: instanceof • Operator that tests whether an object is of a given class public void doSomething(Account acct) { long adj = 0; if (acct instanceof CheckingAccount) { Do not checkingAcct = (CheckingAccount) acct; adj = checkingAcct.getFee(); do this. } else if (acct instanceof SavingsAccount) { savingsAcct = (SavingsAccount) acct; This code adj = savingsAcct.getInterest(); is bad. } … } • Advice: avoid instanceof if possible – Never(?) use instanceof in a superclass to check type against subclass 17-214 5 Continued: instanceof • Operator that tests whether an object is of a given class public void doSomething(Account acct) { long adj = 0; if (acct instanceof CheckingAccount) { Do not checkingAcct = (CheckingAccount) acct; adj = checkingAcct.getFee(); do this. }
    [Show full text]
  • Functional Programming at Work in Object-Oriented Programming
    Functional Programming at Work in Object-Oriented Programming Narbel version 2010 Narbel Functional Programming at Work in Object-Oriented Programming 1 A Claim about Programming Styles Claim: Adding functional programming capabilities to an object-oriented language leads to benefits in object-oriented programming design. Narbel Functional Programming at Work in Object-Oriented Programming 2 Existing Languages with a FP-OOP Mix Some old and less old languages with FP+OOP: For instance, Smalltalk, Common Lisp (CLOS). More recently, Python or Ruby. Notations: FP, Functional programming; OOP, Object-oriented programming, Narbel Functional Programming at Work in Object-Oriented Programming 3 FP techniques emulated in OOP Practices in OOP languages include emulations of FP techniques: C++ programmers: function pointers and overloadings of the () operator, i.e. “object-functions” or functors. Java programmers: anonymous classes and introspection/reflexion. Narbel Functional Programming at Work in Object-Oriented Programming 4 Existence of FP-OOP Comparison Points The idea of using FP to enrich OOP is old, see e.g. the discussions about the problem of the user-defined datatype extension: User-defined types and procedural data structures as complementary approaches to data abstraction. Reynolds. 1975. The Expression Problem. Wadler. 1998. Narbel Functional Programming at Work in Object-Oriented Programming 5 A Trend: FP Extensions for OO Languages A recent trend: to propose and include typed FP extensions in mainstream static OO languages. Extensions for C++ (see e.g. Laufer, Striegnitz, McNamara, Smaragdakis), and work in progress in the C++ standard committees. Java 7 expected to include FP constructs. C# offers FP constructs (even more in its 3.0 version).
    [Show full text]
  • Command Processor
    277 Command Processor The Command Processor design pattern separates the request for a service from its execution. A command processor component manages requests as separate objects, schedules their execution, and provides additional services such as the storing of request objects for later undo. Example A text editor usually provides a way to deal with mistakes made by the user. A simple example is undoing the most recent change. A more attractive solution is to enable the undoing of multiple changes. We want to develop such an editor. For the purpose of this discussion let us call it TEDDI. OOPS! #*@& Patterns book! The design of TEDDI includes a multi-level undo mechanism and allows for future enhancements, such as the addition of new features or a batch mode of operation. The user interface of TEDDI offers several means of interaction, such as keyboard input or pop-up menus. The program has to define one or several callback procedures that are automatically called for every human-computer interaction. Context Applications that need flexible and extensible user interfaces, or applications that provide services related to the execution of user functions, such as scheduling or undo. 278 Design Patterns Problem An application that includes a large set of features benefits from a well-structured solution for mapping its interface to its internal functionality. This allows you to support different modes of user interaction, such as pop-up menus for novices, keyboard shortcuts for more experienced users, or external control of the application via a scripting language. You often need to implement services that go beyond the core functionality of the system for the execution of user requests.
    [Show full text]
  • Design Patterns Mock Test
    DDEESSIIGGNN PPAATTTTEERRNNSS MMOOCCKK TTEESSTT http://www.tutorialspoint.com Copyright © tutorialspoint.com This section presents you various set of Mock Tests related to Design Patterns Framework. You can download these sample mock tests at your local machine and solve offline at your convenience. Every mock test is supplied with a mock test key to let you verify the final score and grade yourself. DDEESSIIGGNN PPAATTTTEERRNNSS MMOOCCKK TTEESSTT IIII Q 1 - Which of the following describes the Composite pattern correctly? A - This pattern builds a complex object using simple objects and using a step by step approach. B - This pattern is used where we need to treat a group of objects in similar way as a single object. C - This pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. D - This pattern is primarily used to reduce the number of objects created and to decrease memory footprint and increase performance. Q 2 - Which of the following describes the Decorator pattern correctly? A - This pattern allows a user to add new functionality to an existing object without altering its structure. B - This pattern is used where we need to treat a group of objects in similar way as a single object. C - This pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. D - This pattern is primarily used to reduce the number of objects created and to decrease memory footprint and increase performance. Q 3 - Which of the following describes the Facade pattern correctly? A - This pattern allows a user to add new functionality to an existing object without altering its structure.
    [Show full text]
  • Bringing Usability Concerns to the Design of Software Architecture*
    To appear in the Proceedings of EHCI-DSVIS'04: The 9th IFIP Working Conference on Engineering for Human-Computer Interaction and the 11th International Workshop on Design, Specification and Verification of Interactive Systems. Hamburg, Germany, July 11-13, 2004. Bringing Usability Concerns to the Design of Software Architecture* Bonnie E. John1, Len Bass2, Maria-Isabel Sanchez-Segura3, Rob J. Adams1 1 Carnegie Mellon University, Human-Computer Interaction Institute, USA {bej, rjadams}@cs.cmu.edu 2 Carnegie Mellon University, Software Engineering Institute, USA [email protected] 3 Carlos III University of Madrid, Computer Science Department, Spain [email protected] Abstract. Software architects have techniques to deal with many quality attributes such as performance, reliability, and maintainability. Usability, however, has traditionally been concerned primarily with presentation and not been a concern of software architects beyond separating the user interface from the remainder of the application. In this paper, we introduce usability- supporting architectural patterns. Each pattern describes a usability concern that is not supported by separation alone. For each concern, a usability- supporting architectural pattern provides the forces from the characteristics of the task and environment, the human, and the state of the software to motivate an implementation independent solution cast in terms of the responsibilities that must be fulfilled to satisfy the forces. Furthermore, each pattern includes a sample solution implemented in the context of an overriding separation based pattern such as J2EE Model View Controller. 1 Introduction For the past twenty years, software architects have treated usability primarily as a problem in modifiability. That is, they separate the presentation portion of an application from the remainder of that application.
    [Show full text]
  • Design Patterns Page 497 Thursday, October 14, 1999 2:35 PM
    Design Patterns Page 497 Thursday, October 14, 1999 2:35 PM A P P E N D I X A Design Patterns Design patterns are partial solutions to common problems, such as separating an interface from a number of alternate implementations, wrapping around a set of legacy classes, protecting a caller from changes associated with specific platforms. A design pattern is composed of a small number of classes that, through delegation and inheritance, provide a robust and modifiable solution. These classes can be adapted and refined for the specific system under construction. In addition, design patterns provide examples of inheritance and delegation. Since the publication of the first book on design patterns for software [Gamma et al., 1994], many additional patterns have been proposed for a broad variety of problems, including analysis [Fowler, 1997] [Larman, 1998], system design [Buschmann et al., 1996], middleware [Mowbray & Malveau, 1997], process modeling [Ambler, 1998], dependency management [Feiler et al., 1998], and configuration management [Brown et al., 1999]. The term itself has become a buzzword that is often attributed many different definitions. In this book, we focus only on the original catalog of design patterns, as it provides a concise set of elegant solutions to many common problems. This appendix summarizes the design patterns we use in this books. For each pattern, we provide pointers to the examples in the book that use them. Our goal is to provide a quick reference that can also be used as an index. We assume from the reader a basic knowledge of design patterns, object-oriented concepts, and UML class diagrams.
    [Show full text]