View this PageEdit this Page (locked)Attachments to this PageHistory of this PageHomeRecent ChangesSearch the SwikiHelp Guide
Hotspots: Admin Pages | Turn-in Site |
Current Links: Cases Final Project Summer 2007

Fall 2005 Discussion 2

One important area in object-oriented design these days is design patterns. Your discussion assignment is to do some independent reading on design patterns. Then, do the following parts.

Part 1 - Answer One Question

Answer one of the questions below (you do not get credit for answering more than 1).
  1. How do design patterns and a pattern languages differ? What is the use of each?
  2. What are the differences between creational, structural, and behavioral patterns?
  3. How does choice of language affect the use of design patterns?
  4. Describe the Portland Form. Why it is useful?
Again, reference your sources—a URL suffices.

Part 2 - Describe an Interesting Pattern

Describe one design pattern or pattern language in your own words. Again, reference your sources. Explain what interests you about this pattern. Does it make sense to you? Can you see using it in your coding? If so, what for? If not, why not?

Note, plagiarism is unacceptable and (frankly) unnecessary. It's fine if you copy a long quote as long as you reference it and then talk about it in your own words. It's almost as easy and acceptable. As a general rule, academics love to see citations (references) and hate plagiarism. So, do the former and not the latter and you'll be in good shape.

Useful Links

To get started, take a look at some of these links:

Posting your Discussion

  1. Post this assignment to your "Who's Who" page. And, edit it until you are happy with it.
  2. Once you are happy with it, post it to the bottom of this page using the "add to the page" box.
Your post will be graded by how well you answer the one question and how informative your analysis of the pattern is. If you have question about this assignment, ask them here.

Post your contribution here


Discussion 2 - Alex Groleau

The Real Discussion 2 - Michael Levy

Discussion 2 - Michael Levy

Discussion 2 - Nishica Akil

Discussion 2 - Guy Hoskinson

Discussion 2: Kyle Spafford

Discussion 2: Vinny Ramachandran

What are the differences between creational, structural, and behavioral design patterns?

There are many differences between these categories of design patterns. Each of these categories aims to model the solution to a problem through in a certain viewpoint. Since there can almost always be multiple solutions to a single problem, the particular point-of-view about how to solve the problem is unique to each category. In order to better understand the difference, an explanation of each category is necessary.

The first category, creational design patterns, is built on the notion of the creation of objects. The solution in a creational pattern, then, is examined by what is being made. That is, the behavior of a system is described by what kind of objects it is creating(2). For example, the AbstractFactory pattern involves making a single AbstractFactory for each class(5). Then, through polymorphism, it can create whatever object it needs to through one method. So, creation is handled through passing around instances of the AbstractFactory. As one can easily tell, this pattern is centered around the factory creating objects in the program. This is an extremely simple example, but it works well to demonstrate the basics of a creational design pattern.

The next category, structural patterns, tends to be a bit more technical. A structural pattern is a pattern that examines different language mechanisms for structuring code and designing objects(3). Example: The AdapterPattern (also called a wrapper) The AdapterPattern takes some client and an interface that the client understands. It also involves a class that does not understand the interface. Once implemented, the client can then understand the class that previously could not use the interface. Essentially, the Adapter allows two classes to understand each other that could not before(6). With this simple example, one can see the ‘structure’ of how the classes could(n’t) communicate. That is the essence of the structural pattern, the system governing what the classes can and cannot do.

Behavioral design patterns can be based either on class or on objects. With class, behavioral patterns describe how inheritance, algorithms and the flow of control work(4). With behavioral patterns based on objects, the pattern usually describes how the group of objects function together to solve a problem that no class by itself could solve(4). Examine the Chain of Responsibility pattern. In this pattern, there is a sender class and a group of receiver classes. It is unknown what type of object is being sent and how it should be handled. The pattern states that once the object has been sent, each receiver class should examine the object, handle it if possible, and send it to the next receiver if it can’t handle it (7). This pattern is good because it reduces coupling between the sender and receiver. How is this a behavioral pattern? Well, it clearly describes how the receiver objects work to accomplish a goal that they couldn’t do by themselves.

Then, the main difference between these categories of design patterns is how they model the solution to a problem. Creational patterns examine how to create and control instances. Structural problems examine how object function within the rules of a language. And behavioral patterns examine how classes work together to accomplish a goal that no individual one could accomplish.

Interesting Pattern:

Command Pattern

The command pattern involves creating a generic command class with some method that is “do” or “handle.(8)” Since each instance can involve a different set of operations to perform, one can handle anything with this simple generic class. It also makes queuing objects easy, as well as undoing things. I found this pattern interesting because it is particularly useful in network coding. In fact, I used this pattern to handle the communication of a simple client/server system over a TCP/IP socket for a project in 2335. Another of the great advantages of this pattern is its reusability. I was able to use the same basic network code for several different projects that had a client/server networking system. Since it is generic, it is easily portable to other projects.


Discussion 2 - Andrew Calvin

Discussion 2 - Joseph Earle

Discussion 2 - Eric Amy

Discussion 2 - Vinayak Kashyap

Discussion 2 - Vinayak Kashyap

Discussion 2 - Michael Hansen

Discussion 2 - Blake O'Hare

Robert Hutson - Discussion 2

Discussion 2 - Travis Shepherd

Discussion 2 - Brian Henke

Discussion 2 by Michael Gorbsky

Discussion 2 - Jonathan Reitnauer

Discussion 2 - David Eakes

Disscussion 2 - David Eakes

Discussion 2 - Brandon Reynolds

Discussion 2 - Amlan Dasgupta

Discussion 2 - Peter Budny


Discussion 2 - Priyanka Mahalanabis

Discussion 2- Fisnik Shpuza

Discussion 2 - Ejike Onyekwuluje

Discussion 2 - Brad Sickles

Discussion 2 - Nick De Jesus

Discussion 2 - Steven Carr

Josh Holt

"Design patterns can speed up the development process by providing tested, proven development paradigms. Effective software design requires considering issues that may not become visible until later in the implementation. Reusing design patterns helps to prevent subtle issues that can cause major problems and improves code readability for coders and architects familiar with the patterns.

Often, people only understand how to apply certain software design techniques to certain problems. These techniques are difficult to apply to a broader range of problems. Design patterns provide general solutions, documented in a format that doesn't require specifics tied to a particular problem.

Patterns allow developers to communicate using well-known, well understood names for software interactions. Common design patterns can be improved over time, making them more robust than ad-hoc designs."

"A pattern language is a structured method of describing good design practices within a particular domain. It is characterized by

1. Noticing and naming the common problems in a field of interest,
2. Describing the most effective solutions for meeting some stated goal,
3. Helping the designer move from problem to problem in a logical way, and
4. Allowing for many different paths through the design process.

Pattern languages are used to formalize decision-making values whose effectiveness becomes obvious with experience but that are difficult to document and pass on to novices."

Wikipedia describes that a design pattern is a way to solve one problem. Many design patterns within the same scope of problems then form a pattern language.

As a design pattern, I happen to like the Singleton. In 2335, i basically had a static class that was my main class. It contained a ton of static methods and was never instantiated, which is just horrible, horrible design. A better solution is to turn the static class into an instance with all the functionality contained in instance methods and variables, and ensure that one, and only one instance of that class exists at any given time. This is a singleton, and it is usefull for managing resources, such as a database, or server connections, etc.

Chris Whalen

Discussion 2 - Elspeth Watson

Discussion 2 - Daniel Kitchener

Discussion 2 - Ashley Durham

Discussion 2 - G. Stepanov

Discussion 2 - Eliot Kim

Discussion 2 - Tom Filip

Discussion 2 - Peter Kinnaird

Discussion 2 - Joung-Goo Lee

Discussion 2 - William Blatt

Discussion 2 - Laura Parker

Discussion 2 - Hitesh Kanwathirtha

Discussion 2 - Stephen Ake

Discussion 2 - Stephen Ake

Discussion 2 - Matias Paulez


Discussion 2 - Kevin Legette

Discussion 2 - Elizabeth Solomon

Discussion 2 - Shaun Duncan

Discussion 2 - Blake Israel

Discussion 2 - Colin Gillens

Discussion 2 - Benjamin McMillan

Discussion 2 - Vehbi Dragaj

Discussion 2-Nicholas Beckmann

Discussion 2 - Derek DeRaps

Discussion 2 - Daniel Engel

Discussion 2 - John David Shirley

Discussion 2 - James "Ben" Mitchell

Discussion 2 - James "Ben" Mitchell"

Discussion 2 - Dasha Kishinevskaya

Discussion 2 - Hai Phan (gtg394v)

Discussion 2 - Sashmit Bhaduri

Discussion 2 - Brian Partick Smith

Discussion 2 - Elliott Clark

Discussion 2 - Nick Bowman

Discussion 2 - Jason McGarr

Discussion 2 - Izudin Ibrahimbegovic

Discussion 2 Vasilios Pantazopoulos

Discussion 2 - Vishal Patel

Discussion 2 - Nazli Dokuzoglu

Discussion 2 - Nazli Dokuzoglu


Discussion 2 - Trung Lai

Discussion 2 - Trung Lai

Discussion 2 - Erik Webb

Discussion 2 - Daniel King

Discussion 2 - Kevin Adkisson

Discussion 2 - William Lee

Discussion 2 - Jeff Watson

Discussion 2 - Jack Gruendler

Discussion 2 - Oh Kil Kwon

Mark Nichols - Discussion 2

Discussion II-Michael Dunn

Discussion 2 - Chris Ronderos

Discussion 2 - Arwa Tyebkhan

Discussion 2 - Arwa Tyebkhan

Discussion 2 - David Sponaas

Discussion 2 - Brandyn Roemer

Discussion 2 - Brandyn Roemer

Discussion 2 - Stephen Rollyson

Discussion 2 - Patrick Bonaparte

Discussion 2 - Michael Groves

Discussion 2 - Trevor Bentley

Discussion 2 - Ryan Nigro

Discussion 2 - Patrick Jarrett

Discussion 2 - Marcus Moore

Discussion 2 - Jiasheng He


Courtland Goodson - Discussion 2

Discussion 2 - Lee Crippen

Discussion 2 - Nirav Shah

Discussion 2 - Manini Patel

Discussion 2 - Robert Simpson

Discussion 2 Kalpit Patel

Discussion 2 - Cooper Welch

Discussion 2 - Matthew Plowden

Discussion 2 - Emily Ewald

Discussion 2 - R. Steven French

Discussion 2 - Jimmy M. Espana

Discussion 2 - Jimmy M. Espana

Russell Myers' Discussion 2

Discussion 2 - Manabu Shimobe

Discussion 2 - Luis F Cruz

Discussion 2 - Kaori Takeuchi

Discussion 2 - Mark Shalda

Discussion 2 - Amro Mousa

Discussion 2 - Wesley Floyd

Discussion 2 - Arcadiy Kantor

Discussion 2 - David Figlar

Discussion 2 - David Figlar

Discussion 2 - Joaquin Estrada

Discussion 2 - Arcadiy Kantor

Discussion 2 - Samuel Young

Courtland Goodson - Discussion 2

Links to this Page