INTRODUCTION OF SOFTWARE DESIGN Lesson 1 Final Version PDF
INTRODUCTION OF SOFTWARE DESIGN Lesson 1 Final Version PDF
INTRODUCTION OF SOFTWARE DESIGN Lesson 1 Final Version PDF
SOFTWARE EVOLUTION
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.
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.
• 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
- Requirement gathering
- Software design
- Programming
- 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:
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.
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:
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.
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.
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.
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”.
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.
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:
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
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:
Architectural 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:
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.
The need of software engineering arises because of higher rate of change in user
requirements and environment on which the software is working.
Source: