Repetition

Saving work.
The foundation of efficient progress.
Systematically developing high quality reusable software components and frameworks is hard.

Repetition is something that occurs at various levels. From a non-technological standpoint, tasks have been automated in society to provide greater use of resources. Adam Smith famously refers to this specialisation of work in his classic work from 1776: The Wealth of Nations". Adam Smith looks at the components of modern economic society that make it efficient. He uses the example of pin-making to get his point across.

The modern pins are computer software programs. Our developers create code which we want to use in our applications with as much efficiency as possible. We want our developers to produce as efficient code as possible.

As a consequence of this, we divide our systems developers and computer programmers into types.

For example we may select someone on the basis of the specialist knowedge that they have, maybe knowledge of a particular technology like:

Microsoft DOTNET
CORBA - Common Object Request Broker Architecture
Sun Java J2EE - Enterprise Edition
RUP - Rational Unified Process
UML - Universal Modelling Language
XML - Extensible Markup Language

Repetition can be formalised internally, thought the assignment of different individual specialists to each set of tasks. This informal specialisation provides the greatest opportunities for quick growth, although it is dependent on the individuals concerned. Here efficiency in the repetition of a variety of tasks is gained through the additional skill level in the individual doing the repetition.

Repetition can be formalised by converting the activity of the developer to something concrete. This is most easily seen in the development of libraries of software functions, in which case a developer need not repeat a piece of code, but instead the developer simply needs to copy the code and then reuse it. Even better is a system where the library performs the interface to the code and the developer simply needs to link in to the function carrying out the task. This is an approach used in Java with the code libraries and with SAP ABAP with the function modules, as well as the provided screens and transactions.

On the code development side, "design patterns" is a form of repetition. The Model-View-Controller framework for Smalltalk [Krasner and Pope, 1988] is one example of an early design pattern. This is equivalent to a "best practice" model of software development.

In terms of modelling, commonly occurring modelled patterns are being mapped within individual companies using the ISO9000 and business definition processes. The attempt to carry this function out at a level beyond the individual business is evolving in a number of directions at the moment, with initiatives like ebXML.

Whether modelling can develop into a truly global structure is a moot point at the moment. The modelling which is carried out for a business incorporates the competitive advantage of the company carrying out the modelling. In this way modelling must always have a unique component for the particular entterprise, however there are some standard functions and standard ways of doing hings which should be cross-corporation and cross-organisation.

As time goes by the set of skills demanded changes. This is largely due to the continual reification of tasks and activities within component systems. For example, recently there has been an increase in demand for skills such as Active Directory, ASP.NET, C#, data modelling, PeopleSoft, SAP APO, SQL Server 2000, Visual Studio.Net and web services, all of which tend to incorporate many computer system designs which have already been reified and componentised.

Here is an example list of current design patterns - thanks to James W. Cooper:

The Factory Method provides a simple decision making class which returns one of several possible subclasses of an abstract base class depending on data it is provided.

The Abstract Factory Method provides an interface to create and return one of several families of related objects.

The Builder Pattern separates the construction of a complex object from its representation, so that several different representations can be created depending on the needs of the program.

The Prototype Pattern starts with an initialized and instantiated class and copies or clones it to make new instances rather than creating new instances.

The Singleton Pattern provides a class of which there can be no more than instance, and provides a single global point of access to that instance.

The Adapter pattern, used to change the interface of one class to that of another one.

The Bridge pattern, intended to keep the interface to your client program constant while allowing you to change the actual kind of class you display or use. You can then change the interface and the underlying class separately.

The Composite pattern, a collection of objects, any one of which may be either itself a Composite, or just a primitive object.

The Decorator pattern, a class that surrounds a given class, adds new capabilities to it, and passes all the unchanged methods to the underlying class.

The Façade pattern, which groups a complex object hierarchy and provides a new, simpler interface to access those data.

The Flyweight pattern, which provides a way to limit the proliferation of small, similar class instances by moving some of the class data outside the class and passing it in during various execution methods.

The Proxy pattern, which provides a simple place-holder class for a more complex class which is expensive to instantiate.

The Observer pattern defines the way a number of classes can be notified of a change,

The Mediator defines how communication between classes can be simplified by using another class to keep all classes from having to know about each other.

The Chain of Responsibility allows an even further decoupling between classes, by passing a request between classes until it is recognized.

The Template pattern provides an abstract definition of an algorithm, and

The Interpreter provides a definition of how to include language elements in a program.

The Strategy pattern encapsulates an algorithm inside a class,

The Visitor pattern adds function to a class,

The State pattern provides a memory for a class’s instance variables.

The Command pattern provides a simple way to separate execution of a command from the interface environment that produced it, and

The Iterator pattern formalizes the way we move through a list of data within a class.