Klassifikation von Mustern zum Aufbau eines Patlet-Archivs

Gesammelte Adressen von online verfügbaren Mustern
(für künftige Erweiterungen des Muster-Archivs)

Zurück zur Diplomarbeitsseite  

Patterns for Managing Software Evolution
Modell-View-Controller / Composite / Object for State / Editor / Observer / Collect Damage / Update at User Speed / Wrapper
Handlers for Seperating Assembly and Processing
Egalitarian Compensation
Early Program
Architecture Prototype
Interface Prototype
Framework Design for End to End Optimization
A Pattern for Printf Debugging and Similar Meta Services
Patterns for Programming Object Communication
A Pattern for Reducing Resource Bottlenecks by Exchanging Resources 
Roles Before Objects
All At Once
Progress&Training Teams 
Sacrifice One Person
Team Per Task
Teams Integrate Diversity
External Polymorphism
Stairway to Heaven
Type destroyer is type restorer
Asynchronous Completion Token -- An Object Behavioral Pattern for Efficient Asynchronous Event Handling
Active Object -- An Object Behavioral Pattern for Concurrent Programming
Double-Checked Locking -- A Optimization Pattern for Efficiently Initializing and Accessing Thread-safe Objects
External Polymorphism -- An Object Structural Pattern for Transparently Extending Concrete Data Types
Service Configurator -- A Pattern for Dynamic Configuration of Services
Half-Sync/Half-Async -- An Architectural Pattern for Efficient and Well-structured Concurrent I/O
Router -- An Object Behavioral Pattern for Communication Gateways
Thread-Specific Storage -- An Object Behavioral Pattern for Accessing per-Thread State Efficiently
Acceptor-Connector -- An Object Creational Pattern for Connecting and Initializing Communication Services
Proactor -- An Object Behavioral Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events
Reactor -- An Object Behavioral Pattern for Event Demultiplexing and Event Handler Dispatchin
Leading organizations build a strong software architecture that provides the framework for reuse activities.
Leading organizations use a software development process that promotes and controls reuse.
Leading organizations reuse more than just code.
Leading organizations practice domain engineering.
Leading organizations integrate reuse into project management, quality initiatives and software engineering activities.
Leading organizations have an organizational structure that facilitates partnering to achieve reuse across product boundaries.
Leaders use automation to support reuse when and where it makes sense for both managers and technicians as driven by business and technical needs.
Patterns for Interactive Applications
A Pattern for Separating Assembly and Processing 
Loose Interfaces -- Parser/Builder -- Hierarchy of Factories -- Handlers 
Eager Compilation, Lazy Evaluation 
Bootstrap Script
Component Interpreter
Configuration Script
Active File
Glue Code
Command Interceptor
Scripted Components
Abstract Session - an Object Structural Pattern 
Author Biographies
Consistent Headers and Footers
Document-Format Consistency
Document-Content Listing
Immediate Document Discussion
Locatable Documents
Downloadable CGI's
Evolving Documents
Exposable Guts
Interlaced Images
Known Audience
Link-Type Distinction
New-Document Notification
Node-Based Documents
Reachable Author
Readable Documents
Readable Hyperlinks
Readable Indices
Reference Section
Relevant Dates
Sparing Images
Worksheet Documents
Animate the Data
Determine The Actors
Factor Out Common Attributes
Identify Problem Domain Relationships
Identify The Nouns
Introduce Virtual Attributes
Normalize The Roles
Time Thread Analysis
Behavioral Requirements
Business Rules
Classifying, Associating and Grouping the Domain Objects
Managing and Meeting Customer Expectations 
Customer Rapport
Defining Requirements 
Elaboration of the Domain Objects
Finding and Defining the Domain Objects
Information Needs 
Object Aging
Object Stereotypes
Pragmatic External Requirements
Problem Domain Analysis
Requirements Specification
Requirements Validation
Sponsor Objectives 
Organization Follows Location 
Organization Follows Market
Developer Controls Process
Architect Controls Product
Conway's Law
Architect Also Implements
Review the Architecture
Code Ownership
Application Design is Bounded By Test Design
Engage QA
Engage Customers
Group Validation
Scenarios Define Problem
Mercenary Analyst
Shaping Circulation Realms
Move Responsibilities
Buffalo Mountain
Self-selecting team
Work Flows Inward
3 to 7 Helpers per Role
Named Stable Bases
Divide and Conquer
De-couple Stages
Aesthetic Pattern
Take No Small Slips
Solo Virtuoso 
Developing in Pairs
Interrupts Unjam Blocking
Don't Interrupt an Interrupt
Compensate Success
Size the Schedule
Form follows Function
Domain Expertise in Roles
Phasing it In
Class Graph
Inventor's Paradox
Structure-Shy Object
Structure-shy Traversal 
Divide and Modernise
Externalising an internal representation
Portability through backend abstraction
Quality Design Solution for Object Synchronization
Customizable Object Synchronization Pattern 
Component Configurer: A Design Pattern for Component-Based Configuration 
Passive Replicator: A Design Pattern for Object Replication 
Functionality and Partitioning Configuration
Naming and Identification in Distributed Systems: A Pattern for Naming Policies 
Customizable Object Recovery Pattern 
Distributed Proxy: A Design Pattern for Distributed Object Communication
Distributed Proxy: Design Pattern and Framework
Objektorientiertes Design Pattern für Multimedia-Oberflächen
Show Computer is Thinking
Give a Warning
Interaction Feedback
Think Twice
Command Control Center
Explorable Interface
Garden of Windows
Goal Oriented Areas
Modeless Feedback Area
Multiple Settings
Single Setting
Visual Symbols
Foundation Class Package
Common Roles
Concurrently Developed Packages
Defined Roles
Developer Audience
Example Packages
Existing Classes As Roles
Feature Kit Packages
Fundamental Roles
Interface-Oriented Code
Interface Package
Packages as Building Blocks
Refocused Abstract Class
Simple Classes
Tool Kit Package(s)
Use Patterns
Utilities Package(s)
Lazy Optimization: Patterns for Efficient Smalltalk Programming
Added Value
Necessary Failures
Progressive Foundation
Revised, Realistic Resource Application 
Studio Approach
Valued Individuals
Shared Vision AND Shared Reality
Artificial Accessors 
Artificial Delegation
Cached Extensibility
Extensible Attributes 
Generated Accessors 
Selector Synthesis 
Reusability Through Self-Encapsulation
ISO IDL Idioms
Smalltalk Best Practice Patterns
Call by reference
Counted body
Customized allocation
Initialize, not assign
Lifetime follows scope
Return "this" by ref
At-Exit Callback
Foreach Multiset
Traced Variable
Widget Facade
Design Patterns in Python
A Developer Process Generative Pattern Language
"Caterpillar's Fate: A Pattern Language for Transformation from Analysis to Design"
"The CHECKS Pattern Language of Information Integrity"
"New clients with old servers: a pattern language for client/server frameworks"
"A Pattern Language for Tool Construction and Integration Based on the Tools&Materials Metaphor"
Caterpillar's Fate: A Pattern Language for Transition from Analysis to Design 
The CHECKS Pattern Language of Information Integrity 
Early Development 
Partitioning Smalltalk Code into ENVY/Developer Components
ENVY Partitioning
EPISODES: A Pattern Language of Competitive Development Part I
Code Formatting Patterns
Parallel Patterns for Synchronization on Shared-Memory Multiprocessors
Recurring Events 
Stars: A Pattern Language for Query Optimized Schema
Temporary Variables 
User Interface 
Understanding and Using ValueModels 
A Pattern Language for Pattern Writing
Experiences -- A Pattern Language for User Interface Design
Evolving Frameworks
Patterns for Abstract Design
Find Architectural Elements, Identify and Seperate Interactions, Generate Open Arcchitectures, Convert Interactions to Collaborations, Choose Implementaion Techniques, In/Out Module Interface Contract
System Test Pattern Language
RAPPeL: A Requirements Analysis Process Pattern Language for Object Oriented Development
Fault-Tolerant Telecommunication System Patterns
Pattern Language for the Perception, Design and Implementation of Distributed Application Partitioning
PattBPR- A pattern language for business process reengineering
Programmers' Canvas
Patterns for Building an Unusually Adaptable Java Framework
Philosophical Patterns In Software Development
Expedient Smalltalk Programming / "Smalltalk Scaffolding Patterns"
Decoupling of Object Oriented Systems 
Error Handling
Relational Database Access Layers
Client/Server Architectures for Business Information Systems
Form-Based User Interface
Mapping Objects to Tables