• Waterfall Model: A traditional, linear approach where each phase (requirements, design, implementation, verification, maintenance) must be completed

ed before the next

begins. It’s suitable for well-defined projects but lacks flexibility. Characteristics: Detailed documentation, upfront planning, and a clear, defined set of requirements.
• Agile Model: In contrast to Waterfall, Agile is an iterative and incremental approach. It focuses on customer collaboration, flexible response to change, and delivering
functional software in short cycles, known as sprints. Characteristics: Emphasizes flexibility, customer collaboration, and responsiveness to change.
• Agile Manifesto: Core Values: Focus on individuals and interactions, working software, customer collaboration, and responding to change. Principles: Emphasize early
and continuous delivery, welcoming changing requirements, and frequent delivery. This Forms the foundation of Agile methodologies.
• Understanding Different Models: Importance knowing when and how to apply these models based on project requirements, resource availability, and client needs.
• Version Control Systems: Central to managing code changes and collaboration. Tools like Git allow developers to track changes, collaborate without overwriting each
other's work, and revert to previous versions if necessary. Importance: Crucial for Agile environments where collaboration and frequent updates are common.
• LVC systems are the simplest form of version control, where the version control database is stored on the local computer where the work is being done. Advantages:
1.Simple to set up and use. 2.Quick access since everything is stored locally. 3.Doesn't require network access. Disadvantages: 1.High risk of data loss if the local system
fails. 2.Lacks collaboration capabilities for team projects. 3.Difficult to track changes and revert to previous versions efficiently.
• CVC, all version control operations are processed on a central server where all versions and history are stored. Advantages: 1.Simplifies collaboration by providing a
single source of truth. 2. Easier to administer and control access. 3.Facilitates tracking of who made what changes and when. Disadvantages: 1.Single point of failure: If
the central server goes down, it impacts all users. 2.Requires network connectivity for most operations. 3.Can be less flexible in handling multiple versions of a project.
• DVC systems like Git allow each user to have a complete copy of the entire repository, including its history and Changes are shared between repositories. Advantages :
1.Enhanced collaboration: Each contributor has the full repository, enabling more flexible workflows. 2.Robust against data loss: Each clone is a full backup. 3.Allows
offline work: Most operations (commit, merge, history) are local. Disadvantages: 1.Can be more complex to understand and use, especially for beginners. 2.Larger initial
clone size due to the entire history being downloaded. 3.Requires more discipline in managing branches and merging.
• Branch Management: Git's branching model allows multiple developers to work on different features simultaneously without affecting the main codebase. This
encourages experimentation and parallel development. Pull Requests: Pull requests in platforms like GitHub or GitLab offer a space for code review and discussion. They
ensure that code is reviewed and meets quality standards before being merged, fostering collaboration and knowledge sharing.
• Simplicity: LVC is the simplest, but least powerful. CVC is more structured but has a single failure point. DVC offers the most features but is the most complex.
Collaboration: LVC lacks collaboration features. CVC centralizes collaboration but depends on a central server. DVC offers distributed collaboration with each user
having the full repository. Data Safety and Redundancy: LVC risks data loss with no backups. CVC relies on a central server for backup. DVC offers full redundancy
with each clone being a complete backup. #git init-Initializes a new Git repository. It creates a .git directory in the project.
• Importance of Git in Agile: Git supports Agile’s need for handling frequent changes and collaboration. Features like branching and merging are essential for managing
different development activities simultaneously.
• Automation of the build process is crucial in Agile development. It ensures consistency, efficiency, and the ability to frequently integrate and test the software.
• Importance: Automating the build process minimizes manual errors, saves time, and supports continuous integration practices.
• Quality Assurance in Agile: focuses on continuous testing and early defect detection to ensure software quality throughout the development process. Importance: on
maintaining software reliability and meeting quality standards in Agile development.
• Automated Testing: including unit, integration, and acceptance testing, is a key component in Agile methodologies. Importance: it supports continuous integration and
delivery by enabling frequent and efficient testing, ensuring code quality.
• Adv Gradle: 1.Flexibility and Customization: Gradle allows for custom scripts for building software Gradle Wrapper ensures that a project can be built with the precise
Gradle version it requires 2. Performance 3. Dependency Management: e.g jacocoTestReport Gradle has a robust dependency management system that handles project
dependencies and library versions effectively. Dis: 1. Learning Curve: Gradle’s flexibility and power come with a steeper learning curve, especially for developers
accustomed to more straightforward tools. 2. Complexity: The flexibility and scripting capabilities can lead to complex build scripts that might be hard to maintain.
• 2.Gradle: Supports incremental builds which can significantly improve build times by only processing code that has changed since the last build. Gradle: Uses a
configuration-on-demand approach which can speed up the build process but Maven’s configuration time can be longer since it might need to configure all modules.
• 2.Maven: Maven also supports incremental builds but often considered less efficient than Gradle’s because Maven’s model requires more information about the project to
determine what can be incremented. Bad: Maven also supports incremental builds but often considered less efficient than Gradle’s because Maven’s model requires
more information about the project to determine what can be incremented
• Gradle in Agile Development: 1.Continuous Integration: Gradle integrates seamlessly with CI tools like Jenkins, Bamboo, or GitHub Actions. This means that every
time code is committed, Gradle can automatically execute the build and test processes, providing quick feedback to developers. 2. Incremental Builds: Gradle's
incremental build capabilities ensure that only the parts of the code that have changed are recompiled. This is crucial for Agile's emphasis on frequent iteration, as it
allows developers to quickly test and integrate changes.3.Gradle's performance, particularly when it comes to large projects with multiple subprojects, is beneficial for
Agile teams that need to maintain a fast pace of development. Features like the Daemon, parallel execution, and build caching reduce the time spent on building and
testing.
• The role of Gradle in facilitating automated testing in an Agile environment: Gradle plays a significant role in facilitating automated testing Gradle supports
integration with a wide range of testing frameworks such as JUnit, TestNG, this makes it easy for teams to incorporate automated testing into their development
workflow.(Easy Integration)2. Test Automation: With Gradle, tests can be run automatically as part of the build lifecycle. This is aligned with the Agile practice of
continuous testing, where tests are run frequently to ensure that new changes do not break existing functionality.
• Semantic Versioning: To communicate the nature and impact of changes in a new software release. It tells users and developers whether a new version introduces major
changes, minor enhancements, or just bug fixes. Version Management: to keep track of and manage changes made to the software, allowing for revisiting older versions,
understanding the evolution of the software, and facilitating collaboration among developers. Configuration Management: To ensure that the software behaves as
expected in all environments (development, testing, production) and that any changes are systematically controlled and documented.
• Scope: Semantic Versioning has a narrower focus on version numbering, while Version Management covers the entire spectrum of tracking and managing software
changes. Configuration Management Activities deal with the operational aspect of software deployment and maintenance. Tools and Practices: Semantic Versioning is a
conceptual tool, Version Management uses tools like Git, and Configuration Management involves tools like Chef or Ansible. Agile Compatibility: All three are integral
to Agile methodologies but play different roles. Semantic Versioning aids in clear communication of changes, Version Management supports collaborative development,
and Configuration Management ensures stable and consistent deployment.
• Usability in Agile: JUnit fits well in Agile methodologies, particularly in test-driven development (TDD). In Agile, frequent changes to codebases are common, and JUnit
helps in quickly validating these changes, ensuring that new features don't break existing functionalities. This aligns with Agile’s emphasis on continuous improvement
and frequent iterations. Adv junit: 1.Ease of Use: JUnit's simple annotation-based approach makes it easy to write and understand tests.2. Integration: It integrates well
with IDEs, build tools, and continuous integration systems. Facilitates TDD: JUnit is conducive to test-driven development, a key Agile practice. DIS: 1.Limited to Unit
Testing: JUnit is primarily focused on unit testing, not suitable for higher-level integration or system tests. 2.Requires Discipline: Effective use of JUnit requires a
disciplined approach to writing and maintaining test cases, which can be time-consuming.
• Continuous Integration (CI) and Continuous Delivery/Deployment (CD) are practices designed to improve software development processes, particularly in Agile
environments. Definition: CI is a development practice of merging all developers' working copies to a shared mainline several times a day. PurposeMinimize the
duration and effort required by each integration. Tools: Common CI tools include Jenkins. Definition: CD is an extension of CI, ensuring that the software can be
reliably released at any time. Purpose: It involves building, testing, and releasing software quickly and frequently. Definition: Continuous Deployment is similar to CD
but goes a step further by automating the release process; every change that passes all stages of the production pipeline is released to customers. Purpose: It aims for a
faster and more streamlined deployment process Comparison: CI vs. CD: CI focuses on the integration of code, while CD extends CI to ensure that the software is always
in a releasable state. CD vs. Continuous Deployment: In CD, deployments are done manually, whereas in Continuous Deployment, they are automated.
• CI->Each commit triggers an automated build and test process, ensuring immediate detection of integration errors and reducing manual testing workload.
• Role in Agile (CI/CD) : CI/CD practices align closely with Agile principles. They facilitate rapid iterations, quick feedback loops, and adaptability to changes, which are
core aspects of Agile methodologies. They support Agile’s focus on delivering working software efficiently and frequently. Test automation ->Build tools (e.g., Maven
or Gradle) along with a Continuous Integration Server (e.g., Jekins) can be configured to automate test execution -> Essential for regular daily tests (agile development)
• CI workflow, This process begins with developers writing and testing code in their local environments before committing changes to a version control system. On commit,
a CI server automatically builds the project and runs tests to validate the changes, providing immediate feedback on the health of the codebase. Successful builds can be
 automatically deployed to a staging environment for further testing and, ultimately, to production. The CI workflow enables teams to detect and resolve conflicts quickly,
maintain a high standard of code quality, and streamline the delivery of software products. This approach is fundamental in Agile development, supporting rapid iteration
and frequent releases while ensuring stability and performance. ##Jenkins is an open-source automation server used in SW development for implem. CI/CD
• Effective Continuous Integration (CI) is a practice within software development where members of a team integrate their work frequently, typically each person
integrates at least daily, leading to multiple integrations per day. E.g Immediate Feedback: Developers receive immediate feedback on their commits so they can fix any
issues before they compound. Automated Testing: Automated tests run with each build to ensure that the application remains in a stable state despite new changes. CI
adv: 1.Early Bug Detection: Frequent integration helps in identifying and fixing bugs early.2 improved Code Quality: Regular testing ensures code quality is maintained.3
Faster Release Cycles: With automation in testing and deployment, CI/CD accelerates the time to market for software products. DIS:1. Initial Setup and Learning Curve:
Setting up a CI/CD pipeline can be complex and time-consuming. It also requires training for team members to adapt to new workflows. 2. Increased Complexity:
Integrating various tools and technologies in the CI/CD pipeline can lead to increased complexity. 3 Costs: Maintaining the CI/CD pipeline and the infrastructure.
• CI with Jenkins: 1. Jenkins automates the process of integrating code changes from multiple developers into a single software project. 2. It routinely builds and tests code
changes, providing immediate feedback on the success of changes. CD with Jenkins: 1. Jenkins extends its capabilities to Continuous Delivery by automating the software
release process. 2. It ensures that the software can be reliably released at any time, automating the deployment process and facilitating the rapid.
• Jenkins with git: 1. Jenkins integrates seamlessly with Git, a distributed version control system. 2. It can trigger builds on Git push events or pull requests, ensuring that
new code is consistently integrated and tested. Jenkins Compatibility with Gradle 1. Jenkins and Gradle together streamline the build process. 2.Jenkins can invoke
Gradle scripts to compile code, run tests, and package applications. Jenkins Role in Agile: 1. Jenkins supports Agile principles by facilitating continuous integration and
continuous testing, key aspects of Agile methodologies. 2. It enables Agile teams to detect issues early, iterate quickly, and deliver high-quality software consistently.
• Scrum Framework: Roles: 1Product Owner: Responsible for maximizing the value of the product and managing the Product Backlog. 2.Scrum Master: Acts as a
facilitator for the team and the Product Owner, ensuring adherence to Scrum practices. 3.Development Team: A cross-functional group responsible for delivering
potentially shippable product increments at the end of each Sprint. importance: Each role has specific responsibilities that ensure collaborative and efficient progress
towards the Sprint goal. ##qs daily > what did/do I do yesterday/today to help development team meet the Sprint goal./ or obstacles that prevent me MTSG.
• Scrum Events:1.Sprint: A time-boxed period (usually 2-4 weeks) during which a releasable product increment is developed. 2.Sprint Planning: Meeting to decide what
to complete in the coming Sprint. 3. Daily Scrum (Stand-Up): A brief daily meeting to synchronize activities and create a plan for the next 24 hours. 4.Sprint Review:
Held at the end of a Sprint to inspect the Increment and adapt the Product Backlog if needed. 5.Sprint Retrospective: A meeting after the Sprint Review to reflect on the
Sprint and plan for improvements in the next Sprint. Importance These events ensure regular inspection, adaptation, and transparency, essential for Agile practices.
• Scrum Artifacts: 1. Product Backlog: An ordered list of everything that is needed in the product. 2.Sprint Backlog: Set of Product Backlog items selected for the
Sprint, plus a plan for delivering them. 3. Increment: The sum of all the Product Backlog items completed during a Sprint and all previous Sprints. Importance Artifacts
provide key information needed to understand the product being developed, the progress towards the Sprint goal, and the work to be performed in the Sprint.
• XP vs scrum :1. Team InteracBon: Both methodologies emphasize collaboraFon, but XP puts more on engineering pracFces like pair programming and collecFve code
ownership.2 Customer Role: In XP, conFnuous customer involvement is a cornerstone, while Scrum involves the customer mainly during sprint reviews and planning.
• Agile approach requirements, which involves continuous stakeholder interaction, flexibility, and prioritization based on evolving project nee
• User Stories- Role in Agile: User stories are a simple way to document requirements in Agile. They describe features from an end-user perspective, ensuring the
development focuses on user value. Structure: Typically written in the format: "As a [user type], I want [functionality] so that [benefit]."
• Behavior-Driven Development-Concept: BDD is an Agile software development process that encourages collaboration between developers, QA, and non-technical
stakeholders. Role in Agile: BDD helps in defining requirements based on expected behavior, often using a language understandable by all stakeholders.
• Agile Tools: Jira and Trello-Functionality and Usage: These tools assist in tracking and managing user stories, sprints, and overall project progress in an Agile manner.
Agile Management: Knowing how these tools support Agile methodologies by enhancing collaboration, transparency, and efficiency in managing and prioritizing work.
• Traditional plan-and-document methodologies emphasize thorough planning and documentation before software development begins. They often follow a linear and
sequential approach like the Waterfall model. Key Features: 1. Structured Process: Each phase of development (requirements, design, implementation, testing) must be
completed before moving to the next. 2. Documentation Focus: Extensive documentation is created at each stage to ensure clarity and maintain a record of the
development process. Implications: Such methodologies are suitable for projects with well-understood requirements but lack flexibility in adapting to changes.
• Agile planning is iterative and flexible, adapting to changes in project requirements or market conditions. Key Principles: 1.Adaptive Planning: Emphasizes the ability
to respond to changes over following a set plan. 2.Customer Collaboration: Regular interactions with customers to refine and review the progress 3.Iterative
Development: The project is divided into small parts, allowing for incremental development and frequent reassessment. Benefits: Agile planning provides a more
dynamic and responsive approach to software development, allowing teams to deliver value more frequently and efficiently.
• Estimation – Story Points Concept: Story points are a unit of measure for expressing an estimate of the overall effort required to fully implement a product backlog item.
Application: They are used in Agile methodologies to estimate the effort for user stories, helping in sprint planning.
• Advantages:1. Relative Sizing: Story points abstract the estimation process from actual time, focusing on the relative difficulty of tasks. 2. Team-Centric: They are
based on the team’s experience and consensus, making them more accurate for the specific team.
• Ideal Days: Refer to the amount of time something would take to complete without interruptions in a perfect scenario. Elapsed Days: Reflect the actual calendar time,
including all kinds of interruptions and delays. Comparison in Agile Context: 1.Ideal Days are less preferred in Agile as they don’t often reflect the real-world scenarios.
2. Elapsed Days provide a more realistic timeline considering all potential delays and non-development activities.
• Task Board- 1.Each story card in a sprint is grouped together with the cards for its tasks and added to the “To Do” section of the task board. 2. Each team member works
on exactly one task at a time by writing his or her name on its card and moving it to the “In Progress” section of the task board. 3.When a team member finishes a task,
they move it to the “Done” section and claims another task—and if all of the story’s conditions of satisfaction are met, the story card is moved to the “Done” section too
• ideal Burndown: The ideal burndown line represents the expected rate of task completion. It is a straight line that shows how work would ideally be completed if it were
burned down at a consistent pace. How It Works: At the start of a Sprint, the total amount of work (usually measured in story points or hours) is plotted on the y-axis,
with time (days of Sprint) on the x-axis. As the team completes tasks, the corresponding points are burned off, resulting in a downward trend in the chart. Benefits:
Burndown charts offer real-time insight into the team’s progress, helping to identify whether the team is on track. They foster transparency and facilitate quick
adjustments in the team’s approach. Realistic Tracking: If the team is ahead or behind schedule, this is reflected in the chart’s divergence from the ideal line.
• Ethical Decision Making: Software engineers often face ethical dilemmas where they must balance business objectives, legal requirements, and ethical considerations.
Understanding how to apply ethical theories and adhere to professional standards is crucial in making decisions that uphold integrity and public interest. Privacy and
Data Protection: In an era of data-driven technologies, the ethical handling of user data is paramount. Software engineers must be versed in privacy laws and ethical
practices to protect user information from unauthorized access and misuse. Product and Software Liability: Understanding liability in software engineering involves
recognizing the legal responsibilities for any harm caused by software malfunctions or failures. This knowledge is crucial in developing software that is not only
functional but also safe and reliable. intellectual Property Rights: Knowledge of IP rights ensures that software engineers can protect their own work, respect the IP of
others, and navigate the complexities of software licensing. It's essential for legal compliance and ethical practice in software creation and distribution. Open-Source
Software and Licensing: Open-source software is a cornerstone of modern software development. Knowledge of different open-source licenses is crucial as it affects
how software can be used, modified, and shared. Understanding these licenses helps in making informed decisions about using and contributing to open-source software.
• Q Why is software artifact management important in Agile development? A Artifact management in Agile ensures organized, efficient tracking and updating of
project components, crucial for Agile's rapid, iterative development cycles. Q How does GitHub support Agile software development practices? A GitHub facilitates
Agile development through features like branch management, pull requests, and issue tracking, enabling collaborative code review and continuous integration. Q
"Describe the role of a Scrum Master in a Scrum team. How does the Scrum Master facilitate the Agile process and support both the Product Owner and the
Development Team? A The Scrum Master guides the Scrum team in adhering to Scrum values and rules, often acting as a coach. They remove impediments, help the
team maximize value, and ensure effective team interactions. For the Product Owner, they assist in managing and clarifying the product backlog, while for the
Development Team, they promote self-organization and facilitate Scrum events, thereby ensuring smooth Agile process execution.
git rebase streamlines history by changing the base of branches, ideal for maintaining a linear project history. In Agile, merge suits collaborative work; rebase is for
updating feature branches before merging. git init & git clone Agile Role: Set up and extend collaborative Agile environments, with init starting a new project and clone
replicating existing ones for teamwork. git add, git commit, git status, git log, git diff, git revert, git reset Agile Role: Manage and document iterative changes. add and
commit track progress, status and log provide transparency, diff reviews changes, while revert and reset offer flexibility in handling updates and mistakes. git branch,
git checkout, git merge Agile Role: Facilitate parallel development of features and issues, supporting Agile's adaptability and continuous improvement. branch creates
isolated environments, checkout switches contexts, and merge integrates changes. git pull, git push, git fetch Agile Role: Synchronize team efforts, ensuring all
members are updated and contributing to the shared codebase, crucial for Agile's collaborative dynamics