 Myth: Wrong belief on mis information.

 S/w Myth: S/w Myths are belief about s/w & the process used to build it.

 Myths have no.of attributes that causes series problems on s/w

 3 types of Myths

 1)Management Myth

 2)Customer Myth

 3)Developer Myth

 Managers with software responsibility, like managers inmost disciplines, are often under
pressure to maintain budgets, keep schedules from slipping, and improve quality.

 Some common managerial myths:

 We have standards and procedures for building software, so developers have everything they
need to know.

 We have state-of-the-art software development tools; after all, we buy the latest computers.

 If we're behind schedule, we can add more programmers to catch up.

 A good manger can manage any project.

 Managers with software responsibility, like managers inmost disciplines, are often under
pressure to maintain budgets, keep schedules from slipping, and improve quality.

 Some common managerial myths:

  We have standards and procedures for building software, so developers have everything they
need to know.

 We have state-of-the-art software development tools; after all, we buy the latest computers.

 If we're behind schedule, we can add more programmers to catch up.

 A good manger can manage any project.

 A customer who requests computer software may be a person at the next desk, a technical
group down the hall, the marketing/sales department, or an outside company that has
requested software under contract.

 In many cases,
The customer believes myths about software because software managers and practitioners
do little to correct misinformation. Myths lead to false expectations (by the customer) and,
ultimately, dissatisfaction with the developer.

 Commonly held myths by the clients are:

 A general statement of objectives is sufficient to begin writing programs -we can fill in the
details later.

 Requirement changes are easy to accommodate because software is flexible.

 I know what my problem is; therefore I know how to solve it. This primarily is seen evidently
because the clients do not have a firsthand experience in software development and they
think that it's an easy process

 Myths that are still believed by software practitioners have been fostered(encouraged) by
over 50 years of programming culture.

 During the early days of software, programming was viewed as an art form. Old ways and
attitudes die hard.

 A malpractice seen is developers are that they think they know everything and neglect the
peculiarity of each problem.

 Some common Myths are:

 If I miss something now, I can fix it later.

 Once the program is written and running, my job is done.

 Until a program is running, there's no way of assessing its quality.

 The only deliverable for a software project is a working program.

Every developer should try to get all requirement is relevant detail to effectively design and
code the system

Software engineering vs software process

Software engineering and software process are related concepts within the field of software
development, but they refer to different aspects of the overall software development lifecycle.
Software Engineering:

Software engineering is a discipline that focuses on the systematic approach to designing,

developing, testing, deploying, and maintaining software systems. It involves applying engineering
principles to software development in order to create high-quality, reliable, and efficient software
solutions. Software engineering encompasses a wide range of activities, including requirements
analysis, design, coding, testing, documentation, maintenance, and project management.

Software engineering also emphasizes the use of best practices, methodologies, and tools to ensure
that software projects are completed successfully, on time, and within budget. It involves
understanding the needs of stakeholders, defining software requirements, designing architecture
and components, implementing the code, testing thoroughly, and delivering a complete and
functional software product.

Software Process:

Software process, on the other hand, refers to the set of activities, methods, and practices that are
followed during the development of software. It outlines the step-by-step approach that a
development team should follow to create software in a systematic and organized manner. A
software process defines how tasks should be carried out, who is responsible for each task, and how
different tasks are coordinated.

Software processes are often described using software development methodologies or frameworks,
such as the Waterfall model, Agile methodologies (Scrum, Kanban), Spiral model, etc. These
methodologies provide guidelines on how to manage the software development lifecycle, from
requirements gathering to deployment and maintenance. They prescribe the order of activities, the
interactions among team members, and the feedback loops to ensure that the software
development process is effective and efficient.

In essence, software engineering deals with the principles and practices of creating high-quality
software solutions, while the software process deals with the systematic approach and
methodologies used to guide the development of software. Both concepts are crucial in ensuring
that software projects are successful, well-organized, and deliver the desired outcomes.

Software Engineering:

Focus: It emphasizes the systematic design, development, and maintenance of software systems
using engineering principles.

Activities: Involves a wide range of activities including requirements analysis, design, coding, testing,
documentation, and maintenance.

Goal: Aims to create high-quware solutions that meet user needs.

Practices: Involves using best practices, methodologies, and tools to ensure successful software
development.

Emphasis: Stresses on understanding user needs, designing robust architectures, implementing

efficient code, and ensuring software quality.

Roles: Involves various roles like software engineers, architects, testers, and project managers.

Output: Produces a complete and functional software product ready for deployment.

Software Process:

Focus: It outlines the structured approach, methods, and practices for carrying out software
development.

Methodologies: Involves using specific development methodologies or frameworks like Waterfall,

Agile, Spiral, etc.

Goal: Aims to guide the team in an organized way to ensure the successful completion of software
projects.

Activities: Prescribes the sequence of activities, their coordination, and responsibilities within the
development lifecycle.

Emphasis: Focuses on the procedural aspects of development, such as the order of tasks and
communication flow.

Roles: Defines roles, responsibilities, and interactions among team members, often including roles
like product owner, Scrum Master, etc.

Output: Results in a structured and controlled approach to software development, aligning with the
chosen methodology.

Software Design Principles

Software design principles are concerned with providing means to handle the
complexity of the design process effectively. Effectively managing the complexity will
not only reduce the effort needed for design but can also reduce the scope of
introducing errors during design.

Following are the principles of Software

Design
Problem Partitioning
For small problem, we can handle the entire problem at once but for the significant
problem, divide the problems and conquer the problem it means to divide the
problem into smaller pieces so that each piece can be captured separately.

For software design, the goal is to divide the problem into manageable pieces.

5.5M
725
OOPs Concepts in Java

Benefits of Problem Partitioning

1. Software is easy to understand

2. Software becomes simple
3. Software is easy to test
4. Software is easy to modify
5. Software is easy to maintain
6. Software is easy to expand

These pieces cannot be entirely independent of each other as they together form the
system. They have to cooperate and communicate to solve the problem. This
communication adds complexity.

Note: As the number of partition increases = Cost of partition and complexity increases
Abstraction
An abstraction is a tool that enables a designer to consider a component at an
abstract level without bothering about the internal details of the implementation.
Abstraction can be used for existing element as well as the component being
designed.

Here, there are two common abstraction mechanisms

1. Functional Abstraction
2. Data Abstraction

Functional Abstraction

i. A module is specified by the method it performs.

ii. The details of the algorithm to accomplish the functions are not visible to the
user of the function.

Functional abstraction forms the basis for Function oriented design approaches.

Data Abstraction

Details of the data elements are not visible to the users of data. Data Abstraction
forms the basis for Object Oriented design approaches.

Modularity
Modularity specifies to the division of software into separate modules which are
differently named and addressed and are integrated later on in to obtain the
completely functional software. It is the only property that allows a program to be
intellectually manageable. Single large programs are difficult to understand and read
due to a large number of reference variables, control paths, global variables, etc.

The desirable properties of a modular system are:

o Each module is a well-defined system that can be used with other

applications.
 o Each module has single specified objectives.
o Modules can be separately compiled and saved in the library.
o Modules should be easier to use than to build.
o Modules are simpler from outside than inside.

Advantages and Disadvantages of Modularity

In this topic, we will discuss various advantage and disadvantage of Modularity.

Advantages of Modularity

There are several advantages of Modularity

o It allows large programs to be written by several or different people

o It encourages the creation of commonly used routines to be placed in the
library and used by other programs.
o It simplifies the overlay procedure of loading a large program into main
storage.
o It provides more checkpoints to measure progress.
o It provides a framework for complete testing, more accessible to test
o It produced the well designed and more readable program.

Disadvantages of Modularity

There are several disadvantages of Modularity

 o Execution time maybe, but not certainly, longer
o Storage size perhaps, but is not certainly, increased
o Compilation and loading time may be longer
o Inter-module communication problems may be increased
o More linkage required, run-time may be longer, more source lines must be
written, and more documentation has to be done

Modular Design

Modular design reduces the design complexity and results in easier and faster
implementation by allowing parallel development of various parts of a system. We
discuss a different section of modular design in detail in this section:

1. Functional Independence: Functional independence is achieved by developing

functions that perform only one kind of task and do not excessively interact with
other modules. Independence is important because it makes implementation more
accessible and faster. The independent modules are easier to maintain, test, and
reduce error propagation and can be reused in other programs as well. Thus,
functional independence is a good design feature which ensures software quality.

It is measured using two criteria:

o Cohesion: It measures the relative function strength of a module.

o Coupling: It measures the relative interdependence among modules.

2. Information hiding: The fundamental of Information hiding suggests that

modules can be characterized by the design decisions that protect from the others,
i.e., In other words, modules should be specified that data include within a module is
inaccessible to other modules that do not need for such information.

The use of information hiding as design criteria for modular system provides the
most significant benefits when modifications are required during testing's and later
during software maintenance. This is because as most data and procedures are
hidden from other parts of the software, inadvertent errors introduced during
modifications are less likely to propagate to different locations within the software.

Strategy of Design
A good system design strategy is to organize the program modules in such a
method that are easy to develop and latter too, change. Structured design methods
help developers to deal with the size and complexity of programs. Analysts generate
instructions for the developers about how code should be composed and how pieces
of code should fit together to form a program.

To design a system, there are two possible approaches:

1. Top-down Approach
2. Bottom-up Approach

1. Top-down Approach: This approach starts with the identification of the main
components and then decomposing them into their more detailed sub-components.

2. Bottom-up Approach: A bottom-up approach begins with the lower details and
moves towards up the hierarchy, as shown in fig. This approach is suitable in case of
an existing system.
Software Design
Software design is a mechanism to transform user requirements into some suitable
form, which helps the programmer in software coding and implementation. It deals
with representing the client's requirement, as described in SRS (Software
Requirement Specification) document, into a form, i.e., easily implementable using
programming language.

The software design phase is the first step in SDLC (Software Design Life Cycle),
which moves the concentration from the problem domain to the solution domain. In
software design, we consider the system to be a set of components or modules with
clearly defined behaviors & boundaries.

Objectives of Software Design

Following are the purposes of Software design:

5.2M
863
Polymorphism in Java | Dynamic Method Dispatch
 1. Correctness:Software design should be correct as per requirement.
2. Completeness:The design should have all components like data structures,
modules, and external interfaces, etc.
3. Efficiency:Resources should be used efficiently by the program.
4. Flexibility:Able to modify on changing needs.
5. Consistency:There should not be any inconsistency in the design.
6. Maintainability: The design should be so simple so that it can be easily
maintainable by other designers.

The design process in software engineering encompasses a series of steps and activities aimed at
transforming high-level requirements into a well-structured and feasible software solution. Here are
some key features of the design process in software engineering:

Problem Understanding: The design process begins with a clear understanding of the problem or
requirements that the software is intended to address. This involves collaborating with stakeholders
to gather and analyze their needs.

Requirements Analysis: The design process involves a thorough analysis of the gathered
requirements. This includes identifying functional and non-functional requirements, as well as any
constraints or limitations.

System Architecture: Designing the system's architecture is a critical phase. This involves defining the
overall structure of the software, including high-level components, their relationships, and
interactions.
Component Design: Once the architecture is in place, the design process moves to defining the
detailed design of individual components or modules. This includes specifying interfaces, data
structures, algorithms, and interactions.

Data Design: Designing the data structures that the software will use is an essential aspect of the
process. This includes database design, data modeling, and data flow diagrams.

Interface Design: Designing user interfaces (UI) and application programming interfaces (APIs) is
important for creating user-friendly software and ensuring proper communication between different
parts of the system.

Algorithm Design: Depending on the nature of the software, designing efficient algorithms for tasks
such as data processing, sorting, searching, and optimization might be necessary.

Security and Privacy: The design process includes considerations for security and privacy measures to
protect sensitive data and ensure the software's robustness against potential threats.

Quality Attributes: Designing for quality attributes such as performance, scalability, reliability,
maintainability, and usability is an integral part of the process.

Patterns and Principles: Applying design patterns and principles, such as SOLID principles, helps
create maintainable and flexible software architectures.

Trade-offs and Decisions: The design process often involves making trade-offs between conflicting
design goals or constraints. Decisions about design alternatives and compromises are crucial.

Prototyping: In some cases, creating prototypes of the software or specific features can help validate
design decisions and gather user feedback early in the process.

Documentation: Proper documentation of the design decisions, rationale, and architectural choices is
essential for communicating the design to other team members and for future reference.

Review and Validation: Regular design reviews and validations with stakeholders help ensure that the
design aligns with the requirements and addresses potential issues before implementation.
Iteration and Evolution: The design process is iterative, allowing for adjustments based on feedback
and changing requirements. Designs may evolve as the team gains a deeper understanding of the
problem domain.

Collaboration: Design is a collaborative effort involving software architects, developers, UI/UX

designers, domain experts, and stakeholders. Effective communication among team members is
crucial.

Tool Utilization: Various design tools and software, such as modeling tools, diagramming software,
and version control systems, are used to aid in the design process.

Alignment with Development: The design process lays the foundation for the development phase,
providing developers with a clear roadmap for implementation.

Traceability: The design process ensures that design decisions are traceable back to the initial
requirements, enabling accountability and transparency.

Continuous Improvement: As the software is developed and deployed, the design may need to be
refined based on real-world usage and feedback, supporting continuous improvement.

Overall, the design process is a structured approach that guides the creation of software solutions,
from initial concept to detailed specifications. It involves a combination of technical expertise,
creativity, and collaboration to achieve software that meets user needs and quality standards.

https://www.tutorialride.com/software-engineering/software-process-framework.htm