scispace - formally typeset
Search or ask a question
Book

Design Patterns: Elements of Reusable Object-Oriented Software

TL;DR: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns, which most experienced OOP designers will find out they've known about patterns all along.
Abstract: The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out they've known about patterns all along. It's just that they've never considered them as such, or tried to centralize the idea behind a given pattern so that it will be easily reusable.
Citations
More filters
Journal ArticleDOI
TL;DR: M mothur is used as a case study to trim, screen, and align sequences; calculate distances; assign sequences to operational taxonomic units; and describe the α and β diversity of eight marine samples previously characterized by pyrosequencing of 16S rRNA gene fragments.
Abstract: mothur aims to be a comprehensive software package that allows users to use a single piece of software to analyze community sequence data. It builds upon previous tools to provide a flexible and powerful software package for analyzing sequencing data. As a case study, we used mothur to trim, screen, and align sequences; calculate distances; assign sequences to operational taxonomic units; and describe the alpha and beta diversity of eight marine samples previously characterized by pyrosequencing of 16S rRNA gene fragments. This analysis of more than 222,000 sequences was completed in less than 2 h with a laptop computer.

17,350 citations

Book
Martin Fowler1
01 Jan 1999
TL;DR: Almost every expert in Object-Oriented Development stresses the importance of iterative development, but how do you add function to the existing code base while still preserving its design integrity?
Abstract: Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky that code base is structured just right to support the new function while still preserving its design integrity. Of course most of the time we are not lucky, the code does not quite fit what we want to do. You could just add the function on top of the code base. But soon this leads to applying patch upon patch making your system more complex than it needs to be. This complexity leads to bugs, and cripples your productivity.

5,174 citations


Additional excerpts

  • ...[4], [5], [6] Object-oriented design techniques such as CRC[7] focus on defining classes and their protocols....

    [...]

Journal ArticleDOI
Gregor Kiczales1
TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Abstract: The performance of relational database applications often suffers. The reason is that query optimizers require accurate statistics about data in the database in order to provide optimal query execution plans. Unfortunately, the computation of these statistics must be initiated explicitly (e.g., within application code), and computing statistics takes some time. Moreover, it is not easy to decide when to update statistics of what tables in an application. A well-engineered solution requires adding source code usually in many places of an application. The issue of updating the statistics for database optimization is a crosscutting concern. Thus we propose to use aspect-orientation to automate the calculation. We show how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries. Due to the automatic nature, computation takes place on time for complex queries, only when necessary, and only for stale tables. The implementation language for the automated aspect-oriented statistics update concern is AspectJ, a well known and mature aspect-oriented programming language. The approach can however be implemented in any other aspect-oriented language. Unlike in traditional object-oriented pattern solutions, e.g. using the interceptor pattern, we do not have to modify existing code.

5,161 citations


Cites background from "Design Patterns: Elements of Reusab..."

  • ...The agent exposes a façade [23] to which the application needs to make calls at significant points in its execution....

    [...]

  • ...Lohmann, Gal, and Spinczyk [23] demonstrate that these mechanisms can be used to develop code with an aspect-oriented style, but without the obliviousness of aspects: everything must be explicitly instantiated through templates, which have to have the extension points designed in....

    [...]

  • ...P6Spy [28] is a popular library the uses the decorator pattern [23] to collect information about JDBC usage....

    [...]

  • ...The main limitation of implementing aspects as templates and of policy classes is that the extension points of an aspect or the actual policy location of a policy class must be designed into the template [23]....

    [...]

  • ...Springer Berlin Heidelberg 2004 [23] Seshadri, P....

    [...]

01 Jan 1999
TL;DR: The Unified Modeling Language Reference Manual as discussed by the authors provides an excellent real-world guide to working with UML, from structured design methods of the '60s and '70s to the competing object-oriented design standards that were unified to create UML.
Abstract: Written by the three pioneers behind the Unified Modeling Language (UML) standard, The Unified Modeling Language Reference Manual provides an excellent real-world guide to working with UML. This title provides expert knowledge on all facets of today's UML standard, helping developers who are encountering UML on the job for the first time to be more productive. The book begins with a history of UML, from structured design methods of the '60s and '70s to the competing object-oriented design standards that were unified in 1997 to create UML. For the novice, the authors illustrate key diagram types such as class, use case, state machine, activity, and implementation. (Of course, learning these basic diagram types is what UML is all about. The authors use an easy-to-understand ticket-booking system for many of their examples.) After a tour of basic document types, The Unified Modeling Language Reference Manual provides an alphabetical listing of more than 350 UML terms. Entries range from a sentence or two to several pages in length. (Class, operation, and use case are just a few of the important terms that are covered.) Though you will certainly need to be acquainted with software engineering principles, this reference will serve the working software developer well. As the authors note, this isn't UML for Dummies, but neither is it an arcane academic treatise. The authors succeed in delivering a readable reference that will answer any UML question, no matter how common or obscure. --Richard Dragan

4,531 citations

Journal ArticleDOI
TL;DR: Galaxy Pages are interactive, web-based documents that provide users with a medium to communicate a complete computational analysis and provide support for capturing the context and intent of computational methods.
Abstract: Increased reliance on computational approaches in the life sciences has revealed grave concerns about how accessible and reproducible computation-reliant results truly are. Galaxy http://usegalaxy.org, an open web-based platform for genomic research, addresses these problems. Galaxy automatically tracks and manages data provenance and provides support for capturing the context and intent of computational methods. Galaxy Pages are interactive, web-based documents that provide users with a medium to communicate a complete computational analysis.

3,576 citations

References
More filters
Book
James O. Coplien1
01 Sep 1991
TL;DR: In this paper, the authors present an overview of C++'s evolution and its evolution in the context of block-structured programming, including the notion of inheritance, inheritance, and inheritance can be found in C++.
Abstract: Preface. 1. Introduction. C++: An Evolving Language. Handling Complexity with Idioms. Objects for the Nineties. Design and Language. 2. Data Abstraction and Abstract Data Types. Classes. Object Inversion. Constructors and Destructors. Inline Functions. Initialization of Static Data Members. Static Member Functions. Scoping and const. Initialization Ordering of Global Objects, Constants, and Static Class Members. Enforcement of const for Class Object Member Functions. Pointers to Member Functions. Program Organization Conventions. 3. Concrete Data Types. The Orthodox Canonical Class Form. Scoping and Access Control. Overloading: Redefining the Semantics of Operators and Functions. Type Conversion. Reference Counting: Making Variables Use "Magic Memory." Operators new and delete. Separating Initialization from Instantiation. 4. Inheritance. Simple Inheritance. Scoping and Access Control. Constructors and Destructors. Class Pointer Conversion. Type Selector Fields. 5. Object-Oriented Programming. C++ Run-Time Type Support: Virtual Functions. Destructor Interaction and Virtual Destructors. Virtual Functions and Scoping. Pure Virtual Functions and Abstract Base Classes. Envelope and Letter Classes. Functors: Functions as Objects. Multiple Inheritance. The Inheritance Canonical Form. 6. Object-Oriented Design. Types and Classes. The Activities of Object-Oriented Design. Object-Oriented Analysis and Domain Analysis. Object and Class Relationships. Subtyping, Inheritance and Forwarding. Rules of Thumb for Subtyping, Inheritance, and Independence. 7. Reuse and Objects. All Analogies Break Down Somewhere. Design Reuse. Four Code Reuse Mechanisms. Parameterized Types, or Templates. Private Inheritance: Does Inheritance Support Reuse? Storage Reuse. Interface Reuse: Variants. Reuse, Inheritance, and Forwarding. Architectural Alternatives for Source Reuse. Generalizations on Reuse and Objects. 8. Programming with Exemplars in C++. An Example: Employee Exemplars. Exemplars and Generic Constructors: The Exemplar Community Idiom. Autonomous Generic Constructors. Abstract Base Exemplars. Toward a Frame Exemplar Idiom. A Word About Notation. Exemplars and Program Administration. 9. Emulating Symbolic Language Styles in C++. Incremental C++ Development. Symbolic Canonical Form. An Example: A General Collection Class. Code and Idioms To Support Incremental Loading. Garbage Collection. Primitive Type Encapsulation. Multi-Methods under the Symbolic Idiom. 10. Dynamic Multiple Inheritance. An Example: A Multi-Technology Window System. Caveats. 11. Systemic Issues. Static System Design. Dynamic System Design. Appendix A: C in a C++ Environment. Function Calls. Function Parameters. Function Prototypes. Call-by-Reference Parameters. Variable Number of Parameters. Function Pointers. The const Type Modifier. Interfacing with C Code. Appendix B: Shapes Program: C++ Code. Appendix C: Reference Return Values from Operators. Appendix D: Why Bitwise Copy Doesn't Work. Why Member-by-Member Copy Isn't a Panacea. Appendix E: Symbolic Shapes. Appendix F: Block-Structured Programming in C++. What is Block-Structured Programming? Basic Building Blocks for Structured C++ Programming. An Alternative for Blocks with Deeply Nested Scopes. Implementation Considerations Block-Structure Video Game Code. Index. 0201548550T04062001

402 citations

Journal ArticleDOI
TL;DR: The knowledge and skills that were central to each of the above contexts are described and discussed and the functional utility of each is discussed.
Abstract: A designer's expertise rests on the knowledge and skills which develop with experience in a domain. As a result, when a designer is designing an object in an unfamiliar domain he will not have the same knowledge and skills available to him as when he is designing an object in a familiar domain. In this paper we look at the software designer's underlying constellation of knowledge and skills, and at the way in which this constellation is dependent upon experience in a domain. What skills drop out, what skills, or interactions of skills come forward as experience with the domain changes? To answer the above question, we studied expert designers in experimentally created design contexts with which they were differentially familiar. In this paper we describe the knowledge and skills we found were central to each of the above contexts and discuss the functional utility of each. In addition to discussing the knowledge and skills we observed in expert designers, we will also compare novice and expert behavior.

392 citations

Journal ArticleDOI
TL;DR: Object-oriented analysis and object-oriented design rely on classes and objects as the lowest level building blocks to form patterns with specific relationships between them, which standardize small piecework into a larger unit and become building blocks for program design and construction.
Abstract: Object-oriented analysis (OOA) and object-oriented design (OOD) rely on classes and objects as the lowest level building blocks. These classes and objects form patterns with specific relationships between them. Groups of classes in an object-oriented environment are likely to be useful repeatedly. Many patterns may be found by trial-and-error and by observation. Examples of pattern types include item description, time association, event logging, roles played, state across a collection, and broadcast. Patterns standardize small piecework into a larger unit and become building blocks for program design and construction.

380 citations

Book ChapterDOI
04 Jul 1994
TL;DR: This paper shows that patterns can be used to derive an architecture from its problem statement, and the resulting description makes it easier to understand the purpose of the various architectural features.
Abstract: We need ways to describe designs that communicate the reasons for our design decisions, not just the results. Design patterns have been proposed as ways of communicating design information. This paper shows that patterns can be used to derive an architecture from its problem statement. The resulting description makes it easier to understand the purpose of the various architectural features.

259 citations