ASE MODULE-5
Q- Principles of Software Delivery
1. Create a Repeatable and Reliable Release Process
● Releasing software should be easy and predictable.
● Ideally, it should be like pressing a button.
● Achieved by automation and version control.
● Same steps every time → fewer mistakes.
2. Automate Almost Everything
● Manual processes are slow and error-prone.
● Automation makes releases fast, consistent, and reliable.
● Automate build, test, deploy, and release steps.
● Automation can be done gradually, not all at once.
3. Keep Everything in Version Control
● Store code, configuration, scripts, tests, documents in version control.
● Every release should be traceable to a specific version.
● Helps in rollback, debugging, and reproducibility.
4. If It Hurts, Do It More Frequently
● Painful tasks mean they are done too late or too rarely.
● Examples:
○ If integration is painful → integrate frequently.
○ If testing is painful → test continuously.
○ If release is painful → release more often.
● Problems are caught early, when cheaper to fix.
5. Build Quality In
● Do not test quality at the end.
● Detect and fix defects early in the delivery process.
● Use automated tests at every stage.
● Early fixes = less cost and less risk.
6. Done Means Released
● A feature is not done until users get value from it.
● “80% done” does not exist.
● Ideally, done means released to production.
7. Everybody Is Responsible for Delivery
● Delivery is a team responsibility, not just developers.
● Developers, testers, operations, managers must collaborate.
● Break organizational silos → faster and better delivery.
● Core idea behind DevOps.
8. Continuous Improvement
● Delivery process should evolve continuously.
● Teams should:
○ Review what worked and what didn’t
○ Improve in the next iteration
● Follows Deming Cycle: Plan → Do → Check → Act
Software delivery focuses on automation, frequent releases, early feedback, shared
responsibility, and continuous improvement to deliver high-quality software quickly
and reliably.
Q- Essential Practices to be Followed by CI Teams
1. Do not check in on a broken build
● If the build fails, fix it immediately.
● Never ignore a failed build.
2. Run all tests before committing code
● Run unit/commit tests on your system before check-in.
● Ensures your changes do not break the build.
3. Check in code frequently
● Commit small changes many times a day.
● Makes integration easier and avoids big conflicts.
4. Fix build failures first
● When the build breaks, stop other work.
● Fixing the build is the top priority.
5. Wait for commit tests to pass
● Do not move to new tasks until CI confirms success.
● Ensures stable main branch.
6. Never leave a broken build
● Do not go home or stop work leaving the build broken.
● Always ensure the build is stable.
7. Be ready to revert changes
● If a fix takes too long, revert to last working version.
● Keeps the system usable for everyone.
8. Do not comment out failing tests
● Removing tests hides problems.
● Fix the issue instead of bypassing it.
9. Take responsibility for failures
● If your change breaks tests, you must fix them.
● CI is a shared responsibility.
Q- Continuous Integration (CI) is a software development practice where developers
frequently merge their code changes into a shared repository, and each change is
automatically built and tested to detect errors early.
How CI Works
1. Developer writes code.
2. Code is committed to version control.
3. CI server automatically builds the application.
4. Automated tests are executed.
5. Result is reported immediately (pass or fail).
Key Features of CI
● Frequent code integration (many times a day)
● Automated build and testing
● Early detection of bugs
● Shared main branch (trunk)
Why CI is Important
● Finds errors early, when they are cheaper to fix
● Reduces large and difficult merges
● Improves code quality
● Ensures software is always in a working state
Prerequisites for CI (essential conditions that must be satisfied before a process can begin)
1. Version Control – all code, tests, scripts stored in one repository
2. Automated Build – build and tests run automatically
3. Team Discipline – everyone commits small changes frequently
Benefits of CI
● Faster development
● Better software quality
● Immediate feedback on errors
● Reliable and stable builds
Examples of CI Tools
● Jenkins
● TeamCity
Q- Continuous Testing is the process of automatically running tests continuously
throughout the software development lifecycle to get quick feedback on software quality.
How Continuous Testing Works
1. Developer commits code.
2. CI system builds the application.
3. Automated tests run immediately.
4. Results are reported instantly.
5. Errors are fixed early.
Types of Tests in Continuous Testing
● Unit Tests – test small parts of code
● Integration Tests – test interaction between components
● System Tests – test complete system
● Regression Tests – ensure new changes don’t break old features
● Acceptance Tests – verify business requirements
Why Continuous Testing is Important
● Detects bugs early
● Improves software quality
● Reduces risk before release
● Saves time and cost
Key Features
● Automated testing
● Runs with every code change
● Part of CI/CD pipeline
● Provides fast feedback
Benefits
● Faster bug detection
● Reliable releases
● Higher customer confidence
● Supports continuous delivery
Q- Continuous Deployment is a software practice where every code change that passes all
automated tests is automatically released to production without manual approval.
How Continuous Deployment Works
1. Developer commits code.
2. CI system builds the software.
3. Automated tests are executed.
4. If all tests pass, the software is automatically deployed to production.
5. Users get the update immediately.
Key Points
● No manual release step
● Fully automated process
● Happens many times a day
● Requires strong testing and automation
Difference from Continuous Delivery
● Continuous Delivery: Software is ready to release, but deployment may need manual
approval.
● Continuous Deployment: Software is automatically released after passing tests.
Advantages
● Faster delivery to users
● Immediate feedback
● Reduced human errors
● Always up-to-date software
Requirements
● Automated testing
● Reliable CI/CD pipeline
● Stable production environment
● High team discipline
Q- Continuous Delivery is a software development practice in which code changes are
automatically built, tested, and prepared for release, so the software can be released at
any time.
How Continuous Delivery Works
1. Developer commits code.
2. CI system builds the application.
3. Automated tests are executed.
4. Software is ready for release.
5. Deployment to production is done manually when needed.
Key Points
● Software is always in a deployable state.
● Deployment is not automatic (manual approval needed).
● Uses automated build and testing.
● Part of the CI/CD pipeline.
Why Continuous Delivery is Important
● Reduces release risk
● Faster and safer releases
● Early detection of defects
● Improves software quality
Benefits
● Reliable releases
● Faster feedback
● Less stress during deployment
● Supports frequent updates
Difference from Continuous Deployment
● Continuous Delivery → Ready to release anytime (manual deploy)
● Continuous Deployment → Automatically released to production
Q- Prerequisites for Continuous Integration (CI)
1. Version Control
● All code, tests, build scripts, and deployment scripts must be stored in one version
control repository.
● Ensures every change is tracked and integrated.
2. Automated Build
● The build process should run automatically from the command line.
● Build and tests must not depend on manual steps.
3. Team Agreement and Discipline
● All team members must commit small changes frequently.
● Everyone must agree that fixing a broken build is the top priority.
Q- Ansible is a configuration management and automation tool used to automate server
setup, software installation, configuration, and deployment.
Why Ansible is Used
● Removes manual work
● Makes tasks repeatable and error-free
● Manages multiple systems from one place
How Ansible Works
1. A control (management) node runs Ansible.
2. It connects to managed nodes using SSH.
3. Ansible sends small programs called modules.
4. Tasks are written in playbooks (YAML files).
5. Modules run and then are removed automatically.
Key Features
● Agentless (no software needed on managed nodes)
● Uses SSH
● Easy to learn (simple YAML syntax)
● Secure and reliable
● Centralized management
Main Components
● Control Node – system where Ansible runs
● Managed Nodes – systems being configured
● Inventory File – list of target machines
● Playbook – set of tasks written in YAML (simple text format used to write configurations
in an easy-to-read way)
● Modules – small programs that perform tasks
Advantages
● Fast and simple automation
● Reduces configuration errors
● Improves consistency across environments
● Easy for new team members to understand
Use Case: Automatic Web Server Deployment
Scenario:
A software project needs to deploy a web application on multiple servers (development,
testing, and production).
Problem Without Ansible
● Servers are configured manually
● High chance of configuration errors
● Different environments may behave differently
● Deployment is slow and inconsistent
How Ansible Helps
● Write one Ansible playbook to:
○ Install web server (e.g., Apache/Nginx)
○ Install required packages
○ Copy application files
○ Configure server settings
● Run the playbook to configure all servers at once
● Ensures same configuration everywhere
Benefits
● Saves time
● Reduces human errors
● Ensures environment consistency
● Easy to repeat and maintain
Q- A deployment pipeline is an automated process that takes software from version control
to production through a series of build, test, and deployment stages.
What It Does
● Automatically builds the software
● Tests it at different levels
● Deploys it to various environments (test, staging, production)
● Ensures only verified software is released
Stages in a Deployment Pipeline
1. Code Commit – Developer commits code to version control
2. Build Stage – Code is compiled and packaged
3. Test Stage – Automated tests (unit, integration, acceptance) run
4. Staging Deployment – Software is deployed to a production-like environment
5. Production Deployment – Software is released to users
Key Features
● Fully automated
● Fast feedback on errors
● Same process for every release
● Reduces manual mistakes
Why It Is Important
● Detects problems early
● Makes releases faster and safer
● Improves software quality
● Supports Continuous Delivery and Deployment
Q- How SCM is Achieved Using Version Control
Software Configuration Management (SCM) is achieved with the help of Version Control by
controlling, tracking, and managing all project changes in an organized way.
Ways Version Control Helps in Achieving SCM
1. Stores all project artifacts
● Source code, documents, test cases, scripts, and configs are stored in one repository.
● Ensures nothing important is lost.
2. Tracks changes
● Every change is recorded with who changed it, when, and why.
● Helps in auditing and understanding history.
3. Maintains versions
● Multiple versions of files are maintained safely.
● Older versions can be accessed anytime.
4. Supports rollback
● If a change causes an error, the system can be restored to a previous stable version.
5. Controls parallel development
● Multiple developers can work simultaneously using branches.
● Changes are merged in a controlled manner.
6. Ensures traceability
● Each build or release is linked to a specific version.
● Helps trace requirements → code → tests → release.
7. Supports CI/CD
● Version control triggers automated build and testing.
● Ensures continuous integration and delivery.
Q- Purpose of Software Configuration
The purpose of software configuration is to control and manage all changes made to a
software system so that it works correctly and consistently throughout its life cycle.
Main Purposes
1. Control changes
● Ensures only approved changes are made.
● Prevents accidental or unauthorized modifications.
2. Maintain consistency
● Keeps software behavior same across development, testing, and production
environments.
3. Ensure traceability
● Tracks what was changed, when, why, and by whom.
● Helps in debugging and auditing.
4. Support reproducible builds
● Allows recreating the same build or release at any time.
5. Improve reliability and quality
● Reduces errors caused by wrong versions or configurations.
Q- Configuration and Flexibility
Configuration means changing the behavior of software without changing its source code.
This is done using settings such as files, parameters, or environment values.
Example:
Changing database name or server port using a config file.
Flexibility means the software can adapt to different needs or environments using
configuration options.
Example:
Same software running in development, testing, and production with different settings.
Configuration vs Flexibility (Key Idea)
● Configuration provides flexibility.
● But too much configuration increases complexity.
Important Points
● Flexible software is useful but not always cheaper.
● Excessive configuration leads to:
○ Harder testing
○ More errors
○ Difficult maintenance
● This problem is called “ultimate configurability” (bad practice).
● Best approach:
○ Start with minimal configuration
○ Add flexibility only when needed
Q- Deployment Tests
Deployment tests are tests performed after software is deployed to an environment to verify
that the application is installed correctly and works properly.
Purpose of Deployment Tests
● Check whether deployment was successful
● Ensure the application starts and runs
● Verify basic critical functions
● Detect configuration or environment issues early
What Deployment Tests Usually Check
● Application starts without errors
● Required services (database, server) are running
● Basic user actions work
● Configuration settings are correct
● No deployment failures occurred
Types of Deployment Tests
● Smoke Tests (most common)
○ Small set of tests
○ Checks core functionality
○ Decides whether the build is stable for further testing
Why Deployment Tests Are Important
● Prevents broken software from reaching users
● Saves time by catching errors early
● Ensures reliability across environments
Q- Importance of Configuration Management
Configuration Management (CM) is important because it controls and manages changes in
software and ensures the system remains stable, consistent, and reliable throughout its life
cycle.
1. Controls changes
● Prevents unauthorized or accidental changes.
● Ensures only approved changes are applied.
2. Maintains consistency
● Keeps software consistent across development, testing, and production environments.
3. Enables version control
● Maintains different versions of software and documents.
● Helps track history of changes.
4. Supports rollback
● Allows restoring previous stable versions if errors occur.
5. Improves software quality
● Reduces configuration-related defects.
● Increases reliability and stability.
6. Ensures traceability
● Tracks what changed, when, why, and by whom.
7. Facilitates automation
● Supports automated build, testing, and deployment.
Q- Benefits of Configuration Management
1. Version control of configurations
● All configuration files are stored and managed with versions.
● Easy to track and restore previous configurations.
2. Detects and corrects configuration drift
● Identifies differences between environments.
● Ensures systems remain consistent.
3. Provides environment consistency
● Development, testing, and production behave the same.
● Reduces “works on my machine” issues.
4. Facilitates automation
● Enables automated build, testing, and deployment.
● Reduces manual effort and human errors.
5. Treats infrastructure as a flexible resource
● Infrastructure can be created, modified, or removed easily.
● Supports modern DevOps practices.
6. Enables automated scaling
● Supports automatic scale-up and scale-out of systems.
● Improves performance and availability.
Q- How Dependencies Are Managed in Software Configuration Management (SCM)
Dependencies are external libraries, frameworks, tools, or components that a software system
needs to work correctly.
SCM manages dependencies in a controlled and predictable way.
Ways Dependencies Are Managed in SCM
1. Specify exact versions
● Always mention the exact version of libraries or tools used.
● Ensures the same build can be recreated anytime.
2. Use dependency management tools
● Tools automatically download and manage required libraries.
● Prevents missing or wrong versions.
3. Store dependencies centrally
● External libraries are stored in a central repository or local storage.
● Makes builds faster and reliable.
4. Version control dependency information
● Dependency lists and configuration files are kept in version control.
● Helps track changes in dependencies.
5. Avoid system-wide dependencies
● Do not rely on libraries installed globally on a machine.
● Keeps builds consistent across environments.
6. Ensure reproducible builds
● Same dependencies + same versions = same output every time.
● Avoids “works on my machine” problems.
Q- Is the Deming Cycle effective in improving the software delivery process?
Yes. It is effective.
Justification
The Deming Cycle (PDCA – Plan, Do, Check, Act) is effective because it supports
continuous improvement, which is essential in software delivery.
How It Improves Software Delivery
1. Plan
● Identify problems in the delivery process (slow releases, defects, delays).
● Plan improvements such as automation or better testing.
2. Do
● Implement the planned changes on a small scale.
● Example: introduce automated testing in CI.
3. Check
● Measure results and analyze feedback.
● Check if quality, speed, or reliability has improved.
4. Act
● If successful, standardize the improvement.
● If not, refine the plan and repeat the cycle.
Why It Is Effective
● Encourages regular feedback
● Helps detect problems early
● Promotes team collaboration
● Supports continuous delivery and DevOps practices
Q- DRY Principle and Smoke Test in Software Configuration Management
1. DRY Principle (Don’t Repeat Yourself)
The DRY principle means avoiding duplication of code, configuration, or scripts.
Role in Software Configuration Management
● Configuration details should be defined once and reused.
● Prevents having the same configuration in multiple places.
● Reduces errors when changes are needed.
Example
● Database connection details written in one config file, not copied into multiple files.
● If details change, update in one place only.
Why DRY Is Important
● Easier maintenance
● Fewer configuration errors
● Better consistency
2. Smoke Test
A smoke test is a basic set of tests performed after build or deployment to check whether
the software works at a basic level.
Role in Software Configuration Management
● Verifies that the application is correctly configured and deployed.
● Ensures critical functions work before deeper testing.
● Detects configuration or environment issues early.
Example
● Check if application starts
● Check if login page loads
● Check if database connection works
Why Smoke Tests Are Important
● Saves time by catching failures early
● Prevents unstable builds from moving forward
● Confirms configuration correctness
Q- Steps Used for Build and Test Automation
Build and test automation means automatically compiling code and running tests whenever
changes are made.
Steps in Build and Test Automation
1. Source Code Checkout
● Code is taken from version control (Git, etc.).
● Ensures the latest code is used for build.
2. Build the Application
● Source code is compiled into executable files.
● Dependencies are resolved automatically.
● Build fails if there are compilation errors.
3. Package the Build
● Compiled code is packaged (JAR, WAR, executable, etc.).
● Creates a deployable artifact.
4. Run Unit Tests
● Tests small parts of code.
● Ensures individual components work correctly.
● Fast and automated.
5. Run Integration / Component Tests
● Tests interaction between modules.
● Checks database, services, and APIs if required.
6. Run Smoke Tests
● Basic tests to verify the build is stable.
● Confirms application starts and core features work.
7. Generate Test Reports
● Test results are collected.
● Shows passed and failed tests.
● Helps developers identify issues quickly.
8. Notify Results
● CI system sends build and test status.
● Team is informed immediately if build fails.
Why These Steps Are Important
● Detect errors early
● Reduce manual effort
● Improve software quality
● Support Continuous Integration and Delivery
Q- Difference Between Build Automation and Deployment Automation
Aspect Build Automation Deployment Automation
Meaning Automates the process of creating Automates the process of deploying
a software build software to environments
Main Purpose Convert source code into a working Install and run the build in
build test/production environments
Key Activities Compile code, resolve Configure environment, deploy
dependencies, run tests, package packages, run deployment tests
artifacts
Output Build artifacts (JAR, WAR, Running application in target
executable, etc.) environment
When Used After code is committed After a successful build
Focus Area Code correctness and build quality Environment correctness and release
reliability
Tools Used Maven, Gradle, Ant, CI servers Ansible, Docker, Jenkins, Kubernetes
Error Type Compilation and test failures Configuration and environment errors
Handled
Q- What is Release Management?
Release Management is the process of planning, scheduling, building, testing, and
deploying software releases so that the right version of software reaches users safely and
on time.
Purpose of Release Management
● Deliver software reliably
● Reduce release risk and errors
● Ensure quality and stability
● Coordinate work between teams
Main Steps in Release Management
1. Release Planning
● Decide what features and fixes go into the release
● Set release schedule and scope
2. Build and Package
● Compile code and create release artifacts
● Ensure correct versions are used
3. Testing
● Perform automated and manual testing
● Verify quality and readiness
4. Approval
● Check if release meets acceptance criteria
● Get authorization to release
5. Deployment
● Deploy software to production or target environment
● Use automated tools when possible
6. Post-Release Review
● Monitor system after release
● Fix issues if found
Why Release Management is Important
● Prevents faulty releases
● Ensures consistent deployments
● Improves customer satisfaction
● Supports Continuous Delivery