Software Engineering

Module 2

By
Dr Deepak M D
Dept. of CSE
GST, BLR
 Introduction
• Definition:
• Software Engineering is the application of engineering principles to software development in
a systematic method.
• Key Concepts:
• Systematic Approach:
– Emphasizes a structured process from requirement gathering to design, development,
testing, deployment, and maintenance.
– Ensures consistency, efficiency, and quality in software products.
• Engineering Principles:
– Utilization of engineering concepts such as modularity, abstraction, encapsulation, and
software architecture to create scalable and maintainable systems.
• Interdisciplinary Impact:
– Integrates principles from computer science, project management, and various
engineering disciplines to address software complexity and performance issues.
• Objectives:
• To design, develop, and manage software projects that are robust, efficient, and meet user
requirements.
• To adapt to evolving technologies and methodologies while maintaining a high standard of
software quality and functionality.
• Why It Matters:
• Software engineering practices are critical for the development of reliable and scalable
software systems that drive modern economies and societal functions.
• Traditional Software Engineering
– Focus: Initial stages of the discipline, primarily focused on structured
methodologies.
– Methodologies: Waterfall Model, Spiral Model.
– Characteristics: Emphasis on thorough documentation, sequential
development phases, and rigid adherence to initial requirements.
• Contemporary Software Engineering
– Focus: Adapting to rapidly changing technologies and market demands.
– Methodologies: Agile, DevOps, and Continuous Integration/Continuous
Deployment (CI/CD).
– Characteristics: Emphasis on flexibility, iterative development,
collaboration, and responding to change over following a fixed plan.
• Technological Advancements
– The role of new technologies like Artificial Intelligence, Cloud Computing,
and Blockchain in shaping modern software development practices.
• The Importance of Both Approaches
– Balancing the structure of traditional methods with the agility of
contemporary methods to meet diverse project needs.
Evolution
SDLC
Waterfall Model
 Verification and Validation
• Verification:
– Are we building the product right?
– It is concerned with Phase containment of errors
– Verification is the process of evaluating software to ensure that
it complies with specified requirements and that it was built
correctly.
• Validation:
– Are we building the right product?
– It is concerned with the final product being error-free
– Validation is the process of evaluating the final product to ensure it
meets the user's needs and requirements.

Verification Validation
QA/QC Quality Assurance Quality Control (QC)
(QA)
Time Before and during After the majority of
software software development
development work has been done
Metho Review, Analysis, Black-box testing
d Inspection,
Walkthrough
November 18, 2024 ***DRAFT*** 7
Advantages of the V-Model
1.Simple and Easy to Use: The model is straightforward and easy to
understand.
2.Emphasis on Verification and Validation: Ensures that testing is
planned and executed at every phase.
3.Early Detection of Defects: Problems are identified early in the
development process, reducing the cost and effort of fixing them later.
4.Structured Approach: Provides a disciplined and systematic approach
to software development.

Disadvantages of the V-Model

5.Rigid and Inflexible: The model is not suitable for projects where
requirements are likely to change frequently.
6.Sequential Phases: Each phase must be completed before moving to
the next, which can be restrictive.
7.Not Suitable for Complex Projects: The V-Model may not be ideal for
complex and long-term projects that require iterative development and
frequent changes.
Incremental model
Advantages of Incremental Model
• Important modules/functions are developed first and then the rest are added in
chunks.
• Working software is prepared quickly and early during the software
development life cycle (SDLC).
• This model is flexible and less expensive to change requirements and scope.
• The customer can respond to each module and provide feedback if any
changes are needed.

Disadvantages of Incremental Model

• Management is a continuous activity that must be handled.
• Before the project can be dismantled and built incrementally,
• The complete requirements of the software should be clear.
• This requires good planning and designing.
• The total cost of this model is higher
Iterative Model
Advantage of Iterative model
• In iterative models, bugs and errors can be identified quickly.
• Under this model, software is prepared quickly with some specifications.
• Testing and debugging the software becomes easier during each iteration.
• We get reliable feedback from users along with blueprints.
• This model is easily adaptable to constantly changing needs.

Disadvantage of Iterative model

• Iterative model is not suitable for small projects.
• Since we have to repeat iterations many times in the software development
process due to which we require more resources.
• Since the requirements are constantly changing, we have to make frequent
changes in the software.

• Due to constantly changing requirements, the budget of the project also

increases and it takes more time to complete it
Spiral model
Advantages of Spiral Model
• If we have to add additional functionality or make any changes to the
software, then through this model we can do so in the later stages
also.
• Spiral model is suitable for large and complex projects.
• It is easy to estimate how much the project will cost.
• Risk analysis is done in each phase of this model.

Disadvantage of Spiral Model

• This is the most complex model of SDLC, due to which it is quite
difficult to manage.
• This model is not suitable for small projects.
• The cost of this model is quite high.
• It requires more documentation than other models.
Prototype model
 Advantages of Prototype model
• Prototype Model is suggested to create applications whose
prototype is very easy and which always includes human machine
interaction within it.
• When we know only the general objective of creating software,
but we do not know anything in detail about input, processing and
output. Then in such a situation we make it a Prototype Model.
• When a software developer is not very sure about the capability
of an algorithm or its adaptability to an operating system, then in
this situation, using a prototype model can be a better option.
Disadvantages of Prototype model
• When the first version of the prototype model is ready, the
customer himself often wants small fixes and changes in it rather
than rebuilding the system. Whereas if the system is redesigned
then more quality will be maintained in it.
• Many compromises can be seen in the first version of the
Prototype Model.
• Sometimes a software developer may make compromises in his
implementation, just to get the prototype model up and running
quickly, and after some time he may become comfortable with
making such compromises and may forget that it is completely
inappropriate to do so
 Unified Process Model
• The Unified Process (UP) in Object-Oriented
Analysis and Design (OOAD) is a flexible and
iterative approach to developing software.
• It focuses on creating working software
increments, collaborating with team
members, and adapting to changes.
The Unified Process (UP) in Object-Oriented Analysis and
Design (OOAD) is a software development methodology
that emphasizes:
Iterative development,
Collaboration, and
Flexibility.
It is based on the Unified Modeling Language (UML) and is
characterized by:
Its use of use cases to drive development,
Its focus on architecture-centric development, and
Its emphasis on risk management and incremental
delivery.
 Importance of Unified Process
• Complex software projects are made- more
manageable
• Clear guidelines and workflows
• Continuous feedback
 Key Principles of Unified Process
• Iterative and Incremental:
• Use Case Driven
• Architecture-Centric:
• Risk Management:
• Continuous Validation
 Phases of Unified Process
1. Inception:
The phases in Unified Process provide a
structured framework for managing the
various activities and tasks involved in building
a software system.
Key activities in this phase include:
Identifying stakeholders,
Defining the initial requirements,
Outlining the project plan, and
Assessing risks.
2. Elaboration
In this phase, the project requirements are analyzed in more
detail, and the architecture of the system is defined.
Key activities include:
1. Developing use cases,
2. Creating the architectural baseline,
3. Identifying key components, and
4. Refining the project plan.
3. Construction
This is the phase where the actual implementation of the
system takes place.
Key activities include:
1. Developing,
2. Testing, and
3. Integrating the system components, as well as
4. Continuously verifying that the system meets the
requirements

4. Transition
In this final phase, the software is deployed to end users.
Key activities include:
1. User training,
2. Final system testing, and
3. Transitioning the system to the operations and
4. maintenance team
 Agile Software Development

However, this approach has many drawbacks:

•It is not flexible to changes in customer requirements.
•Time is wasted building features that nobody needs.
•The end user cannot give feedback till it’s completed
coded
•You don’t know how stable the system is until the end.
 Agile technic
1. Agile model is a combination of iterative and incremental models, that is, it is
made up of iterative and incremental models.
2. In Agile model, focus is given to process adaptability and customer satisfaction.
3. In earlier times, iterative waterfall model was used to create software. But in
the biggest problem is that in the middle of software development, the customer
asks to make changes in the software.
4. It takes a lot of time and money to make these changes.
5. The agile model was created mainly to make changes in the middle of software
development so that the software project can be completed quickly.
6. In the agile model, the software product is divided into small incremental parts. In
this, the smallest part is developed first and then the larger one.
7. And each incremental part is developed over iteration.
8. Each iteration is kept small so that it can be easily managed.
9. And it can be completed in two-three weeks.
10. Only one iteration is planned, developed and deployed at a time.
Principles of Agile model
1. There is a customer representative in the development team to
maintain contact with the customer during software development
and to understand the requirement.
2. When an iteration is completed, stakeholders and customer
representatives review it and re-evaluate the requirements.
3. That is, it does not depend only on documentation.
4. Incremental versions of the software have to be delivered to
the customer representative after a few weeks.
5. In this model it is advised that the size of the development
team should be small (5 to 9 people) so that the team members
can communicate face to face.
6. Agile model focuses on the fact that whenever any changes
have to be made in the software, it should be completed quickly.
7. In agile development, two programmers work together. One
programmer does the coding and the other reviews that code.
8. Both the programmers keep changing their tasks, that is,
sometimes one does coding and sometimes someone reviews.
Why companies are shifting toward agile Software Development
models?

1. In earlier times, iterative waterfall model was used to

create software. The biggest problem is that in the middle
of software development, the customer asks to make
changes in the software.

2. It takes a lot of time and money to make these changes.

3. The agile model was created mainly to make changes in

the middle of software development so that the software
project can be completed quickly.

4. Agile focuses on customer-centric approach that constantly

take feedback from customer and make changes in the
middle of software developer according to their needs and
expectation.

5. Agile Methodologies like scrum adopt iterative and

incremental approach this accelerate the time-to-market
for new features and product.
 Agile software development methods
• •Scrum
•Kanban / Lean
•Extreme Programming (XP)
•Agile Unified Process (AUP)
•Dynamic Systems Development Meth
od (DSDM)
•Disciplined Agile Delivery (DAD)
•Feature-Driven Development (FDD)
•Test-Driven Development (TDD)
•Rapid Application Development (RAD
)
•Scaled Agile Framework (SAFe)
 advantages
 In this, two programmers work together due to which the
code is error
free and there are very few mistakes in it.
 In this the software project is completed in a very short time.
 In this the customer representative has an idea of each
iteration so that he can easily change the requirement.
 This is a very realistic approach to software development.
 In this, focus is given on teamwork.
 There are very few rules in this and documentation is also
negligible.
 There is no need for planning in this.
 It can be managed easily.
 It provides flexibility to developers.
 Disadvantages
 It cannot handle complex dependencies.
 Due to lack of formal documentation in this, there is
confusion in
development.
 It mostly depends on the customer representative, if the
customer representative gives any wrong information
then the software can become wrong.
 Only experienced programmers can take any decision in
this. New programmers cannot take any decision.
 Software Project Planning
• A Software Project is the complete
methodology of programming advancement
from requirement gathering to testing and
support, completed by the execution
procedures, in a specified period to achieve
intended software product.
Need of Software Project Management
1. Software development is a sort of all new streams in world
business, and there's next to no involvement in structure
programming items.
2. Most programming items are customized to accommodate
customer's
necessities.
3. The most significant is that the underlying technology
changes and advances so generally and rapidly that experience
of one element may not be connected to the other one.
4. All such business and ecological imperatives bring risk in
software
development; hence, it is fundamental to manage software
projects
efficiently.
 Software Project Manager
• Software manager is responsible for planning and
scheduling project development.
• They manage the work to ensure that it is
completed to the required standard.
• They monitor the progress to check that the event
is on time and within budget.
• The project planning must incorporate the major
issues like size & cost estimation scheduling, project
monitoring, personnel selection evaluation & risk
management.
• To plan a successful software project, we must
understand:
 Scope of work to be completed
 Risk analysis
 The resources mandatory
 The project to be accomplished
 Record of being followed
Software Project planning starts before technical work start.
The various steps of planning activities are
• The size is the crucial parameter for the
estimation of other activities.
• Resources requirement are required based on
cost and development time.
• Project schedule may prove to be very useful
for controlling and monitoring the progress of
the project.
• This is dependent on resources & development
time.
Software Project Management (SPM)
 Software Project Management is a proper way of planning
and leading software projects.
 It is a part of project management in which software projects
are planned.
Need for Software Project Management

1. Software is a non-physical product. Software

development is a new stream in business and
there is very little experience in building
software products.
2. The most important is that basic technology
changes and advances so frequently and
rapidly that the experience of one product
may not be applied to the other one.
3. Such types of business and environmental
constraints increase risk in software development
hence it is essential to manage software projects
efficiently.
4. It is necessary for an organization to deliver quality
products, keep the cost with in the client’s budget
constraint.
5. Hence, in order, software project management is
necessary to incorporate user requirements along
with budget and time constraints.
 Types of Management in SPM

• Conflict Management
• Risk Management
• Requirement Management
• Change Management
• Software Configuration Management
• Release Management
• Aspects of Software Project Management
Sources of Conflict in Software Engineering
•Technical Disagreements: Team members may have differing opinions on the
choice of technologies, design patterns, or approaches to solving a problem.
•Resource Allocation: Conflicts can arise over the distribution of limited resources,
such as time, budget, or personnel.
•Role Ambiguity: Unclear or overlapping roles and responsibilities can lead to
confusion and disputes over who is accountable for specific tasks.
•Communication Issues: Miscommunication or lack of communication can cause
misunderstandings, leading to conflicts.
•Differing Priorities: Conflicts may occur when team members or stakeholders have
different priorities or expectations regarding project goals, features, or deadlines.
 Risks in Software Projects
Technical Risks: These involve challenges related to the technology used in the project
•, such as the adoption of new or unproven technologies, integration issues, or the risk of
• technical debt due to rushed development.
Project Management Risks: These include risks associated with poor project planning
•, inadequate resource allocation, unrealistic timelines, scope creep, and communication
• breakdowns within the team.
External Risks: These are risks that originate outside the project but can impact its
•success, such as changes in market conditions, regulatory changes, or dependency
•on third-party vendors.
Organizational Risks: These involve risks related to the organization's environment,
• such as changes in management, company policies, or business priorities that may
• affect the project.
Operational Risks: These risks are related to the day-to-day operations of the project,
•including staff turnover, lack of expertise, and issues with the development
•environment or tools.
Aspects of Software Project Management

• Planning
• Leading
• Execution
• Time Management
• Budget
• Maintenance
 SOFTWARE PROJECT MANAGEMENT
• Introduction to Software Project Planning
• Overview
– Importance of Project Planning: Essential for defining the project's scope, schedule, resources, and
risks. Ensures alignment with business goals and sets clear expectations for stakeholders.
– Key Objectives: To identify project activities, allocate resources efficiently, and accurately estimate
time and effort required to complete the project.
• Identification of Activities and Resources
• Activities Identification
– Work Breakdown Structure (WBS): A hierarchical decomposition of the total scope of work to be
carried out by the project team. It breaks down the project into smaller, more manageable tasks.
– Task Sequencing: Identifying dependencies between tasks to determine the optimal order for
completion.
– Milestones and Deliverables: Key checkpoints and outputs that measure project progress.
• Resource Allocation
– Human Resources: Identifying team members with the necessary skills and assigning them to
appropriate tasks.
– Material Resources: Tools, software, and equipment needed for project completion.
– Financial Resources: Budget allocation for various activities and resources.
 A feasibility study
• Feasibility study is an essential step in the
planning phase of any project, including
software development.
• It aims to assess the viability of a project by
evaluating various factors that can affect its
success.
• Here are the key concepts of a feasibility
study:
 Feasibility Study

• Concepts of Feasibility Study

– Technical Feasibility: Evaluates whether the project is
technically achievable with current technology and resources.
– Economic Feasibility: Assesses the cost-effectiveness of the
project and its potential financial benefits.
– Legal Feasibility: Ensures that the project complies with legal
and regulatory requirements.
– Operational Feasibility: Determines whether the project can
be integrated into the current operations and whether it
meets user needs.
– Schedule Feasibility:. Evaluates whether the project can be
completed within the desired timeframe.
Techniques for Estimation of Schedule and Effort

• Estimation Techniques
– Expert Judgment: Leveraging the experience and
insights of experts to estimate effort and time.
– Analogous Estimating: Using historical data from
similar projects to estimate.
– Parametric Estimating: Applying statistical models
based on project parameters (e.g., cost per line of
code).
– Three-Point Estimating: Using optimistic, pessimistic,
and most likely estimates to calculate an average.
 Effort Estimation
– Story Points and Velocity in Agile: Story points
represent the effort required to implement a user
story. Velocity is the average number of story
points completed in an iteration.
– Time boxing: Allocating a fixed time period
(sprint) for each iteration, during which specific
tasks must be completed.
 Software Cost Estimation Models

• Cost Estimation Models

– COCOMO (Constructive Cost Model): A model that estimates the cost, effort, and
schedule of a software project based on the size of the software.
– Function Point Analysis (FPA): Measures the functionality delivered to the user
based on the number of inputs, outputs, user interactions, files, and interfaces.
– Use Case Points (UCP): Estimates effort based on the complexity of use cases and
the actors involved.
– Parametric Models: Uses statistical relationships between historical data and other
variables to estimate project costs.
• Software Engineering Economics
– Cost-Benefit Analysis: Comparing the project's benefits to its costs to determine
feasibility and justification.
– Return on Investment (ROI): Calculating the financial return expected from the
project investment.
– Total Cost of Ownership (TCO): Evaluating the complete cost of acquiring,
operating, and maintaining the project over its lifecycle.
 Software Cost Estimation Models
• Algorithmic Models
• Description: Use mathematical algorithms to predict software cost
based on historical data and project parameters.
• Examples:
– COCOMO (Constructive Cost Model):
• Developed by Barry Boehm.
• Predicts the effort required based on the size of the software (measured in KLOC -
thousands of lines of code).
• Variants: Basic, Intermediate, and Detailed COCOMO.
– Function Point Analysis (FPA):
• Measures the size of the software based on the functionality provided to the user.
• Considers inputs, outputs, user interactions, files, and external interfaces.
– SLIM (Software Life Cycle Management):
• Based on the Rayleigh curve and Putnam’s Model.
• Uses historical project data to predict future project costs.
Importance of the COCOMO Model
1.Cost Estimation: To help with resource planning and
project budgeting, COCOMO offers a methodical approach
to software development cost estimation.
2.Resource Management: By taking team experience,
project size, and complexity into account, the model helps
with efficient resource allocation.
3.Project Planning: COCOMO assists in developing
practical project plans that include attainable objectives,
due dates, and benchmarks.
4.Risk management: Early in the development process,
COCOMO assists in identifying and mitigating potential
hazards by including risk elements.
5.Support for Decisions: During project planning, the
model provides a quantitative foundation for choices about
scope, priorities, and resource allocation.
6.Benchmarking: To compare and assess various
software development projects to industry standards,
COCOMO offers a benchmark.
7.Resource Optimization: The model helps to maximize
the use of resources, which raises productivity and lowers
costs.
• E = a*(KLOC)b PM
• Tdev = c*(E)d
• Person required = Effort/ Time
• Where,
• E is effort applied in Person-Months
• KLOC is the estimated size of the software product
indicate in Kilo Lines of Code
• Tdev is the development time in months
• a, b, c are constants determined by the category of
software project given in below table.
 Software Engineering Economics

– Cost-Benefit Analysis: Comparing the project's

benefits to its costs to determine feasibility and
justification.
– Return on Investment (ROI): Calculating the
financial return expected from the project
investment.
– Total Cost of Ownership (TCO): Evaluating the
complete cost of acquiring, operating, and
maintaining the project over its lifecycle.
 Identification of activities and Resources

• Human Resources
• Roles:
– Project Manager
– Business Analyst
– System Architect
– Developers (front-end, back-end, full-stack)
– QA Engineers
– DevOps Engineers
– Support Engineers
Technical Resources
• Hardware:
– Servers
– Workstations
– Network infrastructure
• Software:
– Development tools (IDEs, compilers)
– Testing tools (manual and automated)
– Deployment and CI/CD tools
– Project management and collaboration tools
• Infrastructure:
– Cloud services (IaaS, PaaS, SaaS)
– Virtualization platforms
– Databases and storage solutions
Financial Resources
• Budget:
– Salaries and wages
– Software licenses and subscriptions
– Hardware procurement
– Training and development
– Contingency funds for unexpected expenses
• Time Resources
• Schedules:
– Project timelines
– Milestones
– Deadlines and deliverables
• Time Tracking:
– Time management tools (e.g., Toggl, Harvest)
Information Resources
• Documentation:
– Requirement documents
– Design documents
– Code repositories
– Test plans and reports
• Knowledge Bases:
– Internal wikis
– Technical support forums
– External documentation and manuals
 Techniques of Software Project Control
and Reporting

Project Control Techniques

1. Gantt Charts: Visual representation of the project
schedule, showing tasks, durations, and dependencies.
2. Critical Path Method (CPM): Identifying the sequence of
crucial tasks that determine the project's duration.
3. Program Evaluation and Review Technique (PERT):
Estimating project duration by analyzing the time required to
complete each task.
4. Agile Burndown and Burnup Charts: Burndown charts
show remaining work in a sprint, while burnup charts show
work completed over time.
5. Milestone Tracking
•Purpose: Break down a project into significant stages or milestones.
•Use: Tracking milestones ensures that key deliverables are met on time, allowing for
assessment of project progress.

6. Risk Management
•Purpose: Identify, analyze, and respond to project risks.
•Use: By monitoring risks, you can mitigate potential issues before they affect the
project's success.

7. Agile Methodologies (Scrum, Kanban)

•Purpose: Manage complex projects by breaking them into smaller, manageable
chunks.
•Use: Techniques like daily stand-ups, sprint planning, and retrospectives help in
continuous monitoring and improvement of project processes.

8. Status Reporting
•Purpose: Provide regular updates on project progress to stakeholders.
•Use: Weekly or monthly reports that summarize project status, risks, issues, and
next steps are essential for keeping all stakeholders informed.

9. Project Audits and Reviews

•Purpose: Conduct periodic assessments of project processes and performance.
•Use: Audits help in identifying deviations from the plan and areas for improvement.
 Reporting

– Status Reports: Regular updates on project

progress, highlighting completed tasks, ongoing
work, and any issues.
– Performance Metrics: Key indicators such as
velocity, defect rates, and schedule variance to
track project health.
– JIRA Dashboards and Reports with examples:
 JIRA 2019

• An amazing software which is built for every member of your

software team to plan, track and release great software.
• Can create user stories and issues, plan sprints and then
distribute the tasks across the software team.
• Can prioritize and discuss your team’s work in full context with
the complete visibility.
• Can also ship with confidence and sanity knowing the
information you have is always updated.
• Can improve team performance based on the real-time visual
data your team puts to use.
• Can transform product requirements in Confluence into a JIRA
software backlog with a single click.
 Introduction
to measurement of software size
• Lines of Code (LOC):
• Function Points (FP):
• Story Points (Agile):
• Use Case Points:
• Object Points:
Measuring software size is a fundamental practice in software
project management. By choosing the appropriate method, project
managers
. can ensure that they have a clear understanding of the
project's scope, which is essential for effective planning, execution,
and reporting. This understanding, combined with effective
reporting mechanisms, forms the backbone of successful software
project delivery
 Configuration
management.
Key Components of Configuration Management
• Configuration Identification
• Configuration Control
• Configuration Status Accounting
• Configuration Audits
• Version Control
• Baseline Management
• Benefits of Configuration Management
Configuration Identification
•Purpose: Identify and define the configuration items (CIs) that need to be managed.
This includes source code files, documentation, libraries, hardware components, and
any other items that form part of the project.
•Process: Establishing a baseline for each configuration item so that changes can be
tracked and managed effectively.

Configuration Control
•Purpose: Manage changes to configuration items. This involves evaluating and
approving or rejecting changes based on their impact on the project.
•Process: Using a change control process where proposed changes are reviewed,
and if approved, are implemented in a controlled manner. This helps in avoiding
unauthorized changes and ensures that all changes are documented and
traceable.
Configuration Status Accounting
•Purpose: Record and report the status of configuration items throughout the project
lifecycle.
•Process: Maintaining records of the current configuration, including versions and
build numbers. This provides visibility into the progress of the project and the status of
different components.
Configuration Audits
•Purpose: Ensure that configuration items conform to their specifications and
that changes have been made correctly.
•Process: Conducting audits to verify that the actual configuration matches
the documented configuration. This helps in identifying discrepancies and
ensuring that the software meets its requirements.

Version Control
Purpose: Manage different versions of software components to ensure that
changes are tracked and previous versions can be restored if needed.
Process: Using version control systems (VCS) like Git, SVN, or Mercurial to
manage changes to source code and other configuration items. Version control
helps in managing concurrent development efforts and ensures that teams are
working with the correct versions of files.

Baseline Management
•Purpose: Establish baselines, which are stable reference points for
configuration items at different stages of the project.
•Process: Once a baseline is established, any changes to the configuration items
must go through the configuration control process. Baselines are essential for
managing releases and ensuring that all components are in sync.
Benefits of Configuration Management
1.Improved Consistency: CM ensures that the software and its
components remain consistent throughout the development process,
reducing errors and rework.
2.Enhanced Collaboration: By maintaining a clear record of changes,
CM facilitates collaboration among team members, allowing them to
work on different parts of the project without conflicts.
3.Traceability: CM provides a history of changes, making it easier to
trace the origins of issues and understand the evolution of the
software.
4.Better Risk Management: CM helps in identifying potential risks
related to changes and provides a structured way to manage those
risks.
5.Streamlined Release Management: CM simplifies the process of
building and deploying software by ensuring that all components are
correctly versioned and tested.
6.Regulatory Compliance: In industries where compliance with
standards is required, CM ensures that all changes are documented
and traceable, meeting regulatory requirements.
 Being Agile
• Move quickly
• Travel light
• Keep aware
• Commit late
• Respond to change
• Don’t get overweight
• Be good at following a moving target
• Evolve and adapt to the local environment
AGILE METHODOLOGY-SCRUM CEREMONY

• Form the teams

• - Scrum Master
• -PO
• - Dev teams
• -QA Teams
SCRUM Meetings(daily standup)
Update JIRA
DOD and Retro
 Key Practice: Test-Driven
Development
• Use tests to drive and direct the development
– Write an automated test before writing the code!
• Two ‘levels’ of testing
• Unit (or ‘Developer’) Tests
– White-box tests that confirm a developers expectation of the behaviour of
their code
– Typically tool: xUnit framework
• Acceptance (or ‘Customer’) Tests
– Black-box tests that confirm the customer’s expectation of system capability
– Typical tool: FIT (Framework for Integrated Testing)
• Run all the tests all the time
– Every test is added to a growing regression suite
– All tests are executed whenever new code is checked-in
 Key drivers for implementing Agile software development processes

• • Accelerating time-to-market
• • Enhancing software quality
• • Increasing productivity
• • Improving alignment between IT and business
objectives
• • Improving project visibility
• • Reducing cost
• • Enhancing the ability to manage changing
priorities
• • Reducing project risk
• • Reducing process complexity
 Agile Practices:
• - “User Stories"
• - Test Driven Development
• - Refactoring: is the process of restructuring
existing computer code without changing its
external behavior. It aims to improve the
internal structure of the code, making it
cleaner, more efficient, and easier to
understand and maintain.
• - Acceptance Testing

User Stories are written by the customers as things that

the system needs to do for them.
They are also used instead of a large requirements
document.
 Agile Practices:

They are in the format of about three sentences

of text written by the customer in the
customers terminology without technical
terminologies.

User stories also drive the creation of the acceptance tests.

One or more automated acceptance tests must be created to verify the user story
has been correctly implemented.
 Agile Practices:

User stories also drive the creation of the

acceptance tests.
One or more automated acceptance tests must
be created to verify the user story has been
correctly implemented.
Continuous Integration (CI) is a software development practice where
developers frequently integrate their code changes into a shared repository,
multiple times a day. Each integration is verified by an automated build and
testing process, allowing teams to detect and address issues early in the
development cycle.
Process of Continuous Integration:
1.Code Commit:
1. Developers write code and commit their changes to the version control
system (VCS) like Git, SVN, or Mercurial.
2. This triggers the CI process, starting with the automatic detection of the
new code.
2.Automated Build:
1. The CI server monitors the repository for changes.
2. Once a change is detected, the CI server pulls the latest code from the
repository and triggers an automated build process.
3. The build process compiles the code, runs scripts, and prepares the
application for testing.
3.Automated Testing:
1. After the build, automated tests are executed. This includes unit tests,
integration tests, and sometimes functional or regression tests.
2. The CI server checks for any failures in the tests, ensuring that new
changes do not break existing functionality.
 4. Feedback:
1. The CI server provides immediate feedback to the developers about
the build and test results.
2. If the build or tests fail, the CI process sends notifications to the
developers, allowing them to fix the issues promptly.
5. Continuous Integration Loop:
3. Developers address any issues and commit their fixes, restarting the
CI process.
4. The process repeats, ensuring that the codebase is always in a
working state.

Importance of Continuous Integration:

•Early Detection of Errors: CI helps identify and fix errors early in the development
cycle, reducing the risk of complex issues in later stages.
•Improved Code Quality: Regular integration and testing ensure that the code
remains stable, functional, and of high quality.
•Faster Development Cycle: Automated builds and tests streamline the
development process, allowing for quicker feedback and more frequent releases.
•Enhanced Collaboration: CI encourages collaboration among team members, as
they are constantly working with the latest codebase and are aware of each other's
changes.
•Reduced Integration Problems: Frequent integration reduces the "integration
hell" that can occur when merging large amounts of code at the end of a
development cycle.
CI Servers and Their Interaction with Configuration
Management Tools
Popular CI Servers:
1.Jenkins:
1. An open-source CI/CD server that supports building, testing, and
deploying code.
2. Highly extensible with a large ecosystem of plugins.
2.GitLab CI/CD:
1. Integrated with GitLab, offering CI/CD pipelines for projects stored in
GitLab repositories.
2. Provides seamless integration with GitLab’s version control and issue
tracking.
3.CircleCI:
1. A cloud-based CI server that integrates with GitHub and Bitbucket
repositories.
2. Offers automated testing and deployment pipelines.
Interaction of CI Servers with Configuration Management Tools:
Configuration Management Tools:
•Examples: Ansible, Chef, Puppet, Terraform.
How CI Servers Interact with Configuration Management Tools:
1.Infrastructure as Code (IaC):
1. Configuration management tools use IaC to define and manage infrastructure
through code.
2. CI servers can trigger these tools to provision, configure, and deploy
environments automatically as part of the CI/CD pipeline.
2.Automated Environment Setup:
1. When a new build is triggered, the CI server can use configuration management
tools to set up a testing environment.
2. This includes provisioning servers, installing necessary software, and
configuring services.
3.Consistent Deployment:
1. After successful builds and tests, CI servers use configuration management
tools to deploy applications to various environments (e.g., staging, production).
2. This ensures that the deployment process is consistent and repeatable,
reducing the chances of human error.
4.Rollback and Recovery:
1. If a deployment fails, CI servers can use configuration management tools to roll
back to the previous stable configuration.
2. This enhances the reliability of the deployment process and minimizes
downtime.
 Basic representation of a Work Breakdown
Software Development Project Structure(WBS) for a software development
project:
├── 1. Requirements Gathering
│ ├── 1.1. Stakeholder Interviews
│ ├── 1.2. Requirement Analysis
│ ├── 1.3. Documentation
├── 2. Design
│ ├── 2.1. System Architecture Design
│ ├── 2.2. UI/UX Design
│ ├── 2.3. Database Design
├── 3. Development
│ ├── 3.1. Frontend Development
│ ├── 3.2. Backend Development
│ ├── 3.3. Integration
├── 4. Testing
│ ├── 4.1. Unit Testing
│ ├── 4.2. Integration Testing
│ ├── 4.3. User Acceptance Testing
└── 5. Deployment
├── 5.1. Production Environment Setup
├── 5.2. Data Migration
└── 5.3. Go-Live
•Gantt chart lists tasks or phases on the vertical axis and time on the horizontal axis.
•Each task has a bar that represents its duration, showing when it starts and ends.
•Tasks can overlap, showing parallel progress (e.g., Design and Requirements Gathering)
•Dependencies can be visualized by connecting bars, showing which tasks need to be
• completed before others can start (e.g., Testing can only begin after Development

•The WBS starts with the overall project at the top level.
•It breaks down into major phases (e.g., Requirements Gathering, Design,
Development, Testing, Deployment).
•Each phase is further decomposed into smaller tasks (e.g., Stakeholder
Interviews, System Architecture Design, Unit Testing).
•The decomposition continues until tasks are manageable and assignable to team
members.
 Three-Tier Client-Server Architecture

• Adding a middle layer enhances the system's

architecture:
• - **Presentation Layer:** Manages user interface
• - **Business Logic Layer:** Processes data,
applies business rules
• - **Data Layer:** Handles database storage

• Common in complex systems like online

appointment scheduling.
 Presentation Layer:

– Manages the user interface (UI).

– Responsible for displaying information to users
and capturing their input.
– Includes components like web pages, forms, and
screens.
– In our claims processing application, this layer
would handle the UI for creating, viewing, and
editing claims.
 Business Logic Layer
• Processes data and applies business rules.
• Contains the core logic of the application.
• Validates input, performs calculations, and
enforces business rules.
• In our example, this layer would handle claim
validation, status updates, and calculations
(e.g., claim amounts).
 Data Layer
• Handles database storage.
• Stores and retrieves data.
• Interacts with the database management
system (e.g., PostgreSQL).
• In our case, this layer manages the claims
data, including storing claimant information,
amounts, and statuses.
 Advantages of Three-Tier Over Two-Tier Architecture

• **Benefits of Three-Tier Architecture:**

• - Improved scalability by distributing load
• - Enhanced security with encapsulated
business logic
• - Greater flexibility and easier maintenance
without affecting other layers