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.

Design Patterns: Elements of Reusable Object-Oriented Software

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.

/pdf/introducing-mothur-open-source-platform-independent-3tr77w6374.pdf

Introducing mothur: Open-Source, Platform-Independent, Community-Supported Software for Describing and Comparing Microbial Communities

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.

/pdf/refactoring-improving-the-design-of-existing-code-3ls0vii4ns.pdf

Refactoring: Improving the Design of Existing Code

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.

Aspect-oriented programming

物件導向軟體之架構(Object-Oriented Software Construction)探討

Pattern languages of program design

We propose design patterns as a new mechanism for expressing object-oriented design experience. Design patterns identify, name, and abstract common themes in object-oriented design. They capture the intent behind a design by identifying objects, their collaborations, and the distribution of responsibilities. Design patterns play many roles in the object-oriented development process: they provide a common vocabulary for design, they reduce system complexity by naming and defining abstractions, they constitute a base of experience for building reusable software, and they act as building blocks from which more complex designs can be built. Design patterns can be considered reusable micro-architectures that contribute to an overall system architecture. We describe how to express and organize design patterns and introduce a catalog of design patterns. We also describe our experience in applying design patterns to the design of object-oriented systems.

https://link.springer.com/content/pdf/10.1007/3-540-47910-4_21.pdf

Design Patterns: Abstraction and Reuse of Object-Oriented Design

The authors describe a user interface toolkit, InterViews, that offers a rich set of composition mechanisms and a variety of predefined objects, allowing easy implementation of complex user interfaces. InterViews supports composition of three object categories, each implemented as a hierarchy of object classes derived from a common base class. The categories are interactive objects, structured graphics objects, and structured text objects. The authors present several simple applications and show how InterViews objects can implement their interfaces. They illustrate the benefits of separating interactive behavior and abstract data in several different contexts. They discuss InterViews support for end-user customization as well as the status of the current implementation. >

/pdf/composing-user-interfaces-with-interviews-3ahmvsfz3e.pdf

Composing user interfaces with InterViews

Design patterns raise the abstraction level at which people design and communicate design of object-oriented software. However, the mechanics of implementing design patterns is left to the programmer. This paper describes the architecture and implementation of a tool that automates the implementation of design patterns. The user of the tool supplies application-specific information for a given pattern, from which the tool generates all the pattern-prescribed code automatically. The tool has a distributed architecture that lends itself to implementation with off-the-shelf components.

John Vlissides

Papers

Design Patterns: Elements of Reusable Object-Oriented Software

Pattern languages of program design

Design Patterns: Abstraction and Reuse of Object-Oriented Design

Composing user interfaces with InterViews

Automatic code generation from design patterns