[Course Name] Report: System Design Analysis with UML Pattern Language

This report provides an analysis of pattern language in system design, focusing on the application of creational patterns. It begins by defining pattern language as a method for describing good design practices in software engineering, emphasizing its role in providing reusable solutions to common problems. The report then delves into creational pattern language, which offers ways to create objects by hiding creation logic, enhancing flexibility in object selection. Several creational patterns are discussed, including Singleton, Factory, Factory Method, Abstract Factory, Builder, Prototype, and Object Pool patterns, explaining their functionalities and applications. The report also addresses the problems solved by these patterns, such as errors in constructor creation, challenges in calling constructors, and the creation of complex objects. References to supporting literature are also included. This report is a valuable resource for students studying system design and software engineering, providing a comprehensive understanding of pattern languages and their practical uses. Explore more assignments and solutions on Desklib.

1Pattern Language (System Design Analysis Using UML)
PATTERN LANGUAGE (SYSTEM DESIGN ANALYSIS USING UML)
By (Student names)
[Course Name]
[Lecture Name]
[University Name]
[City where the university is located]
[Date]

2Pattern Language (System Design Analysis Using UML)
Table of Contents
Pattern language..........................................................................................................................................3
Creational pattern language....................................................................................................................3
Patterns within that language.......................................................................................................................3
Problems solved by the pattern and how.....................................................................................................4
Reference.....................................................................................................................................................5

3Pattern Language (System Design Analysis Using UML)
Pattern language
The pattern language is the method used in description of the good designing practices, however
in software engineering the pattern language represents the general and re-usable solutions used
to handle the problems that are likely to occur often during the software designing process but it
does not represent finished design which can be transformed into source or machine codes.
The design pattern therefore was best practices which were applicable repeatedly to similar
problems that were faced in various software designing contexts, the design pattern are highly
used by the developers who have high level of experience in the object oriented programming
and therefore they use them as solution to the various general problems that are faced by
software developers while developing software applications (Karumanchi, 2012).
Creational pattern language
The creational pattern language is the selected pattern language which is a design pattern that
provides the ways of creating objects through hiding of creation logics instead of instantiating
the objects through the use of operators and as a result the developed program becomes more
flexible in selecting the objects to be created for the respective use cases (Goyal, 2011).
Patterns within that language
In the creational pattern language there are various patterns which are used by the system
developers while implementing the systems which include the following:
i. Singleton pattern: This is the pattern used to ensure that there is only one created
instance of the class which is able to provide global accessing points to the system
objects, therefore the singleton design pattern is used mainly to ensure for every class
there is instantiation of only one instance in order to prevent any execution conflict.
ii. Factory patterns: This is the pattern that is used in creation of objects where the
instantiation logics are not exposed to the clients and also it references the newly
created objects using a common interface. Therefore the factory pattern is used in the
situations which the sub-classes are required to select the classes that they need to
instantiate incase an object was requested, it also plays the abstraction role of the
objects instantiation processes through allowing the sub-classes to choose the classes
to instantiate , the factory class also helps in the separations of the applications and

4Pattern Language (System Design Analysis Using UML)
classes which allows loose coupling between the involved child classes and the
applications.
iii. Factory method patterns: This is a pattern that defines the interfaces used to create
objects but allow the sub-classes select the classes that they will insatiate, it also
references new objects that had been created using a common interface.
iv. Abstract factory patterns: This is a pattern that provides the interfaces used to create
the related objects without the specification of the classes explicitly.
v. Builder pattern: This is pattern that defines the instances used to create objects but
give the sub-class option of choosing the classes that they instantiates it also allow
fine control during the process of constructing objects. This pattern is very essential
in the building of the complex objects for instance the email with attachments,
website forms with input fields where it helps the easy objects creation through the
use of common types of interfaces.
vi. Prototype pattern: This is the pattern that specifies the objects types used to create
using the prototypical instances where new objects are created using the copied
prototypes (Gupta, 2015).
vii. Object pool patterns: This is a pattern that reuses and shares the various designing
objects that are quite expensive to create.
Problems solved by the pattern and how
The selected pattern is able to solve various problems which include the following:
i. Errors in constructor creation: This problem is solved by use of the builder helper
class which is assigned some parameters.
ii. Challenges in calling the constructors in a class. This problem is solved by use of the
builder helper class which encapsulates the required state for the object initialization
iii. Challenges of creating objects instances. This is solved by initializing the class which
has a constructor that instantiates the builder object.
iv. Challenge of creating complex objects. This problem is solved by use of the
creational pattern called the builder pattern and this allows various objects creation

5Pattern Language (System Design Analysis Using UML)
using a single and common interface for instance while creating the emails
attachment or the web contact form which has various input text fields.
v. The dependence of the various child classes. This problem is solved through the use
of the factory pattern that helps in the referencing the specific class that the respective
child classes should be instantiating (Award, 2013).
Reference
Award,E.(2013) Systems Analysis and Design .3rd edn.Delhi:Galgotia Publications Pvt Ltd.
Gupta,B.(2015) Power System Analysis and Design.1st edn.New Delhi: S Chand & Company.
Goyal, A. (2011) systems Analysis and Design Paperback .2nd edn.INDIA:Prentice Hall India
Learning Private Limited.
Karumanchi,N.(2012) Peeling Design Patterns: For Beginners and Interviews.5th edn.New
York:CareerMonk Publications.