About KSC

Press and Media

Job Opportunities

KSC Articles

Contact KSC

Site Map

Home

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

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 

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

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"

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