7 Mar 2007
Part 1 Visitor Pattern by Steve Hayes
Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates. [GoF, p331] Download Presentation Slides
Part 2 Measuring the effects of design patterns by David Kemp
By using software metrics, it may be possible to measure the effect of a design pattern on your software design. As stated in Wikipedia, “A software metric is a measure of some property of a piece of software or its specifications.” In this session, we will discuss a small number of metrics and a small number of design patterns, and look at the impact of one on the other. Download Presentation Slides
06 December 2006
Part 1 Prototype Pattern, by Dave Cameron
Specify the kinds of objects to create using aprototypical instance, and create new objects by copying this prototype. [Design Patterns,Gamma et al]
Part 2 Unit testing Patterns, by Khali Young
TDD is not about testing, it’s about using tests to create software in a simple, incremental way. Not only does this improve the quality and design of the software, but it also simplifies the development process.
If TDD is not about testing, then what are we writing the tests for? Can we write tests which are specifically written for improving design and our development process? A number of questions around this topic will be examined. TDD Design Mind Map OO Design Mind Map An Ideal Test
08 November 2006
Part 1: Command Pattern, by Geoff Burns Encapsulate a request as an object, thereby letting you parameterise clients with different requests, queue or log requests, and support undoable requests. [Design Patterns, Gamma et al] Presentation SlidesPart 2 Book review: Refactoring Databases (Ambler and Sadalage), by Sreeni Ananthakrishna A seminal book describing many techniques to safely make schema changes to a production database. Presentation Slides 11 October 2006
Part 1: Memento Pattern, by Ben Johnston Without violating encapsulation, capture and externalise an object’s internal state so that the object can be restored to this state later. [Design Patterns, Gamma et al]Part 2 Design Pattern Software Tools, by Andy Bulka A discussion of how various UML modelling tools support design patterns. How do they represent design patterns visually and do they let you define your own patterns and add it to their design pattern catalogues? How well is the integrity of a design pattern enforced throughout the lifetime of the development cycle? Andy’s paper Link to Andy’s presentation page Presentation Slides Presentation on YouTube 13 September 2006
Part 1: Chain of Responsibility Pattern, by Guy Geron The Chain of Responsibility (CoR) pattern decouples the sender and receiver of a request by interposing a chain of objects between them..[Design Patterns, Gamma et al]Part 2 Spring Framework, by Scott ArbeitmanSpring is a full-stack Java/J2EE application framework. It includes features such as an IOC container, convenience classes for jdbc, transactions and ORMs plus an MVC web application framework.
16 August 2006
Part 1: Observer Pattern, by Khali Young Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.[Design Patterns, Gamma et al] Presentation SlidesPart 2a: UML 2, by David KempPart 2b: Pracitcal Uses of UML in developing software., by Martin KearnsLove it or hate it, UML seems to be the most widely used notation for expressing software design. Many (most?) software design tools support UML. Many popular books on software design and development use UML, including books on design patterns, refactoring, and software architecture. White board design sessions can be made less ambiguous through the use of formal notations like UML. Thus being fluent in UML is an important skill that every software developer should try to learn. A very brief introduction to the Unified Modelling Language will be given, including a discussion of some of the differences between versions 1 and 2. This will be followed by some discussion of how, when and why you might want to use (or not use) UML. 9 July 2006
Part 1: Mediator Pattern, by John Horman Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.[Design Patterns, Gamma et al] Presentation SlidesPart 2: UML 2, by David Kemp Love it or hate it, UML seems to be the most widely used notation for expressing software design. Many (most?) software design tools support UML. Many popular books on software design and development use UML, including books on design patterns, refactoring, and software architecture. White board design sessions can be made less ambiguous through the use of formal notations like UML. Thus being fluent in UML is an important skill that every software developer should try to learn. A very brief introduction to the Unified Modelling Language will be given, including a discussion of some of the differences between versions 1 and 2. This will be followed by some discussion of how, when and why you might want to use (or not use) UML. Presentation Slides
9 July 2006
Part 1: Mediator Pattern, by John Horman Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. [Design Patterns, Gamma et al]Part 2: UML 2, by David Kemp Love it or hate it, UML seems to be the most widely used notation for expressing software design. Many (most?) software design tools support UML. Many popular books on software design and development use UML, including books on design patterns, refactoring, and software architecture. White board design sessions can be made less ambiguous through the use of formal notations like UML. Thus being fluent in UML is an important skill that every software developer should try to learn. A very brief introduction to the Unified Modelling Language will be given, including a discussion of some of the differences between versions 1 and 2. This will be followed by some discussion of how, when and why you might want to use (or not use) UML. Presentation Slides
21 June 2006
Part 1:Iterator Pattern, by Baljeet Sanohu Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. [Design Patterns, Gamma et al] Presentation SlidesPart 2: Introduction to OFBiz Framework, by Guy Gershoni The Open For Business Project (www.ofbiz.org) is an open source enterprise automation software project licensed under the MIT Open Source License. By open source enterprise automation we mean: Open Source ERP, Open Source CRM, Open Source E-Business / E-Commerce, Open Source SCM, Open Source MRP, Open Source CMMS/EAM, and so on. Presentation Slides
26 April 2006
Part 1: Bridge Pattern, by Derek Weeks Presentation Slides
Part 2: Domain Driven Design – take #2 by Mat Holroyd Presentation Slides, Notes
24 May 2006
Part 1:Composite Pattern, by Aditya Caprihan Presentation Slides
Part 2: Domain Driven Design – take #3 by Mat Holroyd Presentation Slides, Notes
26 April 2006
Part 1: Bridge Pattern, by Derek Weeks Presentation Slides
Part 2: Domain Driven Design – take #2 by Mat Holroyd Presentation Slides, Notes
29 March 2006
Part 1: Adapter Pattern, by Abhijit Hiremagalur Presentation Slides
Part 2: TooledComposite Pattern, by Andy Bulka Presentation Slides
15 February 2006
Book review and discussion: Eric Evans’ Domain-Driven Design, Tackling complexity in the heart of software, moderated by Ben Johnston
18 January 2006
Part 1: Proxy Pattern, presented by Sreeni Ananthakrishna
Part 2: Enterprise Integration Patterns by David Kemp Presentation Slides
See: http://www.enterpriseintegrationpatterns.com/
9 November 2005
Part 1: Builder Pattern, presented by Tracy Oliver
Part 2: Service Oriented Architecture (SOA), presented by Christina Carter and Daryle Burnside
12 October 2005
Part I: Introduction to Python by Bruce Cropley Download PresentationPart II: Python patterns by Bruce Cropley Download Presentation
14 September 2005
Part I: Abstract Factory Pattern, presented by Geoff Burns Presentation SlidesPart II: Continuous Integration by Ben Johnston
17 August 2005
Part I: Template Method Pattern, presented by Dean NethertonPart II: Spring’s support for Inversion of Control by David Kemp Download Presentation
13 July 2005
Part I: Iterator Pattern, presented by Robert SmythPart II: SQLObject– Python object-relational mapper by Andy Bulka
15 June 2005
Part I: Composite Pattern, presented by Christina ChenPart II: Mocking Patterns, presented by Ben Johnston
18 May 2005
Part I: Strategy Pattern, presented by Val SeleznevPart II: Object Role Modeling, presented by Andy Bulka (Video)
20 April 2005
Part I: Decorator Pattern, presented by Ming MaPart II: Modelling in Colour with Archetypes, presented by Ben Sommerville
23 March 2005
Part I: Bridge pattern, presented by Andy Bulka SlidesPart II: Future pattern, presented by David Kemp
23 February 2005
Part I: Abstract Factory by Natalie VincentPart II: Null Object by Ben Johnston
19 January
2005
Part I: State. Discussion of this GOF pattern lead by David Kemp. David’s slides are here.Part II: The Type Object Pattern. Ben Somerville presented this interesting pattern. Some reading is here, and Ben’s slides are here.
3 November
2004
Part I: A Refactoring. Natalie Vincent presented the ‘Extract Superclass’ refactoring from Martin Fowler’s book ‘Refactoring – Improving the Design of Existing CodePart II: Beyond Events. Glenn Stephens travelled from Sydney especially to present his thoughts and implementations of the Command pattern. Glenn’s slides and C# and Delphi examples may be downloaded from here.
6 October
2004
Part I: Visitor. Discussion of this GOF pattern lead by James Hutton.Part II: GOF Patterns in C#. Discussion lead by Andy Bulka.
8 Sept
2004
Part I: Iterator. Discussion of this GOF pattern lead by Natalie Vincent.Part II: Unit Testing Patterns.Orthogonal software design and Test Driven Development: A discussion of
common Unit Testing Patterns and the consequences for software design to be lead by Ben Johnston. Bens presentation and samples may be downloaded from here.
11 August
2004
Part I: Memento. Discussion of this GOF pattern lead by Natalie Vincent.Part II: Blackboard. Andy Bulka lead a discussion of Blackboard, from Patterns of Software Architecture by Bushman et al. Slides Code
14 July
2004
Part I: Flyweight. Discussion of this GOF pattern lead by James HuttonPart II: Dependency Injection. James Hutton introduced this topic, which was presented by Steve Hayes. Martin Fowler’s article on the subject is here.
16 June
2004
Part I: Model-View-Controller, presented by Natalie Vincent – with particular reference to Fowler’s discussion of it in “Patterns of Enterprise Application Architecture”.Part II: Book Review: Object Thinking by David WestThoughts from Andy Bulka.
19 May
2004
Part I: Bridge. Discussion of this GOF pattern lead by James HuttonPart II: An AOP Approach. Conrad Benham presented an Aspect-Oriented-Programming approach to the implementatoin of selected GOF patterns – particularly the Observer pattern. Contrad,s slides and code may be downloaded from here. Reference to the application of AOP to other patterns is here.
21 April
2004
Part I: Decorator. Discussion of this GOF pattern lead by Natalie Vincent.Part II: Fowler’s Offline Concurrency Patterns. David Kemp lead a discussion based on Chapter 16 of Fowler’s ‘Patterns of Enterprise Application Architecture’. Keywords: Optimistic, Pessimistic locking, Coarse grained locking..
10 March
2004
Part I: Chain of Responsibility.. Discussion of this GOF pattern lead by Chetan JoshiPart II: Error-handling patterns and refactoring. James Hutton lead a discussion of some patterns used in error-handling, as well as some related Fowler refactorings.
11 February
2004
Part I: Template Method. Discussion of this GOF pattern lead by James Hutton. Link to ‘Strategy v Template Method’ paper is here.Part II: Database Access Patterns. Discussion of patterns from Martin Fowler’s book ‘Patterns of Enterprise Application Architecture’. Summary of the patterns in the book is here
19 November
2003
Part I: Abstract Factory. Discussion of this GOF pattern lead by Natalie VincentPart II: Aspect Oriented Programming. Inroduction and discussion lead by Conrad Benham. Download presentation.
22 October
2003
Part I: Builder. Discussion of this GOF pattern lead by David Kemp. Download PowerPoint slides, or maze example in java.Part II: Patterns in COM Marshaling. Discussion and demonstration by James Hutton
24 September
2003
Part I: Proxy. Discussion of this GOF pattern lead by Natalie Vincent.Part II: Design Pattern Automation: Presentation and discussion with demonstration of the ModelMaker UML modelling tool by Andy Bulka.
30 July 2003
Part I: Observer. Discussion of this GOF pattern lead by Natalie Vincent.Part II: Garbage Collection: Presentation and discussion lead by James Hutton.
2 July 2003
Part I: Composite. Discussion of this GOF pattern lead by James Hutton.Part II: Relationship Manager: Andy Bulka presented his own pattern : “..a central mediating class
which records all the one-to-one, one-to-many and many-to-many relationships between a group of selected classes.”
4 June 2003
Part I: Strategy. Discussion of this GOF pattern lead by David Kemp. David’s presentation and his demo java code (on a customer pricing strategy) may be downloaded from here.Part II: Two refactorings from Fowler, presented by James Hutton, relating to back pointers: “Change Unidirectional to Bidirectional” and “Change Bidirectional to Unidirectional”
7 May 2003
Part I: Flyweight. Discussion of this GOF pattern lead by Conrad Benham. Download presentation.Part II: A Refactoring: Presentation of the Form Template Method refactoring from Fowler by Natalie Vincent
9 April 2003
Part I: Singleton. Discussion of this GOF pattern lead by Natalie VincentPart II: The Borg Design Pattern – presented by Andy Bulka. Reference here.
12 March 2003
Part I: Memento. Discussion of this GOF pattern lead by Murray BishopPart II: Refactoring. James Hutton demonstrated Fowler’s ‘Replace Exception with Test’ refactoring.
12 February 2003
Part I: Chain of Responsibility. Discussion of this GOF pattern lead by Stuart Pilkington.Part II: C++ and Generic Programming. James Hutton expained how templates work in C++
15 January 2003
Part I: Iterator. Discussion of this GOF pattern lead by Don MacraePart II: A Refactoring: Natalie Vincent demonstrated a refactoring from Fowler
18 December 2002
Part 1 Decorator. Discussion and demonstation of this GOF pattern by James Hutton.Part II: Mediator: A discussion of this pattern with reference to variations as implemented in several gui environments
20 November 2002
Part 1 Interpreter. Discussion of this GOF pattern lead by James Hutton. James’ demontation code may be downloaded from here.
Part II: A Refactoring Demonstrated. Natalie Vincent demonstrated ‘Replace Method with Method Object’, from Martin Fowler’s book
23 October 2002
Part I: Bridge. Discussion of GOF pattern lead by David Kemp.
Part II: Refactoring Tools. A demonstration of editor support of refactoring by Andy Bulka.
25 September 2002
Part I Proxy. Discussion of GOF pattern lead by Natalie Vincent.
Part II The Null Object. Discussion of pattern lead by Andy Bulka. Doco in PLoP3, an old version is at http://www.cs.wustl.edu/~schmidt/PLoP-96/woolf1.ps.gz, and background reading is also here and here.
28 August 2002
Part I: Singleton. Discussion of GOF pattern lead by James Hutton
Part II: Code Smells. Discussion of the notion described by James Fowler in ‘Refactoring – Improving the Design of Existing Code. Lead by Don Macrae
31 July 2002
First of the new format, 4 weekly meetings.Part I: The Command Pattern. Discussion lead by Natalie Vincent of the GOF pattern.
Part II: Five Christopher Alexander Patterns. A discussion lead by James Hutton.
3 July 2002
Serializer (revisited ). A pattern by Dirk Riehle. Doco download.
19 June 2002
Factory and Abstract Factory: What’s the difference? A discussion of these two GOF patterns.
22 May & 5 June 2002
History Patterns. Consideration of Francis Anderson’s paper, ‘A Collection of History Patterns’. In PLoP4, and downloadable from here.
8 May 2002
Design Patterns for Computer Games. A discussion moderated by Andy and Johnno.
24 April 2002
I Are they Patterns? Discussion of a paper by Martijn Van Welie describing a number of well known GUI devices. Download doco.II. Acyclic Visitor. Doco in PLoP3, or http://www.objectmentor.com/resources/articles/acv.pdf
10 April 2002
Extension Object: A pattern by Erich Gamma, one of the GOF. In PLoP3.
13 March 2002
Mediator. GOF pattern, at page 273
13 & 27 February 2002
Lift Simulation. An exercise in using patterns for group members. Rules are available from here. Zip containing the rules and the ShowState.exe are here.Solutions to the problem are also downloadable:
* James Hutton’s C++ solution
* Don Macrae’s Delphi solution
* Andy Bulka’s Python solution
30 January 2002
The Reflection Pattern. Doco at Chapter 17 of PLoP2.
12 December 2001 & 16 January 2002
J2EE Design Patterns. Doco at
http://java.sun.com/blueprints/patterns/j2ee_patterns/catalog.html
28 November 2001
Microsoft’s Multi-User Architecture : from DNA to .Net
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnfmstock/html/fmstocks_starthere.asp
14 November 2001
Big Ball of Mud. Doco at
http://www.laputan.org/mud/mud.html
17 & 31 October 2001
Symmetry and Symmetry Breaking in Software Patterns. Doco at
http://www.bell-labs.com/user/cope/Patterns/Symmetry/GCSE2000/GCSEOOSym.html
3 October 2001
The Selfish Class. Doco at
http://www.joeyoder.com/papers/patterns/Selfish/selfish.html
5 September 2001
Customizable Object Recovery Pattern. Doco at
http://www.esw.inesc.pt/~ars/docs.html , earlier version in PLoP6
22 August 2001
Active Object pattern. Doco at
http://www.cs.wustl.edu/~schmidt/PDF/Act-Obj.pdf
8 August 2001
Reactor pattern. Documentation at
http://webster.cs.uga.edu/~kochut/courses/8060/presentations/papers/patterns/Reactor.pdf
25 July 2001
1. An Implementation of Flyweight
2. Patterns in the Comet library
11 July 2001
Introduction to C++ template idioms
27 June 2001
Half-Sync/Half-Async Pattern
13 June 2001
Selecting Locking Designs for Parallel Programs Pattern Language
30 May 2001
Fibonacci Recruitment Pattern & Coplien Organization Patlets (another set of selected patterns)
16 May 2001
Essence Pattern
2 May 2001
Coplien Organization Patlets (selected patterns)
18 April 2001
Dealing with Roles
4 April 2001
Basic Relationship Patterns
21 March 2001
Product Trader
7 March 2001
Role Object Pattern
21 February 2001
The Trouble with Observer, p72 Pattern Hatching by John Vlissides
13 December 2000
To Kill a Singleton, p61 Pattern Hatching by John Vlissides
22 November 2000
Template Method (GoF 325)
8 November 2000
“Designing with Patterns”; second half of the second chapter from “Pattern Hatching” by John Vlissides
25 October 2000
“Designing with Patterns”; first half of the second chapter from “Pattern Hatching” by John Vlissides
11 October 2000
“Abstraction Descant”, from “Patterns of Software” by Richard Gabriel
27 September 2000
Interpreter pattern (GoF 243)
13 September 2000
Flyweight Pattern (GoF 195)
30 August 2000
Builder Pattern (GoF 97)
16 August 2000
Singleton Pattern (GoF 127)
26 July 2000
RAPPeL: A Requirements Analysis Process Pattern Language for Object Oriented Development
12 July
Chain of Responsibility Pattern (GoF 223)
28 June 2000
Command Pattern (GoF 233)
14 June 2000
Memento Pattern (GoF 283)
31 May 2000
Proxy and Indirection Patterns
17 May 2000
Decorator & Bridge (GoF 175 & 151)
3 May 2000
Wrapper and Adapter (GoF 139)
19 April 2000
Anti Patterns
5 April 2000
State and Strategy (GoF 305 & 315)
22 March 2000
Serializer
8 March 2000
Christopher Alexander’s OOPSLA’96 Speech
23 February 2000
Null Object Pattern
2 February 2000
Visitor (GoF 331)
12 January 2000
Serializer
15 December 1999
OO-RDMBS mapping
1 December 1999
Model View Controller (MVC)
20 October 1999
Christopher Alexander’s “A Pattern Language” (selected patterns)
3 November 1999
Writers workshop II
3 November 1999
Writers workshop I
22 September 1999
A pattern language of pattern writing
30 June 1999
Command (GoF 233)
19 May 1999
Abstract Factory (GoF 87)
5 May 1999
Factory Method (GoF 107)
7 April 1999
Composite (GoF 163)
3 March 1999
Introduction to Patterns
3 February 1999
Opening meeting
