Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

INTRODUCTION OF SOFTWARE DESIGN Lesson 1 Final Version PDF

Download as pdf or txt
Download as pdf or txt
You are on page 1of 11

OVERVIEW OF SOFTWARE ENGINEERING AND SOFTWARE DESIGN

Software is more than just a program code.


A program is an executable code, which
serves some computational purpose.
Software is considered to be collection of
executable programming code, associated
libraries and documentations. Software,
when made for a specific requirement is
called software product.

SOFTWARE EVOLUTION

The process of developing a software


product using software engineering
principles and methods is referred to
as software evolution. This includes the
initial development of software and its
maintenance and updates, till desired
software product is developed, which
satisfies the expected requirements.

Evolution starts from the requirement gathering process. After which developers create a
prototype of the intended software and show it to the users to get their feedback at the early
stage of software product development. The users suggest changes, on which several
consecutive updates and maintenance keep on changing too. This process changes to the
original software, till the desired software is accomplished.
Even after the user has desired software in hand, the advancing technology and the changing
requirements force the software product to change accordingly. Re-creating software from
scratch and to go one-on-one with requirement is not feasible. The only feasible and
economical solution is to update the existing software so that it matches the latest
requirements.

SOFTWARE EVOLUTION LAWS

Lehman has given laws for software evolution. He divided the software into three different
categories:
• S-type (static-type) - This is a software, which works strictly according to
defined specifications and solutions. The solution and the method to achieve it, both
are immediately understood before coding. The s-type software is least subjected to
changes hence this is the simplest of all. For example, calculator program for
mathematical computation.
• P-type (practical-type) - This is a software with a collection of procedures. This is
defined by exactly what procedures can do. In this software, the specifications can be
described but the solution is not obvious instantly. For example, gaming software.
• E-type (embedded-type) - This software works closely as the requirement of real-
world environment. This software has a high degree of evolution as there are various
changes in laws, taxes etc. in the real world situations. For example, Online trading
software.

E-Type software evolution

Lehman has given eight laws for E-Type software evolution -

• Continuing change - An E-type software system must continue to adapt to the real
world changes, else it becomes progressively less useful.
• Increasing complexity - As an E-type software system evolves, its complexity tends
to increase unless work is done to maintain or reduce it.
• Conservation of familiarity - The familiarity with the software or the knowledge
about how it was developed, why was it developed in that particular manner etc. must
be retained at any cost, to implement the changes in the system.
• Continuing growth- In order for an E-type system intended to resolve some business
problem, its size of implementing the changes grows according to the lifestyle changes
of the business.
• Reducing quality - An E-type software system declines in quality unless rigorously
maintained and adapted to a changing operational environment.
• Feedback systems- The E-type software systems constitute multi-loop, multi-level
feedback systems and must be treated as such to be successfully modified or
improved.
• Self-regulation - E-type system evolution processes are self-regulating with the
distribution of product and process measures close to normal.
• Organizational stability - The average effective global activity rate in an evolving E-
type system is invariant over the lifetime of the product.
CHARACTERISTICS OF GOOD SOFTWARE

A software product can be judged by what it offers and how well it can be used. This software
must satisfy on the following grounds:

▪ Operational
▪ Transitional
▪ Maintenance
Well-engineered and crafted software is expected to have the following characteristics:
Operational: This tells us how well software works in operations. It can be measured on:
- Budget
- Usability
- Efficiency
- Correctness
- Functionality
- Dependability
- Security
- Safety

Transitional: This aspect is important when the software is moved from one platform to
another:
- Portability
- Interoperability
- Reusability
- Adaptability

Maintenance: This aspect briefs about how well a software has the capabilities to maintain
itself in the ever-changing environment:
- Modularity
- Maintainability
- Flexibility
- Scalability
SOFTWARE PARADIGMS

Software paradigms refer to the methods and


steps, which are taken while designing the
software. There are many methods proposed
and are in work today, but we need to see
where in the software engineering these
paradigms stand. These can be combined into
various categories, though each of them is
contained in one another:

Programming paradigm is a subset of Software design paradigm which is further a subset of


Software development paradigm.
SOFTWARE DEVELOPMENT PARADIGM
This Paradigm is known as software engineering paradigms where all the engineering
concepts pertaining to the development of software are applied. It includes various
researches and requirement gathering which helps the software product to build. It consists
of –

- Requirement gathering
- Software design
- Programming

SOFTWARE DESIGN PARADIGM


This paradigm is a part of Software Development and includes –

- Design
- Maintenance
- Programming

PROGRAMMING PARADIGM
This paradigm is related closely to programming aspect of software development. This
includes –

- Coding
- Testing
- Integration
SOFTWARE DESIGN

Software Design is the process to transform the user requirements into some suitable
form, which helps the programmer in software coding and implementation. During the
software design phase, the design document is produced, based on the customer
requirements as documented in the SRS document. Hence the aim of this phase is to
transform the SRS document into the design document.

The following items are designed and documented during the design phase:

- Different modules required.


- Control relationships among modules.
- Interface among different modules.
- Data structure among the different modules.
- Algorithms required to implement among the individual modules.

OBJECTIVES OF SOFTWARE DESIGN:

1. Correctness:
A good design should be correct i.e. it should correctly implement all the functionalities
of the system.

2. Efficiency:
A good software design should address the resources, time, and cost optimization
issues.

3. Understandability:
A good design should be easily understandable, for which it should be modular and all
the modules are arranged in layers.

4. Completeness:
The design should have all the components like data structures, modules, and external
interfaces, etc.

5. Maintainability:
A good software design should be easily amenable to change whenever a change
request is made from the customer side.

SOFTWARE DESIGN CONCEPTS:

Concepts are defined as a principal idea or invention that comes into our mind or in thought
to understand something. The software design concept simply means the idea or principle
behind the design. It describes how you plan to solve the problem of designing software, the
logic, or thinking behind how you will design software. It allows the software engineer to
create the model of the system or software or product that is to be developed or built. The
software design concept provides a supporting and essential structure or model for
developing the right software. There are many concepts of software design and some of them
are given below:

The following points should be considered while designing Software:

1. Abstraction- hide Irrelevant data


Abstraction simply means to hide the details to reduce complexity and increases
efficiency or quality. Different levels of Abstraction are necessary and must be applied
at each stage of the design process so that any error that is present can be removed to
increase the efficiency of the software solution and to refine the software solution. The
solution should be described in broad ways that cover a wide range of different things
at a higher level of abstraction and a more detailed description of a solution of software
should be given at the lower level of abstraction.

2. Modularity- subdivide the system


Modularity simply means dividing the system or project into smaller parts to reduce
the complexity of the system or project. In the same way, modularity in design means
subdividing a system into smaller parts so that these parts can be created
independently and then use these parts in different systems to perform different
functions. It is necessary to divide the software into components known as modules
because nowadays there are different software available like Monolithic software that
is hard to grasp for software engineers. So, modularity in design has now become a
trend and is also important. If the system contains fewer components then it would
mean the system is complex which requires a lot of effort (cost) but if we are able to
divide the system into components then the cost would be small.

3. Architecture- design a structure of something


Architecture simply means a technique to design a structure of something. Architecture
in designing software is a concept that focuses on various elements and the data of the
structure. These components interact with each other and use the data of the structure
in architecture.

4. Refinement- removes impurities

Refinement simply means to refine something to remove any impurities if present and
increase the quality. The refinement concept of software design is actually a process of
developing or presenting the software or system in a detailed manner that means to
elaborate a system or software. Refinement is very necessary to find out any error if
present and then to reduce it.

5. Pattern- a repeated form

The pattern simply means a repeated form or design in which the same shape is
repeated several times to form a pattern. The pattern in the design process means the
repetition of a solution to a common recurring problem within a certain context.

6. Information Hiding- hide the information

Information hiding simply means to hide the information so that it cannot be accessed
by an unwanted party. In software design, information hiding is achieved by designing
the modules in a manner that the information gathered or contained in one module is
hidden and can’t be accessed by any other modules.

7. Refactoring- reconstruct something

Refactoring simply means reconstructing something in such a way that it does not affect
the behavior of any other features. Refactoring in software design means
reconstructing the design to reduce complexity and simplify it without affecting the
behavior or its functions. Fowler has defined refactoring as “the process of changing a
software system in a way that it won’t affect the behavior of the design and improves
the internal structure”.

DIFFERENT LEVELS OF SOFTWARE DESIGN:


There are three different levels of software design. They are:

1. Architectural Design:

The architecture of a system can be viewed as the overall structure of the system & the
way in which structure provides conceptual integrity of the system. The architectural
design identifies the software as a system with many components interacting with each
other. At this level, the designers get the idea of the proposed solution domain.

2. Preliminary or high-level design:

Here the problem is decomposed into a set of modules, the control relationship among
various modules identified, and also the interfaces among various modules are
identified. The outcome of this stage is called the program architecture. Design
representation techniques used in this stage are structure chart and UML.

3. Detailed design:

Once the high-level design is complete, a detailed design is undertaken. In detailed


design, each module is examined carefully to design the data structure and algorithms.
The stage outcome is documented in the form of a module specification document.

SOFTWARE ENGINEERING | SOFTWARE DESIGN PROCESS

Engineering on the other hand, is all about developing products, using well-defined,
scientific principles and methods.
Software engineering is an engineering branch associated with development of software
product using well-defined scientific principles, methods and procedures. The outcome of
software engineering is an efficient and reliable software product.

Definitions

IEEE defines software engineering as:


(1) The application of a systematic, disciplined, quantifiable approach to the development,
operation and maintenance of software; that is, the application of engineering to software.
(2) Fritz Bauer, a German computer scientist, defines software engineering as: Software
engineering is the establishment and use of sound engineering principles in order to obtain
economically software that is reliable and work efficiently on real machines.
In short, Software Engineering is a branch of computer science, which uses well-defined
engineering concepts required to produce efficient, durable, scalable, in-budget and on-time
software products.

The design phase of software development deals with transforming the customer
requirements as described in the SRS documents into a form implementable using a
programming language. The software design process can be divided into the following
three levels of phases of design:
- Interface Design
- Architectural Design
- Detailed Design

Interface Design:

Interface design is the specification of the interaction between a system and its
environment. this phase proceeds at a high level of abstraction with respect to the inner
workings of the system i.e, during interface design, the internal of the systems are
completely ignored and the system is treated as a black box. Attention is focused on the
dialogue between the target system and the users, devices, and other systems with which
it interacts. The design problem statement produced during the problem analysis step
should identify the people, other systems, and devices which are collectively called agents.
Interface design should include the following details:

- Precise description of events in the environment, or messages from agents to which


the system must respond.
- Precise description of the events or messages that the system must produce.
- Specification on the data, and the formats of the data coming into and going out of
the system.
- Specification of the ordering and timing relationships between incoming events or
messages, and outgoing events or outputs.

Architectural Design:

Architectural design is the specification of the major components of a system, their


responsibilities, properties, interfaces, and the relationships and interactions between
them. In architectural design, the overall structure of the system is chosen, but the internal
details of major components are ignored. Issues in architectural design includes:

- Gross decomposition of the systems into major components.


- Allocation of functional responsibilities to components.
- Component Interfaces
- Component scaling and performance properties, resource consumption properties,
reliability properties, and so forth.
- Communication and interaction between components.
- The architectural design adds important details ignored during the interface design.
Design of the internals of the major components is ignored until the last phase of
the design.

Detailed Design:

Detailed Design is the specification of the internal elements of all major system
components, their properties, relationships, processing, and often their algorithms and the
data structures. The detailed design may include:

- Decomposition of major system components into program units.


- Allocation of functional responsibilities to units.
- User interfaces
- Unit states and state changes
- Data and control interaction between units
- Data packaging and implementation, including issues of scope and visibility of
program elements
- Algorithms and data structures
ELEMENTS OF A SYSTEM:

1. Architecture – This is the conceptual model that defines the structure, behavior, and
views of a system. We can use flowcharts to represent and illustrate the architecture.
2. Modules – These are components that handle one specific task in a system. A
combination of the modules makes up the system.
3. Components – This provides a particular function or group of related functions. They
are made up of modules.
4. Interfaces – This is the shared boundary across which the components of a system
exchange information and relate.
5. Data – This is the management of the information and data flow.

NEED OF SOFTWARE ENGINEERING

The need of software engineering arises because of higher rate of change in user
requirements and environment on which the software is working.

▪ Large software - It is easier to build a wall than to a house or building, likewise, as


the size of software become large engineering has to step to give it a scientific process.
▪ Scalability- If the software process were not based on scientific and engineering
concepts, it would be easier to re-create new software than to scale an existing one.
▪ Cost- As hardware industry has shown its skills and huge manufacturing has lower
down he price of computer and electronic hardware. But the cost of software remains
high if proper process is not adapted.
▪ Dynamic Nature- The always growing and adapting nature of software hugely
depends upon the environment in which user works. If the nature of software is
always changing, new enhancements need to be done in the existing one. This is
where software engineering plays a good role.
▪ Quality Management- Better process of software development provides better and
quality software product.

Source:

Difference between Clustered and Non-clustered index - GeeksforGeeks


https://www.geeksforgeeks.org/difference-between-clustered-and-non-clustered-index/

Software Design Strategies (tutorialspoint.com)


https://www.tutorialspoint.com/software_engineering/software_design_strategies.htm

You might also like