Module-1 Introduction of Software Engineering Learning Materials

1. Describe important attribute which all software product should have.

Maintainability: Software must evolve to meet changing needs;
Dependability: Software must be trustworthy;
Efficiency: Software should not make wasteful use of system resources;
Acceptability: Software must accepted by the users for which it was designed. This means it must be
understandable, usable and compatible with other systems.
Usability:
Usability is the measure of a product's potential to accomplish the goals of the user.
Some factors used in determining product usability are ease-of- use, visual consistency, and a
clear, defined process for evolution.
Reliability:
Software Reliability is the probability of failure-free software operation for a specified period
of time in a specified environment. Software Reliability is also an important factor affecting
system reliability.
Scalability:
Scalability is an attribute that describes the ability of a process, network, software or
organization to grow and manage increased demand. A system, business or software that is
described as scalable has an advantage because it is more adaptable to the changing needs or
demands of its users or clients.
Portability:
Portability in high-level computer programming is the usability of the same software in
different environments. The prerequirement for portability is the generalized abstraction between
the application logic and system interfaces.
Reusability:
Software reuse is the process of implementing or updating software systems using
existing software components. A good software reuse process facilitates the increase of productivity,
quality, and reliability, and the decrease of costs and implementation time.

2. Define the following :

What is software?

Software is a set of instructions made in the form of written programs, procedures or rules and
associated documentation pertaining to the operation of a computer system and that are stored in
read/ write memory.

20MCA24 –Software Engineering 1

Module-1 Introduction of Software Engineering Learning Materials

What is software engineering?

The IEEE Computer Society defines software engineering as The application of a systematic,
disciplined, quantifiable approach to the development, operation, and maintenance of software; that
is, the application of engineering to software.

Difference of Software engineering and Computer science

• The application of a systematic, disciplined, quantifiable approach to the development, operation,

and maintenance of software; that is, the application of engineering to software. ( Practicalities)

• Computer science is concerned with theory and fundamentals

Software Categories

• System software: serves as a base for application software. System software includes device
drivers, operating systems (OSs), compilers, disk formatters, text editors and utilities helping the
computer to operate more efficiently. It is also responsible for managing hardware components
and providing basic non-task-specific functions.
• Programming software: Is a set of tools to aid developers in writing programs. The various tools
available are compilers, linkers, debuggers, interpreters and text editors.
• Application software: is intended to perform certain tasks. Examples of application software
include office suites, gaming applications, database systems and educational software. Application
software can be a single program or a collection of small programs. This type of software is what
consumers most typically think of as "software."

What is a system?

• A purposeful collection of inter-related components working together to achieve some common

objective.

• A system may include software, mechanical component, electrical and electronic hardware and be
operated by people.

What is Information system?

An information system is software that helps you organize and analyze data. This makes it possible to
answer questions and solve problems relevant to the mission of an organization.

20MCA24 –Software Engineering 2

Module-1 Introduction of Software Engineering Learning Materials

3. Discuss the various challenges and issues in software engineering

What are the key challenges Facing Software Engineering?

Heterogeneity, delivery and trust.

• Heterogeneity
– Developing techniques for building software that can cope with heterogeneous platforms
and execution environments;
• Delivery
– Developing techniques that lead to faster delivery of software;
• Trust
– Developing techniques that demonstrate that software can be trusted by its users.

Issues in Professional and Ethical responsibility

• Software engineering involves wider responsibilities than simply the application of technical skills.
• Software engineers must behave in an honest and ethically responsible way if they are to be
respected as professionals.
• Ethical behaviour is more than simply upholding the law.
• Confidentiality
Engineers should normally respect the confidentiality of their employers or clients
irrespective of whether or not a formal confidentiality agreement has been signed.
▪ Competence
Engineers should not misrepresent their level of competence. They should not knowingly
accept work which is out with their competence.
• Intellectual property rights
Engineers should be aware of local laws governing the use of intellectual property such as
patents, copyright, etc. They should be careful to ensure that the intellectual property of
employers and clients is protected.
• Computer misuse
Software engineers should not use their technical skills to misuse otherpeople’s computers.
Computer misuse ranges from relatively trivial (game playing on an employer’s machine,
say) to extremely serious (dissemination of viruses).

20MCA24 –Software Engineering 3

Module-1 Introduction of Software Engineering Learning Materials

4. Explain ACM/IEEE code of ethics and suggest an appropriate example that

illustrates that clause.
The professional societies in the US have cooperated to produce a code of ethical practice.

The Code contains Eight Principles related to the behaviour of and decisions made by professional
software engineers, including practitioners, educators, managers, supervisors and policy makers, as
well as trainees and students of the profession.

Software engineers shall adhere to the following Eight Principles:

• Public
– Software engineers shall act consistently with the public interest.
• Client and Employer
– Software engineers shall act in a manner that is in the best interests of their client and
employer consistent with the public interest.
• Product
– Software engineers shall ensure that their products and related modifications meet the
highest professional standards possible.
• Judgment
– Software engineers shall maintain integrity and independence in their professional
judgment.
• Management
– Software engineering managers and leaders shall subscribe to and promote an ethical
approach to the management of software development and maintenance.
• Profession
– Software engineers shall advance the integrity and reputation of the profession
consistent with the public interest.
• Colleagues
– Software engineers shall be fair to and supportive of their colleagues.
• Self
– Software engineers shall participate in lifelong learning regarding the practice of their
profession and shall promote an ethical approach to the practice of the profession.

5. Explain in detail the Incremental Development Process with a neat block

diagram.
The incremental build model is a method of software development where the model is
designed, implemented and tested incrementally (a little more is added each time) until the
product is finished. It involves both development and maintenance. The product is defined as
finished when it satisfies all of its requirements. This model combines the elements of the
waterfall model with the iterative philosophy of prototyping.

20MCA24 –Software Engineering 4

Module-1 Introduction of Software Engineering Learning Materials

Sno Model Definition Features When to use Advantages Disadvantages

the Model

1 Incremental Incremental System Such models Generates Each phase of an

Development Model is a development is are used working software iteration is rigid
Model process of broken down into where quickly and early and do not
software many mini requirements during the overlap each
development development are clear and software life other.
where projects can cycle. Problems may
requirements Partial systems implement by More flexible – arise pertaining
are broken are successively phase wise. less costly to to system
down into built to produce a From the change scope architecture
multiple final total system figure it’s and because not all
standalone Highest priority clear that the requirements. requirements are
modules of requirement is requirements Easier to test and gathered up
software tackled first ® is divided debug during a front for the
development Once the into R1, smaller iteration. entire software
cycle. incremented R2……….Rn Easier to manage life cycle.
Incremental portion id and delivered risk because risky
development is developed, accordingly. pieces are
done in steps requirements for Mostly such identified and
from analysis that increment model is used handled during
design, are frozen in web its iteration.
implementation, applications Each
testing/verificati and product iteration is
on, based an easily
maintenance. companies. managed
milestone.

20MCA24 –Software Engineering 5

Module-1 Introduction of Software Engineering Learning Materials

6. Explain the Rational Unified Process in detail.

Rational unified process (RUP) is a software application development technique with many tools to assist
in coding the final product and tasks related to this goal. RUP is an object-oriented approach used to
ensure effective project management and high-quality software production.

RUP has enabled great strides in development community standards and the acceptance of use cases and
unified modeling language (UML). RUP is comprised of three characteristics and a recurring four-phase
cycle.
RUP has the following key characteristics:

• Use-case driven from inception to deployment

• Architecture-centric, where architecture is a function of user needs
• Iterative and incremental, where large projects are divided into smaller projects

RUP follows the following four-phase process:

• Inception: The core idea is envisioned.

• Elaboration: Use cases and architecture are designed.
• Construction: Activities from design to completed product
• Transition: Follow-up activities to ensure customer satisfaction

• Inception
– Establish the business case for the system.
• Elaboration
– Develop an understanding of the problem domain and the system architecture.
• Construction
– System design, programming and testing.
• Transition
– Deploy the system in its operating environment.
RUP iteration
• In-phase iteration
– Each phase is iterative with results developed incrementally.
• Cross-phase iteration
– As shown by the loop in the RUP model, the whole set of phases may be enacted
incrementally.

20MCA24 –Software Engineering 6

Module-1 Introduction of Software Engineering Learning Materials

Workflows in the Rational Unified Process

Workflow Description
Business modelling The business processes are modelled using business use cases.

Requirements Actors who interact with the system are identified and use cases are
developed to model the system requirements.
Analysis and design A design model is created and documented using architectural models,
component models, object models and sequence models.

Implementation The components in the system are implemented and structured into
implementation sub-systems. Automatic code generation from design
models helps accelerate this process.

Testing Testing is an iterative process that is carried out in conjunction with

implementation. System testing follows the completion of the
implementation.
Deployment A product release is created, distributed to users and installed in their
workplace.
Configuration and This supporting workflow managed changes to the system
change management
Project management This supporting workflow manages the system development

Environment This workflow is concerned with making appropriate software tools

available to the software development team.

RUP good practice

• Develop software iteratively

– Plan increments based on customer priorities and deliver highest priority increments first.
• Manage requirements
– Explicitly document customer requirements and keep track of changes to these
requirements.
• Use component-based architectures
– Organize the system architecture as a set of reusable components.
• Visually model software
– Use graphical UML models to present static and dynamic views of the software.
• Verify software quality
– Ensure that the software meet’s organizational quality standards.
• Control changes to software
– Manage software changes using a change management system and configuration
management tools.

20MCA24 –Software Engineering 7

Module-1 Introduction of Software Engineering Learning Materials

7. Explain Spiral model of Software Process with neat diagram.

The spiral model combines the idea of iterative development with the systematic, controlled
aspects of the waterfall model. This Spiral model is a combination of iterative development process
model and sequential linear development model i.e. the waterfall model with a very high emphasis
on risk analysis. It allows incremental releases of the product or incremental refinement through
each iteration around the spiral.
Spiral Model – Design:
The spiral model has four phases. A software project repeatedly passes through these phases in
iterations called Spirals.
Identification: This phase starts with gathering the business requirements in the baseline spiral. In
the subsequent spirals as the product matures, identification of system requirements, subsystem
requirements and unit requirements are all done in this phase.
This phase also includes understanding the system requirements by continuous communication
between the customer and the system analyst. At the end of the spiral, the product is deployed in
the identified market.
Design: The Design phase starts with the conceptual design in the baseline spiral and involves
architectural design, logical design of modules, physical product design and the final design in the
subsequent spirals.
Construct or Build: The Construct phase refers to production of the actual software product at every
spiral. In the baseline spiral, when the product is just thought of and the design is being developed a
POC (Proof of Concept) is developed in this phase to get customer feedback.
Then in the subsequent spirals with higher clarity on requirements and design details a working
model of the software called build is produced with a version number. These builds are sent to the
Customer for feedback.
Evaluation and Risk Analysis: Risk Analysis includes identifying, estimating and monitoring the
technical feasibility and management risks, such as schedule slippage and cost overrun. After testing
the build, at the end of first iteration, the customer evaluates the software and provides feedback.

The following illustration is a representation of the Spiral Model, listing the activities in each phase.

20MCA24 –Software Engineering 8

Module-1 Introduction of Software Engineering Learning Materials

Based on the customer evaluation, the software development process enters the next iteration and
subsequently follows the linear approach to implement the feedback suggested by the customer.
The process of iterations along the spiral continues throughout the life of the software.

Spiral Model Application

The Spiral Model is widely used in the software industry as it is in sync with the natural
development process of any product, i.e. learning with maturity which involves minimum risk for
the customer as well as the development firms.
The following pointers explain the typical uses of a Spiral Model −
• When there is a budget constraint and risk evaluation is important.
• For medium to high-risk projects.
• Long-term project commitment because of potential changes to economic priorities as the
requirements change with time.
• Customer is not sure of their requirement which is usually the case.
• Requirements are complex and need evaluation to get clarity.
• New product line which should be released in phases to get enough customer feedback.
• Significant changes are expected in the product during the development cycle.

Spiral Model - Pros and Cons

The advantage of spiral lifecycle model is that it allows elements of the product to be added in,
when they become available or known. This assures that there is no conflict with previous
requirements and design.
This method is consistent with approaches that have multiple software builds and releases which
allows making an orderly transition to a maintenance activity. Another positive aspect of this
method is that the spiral model forces an early user involvement in the system development effort.
On the other side, it takes a very strict management to complete such products and there is a risk of
running the spiral in an indefinite loop. So, the discipline of change and the extent of taking change
requests is very important to develop and deploy the product successfully.

The advantages of the Spiral SDLC Model are as follows −

• Changing requirements can be accommodated.
• Allows extensive use of prototypes.
• Requirements can be captured more accurately.
• Users see the system early.
• Development can be divided into smaller parts and the risky parts can be developed earlier
which helps in better risk management.

The disadvantages of the Spiral SDLC Model are as follows −

• Management is more complex.
• End of the project may not be known early.
• Not suitable for small or low risk projects and could be expensive for small projects.
• Process is complex
• Spiral may go on indefinitely.
• Large number of intermediate stages requires excessive documentation.

20MCA24 –Software Engineering 9

Module-1 Introduction of Software Engineering Learning Materials

8. Explain Waterfall model in the software development process.

The Waterfall
Model was first
Process Model to be
introduced. It is very
simple to understand
and use. In
a Waterfall model,
each phase must be
completed before the
next phase can begin
and there is no
overlapping in the
phases. Waterfall
model is the earliest
SDLC approach that
was used for software
development.

Model Definition Features When to Use Advantages Disadvantages

Waterfall The Waterfall There are Requirements Easy to All requirements
Model was first separate are well known understand, easy must be known
Process Model to identified and stable to use, especially upfront – in most
9. be introduced.
Explain why change It is Inevitable
phases ininthe by inexperienced
complex systems and explain how projects requirement
is very simple to waterfall Technology is staff change occurs after
10. Explain
understand
Prototyping
and of software
model: process helpunderstood
to more resilient to change? project start
use. In Requirements Milestones are well Can give a false
11. What are agile methods?
a Waterfall Discussand
analysis the principles of agile methods.
Development understood by the impression of
model, each definition team have team progress
12. What are must
phase the practices
be followed in extreme programming
experience Integration is one big
completed before System and with similar Provides bang at the end
13. What
theisnext
software
phaseProcess Model? Explain projects
software with a diagram therequirements
Waterfall model and Little
discuss its
opportunity for
advantages
can beginandanddisadvantages.
design stability during customer to pre-view
there is no development the system.
overlapping in Implementatio Facilitates strong
the n and unit management
phases. Waterfall testing control (plan, staff,
model is the track)
earliest SDLC Integration and
approach that system testing
was used for
software Operation and
development. maintenance

20MCA24 –Software Engineering 10

 Module-1 Introduction of Software Engineering Learning Materials

9. Explain Prototyping of software process.

Software prototyping is the activity of creating prototypes of software applications, i.e., incomplete
versions of the software program being developed. It is an activity that can occur in software
development and is comparable to prototyping as known from other fields, such as
mechanical engineering or manufacturing.

What are the advantages of software prototypes?

▪ Customer and users are involved in all process.
▪ If there is a problem in software, then customers tell us that we should change the design of
the software. This leads to time-saving.
▪ Reduced software development effort.
▪ Helps in clearing the ambiguities in requirements.
▪ Prototypes improve the;
▪ Software Usability.
▪ Software design quality.
▪ Software maintainability.
▪ Reduced software development effort.
▪
When to use Prototype model?
▪ When we give a free end to a customer then he starts to change the software design again and again.
Some psycho customers can take too much time to the software team.
▪ When the software needs to have much interaction with the end users.
▪ For example, following systems have a high amount of interaction with end users;
▪ Web-based applications
▪ Online systems
Prototyping model

20MCA24 –Software Engineering 11

Module-1 Introduction of Software Engineering Learning Materials

Prototype process

Types of Prototype
Throw-away prototypes
• Prototypes should be discarded after development as they are not a good basis for a production
system:
– It may be impossible to tune the system to meet non-functional requirements;
– Prototypes are normally undocumented;
– The prototype structure is usually degraded through rapid change;
– The prototype probably will not meet normal organizational quality standards.
Incremental delivery
• Rather than deliver the system as a single delivery, the development and delivery is broken down
into increments with each increment delivering part of the required functionality.
• User requirements are prioritised and the highest priority requirements are included in early
increments.
• Once the development of an increment is started, the requirements are frozen though
requirements for later increments can continue to evolve.

What are outcomes of activities of prototype process?

Activity Outcome
Prototype purpose Prototyping plan
Prototype functionality Outline definition
Prototype development Executable prototype
Prototype evaluation Evaluation report
Some examples of software prototype tools:
Sno Tool Runs on Prototype for
1 InVision Web ▪ Web
▪ ios
▪ Android
2 WebFlow Web All
3 JustInMind ▪ Windows ▪ Android
▪ OS X ▪ IOS
▪ Web
4 POP ▪ Web ▪ Web
▪ ios ▪ ios
▪ Android ▪ Android
5 Axure RP All ▪ OS x
▪ Windows

20MCA24 –Software Engineering 12

Module-1 Introduction of Software Engineering Learning Materials

10. What are agile methods? Discuss the principles of agile methods.

The Agile Method is a particular approach to project management that is utilized in software
development. This method assists teams in responding to the unpredictability of constructing
software. It uses incremental, iterative work sequences that are commonly known as sprints.

The Four Values of the Agile Manifesto

• Individuals and Interactions over Processes and Tools.

• Working Software over Comprehensive Documentation.
• Customer Collaboration over Contract Negotiation.
• Responding to Change Over Following a Plan.

THE FOUR VALUES OF THE AGILE MANIFESTO

The Agile Manifesto is comprised of four foundational values and 12 supporting principles which lead the
Agile approach to software development. Each Agile methodology applies the four values in different ways,
but all of them rely on them to guide the development and delivery of high-quality, working software.

1. Individuals and Interactions Over Processes and Tools

The first value in the Agile Manifesto is “Individuals and interactions over processes and tools.” Valuing
people more highly than processes or tools is easy to understand because it is the people who respond
to business needs and drive the development process. If the process or the tools drive development, the
team is less responsive to change and less likely to meet customer needs. Communication is an example
of the difference between valuing individuals versus process. In the case of individuals, communication is
fluid and happens when a need arises. In the case of process, communication is scheduled and requires
specific content.
2. Working Software Over Comprehensive Documentation
Historically, enormous amounts of time were spent on documenting the product for development and
ultimate delivery. Technical specifications, technical requirements, technical prospectus, interface design
documents, test plans, documentation plans, and approvals required for each. The list was extensive
and was a cause for the long delays in development. Agile does not eliminate documentation, but it
streamlines it in a form that gives the developer what is needed to do the work without getting bogged
down in minutiae. Agile documents requirements as user stories, which are sufficient for a software
developer to begin the task of building a new function.
3. Customer Collaboration Over Contract Negotiation
Negotiation is the period when the customer and the product manager work out the details of a
delivery, with points along the way where the details may be renegotiated. Collaboration is a different
creature entirely. With development models such as Waterfall, customers negotiate the requirements
for the product, often in great detail, prior to any work starting. This meant the customer was involved in
the process of development before development began and after it was completed, but not during the
process. The Agile Manifesto describes a customer who is engaged and collaborates throughout the
development process, making. This makes it far easier for development to meet their needs of the
customer. Agile methods may include the customer at intervals for periodic demos, but a project could

20MCA24 –Software Engineering 13

Module-1 Introduction of Software Engineering Learning Materials

just as easily have an end-user as a daily part of the team and attending all meetings, ensuring the
product meets the business needs of the customer.
4. Responding to Change Over Following a Plan
Traditional software development regarded change as an expense, so it was to be avoided. The
intention was to develop detailed, elaborate plans, with a defined set of features and with everything,
generally, having as high a priority as everything else, and with a large number of many dependencies on
delivering in a certain order so that the team can work on the next piece of the puzzle.
With Agile, the shortness of an iteration means priorities can be shifted from iteration to iteration and
new features can be added into the next iteration. Agile’s view is that changes always improve a project;
changes provide additional value.

THE TWELVE AGILE MANIFESTO PRINCIPLES

The Twelve Principles are the guiding principles for the methodologies that are included under the title “The
Agile Movement.” They describe a culture in which change is welcome, and the customer is the focus of the
work. They also demonstrate the movement’s intent as described by Alistair Cockburn, one of the
signatories to the Agile Manifesto, which is to bring development into alignment with business needs.
The twelve principles of agile development include:
1. Customer satisfaction through early and continuous software delivery – Customers are happier when
they receive working software at regular intervals, rather than waiting extended periods of time
between releases.
2. Accommodate changing requirements throughout the development process – The ability to avoid
delays when a requirement or feature request changes.
3. Frequent delivery of working software – Scrum accommodates this principle since the team operates
in software sprints or iterations that ensure regular delivery of working software.
4. Collaboration between the business stakeholders and developers throughout the project – Better
decisions are made when the business and technical team are aligned.
5. Support, trust, and motivate the people involved – Motivated teams are more likely to deliver their
best work than unhappy teams.
6. Enable face-to-face interactions – Communication is more successful when development teams are
co-located.
7. Working software is the primary measure of progress – Delivering functional software to the
customer is the ultimate factor that measures progress.
8. Agile processes to support a consistent development pace – Teams establish a repeatable and
maintainable speed at which they can deliver working software, and they repeat it with each release.
9. Attention to technical detail and design enhances agility – The right skills and good design ensures the
team can maintain the pace, constantly improve the product, and sustain change.
10. Simplicity – Develop just enough to get the job done for right now.
11. Self-organizing teams encourage great architectures, requirements, and designs – Skilled and
motivated team members who have decision-making power, take ownership, communicate regularly
with other team members, and share ideas that deliver quality products.
12. Regular reflections on how to become more effective – Self-improvement, process improvement,
advancing skills, and techniques help team members work more efficiently.
The intention of Agile is to align development with business needs, and the success of Agile is apparent. Agile
projects are customer focused and encourage customer guidance and participation. As a result, Agile has
grown to be an overarching view of software development throughout the software industry and an industry
all by itself.

20MCA24 –Software Engineering 14

Module-1 Introduction of Software Engineering Learning Materials

The various agile Scrum methodologies share much of the same philosophy, as well as many of the
same characteristics and practices. But from an implementation standpoint, each has its own recipe
of practices, terminology, and tactics. Here we have summarized a few of the main agile software
development methodology contenders:

11.What are the practices followed in extreme programming

Extreme programming (XP) is a software development methodology which is intended to improve

software quality and responsiveness to changing customer requirements.

Extreme Programming − A way to handle the common shortcomings

Software Engineering involves −
• Creativity
• Learning and improving through trials and errors
• Iterations
Extreme Programming builds on these activities and coding. It is the detailed (not the only) design
activity with multiple tight feedback loops through effective implementation, testing and refactoring
continuously.
Extreme Programming is based on the following values −
• Communication
• Simplicity
• Feedback
• Courage
• Respect

20MCA24 –Software Engineering 15

Module-1 Introduction of Software Engineering Learning Materials

What is Extreme Programming?

XP is a lightweight, efficient, low-risk, flexible, predictable, scientific, and fun way to develop a software.
eXtreme Programming (XP) was conceived and developed to address the specific needs of software
development by small teams in the face of vague and changing requirements.
Extreme Programming is one of the Agile software development methodologies. It provides values and
principles to guide the team behavior. The team is expected to self-organize. Extreme Programming provides
specific core practices where −
• Each practice is simple and self-complete.
• Combination of practices produces more complex and emergent behavior.
Embrace Change
A key assumption of Extreme Programming is that the cost of changing a program can be held mostly
constant over time.
This can be achieved with −
• Emphasis on continuous feedback from the customer
• Short iterations
• Design and redesign
• Coding and testing frequently
• Eliminating defects early, thus reducing costs
• Keeping the customer involved throughout the development
• Delivering working product to the customer
Extreme Programming in a Nutshell
Extreme Programming involves −

• Writing unit tests before programming and keeping all of the tests running at all times. The unit
tests are automated and eliminate defects early, thus reducing the costs.
• Starting with a simple design just enough to code the features at hand and redesigning when
required.
• Programming in pairs (called pair programming), with two programmers at one screen, taking
turns to use the keyboard. While one of them is at the keyboard, the other constantly reviews
and provides inputs.
• Integrating and testing the whole system several times a day.
• Putting a minimal working system into the production quickly and upgrading it whenever
required.
• Keeping the customer involved all the time and obtaining constant feedback.

20MCA24 –Software Engineering 16

Module-1 Introduction of Software Engineering Learning Materials

Why is it called “Extreme?”

Extreme Programming takes the effective principles and practices to extreme levels.
• Code reviews are effective as the code is reviewed all the time.
• Testing is effective as there is continuous regression and testing.
• Design is effective as everybody needs to do refactoring daily.
• Integration testing is important as integrate and test several times a day.
• Short iterations are effective as the planning game for release planning and iteration planning.

Extreme Programming Advantages

Extreme Programming solves the following problems often faced in the software development projects −
• Slipped schedules − and achievable development cycles ensure timely deliveries.
• Cancelled projects − Focus on continuous customer involvement ensures transparency with the
customer and immediate resolution of any issues.
• Costs incurred in changes − Extensive and ongoing testing makes sure the changes do not break the
existing functionality. A running working system always ensures sufficient time for accommodating
changes such that the current operations are not affected.
• Production and post-delivery defects: Emphasis is on − the unit tests to detect and fix the defects
early.
• Misunderstanding the business and/or domain − Making the customer a part of the team ensures
constant communication and clarifications.
• Business changes − Changes are considered to be inevitable and are accommodated at any point of
time.
• Staff turnover − Intensive team collaboration ensures enthusiasm and good will. Cohesion of multi-
disciplines fosters the team spirit.

20MCA24 –Software Engineering 17

Module-1 Introduction of Software Engineering Learning Materials

Agile Project Management

• The principal responsibility of software project managers is to manage the project so that the
software is delivered on time and within the planned budget for the project.
• The standard approach to project management is plan-driven. Managers draw up a plan for
the project showing what should be delivered, when it should be delivered and who will work
on the development of the project deliverables.
• Agile project management requires a different approach, which is adapted to incremental
development and the particular strengths of agile methods.

What is Scrum?

Scrum is a simple empirical process that enables teams to build products incrementally in iterations, to keep
abreast of the changing market needs and align themselves to the organization's business goals.
▪ Scrum advocates self-organizing teams working towards a common goal through continuous
inspection and adaptation.
▪ A minimum viable product at the end of each iteration provides an option for the teams to quickly
get feedback from end users and respond much faster.

"Scrum is an agile process that allows us to focus on delivering the highest business
value in the shortest time.“
- Mike Cohn, Mountain Goat Software
•
•
• There are three phases in Scrum.
– The initial phase is an outline planning phase where you establish the general objectives for
the project and design the software architecture.
– This is followed by a series of sprint cycles, where each cycle develops an increment of the
system.
– The project closure phase wraps up the project, completes required documentation such as
system help frames and user manuals and assesses the lessons learned from the project.

20MCA24 –Software Engineering 18

Module-1 Introduction of Software Engineering Learning Materials

The Scrum Process

Scrum Methodology

Scrum forms the base for many of the other frameworks and hence it is important for an agile practitioner to
understand this methodology.
The Scrum Methodology is defined by:
• Scrum Roles -> A Product Owner, a Scrum Master and the Development Team
• Scrum Events -> Sprint planning , Daily scrum , Sprint review, Sprint retrospective
• Scrum Artifacts-> Product backlog, Sprint backlog, Increment
• Scrum Values -> Commitment, Courage, Focus, Openness, and Respect
Product Owner:
• A Product Owner in a scrum team decides what needs to be built. This person has complete
knowledge about the market and business needs, has a vision, and owns the return on investment
(ROI) or the value delivered by the product.
• Unlike traditional delivery, this person is a part of the team that delivers the product.
• Following are the key responsibilities of the Product Owner:
• Creates the vision
• Represents business, and is responsible for the ROI
• Cascades the vision to the teams
• Owns the backlog of features
• Prioritizes features by market value
• Is empowered to take decisions
• Negotiates with the team and business to deliver the right product at the right time
•

20MCA24 –Software Engineering 19

Module-1 Introduction of Software Engineering Learning Materials

Roles:
• Scrum Master:

• The Scrum Master is not a management title and cannot make decisions on behalf of the
team. The Scrum Master's major responsibility is to ensure that scrum is understood and practiced by
every team member in the true spirit.

• The Scrum Master should understand the different skill sets of his or her team and group
them by having the right sheep in the right flock. A Scrum Master should guide the team such that
the team does not go astray and fall prey to excess time and energy.

A Scrum Master:

• Is a servant leader - mentors and coaches the teams on scrum theory and practices, guides
them on how they need to adapt to those, thereby realizing the benefits of scrum both at
team level and organization level.

• Helps remove obstacles/impediments - supports the Development teams in removing the

impediments by reaching out to the right people, thereby ensuring a smooth development
progress without disrupting the team.

• Facilitates collaboration - enables interactions within the team as well as between the team
and the Product Owner.

• Teaches scrum - to the team.

• Protects the teams - from external disruptions such as changes to stories in the current
sprint.

• Is a change agent - in growing the organization to deliver early and often, and removing
waste.

The Development team:

The Development team in scrum is the team that has all the skills necessary to execute the backlog items. This
team is not a normal team but is committed, dedicated, and motivated to perform the best.
The following are the special characteristics of 'The Development team':
• Self-organizing - the Development team will be a self-managing group, who will decide on the
tasks that they will work on incrementally. There is no 'Manager', who controls their work.
• Empowered - the team should commit to work, determine 'HOW' to deliver and decide on
'HOW MUCH' to deliver in one iteration.
• Cross-functional - the team does not segregate members as developers, testers or analysts
and each member has the necessary skills to deliver the product increment.

20MCA24 –Software Engineering 20

Module-1 Introduction of Software Engineering Learning Materials

• Small-sized - the Development team should ideally have 5 to 9 team members with skills
sufficient to deliver the committed work. Smaller teams will not have the bandwidth to
complete a considerable work and larger teams will increase the complexity.
• Co-located - the agile team is typically co-located to ensure effective collaboration.
• Committed - since the team is empowered to take decisions on the scope of work in a sprint,
they are committed to delivery, should be transparent on the progress, and highlight the
impediments early on.
• Dedicated - this team is focused and is 100% dedicated to product delivery.

Artifcats:
• Scrum focuses more on a working software at the end of every sprint rather than comprehensive
documentation.
• The documentation is to facilitate collaboration and interactions, rather than tracking.
• The progress is always measured through a working software.
Documentation in scrum is only through three main artifacts namely:
▪ Product backlog,
▪ Sprint backlog,
▪ Increment.

Scrum Values
Scrum also states five core values to which teams have to adhere.
The core values are:
▪ Commitment,
▪ Courage,
▪ Focus,
▪ Openness, and
▪ Respect.
These values should be imbibed and lived by the scrum team to ensure the fulfilment of scrum pillars of
transparency, inspection, and adaptation. It builds trust among everyone

20MCA24 –Software Engineering 21

Module-1 Introduction of Software Engineering Learning Materials

Important Questions
1. Describe important attribute which all software product should have.
2. Explain FAQ’s of software engineering.
3. Discuss the various issues in software engineering professional ethics/ responsibility.
4. Explain ACM/IEEE code of ethics and suggest an appropriate example that illustrates that clause.
5. Explain in detail the Incremental Development Process with a neat block diagram.
6. Explain the Rational Unified Process in detail.
7. Explain Spiral model of Software Process with neat diagram.
8. Explain how the universal use of the Web has changed software systems.
9. Explain why change is Inevitable in complex systems and explain how
10. Explain Prototyping of software process help to more resilient to change?
11. What are agile methods? Discuss the principles of agile methods.
12. What are the practices followed in extreme programming
13. What is software Process Model? Explain with a diagram the Waterfall model and discuss its
advantages and disadvantages.

20MCA24 –Software Engineering 22