02. gyakorlat
About Agile Development¶
General Information on Agile Development¶
Agile development methodologies are practices and work organization methods that take place in iterations based on agile values. During each iteration, both development and testing are carried out simultaneously. By applying agile methodologies, developers maintain continuous communication with the customer, which allows faster feedback on developed functionalities and quicker responses to changes reported by clients.
Among the more widely used agile methodologies are Scrum, Extreme Programming (XP), the Crystal methodology, DSDM (Dynamic Software Development Method), FDD (Feature Driven Development), Kanban, Lean software development, TDD (Test Driven Development), and ATDD (Acceptance Test Driven Development).
Meaning of Agility
Agility means flexibility, speed, mobility, and adaptability, enabling a person or organization to respond effectively to changes, challenges, and obstacles.
Why are agile methodologies needed?
Today’s socio-economic environment is changing at an extremely rapid pace, which poses significant challenges for organizations. Organizations can only respond adequately if they have tools that can keep up with these changes and support the organization of activities. Since these tools are typically software-based, software development companies must be prepared for requirements that continuously change during and after development. They must also deliver solutions quickly if they want to remain competitive. Traditional development models, such as the waterfall model, do not provide adequate support for managing rapid changes. In such environments, agile methodologies offer a suitable framework for software development organizations.
Does agile development replace earlier methodologies?
Not entirely. There are projects where requirements are stable, change slowly, or not at all. Such projects are typically technical developments or safety-critical applications, where carefully planned steps remain crucial. These projects still rely on the waterfall model or other engineering-based development models. Agile development has primarily spread in business and administrative software domains, where market or regulatory changes make precise and fixed requirements impossible. However, agile methodologies have also gained ground in technical development projects, mainly where time-to-market, competitive advantage, or market retention is the driving force.
The core principles of agility, which you can read more about here:
- Deliver working software as frequently as possible
- Flexibility in requirements
- Collaboration between developers and experts
- Team orientation
- Motivated teams
- Face-to-face communication
- Continuous improvement of teamwork
- Sustainable development
- Regular planning and delivery of quality code
- Simplicity
The Role of Testing in Agile Development¶
In the world of testing, agility manifests itself in a team-oriented approach. One key skill of a tester is the ability to work effectively in a team and to contribute creatively to achieving team goals. The whole team approach – a practice from Extreme Programming (XP) – builds on this. The essence of the whole team approach is that team members share responsibility for product quality, and there are no strictly dedicated roles within the team. Anyone with the right competencies can perform any task.
Testers work closely with other team members and business representatives, which helps in developing testing strategies and creating acceptance tests that meet expectations.
Since agile development assumes change, detailed documentation is less emphasized, while extensive automation is preferred. The latter increases the efficiency of regression testing.
Regression Testing
Regression testing is a type of testing that ensures code changes do not adversely affect existing functionalities. Its purpose is to confirm that the product continues to function properly after introducing new features, fixes, or changes. Regression testing is essential for maintaining software quality, as it identifies side effects of new code and ensures existing functional tests still pass. It is commonly applied after adding new features, implementing changes, or fixing bugs.
From a testing perspective, the importance of test-driven software development is increasing. These approaches build on iterative models and fit well into the agile framework.
- Test Driven Development (TDD): In this method, instead of comprehensive design, test cases guide the coding process. First, tests are written, followed by code that must satisfy the expectations defined in the test cases.
- Acceptance Test Driven Development (ATDD): A test-driven development approach where tests are derived from acceptance criteria.
- Behaviour Driven Development (BDD): This method involves writing test cases that express expected application behavior in simple, natural language that stakeholders can easily understand – typically using the "Given/When/Then" format.
Forming Project Teams¶
A central element of the practice is completing project tasks through teamwork. For this, students must organize themselves into teams of 4–5 members.
Team Formation
Under the guidance of the instructor, form 4–5 member teams from the students in the class. Team members should sit in a way that makes communication smooth during group work.
Project Selection
The list of available projects can be found in the CooSpace combined practice forum. Applications for projects must be submitted by email no later than 8:00:00 on the day before the next practice session. After that, projects will be assigned to each team during the session. The project repository must then be forked.
Don’t we choose our own project?
Generally, teams choose projects, but conflicts should be avoided. Each project must be assigned to a single team. In case of conflicts, teams are encouraged to negotiate among themselves, but ultimately, the instructor has the final say.
How Would You Test?¶
Have you ever thought about the purpose of testing? A simple and accurate answer is that we are looking for bugs in the software. We do not try to prove that the software is bug-free, because that is impossible. Software is the result of creative human activity, and humans make mistakes. These human errors result in bugs in the software, which may cause malfunctions. Bugs found during testing contribute to improving software quality (provided they are fixed), thereby reducing the likelihood of failures.
The Principles of Testing¶
-
Testing can only show the presence of bugs, not their absence.
AverageBugs per lines of code
The book "Code Complete" by Steve McConnell has a brief section about error expectations. He says the industry average is about 15 - 50 errors per 1000 lines of delivered code.
-
Exhaustive testing is impossible, therefore tests must be prioritized, and exit criteria must be defined. Risk-based testing can also be applied, where high-risk test cases are identified and given higher priority.
What does exhaustive testing mean?
This type of testing attempts to try every possible execution path, but in practice, it is generally unfeasible because it is time- and resource-intensive. Exhaustive testing means testing the program in every possible scenario, input, and configuration.
-
Testing should start as early as possible. Bugs removed early in the process do not cause issues in derived work products. This reduces the cost of quality, as fewer failures occur in later stages of the software lifecycle.
-
Bugs cluster in modules rather than being evenly distributed (Pareto principle: about 80% of problems occur in about 20% of the modules).
Pareto Principle
The Pareto principle states that roughly 80% of effects come from 20% of causes. In quality management, this means that 80% of problems result from 20% of errors. See the Wikipedia article for more details.
-
Pesticide paradox: running the same tests repeatedly will not find new bugs (developers learn from tests and avoid previously identified errors). Therefore, tests must be continuously updated. In other words, tests “wear out” over time.
-
Testing is context-dependent. This principle states that there is no single universally applicable testing approach; it must always be adapted to the specific context.
-
The fallacy of zero defects: there is no such thing as bug-free software. It is a misconception to expect verification alone to ensure system success. Even thorough testing and bug fixing can still result in a system that does not meet user needs, fails to support business goals, or falls behind competitors. Validation must be performed in addition to verification.
What is verification?
Verification checks whether the software meets the requirements defined in the specification and whether it does so at the expected quality. It answers the question: are we building the product right?
What is validation?
Validation checks whether the delivered product meets customer needs. It answers the question: are we building the right product that works according to customer expectations?
Homework Assignments¶
Choose one of the tasks below and complete it as homework. Assignments must be submitted via the designated CooSpace task.
Grading
Homework does not have individual scores. The final score is calculated as the number of submitted assignments divided by the number of required assignments, multiplied by 30.
Required assignments
For this exercise, one task must be chosen. Of course, students may submit more, which will count as additional submissions.
Complete one of the following
Choose one of the following tasks:
- Create a presentation on Scrum roles (Scrum Master, Product Owner, Development Team) and explain how they collaborate.
- Write a comparative essay on agile vs. waterfall models with examples.
- Select 3–4 principles from the Agile Manifesto and demonstrate how they can be applied in development/testing practice.
- Write Gherkin test cases (Given-When-Then format) for a login function.