The software process is a structured collection of activities, actions, and tasks performed to create work products, encompassing communication, planning, modeling, construction, and deployment. It is supported by umbrella activities such as project tracking, risk management, and quality assurance, and shaped by various software engineering principles that emphasize user value, simplicity, and preparedness for changes. Additionally, the document discusses prevalent software myths that mislead both management and practitioners, highlighting the necessity of clear communication and effective requirement gathering.

1. SOFTWARE PROCESS

2. THE SOFTWARE
PROCESS
• A process is a collection of activities, actions, and tasks that are
performed when some work product is to be created.
• An activity strives to achieve a broad objective (e.g.,
communication with stakeholders) and is applied regardless of
the application domain, size of the project, complexity of the
effort, or degree of rigor with which software engineering is to be
applied.
• An action encompasses a set of tasks that produce a major work
product (e.g., an architectural design model).
• A task focuses on a small, but well-defined objective (e.g.,
conducting a unit test) that produces a tangible outcome.
• A process framework establishes the foundation for a complete
software engineering process by identifying a small number of
framework activities that are applicable to all software projects,
regardless of their size or complexity. In addition, the process
framework encompasses a set of umbrella activities that are
applicable across the entire software process.

3. THE SOFTWARE PROCESS
A generic process framework for software engineering encompasses
five activities:
Communication - Before any technical work can commence, it is
critically important to communicate and collaborate with the
customer (and other stakeholders The intent is to understand
stakeholders’ objectives for the project and to gather
requirements that help define software features and functions.
Planning - Any complicated journey can be simplified if a map exists.
The map - called a software project plan - defines the software
engineering work by describing the technical tasks to be conducted,
the risks that are likely, the resources that will be required, the work
products to be produced, and a work schedule.
Modeling - A software engineer creating models to better
understand software requirements and the design that will achieve
those requirements.
Construction-This activity combines code generation (either manual
or automated) and the testing that is required to uncover errors in the
code.
Deployment-The software (as a complete entity or as a partially
completed increment) is delivered to the customer who evaluates
the delivered product and provides feedback based on the
evaluation.

4. Software engineering process framework activities are complemented
by a number of umbrella activities. Typical umbrella activities include:
Software project tracking and control—allows the software
team to assess progress against the project plan and take any necessary
action to maintain the schedule.
Risk management—assesses risks that may affect the outcome of
the
project or the quality of the product.
Software quality assurance—defines and conducts the
activities required to ensure software quality.
Technical reviews—assesses software engineering work products
in an effort to uncover and remove errors before they are propagated to
the next activity.
Measurement—defines and collects process, project, and
product measures that assist the team in delivering software that
meets stakeholders’ needs; can be used in conjunction with all other
framework and umbrella activities.
Software configuration management—manages the effects of
change throughout the software process.
Reusability management—defines criteria for work product
reuse (including software components) and establishes mechanisms
to achieve reusable components.
Work product preparation and production—encompasses the

5. SOFTWARE ENGINEERING PRACTICES
The Essence of Practice
• Understand the problem (communication and analysis)
• Plan a solution (software design)
• Carry out the plan (code generation)
• Examine the result for accuracy (testing and quality
assurance)

6. Software Engineering
Principles:
• The Reason It All Exists- A software system exists for one reason: to
provide value to its users. All decisions should be made with this in mind.
Before specifying a system requirement, before noting a piece of system
functionality, before determining the hardware platforms or
development processes, ask yourself questions such as: “Does this add
real value to the system?” If the answer is “no,” don’t do it.
• All other principles support this one.
• The Second Principle: (Keep It Simple, Stupid!) - All design should be as
simple as possible, but no simpler. This is not to say that features, even
internal features, should be discarded in the name of simplicity.
• The Third Principle: Maintain the Vision - A clear vision is
essential to the success of a software Project.

7. • The Fourth Principle: What You Produce, Others Will Consume
Always specify, design, and implement knowing someone else
will have to understand what you are doing. The audience for
any product of software development is potentially large.
Specify with an eye to the users.
• The Fifth Principle: Be Open to the Future - A system with a
long lifetime has more value. these systems must be ready to
adapt to these and other changes.
• The Sixth Principle: Plan Ahead for Reuse - Reuse saves time
and effort. The reuse of code and designs has been major
benefit of using object-oriented technologies.
• The Seventh principle: Think! - Placing clear, complete thought
before action almost always produces better results. When you
think about something, you are more likely to do it right. You
also gain knowledge about how to do it right again. If you do
think about something and still do it wrong, it becomes a
valuable experience

8. SOFTWARE MYTHS
Software myths—erroneous beliefs about software and the
process that is used to build it—can be traced to the earliest days
of computing.
Today, most knowledgeable software engineering professionals
recognize myths for what they are—misleading attitudes that have
caused serious problems for managers and practitioners alike.
However, old attitudes and habits are difficult to modify, and
remnants of software myths remain.
1)Management myths
2)Customer myths
3)Practitioner myths

9. Management myths.
Managers with software responsibility, like managers in
most disciplines, are often under pressure to maintain
budgets, keep schedules from slipping, and improve
quality.
Myth: We already have a book that’s full of standards and
procedures for building software. Won’t that provide my
people
with everything they need to know?
Reality: The book of standards may very well exist, but is it
used? Are software practitioners aware of its existence? Does
it reflect modern software engineering practice? Is it
complete? Is it adaptable? Is it streamlined to improve time-
to-delivery while still maintaining a focus on quality? In many
cases, the answer to all of these questions is “no.”

10. Customer myths.
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
Myth: A general statement of objectives is sufficient to
begin writing programs—we can fill in the details later.
Reality: Although a comprehensive and stable statement of
requirements is not always possible, an ambiguous
“statement of objectives” is a recipe for disaster.
Unambiguous requirements (usually derived iteratively) are
developed only through effective and continuous
communication between customer and developer.

11. Practitioner’s myths.
Myths that are still believed by software practitioners
have been fostered by over 50 years of programming
culture. During the early days, programming was viewed
as an art form. Old ways and attitudes die hard.
Myth: Once we write the program and get it to work, our
job is done.
Reality: Someone once said that “the sooner you begin
‘writing code,’ the longer it’ll take you to get done.”
Industry data indicate that between 60 and 80 percent of
all effort expended on software will be expended after it
is delivered to the customer for the first time.