|
Crossing Chasms: The
Architectural Patterns
by Kyle Brown
This paper is part of a large pattern language (Crossing Chasms)
currently under development by Bruce Whitenack of The Object People
and myself. The pattern language as a whole addresses the issues
faced by teams trying to build large client-server systems using
Object Technology and Relational data stores.
A Pattern Language
for Relational Databases and Smalltalk
By Kyle Brown and Bruce Whitenack
Early in 1995 we (two experienced Smalltalk programmers) began
a project in analysis and design that would tax our abstraction
abilities to their limits. The result of this ongoing exercise is
a pattern language we call Crossing Chasms. This article describes
Crossing Chasms as well as exploring the thought processes that
led us to write it, what we discovered in its writing, and how we
have used the document since its creation.
The Type Object Pattern
by Ralph Johnson and Bobby Woolf
Decouple instances from their classes so that those classes can
be implemented as instances of a class. Type Object allows new "classes"
to be created dynamically at runtime, lets a system provide its
own type-checking rules, and can lead to simpler, smaller systems.
Using Patterns in Order
Management Systems:
A Design Patterns Experience Report
By Kyle Brown
Designing and implementing a new OO system is a challenging task,
especially when the implementors are novice OO programmers. In this
project we turned to design patterns to help design our system,
and to explain the design choices made. Using design patterns helped
us accelerate the design phase of our project, and resulted in a
more easily understandable and better factored design.
Crossing Chasms:
A Pattern Language for Object-RDBMS Integration
"The Static Patterns"
By Kyle Brown and Bruce G. Whitenack
Crossing Chasms is a growing pattern language to help design and
build object-oriented applications that use a relational database
for persistent storage. Crossing Chasm's patterns are categorized
into three groups: static, dynamic and client-server. Static patterns
deal with the definition of the relational schema and the object
model. This section of Crossing Chasms specifically addresses the
static issues.
Understanding
and Using ValueModels
By Bobby Woolf
In Objectworks 4.1, ParcPlace introduced the Value Model framework.
Back then, it only consisted of two concrete classes. The Objectworks
code didn't use this framework very much, so neither did most application
developers. However, this framework was greatly enhanced to help
form the foundation of ParcPlace's next release, VisualWorks 1.0.
This version of Smalltalk expanded the framework to contain numerous
concrete subclasses and associated classes.
Use Cases: the Pros and
Cons
By Donald G. Firesmith
Over the last three years, use cases have become well established
as one of the fundamental techniques of object-oriented analysis.
Although initially introduced by Ivar Jacobson to the object community
at the 1987 OOPSLA conference [1], it was the publication of his
book Object-Oriented Software Engineering: A Use Case Driven Approach
[2] in 1992 that marked the true beginning of use cases´ meteoric
rise in popularity
|
