Gang of Four Design Patterns

Summary of all Findings from the Literature Review
Content Summary

What has been done so far • Design Pattern has continuously proven to be an efficient and more reliable solution to common software troubles
• Design patterns existed several years ago with architects of great pyramids using the patterns to envisage and build quality-engineering proof over the years
• Gang of Four patterns can always be redesigned by software engineers in an attempt to create an upshot anticipated by the architect upon completion
• Design Patterns are major tools for propagating the generalist approach regarding structure
• Applying the Gang of Four Design Patterns to facilitate control of software security, by incorporating password that on the users recognize
• Design patterns are categorically identified through documentation with respect to different aspects such as structure, behavior, sample code, linked patterns, intent and motivation
• Design patterns have been used to speed up development processes as it provides tested and proven development paradigm
What needs to be done in the future • Eliminating fear among managers who are always scared of hiring engineers to fix non-critical problems in their software structures within organizational setting
• Establishing a clear foundation (formal foundation) for design patterns as these patterns are extremely ad hoc.
• The concept should be put on a relatively formal footing.
• Using design patterns to enhance efficient and dependable solutions. Design pattern only attempts to standardize the already accepted best practices.
• Developing mechanism that will ensure design patterns differ significantly from all other forms of abstractions.

Annotated Bibliography
Alur, D., Crupi, J., & Malks, D. (2009). Core J2EE patterns: Best practices and design strategies. Upper Saddle River, NJ: Prentice-Hall PTR.
Alur et al notes that the core merits of design patterns are the following. They say that it captures the facility and makes it accessible to unskilled in conventional forms. According to them design patterns facilitates communication amongst software developers and provides a universal language. Design patterns make reuse of designs and ignore options that reduce reusability. In conclusion they say that design patterns assist in design modifications, documentation and the ability to comprehend.
Bishop, J. M. (2007). C♯ 3.0 design patterns. Sebastopol, Calif.: O’Reilly.
Judith bishop split structural patterns into two divisions. These are the composite and flyweight. She notes that the composite and the flyweight structural patterns are used in systems with many objects. She adds that the composite pattern has wider applications and, in addition, their composite lists entail the flyweight patterns. The author states that, in the implementation of the structural patterns, it uses features like generics, properties, struts, indexers, implicit typing, initializers and many others.
Bowers, M. (2007). Pro CSS and HTML design patterns. Berkeley, CA: Apress.
The author explores the successful use of design patterns in software engineering. In the perspective of CSS and HTML, the 23 patterns improvise the output, competence, and resourcefulness in web design and advancement. He defines the design patterns to be sets of universal functionality, which coordinates to work across a range of browsers and display readers. He suggests that they improvise creativity and its output. When combined with other patterns, it forms a complex outcome. These patterns do not bind inventiveness but improve creativity. The author focuses majorly on the core patterns created into CSS and HTML. He explores the new design patterns by bringing in together the recent patterns into the improvised patterns to implement its elements productivity.
Bruce Eckel (2003) Thinking in Patterns by Revision 0.9, 5-20-2003 (This version contains the material that will beused in the Crested Butte seminar; see
http://www.mindview.net/Seminars/ThinkingInPatterns/
In this article, Bruce Eckel writes about the functioning of GoF pattern and designs. In this article, he presents modification in revision and modification. The author presents patterns as a good way to learn from the mistakes of others. This book is especially reliable because it presents 23 ways on how to do this modification of patterns. This author further incorporates his creativity in his work when he categorizes the already categorized patterns into four taxonomic groups. These are idioms, specific design, standard design and design patterns. This publication is commendable as it gets readers who understand designs thinking in patterns. It is a perfect article to use to do further research.
Burge, J. E., & Brinkman, B. (2010). USING RATIONALE TO ASSIST STUDENT COGNITIVE AND INTELLECTUAL DEVELOPMENT. Human Technology, 6(1), 106-128.
In the journal, Janet Burge and Bo Brinkman observe that there is direct link between cognitive development of students and the ability to engage in creative processes. They acknowledged the nine positions of development, which include duality, multiplicity, and relativism, among others. Duality dictates that there are always answers for everything and such answers can be right or wrong. Multiplicity refers to a practice in which all answers are treated as valid. However, relativism is a situation in which researchers begin to evaluate solutions based on context. Just like creativity among students, software development is a creative enterprise. For every problem, there are many possible solutions. In essence, several practitioners are attracted to the field of software development since the exercise involves application of creative design.
Buschmann, F., Henney, K., & Schmidt, D. C. (2007). Pattern-oriented software architecture: Vol. 5. Chichester, England: Wiley.
Frank etal introduces pattern language as a family of inter-connected patterns that define a practice systematically and hence resolving the challenges arising in the course. The authors stress the value of individual patterns. They say that patterns work in groups with other patterns. They state that the best way of representing the design history should be based on rationale and may the future.
They say that the pattern language includes the sequence and therefore the knowledge of how to handle the feedback is very essential. The authors while referring to Jacks work examine the three different types of GoF design pattern highlight the importance of eliminating some pattern types from the groups. He says that creational patterns are required to implement validation.
By Nija Shi, University of California, Davis (2001) Reverse Engineering of Design Patterns from Java Source Code University of Wyoming
In this publication, Ninja examines software pattern designs recovery in software engineering using the GoF patterns. According to their article, dessertition can provide a new automated detection approach upon reclassification of these GoF patterns. To develop this software knowledge individuals must use patterns. GoF (Gang of Four) is one such pattern design. It is especially good because in his research he uses PINOT to detect these GoF patterns. The author believes the research is helpful especially in automated connection breakdown. In this paper, the author purposes to establish a connection between the embedded software and GoF’s software designs. To use PINOT successfully according to the author, learners have to apply the MUSCAT language. This assists in classification of these GoF patterns. This publication is good for further research as it creates a good reference.
Cinneide & Nixon. Automated Software Evolution Towards Design Patterns.
The two writers argue about the evolutionary process that software system has gone through. They acknowledge the importance of refactoring as applied to suitable design patterns to the program that in the end improves its flexibility. An automated support system is highly recommended in performing such transformation because if done by hand it becomes more erratic. The duo therefore developed a methodology that would create an automated transformation that applies a design pattern to already existing program. Apparently, it is technically impossible to get a design pattern right. They make further recommendations that essentially breaks the process of extending a system into two stages namely program restructuring and actual updating. The methodology applied in the article helps in design pattern transformation under development process. The observation by the two if fundamentally important for the research process as it helps in determining the precursor of the design structure.
Duffy, D. J., & Kienitz, J. (2009). Monte Carlo frameworks: Building customisable high performance C++ applications. Chichester, U.K: Wiley.
In this article, the author focuses on implementation of the patterns and designs blueprints by using an arrangement of objective-based oriented and basic programming models. The process of converting patterns to code involves documents in computational devices. However, the author focuses on the object-oriented perspective with its effort on inheritance while others can be implemented as C++template classes. The author uses class and functional templates extensively in this article to help in creating reusable code framework. This helps create possible elastic software that meets existing requirements. The author first considers the structural link between consumer and server components, which is inheritance, and composition. The next step is to conclude if the client has unambiguous knowledge of the names of its servers or in any way interfaces with a basic data type. The specified server type can be instantiated at some point using template instantiation. This creates the possibility to combine OOP and GP hence creating inheritance and composition structures.
Elisa Baniassad L.A. (1997) Design Patterns Rationale Graphs: Linking Designs to Sources M.S. c University of British Columbia
In this paper Elisa, examines and tries to link designs to sources. This paper is especially good because the thesis it contains the department of University of British Columbia accepts them as proven. The author sees the need to link design to sources as the more the designs evolve the more they lose design decisions. This prompted Elisa to research how to link designs to sources. This is a good paper for further research as to have a good research one must consider the source of information.
Erich Gamma (2002) Design Patterns Object Technology International, Zürich
erich_gamma@oti.com
This paper discusses in details the conceptions and misconceptions of designs. A design should provide reuse and guidance according to this author. Erich Gamma also states that a good design should conform to all the literary styles. These design an agreed language of designs where two designers can communicate using the designs. This author presents his work systematically clearly elaborating his points. In case of further research, this paper is a good source of research ideas and reference.
Fischer, T. (2002). Professional design patterns in VB.NET: Building adaptable applications ; [provides examples of design patterns in the data tier, business logic tier, and presentation tier ; introduces a practical approach to design patterns in VB.NET ; covers model/viewer/controller, asynchronous programming, and flexible policy management]. Berkeley, Calif: Apress.
In this paper, Fischer defines the relationship between the different GoF designs. There are twenty-three GoF designs, all of which belong to the same designers. They have a similarity in their application. They have the same concurrency. They have a same double checking spin locking and the same pi calculus. As they have common designers, the Gang of Four (GoF) designs have the same structural origin. Fischer explains that these designers developed a preceding design to develop the subsequent one. This means that all the Gang of Four designs have a relationship in that they are developments of similar designs.
Garzás, J. (2007). Object-oriented design knowledge: Principles, heuristics and best practices. Hershey: Idea Group Pub.
The author in this article explains that a regular layout basing on an extension of OMT (object modeling technique) describes GoF catalogue patterns. This presentation gives an excellent outcast of the patterns, but it is not much reliable to let a designer to exhibit that a certain setback matches an exact pattern or that suggested solution is dependable with a unique pattern. The author further says that, it is hard to ascertain that patterns particularly are most significant and has no inconsistencies. A design process, which takes place in the application of patterns, accompanied with a necessity of elements from pattern roles the design relations redefines itself.
Garzás, J. (2007). Object-oriented design knowledge: Principles, heuristics and best practices. Hershey: Idea Group Pub.
The author in this article explains that a regular layout basing on an extension of OMT (object modeling technique) describes GoF catalogue patterns. This presentation gives an excellent outcast of the patterns, but it is not much reliable to let a designer to exhibit that a certain setback matches an exact pattern or that suggested solution is dependable with a unique pattern. The author further says that, it is hard to ascertain that patterns particularly are most significant and has no inconsistencies. A design process, which takes place in the application of patterns, accompanied with a necessity of elements from pattern roles the design relations redefines itself.
Ghulam Rasool. ( 2010). Customizable Feature based Design Pattern Recognition Integrating Multiple Techniques
In this article, the author focuses on the application of design patterns. The appropriate use of design patterns can be used to improve the quality of software and develop productivity. Adoption of these GoF design patterns in singleton and factory method leads to the implementation of java tool kit in AWT package. The patterns form the fundamental forms of architecture of jikes (C++). The decorator pattern is also applicable in developing websites. The author further explains that GoF patterns used in Microsoft provides .NET developers with the fundamental blocks to accurately construct complex applications to meet structured application environment adaptable to change. The filter pattern in web application patterns executes specific codes provisionally at the beginning and end of the table as indicated by the author. This article is good for research because it analyses and focuses on design information and recovery from legacy application.
Horstmann, C. S. (2009). Object-oriented design & patterns. Hoboken, NJ: Wiley.
Horstman notes that object oriented programming paradigm started in 1960. He notes that the approach is effortless, tangible, flexible, robust and modular. He, however, cautions that if the developer manages it crudely it can be unfortunate. He adds that object oriented is superior to other paradigms because it can increase the number software metrics. He also notes that this programming progress encapsulation. In addition, he acknowledges data driven approach is recognizable with software developers.
Huzar, Z., & CEE Set (3, 2008, Brno). (2011). Software Engineering Techniques: Third IFIP TC 2 Central and East-European Conference, CEE-SET 2008, Brno, Czech Republic, October 13-15, 2008 ; revised selected papers. Berlin [u.a.: Springer.
In the book, the author refers to the catalogue of implemented patterns with all GoF patterns that have the same group of implementation variant for each pattern. He further elaborates on how level of accuracy determines the resolution of the pattern. He further defines observer and iterator patterns according to GoF catalogue. In his research, the author used existing language and he indicates that his main aim is the development of software and not invention. Despite this, throughout the research the author maintains an open mind and changes tools and methodologies to get desired results. He made tests on both the free and the commercial project platforms. Results of this author’s analysis he presents in a table. In the table he shows that Gang of Four as a pattern is secure to apply when handling software.
Jason O. Hallstrom. (2004). design pattern contracts dissertation
In this article, Jason describes design patterns to be commonly recurring problem in object-oriented software and part of the solution to the problem. He analyses the design pattern contract, which characterizes the requirements to be satisfied in the application of specific patterns. It describes the contract that binds two parties. He also covers class structure, role, and its applications. This is only applicable when the specified responsibilities are justified following the complex nature of the design patterns. This article is good for your research because it covers the tools and techniques in the production of quality software on time.
Jason Smith, (2005) Elemental Design Patterns and Automated Design Pattern Analysis U.S. Environmental Protection Agency’s Science to Achieve Results (STAR) program, grant #R-82795901
In this publication, the author writes about sixteen small designs (EDP’s) that can make a pattern in the series of Gang of Four patterns. As they are small designs, it is easy to identify them and find them from a source, as they do not have complications like the GoF designs. This research is good as it is short and precise. The author further details a systematic procedure on how to design patterns. This article is especially good for further research as the author provides active links learners can follow to further their research.
Kedar K. Aras D, (2005) empirical analysis of design patterns: Object Oriented Programming (OOP)
The author puts much emphasis on computer programming that analysis the concept of objects, abstraction, encapsulation, polymorphism inheritance, and inheritance. This is good for the research behind object-oriented programming composing of single units more than the object receiving data and sending to other objects. It also analyses the rules involved and the method to manipulate data. It also explores how a framework of scientific software grows in convolution. This is good for research due to the analysis of the structural development on the morphogenesis of grids of pixels in software patterns.
Kubo, A., Washizaki, H., Takasu, A., & Fukazawa, Y. (2005). EXTRACTING RELATIONS AMONG EMBEDDED SOFTWARE DESIGN PATTERNS. Journal Of Integrated Design & Process Science, 9(3), 39-52.
In this article Washizaki, Takasu and Fukazawa examine software pattern designs in software engineering. According to their article, to develop software knowledge individuals must use patterns. GoF (Gang of Four) is one such pattern design. According to these authors, relation between patterns is further knowledge. The authors believe their research is helpful especially in automated connection breakdown. In their paper, they purpose to establish a connection between the embedded software and Gang of Four software designs. If the investigations prove this connection existed, it would be easy to develop these patterns further.
Larman, C. (2002). Applying UML and patterns: An introduction to object-oriented analysis and design and the unified process. Upper Saddle River, NJ: Prentice-Hall PTR.
In this publication, Larman tell how to apply GoF designs. As he writes issues of multiple conflicting, and design policies are both a requirement and a design problem in the application of GoF designs. The author notes that for safe application the applicants have to solve this. The solution he offers is to define classes of these GoF patterns and apply them for executing similar interface. GoF patterns applicant can redesign them to create the impact the architect intends upon completion. Subsystems components allow for proper monitoring of their application according to Larman. Facades are the entry services of these subsystems and ensure security as they allow for private and secure application.
Lasater, C. G. (2007). Design patterns. Plano: Wordware Pub.
According to Christopher, the design models depend on the aspects of object oriented languages. In addition, the aspects of object oriented are abstraction and encapsulation. Others include polymorphism and inheritance but they are derived form pattern-based coding. The author states that the creational patterns are applied in creating, initializing, and constitution of the objects and classes. This is how they were first grouped by their pioneers (gang of four).creational patterns according to him creates classes, attributes, interface implementation and any other structural types.
MARCEL BIRKNERA, (2007). Objected-oriented design pattern detection using static and dynamic analysis in java software
This article covers the reusable software design patterns and the solutions it covers in every day development in software. It also covers the setbacks of detecting patterns using their static structure and their dynamic behavior. These results can be then useful in verification of the implementation in the phase of software maintenance. The author also notes the importance of documenting design choices in software understanding. The article also covers the detailed definitions of factors in the detection of software design patterns. This article can be very good for research with the use of static and dynamic code analysis on dynamic definitions of GoF patterns and the use of adapter design pattern to run models in detailed basis.
Master’s thesis by Magnus Kardell Umeå University A CLASSIFICATION OF OBJECT-ORIENTED DESIGN PATTERNS retrieved from:
http://www8.cs.umu.se/~jubo/ExJobbs/MK/patterns.htm
In this article, the author refers to the catalogue of implemented patterns with all GoF patterns that have the same group of implementation variant for each pattern. He further elaborates on how level of accuracy determines the resolution of the pattern in his concept of patterns and pattern language. In the section where he addresses construction of patterns, he writes of the three aspects rule in each pattern. He refers to the work of Alexander and writes each pattern has a context a hitch it presents and provides some answers. In his research, the author used existing language and he indicates that his main aim is the development of software and not invention. Despite this, throughout the research the author maintains an open mind and changes tools and methodologies to get desired results. At the end of his research, he presents designs in their categories and describes their interface and function ability. This simplifies further research and makes the article good for further research.
Miguel A. Castro. (2008). Design Patterns http://www.dofactory.com/Patterns/Patterns.aspx
In this article, the author deeply highlights on the GoF patterns. He analyses creational design patterns and its subdivisions. The abstract factory pattern gives an edge for making objects relate without noting the objects core classes. The factory method pattern enables a class to diverge itself from installation to minor classes. He also analyses the builder pattern that distinguishes the making of a complex object from its account to enable the similar construction process. This ensures that there is an output of a dissimilar representation. Prototype pattern, singles out the design of the object under observation using a prototypical instance, and makes new objects by replicating its prototype. Singleton pattern ensures maintenance of one instance in a class and gives a global dimension of accessing it. The coordination of all these creational patterns enhances a systems flexibility in the dimension of what, how and when of the creation of the object. It is applicable when a class wants a divisible subclass to make changes to the object.
The author also looks into Structural patterns. These include adapter patterns that majorly focus on match interfaces of different classes. The bridge pattern specifically separates an interface of an object from its implementation is also a significant pattern. The decorator, facade, flyweight, and proxy that represent another object make up the structural patterns. He also focuses on behavioral patterns. It includes a chain of responsibility, command, interpreter, mediator, state, template method, strategy; iterate that distinctively access sets of elements. This pattern coordinates participants to initiate an object to the next in line. It involves the handler who implements the successor link, the concrete handler that relays request to the successor and finally, the client that initiates the request to an object in the chain. In this article, the author refers to design patterns as to solutions to problems associated with software design in application development. He suggests that the Gang of Four patterns provide a communication policy that relates to commonly encountered programming setbacks. They form the foundation to all the patterns and UML diagrams. This article is convenient for your research due to the detailed analysis of the Gang of Four design patterns.
Miguel A. Castro. (2008). Design Patterns http://www.dofactory.com/Patterns/Patterns.aspx
In this article, the author analyses creational design patterns and its subdivisions. The abstract factory pattern giving an edge for making objects relate without noting the objects core classes enabling a class to diverge itself from installation to minor classes. He also analyses the builder pattern that distinguishes the making of a complex object from its account to enable the similar construction process. The author also looks into Structural patterns: decorator, facade, flyweight, and proxy that represent another object make up the structural patterns. The article also focuses on behavioral patterns including a chain of responsibility, command, interpreter, mediator, state, template method, strategy; iterate that distinctively access sets of elements. This article is genuine for research because it focuses on GoF patterns providing a communication policy that relates to commonly encountered programming setbacks. They form the foundation to all the patterns and UML diagrams. This article is convenient for your research due to the detailed analysis of the GoF design patterns.
Moore, R., & Stevens, M. M. (2008). Local Patterns of Nucleotide Polymorphism Are Highly Variable in the Selfing Species Arabidopsis thaliana. Journal of Molecular Evolution, 66(2), 116-129. Doi: 10.1007/s00239-007-9063-3
In this article, the author explains that the forces that shape patterns are evolutionary and outstanding. This especially is considerable in nucleotide polymorphism. This makes it a crucial aspect in population genetics. Analysis of the patterns in genome suggests that the values involved ensure that general preservation between linked loci takes place. This methodology also extends to protein evolution considerably in mouse genome. This ability of identification is significantly potential as it contributes to change in evolution. The author suggests that balancing in selection may maintain alleles, increasing diversity of nucleotide in selective loci. This roots how peculiar patterns are to evolution.
Nien-Lin, H., Jong-Yih, K., & Ching-Chiuan, L. (2009). Object-oriented design: A goal- driven and pattern-based approach. Software & Systems Modeling, 8(1), 67-84. doi:10.1007/s10270-007-0063-y
Apparently, a software system can be designed by use of AOSD model and in the end make the software system more re-usable. The Object Oriented Model (OOM) has numerous limitations that include comprehensibility, maintainability, adaptability, and re-usability. The results obtained from the AOSD models can be used as a guidebook for the design stage on software expansion process. In addition, the results are integrated into the catalogue of the pattern for future reference.
Philippow, I., Streitferdt, D., Riebisch, M., & Naumann, S. (2005). An approach for reverse engineering of design patterns. Software & Systems Modeling, 4(1), 55-70. doi:10.1007/s10270-004-0059-9
The author in this article explains that pattern search in software systems is oriented considering the human techniques of searching. It corresponds to similar approaches based on search criteria. Search based on this approach alleviates biased positive results and improvise precision value. This encourages the use of bigger software systems to evaluate the search method. The author notes that human based search procedures are preferable on model based design. The languages involved in programming extend to pattern based design to enhance the suitability of source code. This requires the developers to familiarize themselves with the pattern structures and its application. The author further explores the source of code analysis procedures and its extraction from the search criteria. He also notes the ongoing improvisation on reengineering capabilities on integration of algorithms in case tool for comparable results.
Rashid, A., Royer, J.-C., & Rummler, A. (2011). Aspect-oriented, model-driven software product lines: The ample way. Cambridge: Cambridge University Press.
Rashid notes that experts recommended GoF design patterns work out the problems that object oriented could not. He notes that aspect oriented programming started recently as in comparison to object orientated ways. He notes that aspect oriented programming (AOP) uses a case of code scattering, as opposed to others. In addition to that, he argues that AOP benefits are that when using it, GoF patterns are is easy to localize. Therefore, some codes can usually be shared between different pattern instances. He states that the programmer can leave some code level dependencies when using AOP.
Richard Amphlett, Ian Bayley, Lijun Shan, Hong Zhu (2008) Validating the existence of Design Patterns in UML models using First-Order Logic statements derived from GEBNF definitions
Richard Amphlett and fellow researchers look for ways to develop quality software in their quest to equal software engineering to other engineering professions. In their conclusion, they came up with Unified Modeling Language (UML) and design patterns to improve quality of software designs. It is a good article because it explains the reusability of these patterns emphasizing on the popular GoF patterns. For DP verification, they completed UML models and GoF patterns. This is also a good reference for further research.
Robert C. Martin www.objectmentor.com (2000) Design Principles and Design Patterns Copyright (c) 2000 by Robert C. Martin. All Rights Reserved.
Robert C Martin addresses the question of design principle and design patterns in this paper. He explains that each design starts as an idea in the mind of an architect. This article is good for application as he systematically explains how to take the idea from the mind to the actual designing of the pattern. This is a good paper for further research as it contains all details of a research.
Ruel, A. (2011). Piercing by Design. Pottery Making Illustrated, 14(6), 39.
The article provides vital information especially for potters and ceramists on how to create curved and pierced designs. Special focus is to author’s technique to transfer out patterns. The curved designs have varied applications in ceramics among other fields of art. The curved design is also relevant in this of research initiative in an attempt to understand the significant elements of design patterns of various structures.
Savić, D., Simić, D., & Vlajić, S. (2010). Extended Software Architecture Based on Security Patterns. Informatica, 21(2), 229-246.
In this paper, the authors propose three tiered software architecture. Architecture is the chief activity in defining software. This according to these authors ensures security of the software. The writer recommends application of GoF patterns as it is easy to base their application on controlling software security. Savic, Simic and Vlajic in their paper write that identification; authentication and access controls are the key managers of computers security. An easier way to do this is applying a password that only the users know. Authentication determines what the user will and will not do upon gaining access through positive identification. A great part of applying this security is to decide what technology to use in authentication and identification. In this paper, the authors used Gang of Four patterns to define software architecture and process of their security.
Savić, D., Simić, D., & Vlajić, S. (2010). Extended Software Architecture Based on Security Patterns. Informatica, 21(2), 229-246.
In this paper, the authors propose three tiered software architecture. Architecture is the chief activity in defining software. This according to these authors ensures security of the software. The writer recommends application of GoF patterns as it is easy to base their application on controlling software security. Savic, Simic and Vlajic in their paper write that identification; authentication and access controls are the key managers of computers security. An easier way to do this is applying a password that only the users know. Authentication determines what the user will and will not do upon gaining access through positive identification. A great part of applying this security is to decide what technology to use in authentication and identification. In this paper, the authors used GoF patterns to define software architecture and process of their security. This is a good article learners can refer to and from while doing further research.
Schmidt, D. Using Design Patterns and Frameworks to Develop Object-Oriented communication Systems.
Douglas Schmidt observed motivation as an essential tool in the software development. To him, motivation would ensure an efficient, portable, robust and extensible system of technology. Furthermore, motivation helps understand the successful techniques that would prove effective in providing solution to the development challenges. Finally, design patterns would immensely help capture, =articulate and validate some of the successful techniques. According to him, a design pattern would serve to represent solutions to pertinent problems that arise when developing software within a given context. In essence, the design pattern does not represent a vast problem but part of solution to various problems facing the development of software.
Seth James Nielson, (2004). OO++ design patterns: GoF revisited
This article places emphasis on the paradigm as a set of concepts, values, and acts involved in software engineering. These design paradigms comprehend major software tasks that break into relatively smaller logical units and search for solutions to obstacles. The author analyses the programming language features based on the paradigm. This article explores design dysphasia in contemporary object-oriented design and the possible solutions. This article is good for research following the facts it explores the shift in modern languages from object-oriented to paradigm with the resulting dysphasia. It also illustrates on the advantages of evolutionary maintenance in software design patterns for degrading design dysphasia. The basic discussion in this article on the principles related to the twenty-three object oriented patterns and production of multiparadigm patterns in the modern language programming is good for your research.
Shalloway, A., & Trott, J. R. (2009). Design patterns explained: A new perspective on object- oriented design. Boston [u.a.: Addison-Wesley.
Shalloway et al notes that design patterns originated from the works of an architect who tailored the language for encoding the first knowledge for design. They note that the design patterns facilitate the a lot. Because reusable software is hard to make, people prefer using reusable frameworks to avoid to doing repetitive and common coding .Frame work programming support the use of patterns. They note that skilful programmers apply reusable conceptual design to perfect and ease his job.
However, the note that patterns is applied only when the solutions to problems occur repetitively. The author notes that strengths of pattern are the following. They note that a design pattern provides common vocabulary. In addition he notes that design patterns perfectly captures the designer’s knowledge and trade –offs. He notes that, design patterns improve developer’s communication. The author states that design patterns therefore promotes ease of maintenance and furthermore provides a structure for change.
The author however, notes the following to be the limitations to pattern design. He mentions that it cannot facilitate code direct reuse. He adds that pattern design may appear simple but usually it is not simple.
Thilmany, C. (2004). .NET patterns: Architecture, design, and process. Boston, Mass: Addison-Wesley.
Thilmany in his book tells of the history, patterns and the process of designing GoF patterns. Gang of Four is a development of existing work by four men called the Gang of Four (GoF). Today their manifestation is a customary set of technological practices where technologists can construct objects course. Architecture of GoF patterns provides new twists in designing and developing these patterns. While it is possible to categorize Gang of Four patterns, they have subjective categorization where individuals categorize them very differently. The Gang of Four is properly design patterns but it does not necessarily mean the architects were professionals. According to Thilmany, the architectures rely on environmental and technological fundamentals to design these patterns.
Toufik Taibi (2007) Design Patterns Formalization Techniques United Arab Emirates University, UAE
In this publication, Toufik Taibi tells how to apply GoF designs in design patterns formalization techniques. As he writes issues of multiple conflicting, and design policies are both a requirement and a design problem in the application of GoF designs. This is mainly due to the reason that design patterns should prove a solution for reoccurring design problems. The solution he offers is to define classes of these GoF patterns and apply them for executing similar interface. GoF patterns applicant can redesign them to create the impact the architect intends upon completion. Subsystems components allow for proper monitoring of their application according to Toufik Taibi. Facades are the entry services of these subsystems and ensure security as they allow for private and secure application. This publication is good as the author details his research and is applicable for further research.
Vlisides, J. (1995). An Introduction to Design Patterns. Addison- Wesley Publishing Company. Watson Research
Vlisides argues that Design Pattern has four basic parts which include name, problem, solution and consequences as well as trade-offs of application. He points out the significance of setting goals in a research concerning design pattern as it would help codify good design apart from giving design structures explicit names.
Weisfeld, M. (2004). The object-oriented thought process: [an introduction to object- oriented concepts for programmers looking to master modern application development tools, including Java and .NET]. Indianapolis, Ind: Sams.
The author describes the four elements of GoF pattern. First, name of the pattern that addresses the problem with its solution. This improvises the designs vocabulary. Having a wide range of vocabulary enables us to think easy on designs and communicate them to others or even document. Second, the problem that explains on where to apply a pattern. The problem will involve a range of conditions considered before making sense on applying the pattern again. The author also mentions solution as an element that describes the makeup of the design, their association, and collaborations. The solution does not elaborate on a particular solid design a pattern is like an outline that is applicable in a variety of different situations. The author further explains that the pattern gives summary account of a design limit, and how the arrangement of elements solves it. He also views the consequences/tradeoffs of applying the pattern. They are significant for evaluating design alternatives and the remuneration of the applied pattern. These penalties include the impact on systems elasticity and portability.
Weisfeld, M. (2004). The object-oriented thought process: [an introduction to object- oriented concepts for programmers looking to master modern application development tools, including Java and .NET]. Indianapolis, Ind: Sams.
The author describes the four elements of a pattern in GoF. First, name of the pattern that addresses the problem with its solution. This improvises the designs vocabulary. Having a wide range of vocabulary enables us to think easy on designs and communicate them to others or even document. Second, the problem that explains on where to apply a pattern. It elaborates on the setback and its immediate contents. It could elaborate on the design setbacks; describe class/structures that are suggestive of a nonflexible design. The problem will involve a range of conditions considered before making sense on applying the pattern again. The author also mentions solution as an element that describes the makeup of the design, their association, and collaborations. The solution does not elaborate on a particular solid design a pattern is like an outline that is applicable in a variety of different situations. The author further explains that the pattern gives summary account of a design limit, and how the arrangement of elements solves it. He also views the consequences/tradeoffs of applying the pattern. They are significant for evaluating design alternatives and the remuneration of the applied pattern. These penalties include the impact on systems elasticity and portability.
Yacoub, S. M., & Ammar, H. H. (2004). Pattern-oriented analysis and design: Composing patterns to design software systems. Boston [u.a.: Addison-Wesley.
According to Yacoub and Ammar, GoF grouping of design patterns may also be divided into the following. They regard purpose, range as the main branches. According to them, the principles can further be divided into creational, structural, and behavioral. According to them the extent includes class and object patterns. According to Yacoub and Ammar, GoF grouping of design patterns may also be divided into the following. They regard purpose, range as the main branches.
According to them, the principles can further be divided into creational, structural, and behavioral. According to them the extent includes class and object patterns. According to Yacoub and Ammar, Gang of Four grouping of design patterns may also be divided into the following. They regard purpose, range as the main branches. According to them, the principles can further be divided into creational, structural, and behavioral. According to them the extent includes class and object patterns.
Zimmer, W. Relationships between Design Patterns. Karlsruhe, Germany.
In the article, Relationship between Design Patterns, Walter Zimmer recognizes the mutual relationship that exists between the over twenty design patterns. He organizes the relationship into different categories and reviews the design patterns. By organizing such kind of relationships into various categories or classes, it becomes possible to arrange the design patterns in different layers. The general outcome would then simplify the understanding of the overall structure of the catalogue. Thus, it becomes easier trying to classify other design patterns and application of these patterns to development of the software. The article shall have therefore helped in achieving a design pattern that would aid system development.
Literature Review
(I). Evolution of Design Patterns
With the general growth of software design in the field of engineering, design pattern has continuously proven to be an efficient and more reliable solution to common software troubles (Kaisler, 2005). Design patterns existed many years ago with architects of great pyramids using the patterns to envision and construct swanky engineering testimonies over the years. A pattern is a concept of architecture brought in the limelight in the late 1970s by Christopher Alexander (Kaisler, 2005). Apparently, formulization of GoF patterns primarily took three dimensions namely creational, structural and behavioral models. The creational pattern refers to those patterns that would create an object for an individual without necessarily initiating such objects personally. In essence, this will ensure program flexibility. Factory method, prototype, singleton, builder, and abstract factory are examples of creational patterns.
Structural pattern is a kind of pattern majorly concerned with object and class composition. They include the bridge, adapter, decorator, composite, flyweight, façade, and proxy. Behavioral pattern refers to a type of pattern exclusively designed to demonstrate communication between different objects. Examples include command, iterator, mediator, and interpreter among others (Kaisler, 2005).
(II). Origin and Development of Gang of Four Design Patterns
The year 1995 saw The Gang of Four inventing a magnificent chain of design patterns. The initiative to adopting design patterns got rolling in the field of software engineering because of a publication of the four design engineers. The quartet, alias Gang of Four comprises Erich Gamma, Ralph Johnson, Richard Helm and John Vlissides published one of the most famous books in the history of software engineering entitled Design Patterns, Elements of Reusable Object-Oriented Software. They established the difficulty with transforming design pattern directly into code as it is not yet a finished design (Kaisler, 2005). Instead, considered design pattern as template or description of solution to problems, applicable in various situations. Design patterns have gained prominence because they expedite development process by providing tested and proven development paradigms. A valuable software design necessitates consideration of issues, which may not be visible until implementation period (Kaisler, 2005).
Various software engineers, architects and scholars drawn from other fields, reinforced the relevance of design patterns as proposed by the Gang of Four, through diverse publication. Taibi’s work (2007), for instance, emphasized application of GoF design patterns formalization techniques (Taibi, 2007). The design formalization techniques present multiple arithmetical, formal approaches for pattern specification, and laying emphasis on software upgrading. Formalization techniques focuses on making solution element of patterns relatively formal and providing substantial benefits to pattern users, scholars, researchers, practitioners, and students (Taibi, 2007). He argues that multiple conflicting and design policies serve as prerequisite over and above design problem in GoF designs application. In essence, formalization technique would allow readers to make a choice as regards the most suitable formal technique to help solve specific enquiries (Taibi, 2007).
Taibi’s publication shows why it is indispensable to define classes of Gang of Four Patterns and accordingly apply them in executing related interfaces. Fundamentally, a software engineer who applies Gang of Four patterns can always redesign them in an attempt to create an upshot anticipated by the architect upon completion (Taibi, 2007). The subsystem components will allow for proper monitoring of various applications. Taibi believes that facades are the entry services for these subsystems as they allow private and secure application to take pace. In the end, this form of application guarantees the subsystem’s security (Taibi, 2007). The publication of the author is vital for research undertaking in the present and further research in future.
Different authors have acknowledged the existence of design patterns in the universe for quite a few decades. Originally, the Gang of Four that includes Richard Helm, Ralph Johnson, John Vlissides and Erich Gamma created design patterns. The quartet is responsible formalizing the design patterns widely applicable today. Lasater, in his book (2007), goes further to analyze the 23 documented design patterns including principles of object-oriented programming that essentially helps an individual become a better designer. Design patterns are tools of design generally meant to improve the existing code (Lasater, 2007). Through analysis of the 23 design patterns, it would facilitate drafting of a code that is easier to build, implement and maintain. The tools will not only improve efficiency but also allow project developers to improve their overall design skills and quality of projects (Lasater, 2007).
Moreover, design patterns are dependent on the elements of object-oriented languages. Consequently, pattern-based programming will not make much sense without recognition of such languages (Lasater, 2007). Therefore, elements like polymorphism, abstraction, encapsulation and inheritance, which belong to object-oriented languages, extend their features into coding system that is pattern-based. The most interesting thing about design patterns is their capacity to redefine or complement each other (Lasater, 2007). According to the book, creational patterns play crucial role in bringing out the practicality and applicability of design patterns in real life. Ideally, creational patterns act as factories, class iniatializers, builders and configuration constructs. Factory patterns, for instance, are classes that construct or create something. These patterns construct and return an instance of class type in the case of object-oriented code languages. A factory has the ability to initialize, pull in data, set state, configure and execute almost all operations needed for a class (Lasater, 2007).
(III). Implications of Design Patterns
In 2007, a publication by Judith Bishop took a generalist approach to understanding design patterns and problems associated with such patterns. She attests to the significance of design patterns; as they are major tools for propagating the generalist approach. Even though an assessment of the samples from a broad spectrum of software solutions may show wide variations, there is always certain underlying similarity regarding the structure. The designs, alongside implementation of the programming of languages, are the primary examples of the generalist approach. Thus, it becomes hard trying to get more general than a programming language like C# once problem-solving tools are gone. She argues that whenever a new programming language is designed, people tend to think about the day-to-day problems real developers face. Creating a language that solves all these problems in general is inevitable and is one of the powerful ways that are immensely applicable (Bishop, 2007). She believes that this is quite a tedious job that requires good programmers.
Similarly, various design engineers concur that a successful programmer has two primary tools namely fine programming language and design patterns (Bishop, 2007). Judith’s volume shows how the combination would eventually turn ordinary programmers into an empire of pundits. The book has the objective of presenting C# in its best style possible. The five significant features of C# discussed in the book include Generics, which always allow for classifications. In addition, delegates, and methods, which form the parameter of works they store and manipulate, are another important feature (Bishop, 2007). Iterators, which incrementally compute and yield sequences of values and anonymous methods that give room for writing codes inline, are other fundamental features. Finally, partial types, which always give way for breaking down classes, interfaces and structs into multiple pieces, and null able types representing unknown values are other vital features discussed in this book. The author focused on structural patterns as well, which mainly included decorator, bridge and proxy. The structural pattern facilitates a fundamental course of building flexibility, durability and safety into computer software (Bishop, 2007). Other patterns include composite, flyweight, adapter and façade. The major concern of the structural patterns is how composition of objects and classes generally lead to formation of relatively larger structures (Bishop, 2007). The merits of the seven structures patterns are addition of new functionality to already existing objects, control access to objects, creating an expensive object on demand, building an enabling environment for development of interface and component implementation.
(IV). Transformation of Design Patterns
Apparently, the concept of design pattern has undergone a tremendous transformation since the gaining its polarity in the 1970s. Architect Christopher Alexander in his book A Pattern Language, chronicled about 253 classic, tested architectural patterns, which comprises design of cities and buildings. Alexander’s patterns provided the roadmap for other architects and software developers to follow. With increase in studies and researches related to computing pattern language, Buschman among other authors (2007) defines pattern language as family comprising interrelated patterns describing a process that would systematically solve problems arising from development of software for distributed systems. A pattern includes both problem and solution structure, including the rationale that binds them together. Usually, engineers recognize a problem depending on certain conflicting forces, giving detailed insights about the problem. Project developers take advantage of knowledge they already have in applying common techniques to strange applications (Buschman et al, 2007). Patterns originated in the physical world of building though are today popular and widespread in the field of software development. Besides, entire community has sprung up and put much focus on collection and documentation of patterns.
The twenty-three design patterns shaped modern architectural designs apart from improving the quality of buildings among other structures built. Modern architects and software designers (2012) acknowledge the important contributions of previous researches especially those of GoF and Chris Alexander (Buschman et al, 2007). They have categorically generated integrated systems of design patterns to supplement the already invented design patterns. The contemporary patterns provide a refined solution to numerous problems that architects encounter in a bid to apply those patterns that match particular environment. The researches have played critical role of strengthening various sources and materials advanced by Gang of Four among other early scholars of design. Majority of the researches seek to simplify solutions to various problems that software engineers and architects experience (Buchman et al, 2007). The forces characterize in detail the heat of every pattern once the context has set the scene for a problem. Forces will even determine what a suitable and efficient elucidation must take into account. The knowledge about ways of handling feedback as well as sequence of a pattern language should form the basis of determining scope and responsibility of a language. A pattern sequence has the potential to perform a number of roles (Buschman et al, 2007). However, are never explicit as part of presentation of a language. In order to illustrate pattern languages, the common vehicle always in action is stories (Buchman et al, 2007). Although many people take stories literally, a pattern story would end up scaling heights to steal the limelight depending on the language that it represents.
Therefore, it is imperative to strike a balance between the general and specific language patterns. This will ensure documentation of patterns within a language sufficiently completed by the pattern developers (Buschman et al, 2007). The volume also focuses on a distributed system, which is essentially a computing system whereby several components cooperate through communication over a network. The growth of internet and World Wide Web has moved distributed systems to a completely new level. The benefits of distribution include collaboration and connectivity, economics, failure tolerance, scalability and performance, and inherent distribution (Buschman et al, 2007). Distribution has also faced a number of challenges that include accidental complexities, inherent complications, and continuous re-invention.
(V). Relevance of the Ancient and Fashionable Patterns
Patterns such as decorator, façade, strategy, store and forward (S & F) and singleton, have a wide range of application (Fischer, et al, 2007). A middle-tier can be built from these patterns and is able to support web services. Singleton pattern, for instance, facilitate performance in Receive Document application, decorator applicable in Process Document application while Façade pattern simplified access to Inventory system (Fischer, et al, 2007). Overall, all design pattern exhibit the following characteristics: a name, a description of the dilemma addressed, account of the solution, and a comprehensive evaluation of consequences of the pattern. Software architects and developers show much concern about design patterns as the patterns provide common vocabulary thereby facilitating communication (Chung, 2011). The pattern would as well provide guidelines or templates that help in solving basic design problems. Similarly, design patterns provide recipe that is instrumental in understanding the outcome of habitual decisions regarding designs (Kaisler, 2005).
Every development initiative has its challenges in design that might sometimes make it more costly than previously anticipated by the developer. Different developers experience the same problem across the board even if the authorities hand over the yet to be completed project to a different developer. Most engineers find it difficult to contain the pressure to build software that is more reliable swiftly, and making sure, they meet all the prerequisites. By integrating a different idea or technology, the work could sometimes become much simpler. The Gang of Four design patterns have the ability to work out problems that object-oriented patterns cannot provide its solution (Rashid, Royer & Rummler, 2011). According to the trio, in the book entitled: Aspect-oriented, Model-driven software product lines: The ample way, a programming mode, which is aspect-oriented, started recently compared to the object-oriented ways. The aspect-oriented programming (AOP), employs a case of code scattering, which is in contrast to other forms of programming. When aspect-oriented programming (AOP) is used, it becomes easier to localize the Gang of Four patterns. This is one of the fundamental advantages associated with aspect-oriented programming.
Design patterns have come into sight at the forefront of object-oriented software engineering. They have motivated many conferences, books, well-designed solutions of software and online communities. Particularly, GoF patterns are useful in developing productivity and efficiency. It has been noted that design patterns are a crucial method in the toolbox of a software developer. Design patterns are founded on the object-oriented archetype that became fashionable in the 1990s when this new design practice was actually taking the software developing business by storm (Nija Shi, University of California & Davis, 2001).
Notably, there was a technical papers’ proliferation, communities and conferences that offered vehicles for programmers to swap over their latest patterns and ideas. Initially information regarding the design patterns was not appropriately cataloged and understood. This led Erich Gamma, Richard Helm, John Vlissides and Ralph Johnson to remedy the deficiency that was noted. The four wrote a successful book, “Design pattern, elements of reusable object-oriented software” (Nija Shi, University of California & Davis, 2001).The success of the book earned the four developers an affectionate nickname, the “Gang of Four) hence the name GoF design patterns. It is important to note that the book by the four authors led to the launching of design pattern prototype into famous consciousness. The predominant thesis that GoF argued explained as opposed to offering solution to software engineering design problem. Figure 2 below illustrates the relationships between GoF design patterns.
It is easier to share a quantity of patterns between different pattern instances (Rashid, Royer & Rummler, 2011). The programmer will be in a better position to leave some code level dependencies when using aspect-oriented programming. The AOP programming also provides a way of specifying crosscutting apprehension in a system. Hence, it becomes cheaper maintaining systems as they evolve. AOP may also be a great advantage to the toolboxes of quality professionals. In essence, a software technician is able to test the application code automatically with little disturbance to the code when using an AOP language (Rashid, Royer & Rummler, 2011). Observed motivation is another contributing factor to software development. Motivation would ensure robust, portable, extensible and efficient system of technology (Schmidt). A software engineer or an architect requires motivation to understand various techniques that would provide solution to development challenges. Design pattern does not represent a vast problem but is part of the solution to problems facing software development (Schmidt).
Apart from development of software that meets all the prerequisites, professionals need to lay much emphasis on developing finest software. Whenever quality is guaranteed, the users are assured of excellent job in the end. The initiative aimed at developing first-rate software will ensure provision of equal software engineering to other professions (Richard et al, 2008). The Unified Model Language (UML) and design patterns improve the quality of software design. In their article, validating the Existence of Design patterns in UML Models using First-Order Logic Statements, Richard and his colleagues explained the reusability of such patterns, with close emphasis of the GoF patterns. The four software designers completed the Unified Modeling Language (UML) models alongside the GoF patterns to enhance verification of the design patterns (Richard et al, 2008). Their article provides the basis for further research in the field of software engineering and design patterns in general. Software engineering and other engineering professions should be treated as equals (Richard et al, 2008). An efficient design pattern (DP) verification should be developed to counter the timeouts that have accompanied increases in complexity of the UML models. Thus, it will be possible to detect design patterns in real industrial UML models. Following the surging complexity of UML models, it is evident that the number of false positives will also increase mainly due to accidental matches (Richard et al, 2008).
Demonstrating the relevance of design principles is central to the development of a design pattern. To many architects, every design starts as an idea in the mind (Martin, 2000). In his article, Robert Martin attests to the need to take the whole idea from the mind to actual designing of the pattern. The design principles will ensure uniformity in the development of patterns to meet the conventionally accepted standards. Software professionals among other professionals in the field of engineering must adhere to the principles governing design patterns. However, designs might also have weaknesses that always develop in the end (Martin, 2000). There are four assumptions, which show presence of rot and flaws in the design model used. They are fragility, rigidity, viscosity and immobility. Fragility refers to the tendency of the software to break whenever it is changed. Usually, the areas that incur breakages have no conceptual connection with the part that was altered. Thus, managers are scared whenever they authorize a fix because the software could end up breaking in less expected way (Martin, 2000). Rigidity refers to a tendency whereby it becomes difficult to change software.
The moment an alteration is done to a module of software, including simple changes, it turns out to be a weeklong process of initiating change. Hence, managers are scared of hiring engineers to fix non-critical problems in their software structure. Viscosity depends on design and environment. Upon experiencing change, there is always more than one way engineers can employ to effect that change. Some ways will preserve the design while others will not. Viscosity of the environment has to do with inefficient and slow development surrounding. Immobility, which is the failure to reuse software from other projects, would sometimes make particular software obsolete (Martin, 2000). Although the change to the design works, it may at times violate the original design. Introducing new and unplanned dependencies between the modules of the software is to blame for the rise in cases of design rot. The dependency architecture is degraded in the process thus giving room for the ability to maintain the software. Management of dependencies between modules in a given application is inevitable, as it will ensure that degradation of dependency architecture forestall. This involves creating dependency firewalls and ensuring that dependencies do not propagate across such firewalls.
Another fundamental aspect of design pattern is the software engineer’s or architect’s ability to transfer out patterns. Curved designs, in particular, have varied applications in ceramics among other fields of art (Ruel, 2011). Ceramists and potters find curved and pierced designs significant in their day-to-day activities. The two design models help them successfully come up with desirable shapes and designs of their products. Through employing techniques of pierced and curved designs, they find it easier to make products that suit customers’ interest (Ruel, 2011). Glazing techniques, which forms the basis of final steps of pottery making, gives the pottery a personal style. This ranges from a simple technique of finishing an artwork to a more intricate glazing technique. Pottery suppliers have readymade glazes hence can be bought from them. Similarly, the potter may buy raw materials and mix by the potter according to the customers’ specifications. Glazing has gained prominence in the recent past as it adds magnificence (Ruel, 2011). The design presents splendor and attractiveness that is associated with finishes of pottery. Glazing as a technique is ideal for adding beauty to much of the household products, especially those made from pottery and piercing technique. Therefore, glazing forms the basis of desirable design patterns as applied in pottery (Ruel, 2011). In essence, different design patterns and decorations are employed to complete the pottery items.
Software security is another important area in software design. The GoF patterns can be applied to ensure control of software security. However, the key managers of software and computer security as a whole are identification, authentication, and access controls (Savic et al, 2010). The simplest way of applying software security is through application of password that only the users know. Authentication determines the kind of activities the user will do and those that he will not do upon gaining access through successful identification. Technology would be the major determinant of the forms of identification and authentication users are subject. GoF patterns will define the software architecture and due process of their security (Savic et al, 2010).
Software engineers and architects emphasize on paradigm because it is as a set of concepts, values and acts that are involved in software engineering. The design paradigm breaks into smaller units by comprehending major software tasks. The language for programming should also be analyzed carefully based on the paradigm (Nielson, 2004). Seth James in his 2004 article titled: Design patterns: GoF Revisited explores the shift in modern language from the object-oriented to paradigm. The article also pays much focus to the advantages of evolutionary maintenance as manifested in software design patterns for degrading dysphasia. The bottom line is that the twenty-three object-oriented design patterns are applicable various research undertakings in software engineering and architecture (Nielson, 2004).
A design pattern is described as a combination of two objects. The two objects entail an explanation of a problem and the depiction of the solution to the problem. A design pattern depicts a problem in terms of its delineating features (Bowers, 2007). This is then followed by description of the problem with respect to the components involved, the functions of the components and how they work jointly. It must be noted that design patterns are utilized in different lifestyles. They are used in architecture and town planning. More to the point, design patterns are applied to define the features of generic problems in building and civic design (Bowers, 2007). More importantly, they are used to offer standard solution blue prints that are applicable in solving a given problem. However, architects and civic designers must learn to recognize the blue prints in actual life problems. Civic designers and architects are also faced with the challenge of corresponding the patterns to the conceptual problem of one of the principle design patterns, and solving the problem through application of prescribed solution. According to Bowers (2007), design patterns have been utilized with considerable success in software programming. They function to enhance creativity, efficiency and productivity in web development and design. More significantly, design patterns lowers code complexity and bloat. In the context of HTML and CSS, design patterns are common functionality sets that functions across different screen readers and browsers without forfeiting design accessibility, values or depending on filters and hacks. Designs motivate all creative actions and are similar to document templates. With respect to programming, design patterns are akin to reusable algorithms, which can be systematically combined and varied with each other to present desired results. Noticeably, design patterns are used to enhance productivity and creativity in the sense that they help in creating quick results.
Design patterns can as well be integrated with other blueprints to form more complex results through amplifying and simplifying the creative procedure (Bowers, 2007). Gamma (2002) confirms that a pattern is a new means through which problems are solved, and design patterns are established from object-oriented frameworks. Designs patterns facilitate application of insights obtained in framework design to application development. More so, design patterns are more conceptual compared to frameworks and they prose descriptions with few prospects for reuse of code. Garzás (2007) confirms that design patterns are used as common laws to develop software quality model. Due to their well-known constructs and expansive studies concerning them, design patterns offer good solutions to frequent design problems. They help in defining a problem through the form of motivations and intent thereby providing a solution in design motif form. This design motif is known as a prototypical micro-architecture that developers utilizes in their design to help them solve a problem. More so, design patterns are said to enhance software elegancy through reusability, understandability and flexibility (Horstmann, 2009). It must be noted that the elegancy of software is highly crucial in the course of software maintenance since it helps in lowering cost and time of maintainers.
Alur, Crupi & Malks (2009) assert that patterns specifically J2EE patterns are applicable in a project life cycle where they offer considerable benefits. Moreover, patterns can be applied during the implementation stage but one might need to rework the already existing code. Alur, Crupi & Malks (2009) ascertain that design patterns enhances communication between developers of a given software more to the point offering universal language. Particularly, design patterns employ design reuse thereby ignoring alternatives that lowers reusability. Precisely, design patterns facilitate modifications of designs, comprehension and documentation.
Design patterns are categorically identified through documentation with respect to different aspects such as structure, behavior, sample code, linked patterns, intent and motivations. The descriptions and specifications of design pattern are very significant because of their successful recovery and implementation. Competent programmers and designers reuse existing approved solutions that save their efforts and time. Conventionally, patterns were stipulated through class diagrams and informal English where most of writers of patterns apply an integration of graphical notations, sample code fragments and textual descriptions to categorize each pattern (Huzar & CEE, 2011). The structural pattern stipulation is central to patterns specifications given that it stipulates the structure characteristics that are further applied in describing vibrant pattern features. Stipulating pattern solutions at metamodel level of UML permits tool builders to develop enhancements for forming patterns as well as for monitoring conformance to specifications of pattern. This is illustrated in Figure 1 below
Figure 1: Design Patterns Specifications in Reverse and Forward Engineering

Note: From Rasool, G. ( 2010). Customizable Feature based Design Pattern Recognition Integrating Multiple Techniques
Categories of Design Patterns
Holding an affluence of experience as pertaining to object-oriented software design, designers provides a succinct and simple solutions catalog to occurring design issues (Alur, Crupi & Malks, 2009). There are twenty-three general design patterns, which are categorized and based on their scopes and purpose. The purposes on the other hand hold three different categories, which include behavioral, creational and structural. Structural patterns centers on organization of class by roles where structural relationships are used. On the other hand, creational blueprints centers on the manner in which objects are formed while behavioral design patterns centers on separation of object responsibilities that are founded on delegation and polymorphism (Alur, Crupi & Malks, 2009). It must be noted that patterns are portioned through scopes into class or object patterns. Class patterns handle links between classes. The link is formed during compile-time through inheritance.
Remarkably, object patterns handles dynamic links between objects in the course of runtime. It is believed that structural patterns can be determined through inter-class links only and they require less effort to assess. Structural patterns are then followed by creational patterns given that object creation statement can be detected easily. However, behavioral patterns are thought to be the most intricate to detect in the view of the fact that their evaluation of behavior in the technique body is needed. According to Alur, Crupi & Malks (2009), patterns provide expert resolution to recurring issues in a context. In this view, patterns have been captured at different abstraction levels as well as in numerous domains. Besides structural, creational and behavioral patterns, software patterns can as well be classified in terms of design patterns, analysis patterns and architectural patterns.
Bruce (2003) asserts that design patterns are tied in the sphere of design. He further states that a pattern represents a full notion within a program. As a result, it can appear in the analysis level of high-level design stage. A pattern holds a direct execution in code and the fundamental course of a blue print can as well be viewed as the major idea of program design. Bruce (2003) affirms that design patterns demonstrate a superlative means through which one can learn from the mistakes of others. He further ascertains that design patterns are used in isolating changes in ones code. For instance, inheritance can be considered as a design pattern given that design patterns allow one to express disparities in behavior. Burge & Brinkman (2010) confirms that software development is its major creative enterprise. This is in the view of the fact that it helps in providing possible solutions in businesses where designs to handle complex solutions are created.
Figure 2: Links between GoF Design Patterns

Note: From Rasool, G. ( 2010). Customizable Feature based Design Pattern Recognition Integrating Multiple Techniques
With the discovery that design patterns really works, software architects continued to make use of the GoF designs over and over again (Nija Shi, University of California & Davis, 2001). This is in the view of the fact that design patterns solved problems of design besides making object-oriented designs become more flexible, reusable and elegant. In fact, an engineer who is aware of GoF design patterns can apply them straight away to design problems without necessarily rediscovering them.
The GoF catalogues twenty-three design patterns, which are, described as not just a group of ideas that interested the authors but as patterns that represent a design motifs collection that took place regularly in most well developed object-oriented applications. For instance, the adapter pattern comprises of a pattern for translating the crossing point of an already existing class into varying situations with minimal exertion (Bowers, 2007). Every GoF pattern is presented with respect to a statement of problem, generic language, the type of the intent of the pattern, its applicability and inspiration. More so, each Gang of Four pattern is as well presented as a solution description, in terms of its participants list, its structure, the collaborations, pattern application consequences sample code, implementation notes and related patterns list. It must be noted that the twenty-three GoF blue prints are not to be considered as the only OO design patterns that are in constantly used (Bowers, 2007).
Garzás (2007) ascertains the challenges that are still encountered while tackling the formation of OO systems. Specifically, there are major difficulties in the change between the assessment procedure and the object-oriented designs. This aspect is indistinguishable in OO paradigm. However, designers have gathered a body of skills, which are applicable in the course of the procedure. It must be noted that in the past years, these skills were very embedded. Nevertheless, in the contemporary world, the knowledge is being popularized and specified in varying forms, heuristics, patterns, principles and refactoring. The disparities between these notions is basically unclear and not all of these concepts have gotten similar amount of focus or achieved the same maturity degree. Nonetheless, in order to enhance object-oriented designs, OO design knowledge should be used effectively and systematically ( Hallstrom, 2004). This has been made possible through a well-defined ontology that brings together best practices heuristics and principles.
Notably, GoF utilizes composition, inheritance and subtypes that languages with an example of C++ fosters. The GoF illustrates their ideas through Smalltalk and C++. It is imperative to note that the two languages are considered as object-oriented .Nevertheless, GoF patterns are not a universal remedy to all issues and it is essential that one comprehends the situations where their usage is suboptimal as well as the conditions in which these patterns do not operate properly. It is quite important that a developer understand the situations in which he/she might not need to use design patterns. In fact, one would not need to use an instrument that adds complexity level unless the tool offers discernable benefits. Among the major situations that do not require usage of design patterns is when an application that is being developed will never change in the sense that the code captures all needs hence no planned modifications or characteristics are needed in future (Cinneide & Nixon, 2001). When ones’ application code needs are exclusive in the sense that no other software developer has ever developed a similar application code. In such a case, the program does not handle any of routine concerns such as event notification and object creation. More so, when a developer has enough time to protype his new design notions, he/she does not require design patterns.
Evidently, GoF patterns consider micro-patterns and as a result, they are not appropriate as tools for high-level logical or architectural designs. However, this limitation can be resolved through application of suitable POSA patterns. According Nija Shi, University of California & Davis (2001), design patterns enhance existing source code’s assessment tools through bringing program comprehension to the level of design. The advantages of utilizing design patterns for object-oriented software engineering has proven to be significant and numerous. While object-oriented archetype dealt with reusability at the object and algorithm level, design patterns make it easier to reprocess successful designs in the architectural level (Nija Shi, University of California & Davis, 2001). This aspect facilitates faster build up spin as well as a code that is more reliable. Additionally, design patterns form consequences and assumptions of design options more ascetically visible. This raises the procedure of software development.
As far as structural factors are concerned, the factors assess inter-class links in order to determine the structural facets of patterns notwithstanding their behavior factor. The inter-class links entail interface hierarchies, class inheritance modifiers of methods and class, as well as the accessibility and types of attributes. Nija Shi, University of California & Davis (2001) confirm the applicability of GoF patterns in development of software skills. The authors further ascertain that most GoF patterns such as PTIDEL, which recognizes destroyed patterns implementations, and FIJABA, which links fizzy values to definitions of patterns, hold concrete descriptions on their recognition in system behavior and code structure.
Rasool (2010) asserts that design patterns hold the aptitude to enhance quality of software and effectiveness of development. In fact, software developers who adopt practices and patterns expect an average rise of productivity of about twenty five to forty percent. However, this depends on their knowledge level as well as the intricacy of application. Notably, copious commercial, open source and business functions have used patterns productively and have obtained significant advantages in terms of enhanced application management, reduced maintenance cost, reduced updating cost and enhance application performance (Kubo, Washizaki, Takasu & Fukazawa, 2005). Specifically, GoF design patterns are used in varying commercial applications and open source (Smith, 2005). In addition, GoF patterns are applied in architecture where they help in development of architectural frameworks. For instance, Factory and Singleton technique are applied in implementation of java.awt.Toolkit (Rasool, 2010). On the other hand, service oriented architecture blue prints are applied in different web and business services. Particularly, Microsoft practices and patterns offer NET developers a building block and management to speedily develop complex, loosely coupled appliances to achieve their present business requires ( Kedar & Aras, 2005) . More so, Microsoft practices and software offer a structure application atmosphere that is cost effective.
Conversely, Cinneide & Nixon (2001) affirm that design patterns categorically loosen the coupling between elements of a program an aspect that enables particular types of program evolution to take place with minimal modification to the program itself. Nonetheless, program developers must apply an appropriate design pattern into the program to promote its litheness. Through their research, Cinneide & Nixon (2001) developed a method for formation of automated modifications, which can apply design pattern to an already existing program. This is illustrated in the Figure 1 below
Figure 3: The Design Pattern Methodology

Select Design

Pattern

Decide on Precursor for this pattern

Decompose into
Minipatterns
Define Do minitransformations
minitransformations no exist?

Yes
Define transformation as composition
of minitransformations
Note: From Cinneide, M., & Nixon, P (2001). Automated Software Evolution Towards Design Pattern,. Department of Computer Science
Duffy & Kienitz (2009) ascertain that the procedure of transforming patterns to codes entails documents that are in computational devices. However, this is promoted through structural relationship between server components and consumer. The server components include composition and inheritance. According to Duffy & Kienitz (2009), patterns are essential given that they offer designers with an efficient pattern name that serves as an accurate and brief way of referring to a design method that well documented. Among the most popular and specific software design patterns, which are independent of any special application domain, are the GoF patterns. Even though there is naught in design pattern that makes them inherently object-oriented, GoF catalogue utilizes object-oriented ideas to identify twenty-three blue prints. The twenty-three patterns compact and capture the important parts of consequent design solutions. As a result, each GoF pattern describes a group of classes together with the major factors of their interactions and functionality, which generally take place in an assortment of varying object-oriented design issues (Garzás, 2007). The definitions of GoF patterns are widely informal and consist of a blend of a graphical notation that is established on an extension of Object Modeling Technique (OMT) along with sample code and natural language (Duffy & Kienitz, 2009). This process offers a superlative spontaneous picture of the design patterns although it insufficiently permit the designer to exhibit irrefutably that a certain problem corresponds with a certain pattern or that a recommended solution is unfailing to a given pattern. In the context of OMT notation, a design comprises of a collection of classes and relations linking the classes. Principally, each class is indicated as a rectangle that holds the class name, the operations signatures or techniques which class objects can actually perform, as well as the instance or state variables that represent the internal information that is stored through class instances(Duffy & Kienitz, 2009). It is imperative to note that methods and classes are designated as concrete or abstract through writing their names in upright script or italic in the OMT diagram. Reasonable techniques that can be implemented may hold annotations in the OMT diagram (Duffy & Kienitz, 2009). The annotations show the actions that the technique should undertake. They appear in the rectangles with a corner that is folded and are attached to a technique with the class definition rectangle through a dashed line that ends in a small circle.
More so, the notation makes it intricate to be sure that the patterns employed are momentous and hold no inconsistencies. Baniassad (1997) asserts that software is the epitome of the design goals of a system. To help software developers in gaining information of design goals and in inspiring their source code, different perspectives can be employed. Among them is the methods of allowing developers view the source code for design data. These techniques entail encoding design data into source code. More so, there are tools that permit developers to evaluate their code with respect to design. Such instruments utilize mechanisms that authenticate the code structure or formulate design abstractions from source code. The third approach helps developers in tracing objectives down to source.
With respect to design patterns, a software entropy may be lowered if software developers comprehends the underlying principle behind the code (Baniassad, 1997) . Nevertheless, there are notable obstacles to this comprehension. For instance, in an ideal condition, the source code matches the design but in practice, scores of goals cannot be provided through a source code that executed them. This is because some design goals are conceptual such as maintainability or usability while other design goals are more concrete with an example of memory location or blocking. Characteristically, the more conceptual a design goal is, the larger the effect scope on a system. Notably, goals map in varying ways to source data. However, concrete design goals with an example of memory allocation can be presented straightforwardly in given programming languages while design goals like usability may not be openly expressible. However, design goals that are not openly represented in a programming language may be handled in the base of a code (Garzás, 2007). This can happen when software module system simultaneously interacts with several design goals. In this regard, design patterns are written carefully but aligning the solutions offered in design patterns with a certain execution is not usually definite. Baniassad (1997) stresses those mechanisms that help a software developer in upholding rationale recognition must permit crosscutting of nature goals all through a code base. Moreover, the mechanism must be flexible as regards the levels of pensiveness of the goals, must offer information regarding goals in a logically structured means besides enabling a software developer to gain access of rationale information contained by time limits of maintenance activities of software.
According to Shalloway (2009) design patterns came as a result of architects who used tailored language to encode first knowledge for design. It was noted that the design patterns were quite useful in making the work easier. In most cases reusable software is difficult to make and hence people prefer to use reusable frameworks to avoid recurring coding. The use of patterns is also supported by framework programming. Shalloway (2009) adds that advanced programmers apply the reusable conceptual design as a way of making their work easier.
It is also important to note that the patterns can only be applied when the solutions to specific problems occur in many times. According to the author, the Gang of Four (GoF) design patterns have several strengths. These include the ability to provide a common vocabulary and the ability to address the designer’s knowledge. In addition, the developer’s communication is also improved by the designer’s patterns. By using the design patterns, it is easier to promote maintenance while at the same time a structure for change is provided. However, pattern designs have some limitations such as the inability to facilitate code direct reuse
According to Thilmany (2004) the GoF patterns were not very professional as the architectures mainly relied on technological and environmental basics. However, Vlisides (1995) reports that design patterns constitute of four basic parts such as name, problem, solution, and the consequences. He also highlights the importance of setting goals in a research that touches on design pattern as this assists in coding specific designs instead of relying on names alone.
The initial part of the design process is to name the pattern to offer a solution for some problem that may be associated with certain patterns (Weisfeld, 2004).This is quite useful as it also assists in improving the vocabulary of designs. With a wide vocabulary of designs it is easy to understand designs better and to communicate to others easily about them through documentation or verbally.
Vocabulary may also be used to elaborate on the problems facing design patterns and hence enabling the designers to offer appropriate solutions. Description of class structures is also done using vocabulary. Through a pattern, the summary account of the design limit is given. By understanding the patterns, it is easier to evaluate the design alternatives and the cost of applying the patterns.
According to Yacoub & Ammar (2004) The 23 GoF design patterns are categorized based on their purposes and scopes. Purposes are further divided into three categories namely, structural, behavioral, and creative. According to Thilmany (2004) structural patterns focus on class organization by roles where structural relationships such as interface hierarchies, attribute associations, and class inheritances, are used.
Behavioral patterns mainly concentrate on unraveling objects responsibilities based on polymorphism and delegation. In this category, patterns are grouped by their scopes of either object or class patterns (Shi, 2007). All the class patterns are concerned with relationships between classes. This type of relationship is established statically through inheritance and mostly during the compile time. Object patterns deal with active relationship between objects during runtime.
Similarly, researchers believe that structural patterns can be identified based on their inter-class relationships and hence require least energy to analyze. Creation patterns are considered next since it is easy to detect statements of object. According to Shalloway & Trott (2009) behavioral patterns are the most difficult to detect since one is required to analyze the behavior in the method. This has however been disapproved by some researchers who believe this is not always accurate. For instance, according to Shi (2007), the singleton pattern, which is a creational pattern, requires more than just detecting the existence of the object creation. In addition, it is significant to verify the behavior of the method body that creates and returns the singleton.
The flyweight pattern, which is a structural pattern, also requires behavioral analysis to authenticate whether the flyweight objects are singletons and that they are created based on their demand. The template method and Visitor pattern, which are both behavioral patterns, categorize their behavior in the class definitions (Shi, 2007). These definitions are normally identified as per their structural analysis. This categorization is quite useful for programmers but it is not supportive for pattern detection.
It is quite appropriate to categorize patterns in the reverse engineering, using their definitions from structural and behavioral aspects instead of scopes and purposes (Zimmer, 1995). There are some patterns that are mostly driven by code structures and are designed to decouple objects structurally. Other patterns are determined by system behavior and hence need unique actions applied in the method bodies.
From the above observation, it is necessary to reclassify GoF design patterns in the reverse engineering logic. For this to be achieved, the GoF patterns are divided, into five categories, depending on their structural and behavioral similarities (Weisfeld, 2004). These categories include patterns that are already provided in the language, patterns that are determined by structural design and detected by structural analysis, patterns determined by behavioral design and detected by use of static behavioral analysis, domain-specific patterns, and patterns considered only generic models.
In the language-provided patterns, the concept of reverse engineering reverse patterns is not limited to detecting patterns that are illustrated in particular programming language. Instead, the design patterns that are used nowadays use many languages such as Java and Python. They also use packages such as JDK and STL to facilitate programming. Java provides the Iterator and Prototype patterns (Mariano, 2010). Practically, most program developers use such facilities to deliver effective results in building software systems. The patterns are recognized by matching specific names of methods or by ensuring that a class makes use of a java interface.
The structure-driven patterns are recognized by inter-class relationships. This type of relationships forms the basis of the overall system architecture but it does not specify the actual system behavior. Some of the structure-driven patterns include Composite, Bridge, Adapter, Proxy, Façade, Template method, and Visitor patterns. The class hierarchies are separated by the Bridge and Composite patterns on the basis of their association relationships whereas the Facade, Adapter, and Proxy patterns separate class functions based on method delegation relationships. The Visitor and Template Method patterns are known to postpone class tasks through delegation.
Mariano (2010) adds that behavior-driven patterns are designed to fulfill some specific behavioral requirements. These design patterns are entrenched with a program that mainly functions in inter-class relationships and method bodies. Some of the common behavior-driven patterns include the Abstract factory, Singleton, Factory Method, Flyweight, Decorator, Strategy, Chain of Responsibility (CoR), Mediator, State, and Observer patterns.
In general, the GoF creation patterns are determined by some restrictions on object creation, such as the number of objects to be created. For instance, the Singleton pattern guarantees that a class has a maximum of one instance for the entire program implementation (Mariano, 2010). Although the Flyweight pattern classified as a GoF structural pattern, it is designed to handle a collection of sharable objects. The CoR and the Decorator patterns are used to define different behavior depending on how a request is presented to a list of handlers. The decorator allows every handler to process the same request, while the CoR pattern passes a request along until the right handler processes it.
The state and strategy patterns share similar inter-class structures but are different in behavior. Each of the patterns entails a context class with an attribute that takes a function of either strategy or a state (Yacoub & Ammar, 2004). The two patterns are different in how the attribute is modified. In the Strategy pattern, the attribute is actively modified by other class entity by use of the context class, while in the State pattern the attribute is passively modified by state objects.
It was also noted that the Mediator and Observer patterns share the same 1: N aggregation relationship but vary in their communication style. The observer pattern transmits information to its observers while the Mediator pattern serves as the communication centre for its colleagues.
Shi (2007) clarifies that in the domain-specific patterns, the Interpreter and the Command Patterns combine with other GoF patterns to fit in a certain domain. The Interpreter pattern makes use of the Composite pattern structure and the behavior of the Visitor pattern. On the basis of this arrangement and a grammar of language, the Interpreter pattern is able to interpret the language. This pattern is therefore considered as an unusual case of achieving the Visitor and Composite patterns. It was also noted that the command pattern is realization of the Bridge pattern that is used to separate the user interface from the real achievement of the command execution. In contrast, the Command pattern integrates the Composite with an aim of supporting multi-commands and other undoable commands. This is done by use of Memento pattern that stores the history of all the executed commands. It is therefore possible to detect such patterns but their identification requires some evaluation that integrates specific knowledge on domains. This is probably the reason why no engineering work has so far targeted these patterns.
The Assessment of Design Patterns
Design patterns have wide application for building extensible and flexible structures. Incidentally, such application might come along with a considerable reduction in performance which may be unacceptable for intensive scientific applications that are computational in nature. Thus, assessment of effects of design patterns on application performance is inevitable (Birkner, 2007). The investigation is necessitated through a detailed profiling as well as measurement of Computer Cell3D. The ComputerCell3D is a software framework for three-dimensional (3D) modeling of morphogenesis. Morphogenesis is defined as a stage in embryonic development characterized by clustering of cells into tissues and organs (Kedar, 2005). A computer program consists of a collection of individual units contrary to traditional perception of program whereby a program [was considered as merely a list of instructions fed to the computer. Each unit or object has the capacity to receive messages, processing data and sending messages to other units within the system. Hence, it is easier to handle variety of messages by a single chunk of codes or several codes in a seamless way (Kedar, 2005).
One of the most popular and well-developed model of Object-oriented is the class based model. Under the class based model, the general concept of class2 is highly centered. Apparently, a class consists of collection of given types of encapsulated variables alongside the methods. The class gives a description of how objects behave commonly referred to as Instances of that particular class. In addition, a class will specify the structure of data contained in each instance as well as the procedure and methods which themselves manipulate the data of the object (Kedar, 2005). The object-oriented design refers to construction of software systems usually structured collection of classes. Emphasis is always put on structuring of the system around the objects it manipulates. This is in addition to reusing the whole data structures alongside the associated operations. Classes are usually designed as interesting and important on their own way which is independent of the system they belong. Moreover, they can be reused by several other systems. Construction of software is hence viewed as assembly of existing classes, and not as stop-down process that has started from scratch.
The process of designing object-oriented software is quite a challenging task. It is vital for a software engineer or architect to determine the pertinent issues or objects, and accordingly factor them into different classes at a correct granularity (Kedar, 2005). Defining class interfaces and evaluating the hierarchies of inheritance would help establish the major relationships among them. Therefore, the design should be specific to the problem at hand and at the same time general enough to address future problems as well as [requirements. It is necessary for software practitioner to avoid redesign or even attempt to minimize it altogether because it might lead to other complications to the design pattern (Birkner, 2007). The object-oriented systems exhibit patterns of classes and communicating objects. The patterns help solve certain design problems and in the process making object-oriented designs more ultimately reusable, elegant and flexible. Overall, design patterns exhibit the following characteris0tics:
The pattern name forms the basis for describing a design problem, in additions to its solutions as well as the consequences. In addition, the patter will always describe when to apply the pattern. Thus, explains the problem together with the context (Birkner, 2007). Further, the solution would give a comprehensive description of elements that make up design, their responsibilities, collaborations and relationships. The solution does not give a clear description of specific concrete design or even implementation. Instead, it is an abstract description of a design problem including how a particular arrangement of elements can solve it (Birkner, 2007). Finally, design patterns are characterized by an element of consequences which form part of the results and trade-offs that applies to the pattern.
Detecting design patterns facilitates understanding of a program together with existing source code as well as documentation. It is vital to have vast knowledge about software system. The developers of time should understand the fact that a software system decreases provided they have access to good documentation about application design. In essence, a lot of research has been done in design pattern detection area over the last few years. In order to show the effectiveness of software systems, different approaches have been developed with some attaining full implementation. One way of detecting design patterns in C++ code was introduced by Cansino, Esqueer and Espinoza (Birkner, 2007). They formulated a canonical model which represents 9design patterns.

References
Alur, D., Crupi, J., & Malks, D. (2009). Core J2EE patterns: Best practices and design strategies. Upper Saddle River, NJ: Prentice-Hall PTR.
Bishop, J. M. (2007). C♯ 3.0 design patterns. Sebastopol, Calif.: O’Reilly
Bowers, M. (2007). Pro CSS and HTML design patterns. Berkeley, CA: Apress.
Bruce Eckel (2003) Thinking in Patterns by Revision 0.9, 5-20-2003 (This version contains the material that will beused in the Crested Butte seminar; see
Burge, J. E., & Brinkman, B. (2010). Using rationale to assist student cognitive and intellectual development. Human Technology,
Buschman, F., Henney, K. & Schmidt, D. (2007). Pattern-Oriented Software Architecture. John Wiley & Sons Ltd : West Sussex. Volume 4
By Nija Shi, University of California, Davis (2001) Reverse Engineering of Design Patterns from Java Source Code University of Wyoming
Chung, C. (2011). Pro Objective-C design patterns for iOS. New York: Apress.
Cinneide, M., & Nixon, P. (2001). Automated Software Evolution Towards Design Patterns. Department of Computer Science.
Duffy, D. J., & Kienitz, J. (2009). Monte Carlo frameworks: Building customisable high performance C++ applications. Chichester, U.K: Wiley.
Elisa Baniassad L.A. (1997) Design Patterns Rationale Graphs: Linking Designs to Sources M.S. c University of British Columbia
Erich Gamma (2002) Design Patterns. Object Technology International, Zürich
erich_gamma@oti.com
Fischer, Slater, Stromquist, Wu, Gosling, Krowczyk, & Rostad. Professional C# Design Patterns
Garzás, J. (2007). Object-oriented design knowledge: Principles, heuristics and best practices. Hershey: Idea Group Pub.
Ghulam Rasool. ( 2010). Customizable Feature based Design Pattern Recognition Integrating Multiple Techniques
Horstmann, C. S. (2009). Object-oriented design & patterns. Hoboken, NJ: Wiley.
http://www.mindview.net/Seminars/ThinkingInPatterns/
Huzar, Z., & CEE Set (3, 2008, Brno). (2011). Software engineering techniques: third ifip tc 2 central and east-European conference, cee-set 2008, brno, Czech Republic, October 13-15, 2008 ; revised selected papers. Berlin [u.a.: Springer.
Jason O. Hallstrom. (2004). design pattern contracts dissertation
Jason Smith, (2005) Elemental Design Patterns and Automated Design Pattern Analysis U.S. Environmental Protection Agency’s Science to Achieve Results (STAR) program, grant #R-82795901
Kaisler, S. H. (2005). Software paradigms. Hoboken, NJ: Wiley-Interscience.
Kedar K. Aras (2005). Empirical Analysis of Design Patterns-A Case study in ComputerCell3D Notre Dame, Indiana
Kedar K. Aras D, (2005) empirical analysis of design patterns: Object Oriented Programming (OOP)
Kubo, A., Washizaki, H., Takasu, A., & Fukazawa, Y. (2005). Extracting relations among embedded software design patterns. Journal Of Integrated Design & Process Science, 9(3), 39-52.
Lasater, Christopher G. (2007). Design Patterns. Texas: Wordware Publishing, Inc.
Marcel Birkner. (2007). Objected-Oriented Design Pattern detection using
Mariano, I. (2010). The 23 Gang of Four Design Patterns . Retrieved on 25/5/12 from http://geekswithblogs.net/subodhnpushpak/archive/2009/09/18/the-23-gang-of-four- design-patterns-.-revisited.aspx
Rashid, A., Royer, J.-C., & Rummler, A. (2011). Aspect-oriented, model-driven software product lines: The ample way. Cambridge: Cambridge University Press.
Richard Amphlett, Ian Bayley, Lijun Shan, Hong Zhu (2008) Validating the existence of Design Patterns in UML models using First-Order Logic statements derived from GEBNF definitions
Robert C. Martin www.objectmentor.com (2000) Design Principles and Design Patterns Copyright (c) 2000 by Robert C. Martin. All Rights Reserved.
Ruel, A. (2011). Piercing by Design. Pottery Making Illustrated, 14(6), 39.
Savić, D., Simić, D., & Vlajić, S. (2010). Extended Software Architecture Based on Security Patterns. Informatica, 21(2), 229-246.
Schmidt, D. Using Design Patterns and Frameworks to Develop Object-Oriented communication Systems.
Seth James Nielson, (2004). OO++ design patterns: GoF revisited
Shalloway, A., & Trott, J. R. (2009). Design patterns explained: A new perspective on object- oriented design. Boston : Addison-Wesley.
Shi, N. (2007). Reverse Engineering of Design Patterns from Java Source Code. New York: ProQuest.
Static and Dynamic analysis in java Software.
Thilmany, C. (2004). .NET patterns: Architecture, design, and process. Boston, Mass: Addison- Wesley.
Toufik, Taibi (2007) Design Patterns Formalization Techniques United Arab Emirates University, UAE
Vlisides, J. (1995). An Introduction to Design Patterns. Boston: Addison- Wesley Publishing Company.
Weisfeld, M. (2004). The object-oriented thought process: [an introduction to object- oriented concepts for programmers looking to master modern application development tools, inc. Indianapolis: Sams.
Yacoub, S. M., & Ammar, H. H. (2004). Pattern-oriented analysis and design: Composing patterns to design software system lncluding Java and .NET]. Indianapolis : Sams.
Zimmer, W. (1995). Relationships between Design Patterns. Germany: Karlsruhe
Pedersen, R. E. (2009). Game design foundations. Sudbury, MA: Wordware Pub.
Metsker, S. J. (2002). Design patterns Java workbook. Boston [u.a.: Addison-Wesley.