SOFTWARE ARCHITECTURE AND DESIGN PATTERN

Hi.. i welcome u all to this blog...
I need to share some knowledge about basics of this subject...

Software: A collection of number of separate programs, configuration
files, which are used to set up these programs, system documentation,
which describes the structure of the system.

Architecture : It is an organizational structure of a system. An
architecture can be recursively decomposed into parts that interact
through interfaces, relationship that connect parts and constraints
for assembling parts. Parts include classes, components and sub
systems.

Software Architecture: It is defined as "Set of a program or
computing system is the structure or structures of the systems, which
comprise software elements, the externally visible properties of those
elements and the relationships among them".
OR
"The structure of the component of a program/ system,their
interrelationships and principles and guidelines governing their
design and evolution over time."

Pattern: Each pattern is a relationship between a certain context, a
certain system of forces which occurs repeatedly in that context and a
certain spatial configuration which allow these forces to resolve
themselves.

Design : Defined as "combination of details or features of something
executed or constructed".

Design Pattern : It describes a commonly recurring structure of
communicating components that solve a general design problem in a
particular context.

Benifits of Design Patterns

A design pattern is a general reusable solution to a commonly occurring problem in software design.

Design patterns give you four main benefits:

(1) design reuse, which is more powerful than code reuse (and often brings code reuse with it);

(2) a common vocabulary for design, each pattern name contributing to that vocabulary;

(3) referring to the patterns you've used in your documentation makes it far easier for others to understand what you did and why, even if they're not up on the design patterns initially;

(4) they help you restructure your system

Systems designed with patterns make it easy to transform an application of one pattern to an application of another

(If anyone can explain in much simplers terms please do come forward and post it so that everyone can understand much better... since as we all know a strong base makes it easier to understand the other related stuffs)

Software Architecture

Software Architecture

Before we try to understand the term Software Architecture, let us understand what is an Architecture?

Architecture is a process of planning and designing of a complex product. Say an Example for Civil engineers, product may be buildings, dams, bridges etc....

So now You may be able to define “what is a Software Architecture?”. It is a process of planning and designing a software.

For a definition,

Software architecture is the process of defining a structured solution that meets all the technical and operational requirements, while optimizing common quality attributes such as performance, security, and manageability.

Let us see what are the Advantages of Software Architecture?

• Architecture drives architectural integrity

to make sure that the architecture provides a solid framework for the work undertaken by the designers and implementers.

• Architecture helps manage complexity

• Architecture provides a basis for reuse

• Architecture reduces maintenance costs

• Architecture supports impact analysis

An important benefit of architecture is that it allows us to reason about the impact of making a change before it is undertaken. An architecture identifies the major components and their interactions, the dependencies between components, and traceability from these components to the requirements that they realize.

Key Architecture Principles

Consider the following key principles when designing your architecture:

• Build to change instead of building to last. Consider how the application may need to change over time to address new requirements and challenges, and build in the flexibility to support this.

• Model to analyze and reduce risk. Use design tools, modeling systems such as Unified Modeling Language (UML), and visualizations where appropriate to help you capture requirements and architectural and design decisions, and to analyze their impact. However, do not formalize the model to the extent that it suppresses the capability to iterate and adapt the design easily.

• Use models and visualizations as a communication and collaboration tool. Efficient communication of the design, the decisions you make, and ongoing changes to the design, is critical to good architecture. Use models, views, and other visualizations of the architecture to communicate and share your design efficiently with all the stakeholders, and to enable rapid communication of changes to the design.

• Identify key engineering decisions. Invest in getting these key decisions right the first time so that the design is more flexible and less likely to be broken by changes.

Design Pattern

From the previous section we understood about software architecture. Here we are going to describe about design patterns.

• When ever you are planning and designing something, you may get similar kind of difficulties in different project. Here comes the use of Design Pattern.

  Definition:- In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design.

  A design pattern isn't a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

  
  

  A pattern must explain why a particular situation causes problems, and why the proposed solution is considered a good one. A pattern must also explain when it is applicable.

  
  

Design patterns

Instead of defining what is design pattern...Lets define what we mean by design and what we mean by pattern.

In general we all know design is blue print or sketch of something so it can be defined as creation of something in mind and about pattern, we can define it as guideline, or something that repeats.

Now the definition of design pattern becomes creating something in mind that repeats or in other words capturing design ideas as a "pattern" to the problems.( Don't u think it sounds interesting.... :))

Design Pattern provides a core of the solution in such a way that you can use the core solution every time but implementation should and may vary ....

The main reason behind that is we have the core solution and not the exact solution.

An example.....

Lets discuss an simple example here about database normalization.

Normalization is a pattern (Core solution to database design) but what level of normalization you need (exact solution) depends on your requirement and context.

(any addition or any changes please kindly let me know.. :))

Software Architecture, Design and Patterns

Software Architecture

Software architecture is actually combination of following concerns:

• An overall view of the solution to a problem.
• Extensible to extent.
• Easily Maintained.
• Easily debuggable.
• Loosely coupled among integrated components/modules.
• Platform independent if possible.
• Documented enough so that can be viewed in papers.
• Optimizable.

Software Design Patterns

Software design is a process of problem-solving and planning for a software solution. After the purpose and specifications of software is determined, software developers will design or employ designers to develop a plan for a solution. It includes low-level component and algorithm implementation issues as well as the architectural view.

A software design pattern describes a family of solutions to a software design problem. It consists of one or several software design elements such as modules, interfaces, classes, objects, methods, functions, processes, threads, etc., relationships among the elements, and a behavioral description.

Example of an software application Architecture

Software application architecture is the process of defining a structured solution

that meets all of the technical and operational requirements,

while optimizing common quality attributes such as performance, security, and manageability.

It involves a series of decisions based on a wide range of factors,

and each of these decisions can have considerable impact on the quality, performance,

maintainability, and overall success of the application.

Like any other complex structure, software must be built on a solid foundation.

Some of the factors which might put our applications at risk are given below...

1) If we fail to consider key scenarios

2) failing to design for common problems

3) failing to appreciate the long term consequences of key decisions.

Few Modern tools and platforms may help to simplify the task of building applications,

but they do not replace the need to design our application carefully,

based on our specific scenarios and requirements.

If the architecture is poor then the risk exposed by the poor design includes few of these below

1) it will be unstable

2) it will be unable to support existing or future business requirements,

3) it will also be difficult to deploy or manage in a production environment.

Application architecture seeks to build a bridge between business requirements and

technical requirements by understanding use cases,

and then finding ways to implement those use cases in the software.

The goal of architecture is to identify the requirements that affect the structure of the application.

Good architecture reduces the business risks associated with building a technical solution.

Keep in mind that the architecture should:

Expose the structure of the system but hide the implementation details.

Realize all of the use cases and scenarios.

Try to address the requirements of various stakeholders.

Handle both functional and quality requirements.

(if any changes or any additions or something wrong kindly let me know.. just tried to give an example which might help us to know what all we got to consider while designing an architecture and if we fail to consider few scenarios what might happen )

Software Architecture in a simple words

Hi everyone....

Here i would like to share about Software Architecture in few simple words....

Few say...

Software Architectures deals with the issue of complexity by defining a software system

from an abstract point of view. Breaking a problem into smaller parts makes it easier to analyze

separate entities and the relationships between them.

(May be we find it bit difficult to understand the first line but the second line gives a bit better understanding about a word Architecture)

A few points below gives us a bit more clearer view about what is entity and the relationship between and also how to communicate between entities with a simple example below....

The architecture of a software system defines the overall structure in terms of

components and interactions among components.

A component, or a module, can be identified as a well defined unit that performs some function.

An example of a component is a database or some object.

Interactions among components occur through connectors such as a procedure call, or some protocol.

Finally, properties of a component specify how a connection with other components can be made

via a connector..

[Enter Post Title Here]

Defining Software Architecture

A common definition …

The software architecture of a program or computing system is the structure or structures of the system, which comprise software elements the externally visible qualities of those elements, and the relationships among them. By analogy the architecture of a building has to take into account the use of the building, what are the people living/working in it expecting and then has to define the size, shape, structure and so forth. The architecture has a set of guiding principles as well as known criteria and constraints that shape the proposed architecture. The designers then have to develop detailed specifications not only for the selection of materials but the placement of wiring, plumbing, lighting and so forth. Finally the building is finished and populated in accordance with the vision outlined prior to the first pen touching the draftsmen’s paper. Architecture strictly from a software engineering point of view. That is, we will explore the value that software architecture brings to a development project in addition to the value returned to the enterprise. The study of software architecture has evolved by observation of the design principles that designer's follow and the actions that they take when working on real systems. It is an attempt to abstract the commonalities inherent in system design, and as such it must account for a wide range of activities, concepts, methods, approaches, and results.

Let's look at some of the implications of this definition in more detail.
First, architecture defines software elements . The architecture embodies information about how the elements relate to each other. This means that it specifically omits certain information about elements that does not pertain to their interaction. Thus, an architecture is foremost an abstraction of a system that suppresses details of elements.
Second, the definition makes clear that systems can and do comprise more than one structure and that no one structure can irrefutably claim to be the architecture. For example, all nontrivial projects are partitioned into implementation units; these units are given specific responsibilities and are frequently the basis of work assignments for programming teams.
Third, the definition implies that every computing system with software has software architecture because every system can be shown to comprise elements and the relations among them.
Fourth, the behavior of each element is part of the architecture in so far as that behavior can be observed or discerned from the point of view of another element. Such behavior is what allows elements to interact with each other, which is clearly part of the architecture.
Finally, the definition is indifferent as to whether the architecture for a system is a good one or a bad one , meaning that it will allow or prevent the system from meeting its behavioral, performance, and life-cycle requirements.

Design Patterns

A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Each pattern is a three-part rule, which expresses a relation between a certain context, a problem, and a solution. It also expresses a relation between a certain context, a certain system of forces that occurs repeatedly in that context, and a certain software configuration that allows these forces to resolve themselves. A pattern for software architecture describes a particular recurring design problem that arises in specific design contexts and presents a well-proven generic scheme for its solution.

Design patterns can be classified as follows:

„ Fundamental patterns

„ Creational patterns

„ Structural patterns

„ Behavioral patterns

„ Concurrency patterns

„ Architectural patterns

Documentation

The documentation for a design pattern should contain enough information about the problem that the pattern addresses, the context in which it is used, and the suggested solution.

A commonly used format is the one used by the Gang of Four. It contains the following sections:

Pattern Name and Classification: Every pattern should have a descriptive and unique name that helps in identifying and referring to it. Additionally, the pattern should be classified according to a classification such as the one described earlier. This classification helps in identifying the use of the pattern.

Intent: This section should describe the goal behind the pattern and the reason for using it. It resembles the problem part of the pattern.

Also Known As: A pattern could have more than one name. These names should be documented in this section.

Motivation(Forces): This section provides a scenario consisting of a problem and a context in which this pattern can be used. By relating the problem and the context, this section shows when this pattern is used.

Applicability: This section includes situations in which this pattern is usable. It represents the context part of the pattern.

Structure: A graphical representation of the pattern. Class diagrams and Interaction diagrams can be used for this purpose.

Participants: A listing of the classes and objects used in this pattern and their roles in the design.

Collaboration: Describes how classes and objects used in the pattern interact with each other.

Consequences: This section describes the results, side effects, and trade offs caused by using this pattern.

Implementation: This section describes the implementation of the pattern, and represents the solution part of the pattern. It provides the techniques used in implementing this pattern, and suggests ways for this implementation.

Sample Code: An illustration of how this pattern can be used in a programming language

Known Uses: This section includes examples of real usages of this pattern.

Related Patterns: This section includes other patterns that have some relation with this pattern, so that they can be used along with this pattern, or instead of this pattern. It also includes the differences this pattern has with similar patterns.

Software Architecture and Design Pattern

The origin of software architecture as a concept was first identified in the research work of Edsger Dijkstra in 1968 and David Parnas in the early 1970s.

The software architecture of a system is the set of structures needed to reason about the system, which comprise software elements, relations among them, and properties of both. The term also refers to documentation of a system's software architecture. Documenting software architecture facilitates communication between stakeholders, documents early decisions about high-level design, and allows reuse of design components and patterns between projects.

Architecture Description of Software-Intensive Systems is the first formal standard in the area of software architecture, and was adopted in 2007 by ISO as ISO/IEC 42010:2007.

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.

There are many types of design patterns, like

Algorithm strategy patterns

Computational design patterns

Execution patterns

Implementation strategy patterns

Structural design patterns

definations on software architecture and design pattern

Software architecture

The software architecture is centered on the idea of reducing complexity through abstraction and seperation of concerns.

Design pattern

a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code.

SOFTWARE ARCHITECTURE & DESIGN PATTERNS

Software Architecture:

“The software architecture of a program or computing system is the structure or structures of the system, which comprise software elements, the externally visible properties of those elements, and the relationships among them. Architecture is concerned with the public side of interfaces; private details of elements—details having to do solely with internal implementation—are not architectural.”

Pattern:

Patterns and Pattern Languages are used to describe best practices, good designs, and capture experience for reuse.

Design pattern:

A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability.

Design patterns are classified as:

A) Creational patterns:

Creational design patterns deal with object creation mechanisms

B) Structural patterns:

Structural design patterns focus on relationships/interfaces between entities and objects

C) Behavioral patterns:

Behavioral design patterns focus on common communication patterns between objects.

Software Architecture and Design Patterns

Hi Friends..........

(This is my first blog post. I'm welcoming myself and all you guys out there. Whatever i'm posting its only upto my knowledge. so if there is something wrong, do correct me. Okay after all this, lets see why i'm here for....)

I'd like to share something about software architecture but before that we need to be aware of what exactly is software which we've been hearing since our engineering days.

SOFTWARE is a collection of programs and associated data which tells a computer what to do and how to do it.

Software is of 2 types:-Generic and Customized software.

Generic software is designed for a large user group with common requirements. The requirements and specification is controlled by the developer. EX: Word Processor.

Customized software is developed to meet the requirements of a specific user. The requirements specification is controlled by the user. EX: Hospital management system.

Lets move on to architecture, Well what actually is an architecture?

The word architecture can have different meanings depending on the context in which it is used.

Architecture could be:

• a man made building or a large structure.
• Iin a larger perspective,design of a park,city or landscape.
  
• a well designed object such as a chair or spoon.

After knowing the terms software and separately,we shall try combing them…..

SOFTWARE ARCHITECTURE is a conceptual framework indicating structural elements that make the system,their relationships and their interaction to fulfill the system requirements.

he various requirements which needs to be accounted are:

Reliability, Usability, Scalability, Maintainability.

Now lets see what are Patterns????

Generally PATTERNS are something which are well known and recurs in a predictable manner. It can be created or can reuse an existing one when the need arises. Ex: Pipes

Using a pattern, we can create a design.

DESIGN PATTERN is a general reusable solution to a commonly occurring problem within a given context. They are medium scale patterns and platform independant. EX: publisher-subscriber.

(Thanks for your time)

Software architecture,Design and Pattern

 Software Architecture: Set of structures needed to reason about the system i,e software elements, relations among them and their properties. A structural element can be a sub system, process ,library, database etc.It is the highest level of abstract of system, what kind of data storage is present ,how modules interact. So it is more about design of entire system.

 Design: is planning and arrangement of form. Is a informative representation of the (proposed) implementation of the function.emphasizes on modules or component. So it can be considered as a design of individual modules that actually make up a system.

 Pattern: description or template for how to solve a problem that can be used in different situation. It solves problem in design and it keeps recurring.

SOFTWARE ARCHITECTURE AND DESIGN PATTERNS

Software Architecture : Software architecture is the structure of a program or a system’s components, the interrelationships among the components, and a set of rules that govern the interaction and evolution of the program or a system. Architectural Description Languages (ADL) are the formal languages that are used to describe or represent architectures. Architecture promotes the understandability and reusability of architectural designs. Patterns are used to capture and organize the design .

Design paterns : A Design pattern is essentially a description of a commonly occurring design problem and how to solve it. In Software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. For example : object oriented design patterns typically show relationships and interactions between classes or objects.

The design patterns are broken down into three subsections: Creational, Structural, and Behavioral patterns.

Creational patterns are used to create objects in an application.

Structural patterns are used to design the structure of modules in an application.

Behavioral patterns describe how objects communicate with each other.