SOFT2412 Exam Study Guide: Agile, DevOps, Gradle, GitHub, TDD

Introduction: Why Agile and DevOps Matter in 2026

As you gear up for the SOFT2412 or COMP9412 exam, you're diving into the core of modern software engineering: Agile methodologies, DevOps practices, and the tools that keep teams shipping quality code. In May 2026, these skills are more relevant than ever—think of the latest AI coding assistants, the explosion of open-source AI models, and the demand for rapid, reliable software delivery in everything from gaming to finance. This tutorial breaks down the key exam topics with clear explanations, real-world analogies, and study tips to help you ace those multiple-choice and short-answer questions.

1. Empirical Process Control: The Heart of Scrum

Question 1 asks: What aspect of empirical process control theory involves frequently examining Scrum artifacts and ensuring the team is still on track? The answer is Inspection. Empirical process control rests on three pillars: transparency, inspection, and adaptation. Inspection means regularly checking Scrum artifacts (like the product backlog, sprint backlog, and increment) to detect undesirable variances. Think of it like a gaming live stream where the streamer constantly checks chat and game stats to adjust their strategy—inspection without adaptation is just watching; you need to adapt based on what you see.

2. Agile Teams: Size, Harmony, and Mutual Respect

Question 2 tests your understanding of Agile teams. Which statement is true? The correct one: Members of Agile teams have mutual respect and mutual responsibility toward the work needs to be done. Agile teams thrive on collaboration, not size. A small, harmonious team of 5–7 members often outperforms a larger group. In the world of esports, a coordinated 5-person team can beat a disorganized 10-person squad every time. Remember: Agile teams are cross-functional, self-organizing, and focused on delivering value.

3. Semantic Versioning, Patents, and Codelines

Question 3 asks which statement is not correct. The incorrect one: Patents grant inventor(s) the right to exclude others from making, using or selling and importing an invention for a limited time in exchange for public disclosure of the invention. Wait—that statement is actually correct. Let's re-read: the question says 'Which of the following statements is not correct?' The correct answer is the one that is false. Among the options, the false statement is: Codeline specifies the component versions that are included in the system plus a specification of the libraries used and configuration files. Actually, that's a definition of a configuration specification, not a codeline. A codeline is a set of related files under version control. Semantic versioning (MAJOR.MINOR.PATCH) helps manage dependencies—like how AI model versions (e.g., GPT-5.1.2) indicate breaking changes.

4. Test-Driven Development (TDD) Myths

Question 4 reveals common misconceptions about TDD. Which is true? Development happens in very short cycles in which requirements are turned into specific test cases which must fail before implementing the requirements. That's the essence of TDD: red-green-refactor. TDD is not exclusive to XP, and unit tests are written before code, not after. Yes, writing tests takes time, but it reduces debugging later—like a smart home device that tests its sensors before activating an alarm.

5. Agile Mindset: Working Software

Question 5 asks what is not part of an agile team's mindset toward working software. The answer: It contains the final version of all features. Agile delivers incrementally, not all at once. Working software is the primary measure of progress, delivered frequently to get feedback. Think of mobile app updates—you release a minimum viable product, then iterate based on user reviews.

6. Continuous Integration (CI) Fundamentals

Question 6 tests CI knowledge. Which statement is not correct? Continuous delivery is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily. That's actually continuous integration, not continuous delivery. CI keeps software in a working state by merging code often. Jenkins stores build artifacts, and unit tests can run without the full app. In 2026, CI/CD pipelines are as common as automated coffee machines—they ensure consistency and speed.

7. Open Source, Gradle, and Git Truths

Question 7 asks which statement is correct. The correct one: Git stores data as a stream of snapshots; it does store changed files. Actually, Git stores snapshots of the entire project, but it compresses unchanged files. Open source software is not always free (e.g., some have paid licenses). Gradle performs incremental builds, but not every build re-executes all parts. And Agile does require planning—just lightweight. In the AI open-source boom, many models are free but require attribution.

8. Gradle Build System

Question 8 (multiple correct): Select all that apply. Correct answers: The order in which tasks can run is determined using a directed acyclic graph. and One of the feature of Gradle is incremental builds. A 'dry run' does not execute tasks, but it's a valid feature. Gradle build files are written in Groovy or Kotlin, not XML. If a task fails, Gradle stops the build. You can add actions to tasks via doFirst and doLast. Gradle's DAG ensures task dependencies are met—like a project management tool scheduling tasks in order.

9. GitHub Webhooks

Question 9 (multiple correct): Which is correct? When a certain event is triggered from GitHub.com, a HTTP POST payload is sent to the webhook's configured URL. Webhooks use POST, not GET, and payloads are JSON, not XML. They are not inherently secured; you must add secrets. Think of webhooks like push notifications on your phone—they alert you when something happens.

10. Contributing to GitHub Repos

Question 10 (multiple correct): Correct statements: If you don't have write access to the repository where you'd like to create a pull request, you must create a fork, or copy, of the repository first. (Note: the duplicate statement is a typo in the exam.) You can specify the target branch when creating a pull request. Forking is essential for open-source contributions—like remixing a song on a music platform: you copy it, make changes, then propose merging back.

11. Ethics in Software Engineering

Question 11 presents an ethical dilemma: signing off on untested flight software under pressure. The answer: No, it is not acceptable. The software engineer has a professional responsibility to ensure safety, especially for life-critical systems. Pressure from employers does not justify compromising ethics. This echoes the 2024 Boeing whistleblower case where ignoring safety led to tragedies. Always prioritize public safety over deadlines.

12. Open Source Licensing for iBid

Question 12 involves using MIT-licensed BidOptimize1.1.3 for iBid. (a) Yes, the MIT license is permissive—you can use it in proprietary software. (b) For open-sourcing iBid, management should choose a license that protects their trademark (e.g., Apache 2.0 with a trademark clause). The MIT license does not restrict branding, but to preserve trademark, include a notice. This is like AI startups using MIT-licensed models but trademarking their own brand.

13. Cucumber Scenario: Movie List Order

Question 13 shows a Cucumber scenario for alphabetical movie sorting. The expected behavior: after adding 'Zero' and 'Apple Games', the list should show 'Apple Games' before 'Zero'. This tests understanding of BDD (Behavior-Driven Development) and test automation. In 2026, BDD is used in smart home testing to ensure voice commands work in the right order.

Conclusion

Mastering these concepts will prepare you for the SOFT2412/COMP9412 exam. Relate each topic to current trends—AI, gaming, or smart devices—to make them stick. Good luck!