DEV Community: Mathilde Lelong

Practical Guide to Test-Driven Development (TDD) in Web Development

Mathilde Lelong — Tue, 08 Aug 2023 08:36:57 +0000

‍Test-Driven Development (TDD) is a powerful approach in web development that helps ensure code quality and efficiency. It involves writing tests before writing the actual code, which may sound a bit unusual at first. However, by following this practice, developers can have a clear understanding of what they want to achieve and can build robust and reliable web applications. TDD encourages a systematic process where tests are written, code is implemented to pass those tests, and then the code is improved. This practical guide will walk you through the basics of TDD, provide tips for writing effective tests, and explain how to integrate TDD into your web development workflow.

What is TDD?

Test-Driven Development (TDD) is a software development approach that emphasizes writing tests before writing the actual code. It follows a cycle of writing small, automated tests, implementing the code to make the tests pass, and then refactoring the code. TDD has three core principles:

Test First: TDD encourages writing tests before writing production code. This ensures that code is developed with a clear goal and purpose in mind.
Small Steps: TDD promotes an incremental approach to development. Developers take small steps by writing one test at a time and implementing the necessary code to pass it.
Continuous Testing: TDD focuses on maintaining a comprehensive suite of tests that can be executed frequently. This provides ongoing feedback about the code's correctness and helps catch issues early.

Advantages of TDD in Web Development

Test-Driven Development (TDD) offers several advantages in web development. Let's explore these benefits in easy and understandable terms:

Improved Code Quality and Maintainability: TDD requires developers to write tests before writing actual code. This approach helps to guarantee that the code fulfills the necessary functionality and requirements. Continuous testing allows developers to detect errors and issues earlier in the development process, resulting in greater code quality. Furthermore, TDD promotes modular and loosely coupled code, which makes it easier to understand, maintain, and update in the future.
Faster Development Cycles and Reduced Debugging Time: TDD encourages an iterative development process. Developers gain clarity on what the code has to perform by writing tests beforehand, which streamlines the implementation process. As a result, development cycles become more efficient, with fewer back-and-forth revisions. Furthermore, because TDD catches flaws early, debugging time is greatly decreased. Developers can immediately identify and resolve issues, resulting in a better and faster development experience.
Enhanced Collaboration Among Team Members: TDD encourages development teams to work together. When developers write tests, they gain a clear understanding of the requirements and expectations. This shared comprehension increases communication and prevents misunderstandings among team members. Furthermore, when developers work on the same codebase, they can run each other's tests to guarantee that their changes do not break existing functionality. This style of collaboration fosters teamwork, knowledge exchange, and a sense of project ownership.
Increased Confidence in the Codebase: One of the significant benefits of TDD is the increased confidence it provides in the codebase. A complete suite of tests allows developers to be more certain that their code works as intended. Tests act as a safety net, giving developers reassurance that changes or additions to the codebase won't introduce regressions or break existing functionality. This confidence allows for more experimentation and refactoring without fear of unintended consequences, leading to a more robust and stable codebase.

Red-Green-Refactor Cycle

The Red-Green-Refactor cycle is a fundamental concept in Test-Driven Development (TDD) that guides the development process. It consists of three stages, each serving a specific purpose to ensure the code is reliable and maintainable.

Writing failing tests (Red): During this stage, you start by writing tests that describe the expected behavior of the feature or functionality you are working on. These tests should initially fail because you haven't implemented the corresponding code yet. The Red phase helps you clearly define what you want to achieve and serves as a guide for writing the necessary code.
Implementing the minimum code to pass the tests (Green): In the Green stage, you write the minimum amount of code required to make the failing tests pass. The focus here is on functionality rather than perfection. The goal is to make the tests go from failing (red) to passing (green). This minimal implementation should be simple and straightforward, addressing only the immediate requirements of the tests.
Refactoring the code while keeping the tests passing (Refactor): Once the tests are passing, you can move on to the Refactor stage. Here, you improve the code's design, structure, and readability without changing its behavior. Refactoring allows you to eliminate duplication, improve naming conventions, and make the code more maintainable. The key principle is that you refactor with confidence because the tests act as a safety net. If you accidentally introduce a bug, the tests will catch it.
The cycle then repeats as you go back to writing failing tests (Red) for the next feature or functionality you want to add. This iterative process helps you incrementally build a reliable codebase that is thoroughly tested and easy to maintain.

Writing Effective Test Cases
Writing effective test cases is crucial for successful Test-Driven Development (TDD) in web development. Well-designed tests ensure that your code functions as intended and can catch potential bugs early in the development process. Here, we will discuss the characteristics of good test cases, choosing appropriate test granularity, and the concepts of test coverage and prioritization.

Characteristics of Good Test Cases

Good test cases exhibit the following characteristics:

Clarity: Test cases should have clear and understandable objectives. They should be written in a way that anyone reading them can understand what the test is verifying.
Independence: Test cases should be independent of one another, meaning that the outcome of one test case should not influence the outcome of another. This allows for easier debugging and identification of the root cause of failures.
Reproducibility: Test cases should be reproducible, meaning that they can be executed multiple times with the same inputs and produce the same expected results. This ensures consistent and reliable testing.
Completeness: Test cases should cover a wide range of scenarios and edge cases to ensure comprehensive coverage of the functionality being tested. It's important to consider different inputs, boundary conditions, and potential failure scenarios.
Maintainability: Test cases should be easy to maintain as the codebase evolves. They should be designed in a way that allows for easy updates and modifications when changes are made to the system.

Choosing Appropriate Test Granularity

When writing test cases, it's important to choose the appropriate level of granularity based on the scope and complexity of the code being tested. The three common levels of test granularity are:

Unit Tests: These tests focus on testing individual units or components of code in isolation. Unit tests are typically small in scope and verify the behavior of specific functions, methods, or classes. They are fast to execute and help catch bugs early in the development process.
Integration Tests: Integration tests validate the interaction between different components or modules within the system. They test how these components work together and ensure that they integrate correctly. Integration tests provide confidence in the system's overall functionality and its ability to handle interactions between different parts.
End-to-End Tests: End-to-end tests simulate real user scenarios and cover the entire system from start to finish. They test the system as a whole, including its various components and external dependencies. End-to-end tests help ensure that all parts of the system work together seamlessly and validate the system's behavior from the user's perspective.

Test Coverage and Prioritization

Test coverage refers to the extent to which the codebase is exercised by your tests. It's important to achieve sufficient coverage to catch potential bugs and ensure that all critical functionality is tested. However, achieving 100% coverage may not always be practical or necessary.

Prioritizing test coverage involves identifying the most critical and high-risk areas of your codebase and ensuring that they are thoroughly tested. This includes focusing on complex algorithms, critical business logic, error-handling scenarios, and edge cases that could have significant impacts on the system's behavior.

Consider the following factors when prioritizing test coverage:

Business Impact: Focus on areas of the codebase that directly impact the core functionality or critical business processes. These areas should be thoroughly tested to minimize the risk of failures.
Complexity: Prioritize testing complex areas of the codebase that involve intricate logic, calculations, or algorithms. These areas are more prone to errors and require thorough testing.
Error-Prone Scenarios: Identify scenarios that are more likely to result in failures or errors. These scenarios could involve input validation, data transformation, or external dependencies. Test these areas rigorously to ensure robustness.
Code Changes: When making changes or adding new features, prioritize testing the affected areas to verify that the changes are working as intended and do not introduce regressions.
Understanding the characteristics of effective test cases, selecting the appropriate granularity, and prioritizing test coverage will help you build successful test cases that contribute to the success of Test-Driven Development in web development. These techniques will help to improve the code quality, maintainability, and overall stability of your web applications.

Best Practices and Tips for TDD in Web Development

Read full article here. An article by Paula Isabel Signo.

Effective Testing Techniques and Mobile App Development Cost Estimate

Mathilde Lelong — Tue, 18 Jul 2023 07:22:45 +0000

In the world of mobile app development, testing techniques play a crucial role in ensuring the quality and success of an application. At the same time, accurately estimating the cost of developing a mobile app is essential for effective project planning. In this article, we will explore different testing techniques that can be employed during the app development process. We will discuss factors that influence the cost estimate.

Understanding Testing Techniques for Mobile App Development

Testing is an integral part of mobile app development, as it helps identify and address issues, improve performance, and enhance the user experience. Let's explore some standard software testing techniques:

Functional Testing

Functional testing involves testing the app's functionality to ensure it performs as expected. This includes verifying individual features, user interactions, data handling, and overall app behavior. It involves evaluating an application's parts and functionalities to ensure they work as intended.

Developers can identify and address any issues or bugs hindering the app's performance by conducting functional testing. This type of testing focuses on verifying that the software meets the specified requirements and delivers a seamless user experience. By thoroughly testing each function and interaction, functional testing helps ensure the application performs flawlessly and meets user expectations.

Performance Testing

Performance testing evaluates the app's performance under different scenarios, such as load, stress, and endurance. It helps identify bottlenecks, assess response times, and optimize resource utilization.

By simulating real-world scenarios, performance testing measures the system's ability to handle high user loads, heavy data volumes, and concurrent transactions. It helps identify bottlenecks, resource limitations, and potential performance issues, allowing developers to optimize the application's speed and efficiency.

Usability Testing

Usability testing examines how users interact with the app, assessing its ease of use, intuitiveness, and overall user experience. This involves gathering feedback from real users to improve the app's design and navigation.

Usability testing aims to identify usability issues, confusing interface elements, or obstacles hindering users from accomplishing their tasks efficiently. By conducting usability testing, developers gain valuable insights into user preferences, behavior, and pain points, enabling them to make informed design decisions and improve the overall user experience of the application.

Compatibility Testing

Compatibility testing ensures the app works seamlessly across various devices, operating systems, and screen sizes. It verifies that the app functions correctly and displays appropriately on different platforms.

It involves validating that the software functions correctly and displays appropriately regardless of the user's chosen environment. Compatibility testing helps identify compatibility issues, such as layout distortions, functionality conflicts, or performance variations, that may arise due to differences in hardware or software configurations.

Security Testing

Security testing is crucial for protecting user data and ensuring the app's resistance against potential vulnerabilities. It involves testing for weaknesses, verifying secure data transmission, and implementing appropriate encryption measures.

It involves evaluating the software's ability to protect data, prevent unauthorized access, and withstand potential security threats. Security testing encompasses various techniques to uncover potential security loopholes and weaknesses to uncover potential security loopholes and liabilities, such as penetration testing, vulnerability scanning, and risk assessment.

By conducting thorough security testing, developers can identify and address potential security risks before deploying the application, safeguarding sensitive information and ensuring the software's resilience against malicious attacks.

Mobile App Development Cost Estimate

Accurately estimating the cost of developing a mobile app is vital for budgeting and decision-making.

Several factors influence the cost estimate:

Read full article on Agilitest blog.

#TestCulture Episode 38 – Unlock the intrinsic motivation of employees

Mathilde Lelong — Wed, 12 Jul 2023 08:32:31 +0000

This practice consists of applying the levers of self-interest close to vocation. Intrinsic motivation, unlike extrinsic motivation, is based on ⬇️
1️⃣ Sufficient remuneration to remove the question of money from the discussion and to decouple remuneration from accomplished actions.
👉🏼 Because beyond a certain threshold, financial incentives are no longer a source of motivation.
2️⃣ A rewarding and necessary learning process to achieve a certain level of mastery. 🔝
3️⃣ A noble objective aimed at by the mission of each person and not a 𝐦𝐚𝐭𝐞𝐫𝐢𝐚𝐥𝐢𝐬𝐭𝐢𝐜 𝐟𝐢𝐧𝐚𝐧𝐜𝐢𝐚𝐥 𝐠𝐨𝐚𝐥 ⭐
4️⃣ Maximum autonomy given and 𝚗𝚘𝚝 𝚘𝚛𝚍𝚎𝚛𝚜 to be carried out under the control of a manager.
The agility mindset goes in this direction, and SAFe includes it directly in its list of principles. The conditions for this situation are in the hands of the managers, who thus gain leadership. 🏅
🔓 Learn more about how to unlock the intrinsic motivation of employees: https://agilitest.com/cards/unlock-the-intrinsic-motivation-of-employees

#TestCulture 🦅 Episode 37 – Work in a cadenced and synchronized way

Mathilde Lelong — Mon, 03 Jul 2023 08:29:19 +0000

Software Dev is a complex activity and because of the uncertainties associated with this context, things emerge.
The agile approach is a good way to move forward gradually in building the system. 👍🏼
Furthermore, moving forward in a paced manner allows this progress to be chopped up and uncertainty to be reduced in a rhythmic way in order to 👇🏼

Convert unpredictable events into predictable ones at lower cost
Make waiting times for new results predictable
Support good regularity in planning and coordination
Limit the size of the work to a single interval Timing then provides better control over when to add new outputs to what already exists at planned synchronisation times… 🎴 Learn more about this concept. A thread on Twitter.

#TestCulture 🦅 Episode 36 – Milestones are evaluated objectively

Mathilde Lelong — Mon, 26 Jun 2023 15:15:16 +0000

In agile, milestones are, among other things, the moments when the product is delivered to the customer. 🕰️
There are other types of milestones such as the delivery of each User Story (US).
SAFe proposes other milestones such as the Program Increment (PI) which classically frames four consecutive two-week sprints.
The point made by this practice is that each of these milestones must be framed by verifiable criteria that allow us to say whether the milestone has been reached. ✅

In agility, this practice must absolutely be combined with the incremental approach, otherwise we fall back into the waterfall and tunnel effect...

👉🏼 Learn more about this concept: here

A thread on Twitter.

Continuous Testing: Streamlining Your Testing Process in Web Development

Mathilde Lelong — Mon, 19 Jun 2023 09:10:11 +0000

In the fast-paced world of web development, delivering high-quality software in a timely manner can make all the difference in staying ahead of the competition. That's where continuous testing comes in. Continuous testing is an automated approach to testing that helps streamline the testing process, catch errors earlier, and ultimately deliver better software faster. In fact, according to a study by MarketsandMarkets, the continuous testing market is estimated to grow at a rate of around 16% annually from 2018 to 2023, reaching a value of $2.41 billion. This statistic alone highlights the importance of implementing continuous testing in web development to meet the growing demand for top-notch software delivery. In this article, we will explore continuous testing and how it can streamline the testing process in web development.

What Is Continuous Testing?

Continuous testing is an automated approach to testing in web development that involves continuously testing software throughout the development process. This means that tests are run automatically and continuously throughout the development cycle, catching errors and bugs early on and allowing for quick fixes. Continuous testing includes a variety of testing methods, such as unit testing, integration testing, and performance testing, among others. Continuous testing in web development allows developers to ensure high-quality software is delivered on time while also lowering overall testing costs.

What Are the Benefits of Continuous Testing?

Continuous Testing offers several benefits in web development, including:
Early detection of defects: Continuous testing helps to identify defects early in the development cycle, allowing for quicker resolution and reducing the risk of these defects affecting the overall quality of the software.
Increased test coverage: Automated testing allows for a wider range of tests to be executed, covering more scenarios than manual testing alone. This helps to increase the overall test coverage and ensure that all parts of the software are thoroughly tested.
Reduced time and cost: With continuous testing, developers can identify and fix defects earlier in the development process, reducing the overall cost of development and decreasing the time to market for the software.
Improved software quality: Continuous testing ensures that the software meets the highest quality standards and meets customer expectations, resulting in higher customer satisfaction and increased trust in the software.
Better collaboration and communication: Continuous testing encourages better collaboration between developers, testers, and other stakeholders, ensuring that everyone is working towards the same goal of delivering high-quality software.
Continuous Testing is a crucial process for streamlining the testing process in web development, and its benefits are numerous. It helps to catch defects early, increase test coverage, reduce time and cost, improve software quality, and foster better collaboration and communication among development teams.

Real-time Reporting in Continuous Testing

Real-time reporting is a crucial aspect of continuous testing in web development. It allows developers and testers to get immediate feedback on the quality and performance of their software as soon as a change is made. This section will discuss the role of real-time reporting in continuous testing and how it can help streamline the testing process.

The Role of Real-Time Reporting in Continuous Testing

Real-time reporting is crucial for continuous testing, allowing developers and testers to identify and address issues as they arise. It provides immediate feedback on test status, enabling developers to make quick adjustments to ensure software functionality. Real-time reporting also facilitates collaboration between stakeholders, ensuring everyone is aligned on the software status and enabling swift issue resolution.

Moreover, real-time reporting enhances testing process efficiency by prioritizing efforts on critical issues. Developers and testers can focus their efforts on areas that have the most impact on software quality by providing a thorough and up-to-date view of the software status. This helps to deliver high-quality software faster and more efficiently.

Best Practices for Real-Time Reporting in Web Development

Read full article on Agilitest blog. An article by Paula Isabel Signo.

The Role of Continuous Testing in Building High-Quality Software

Mathilde Lelong — Mon, 12 Jun 2023 12:58:21 +0000

The role of continuous testing in the delivery of high-quality software can never be emphasized, however, it is important that we understand the rudimentary nuggets of the concepts we are about to explore. For starters, software testing analyzes and verifies that a software product or program accomplishes its intended work. Some advantages include bug prevention, reduced development costs, and improved performance.

Furthermore, you should know that continuous testing is an integral part of software testing. It involves testing software continuously and automatically throughout its development and maintenance lifespan. It is critical for ensuring software quality, decreasing errors, shortening time to market, and increasing customer satisfaction. It’s an essential technique for software development, allowing firms to provide high-quality software that satisfies user expectations, minimizes costs, and retains a competitive advantage. Let us dive deeper.

What is Continuous Testing?

Over the years, software development has changed at a rapid pace. What is the catalyst for this evolution? Advanced software ensures quick and efficient service, utilizing Agile and DevOps to satisfy customers. The development period is shortened from weeks to months to days and hours, and automated testing progressively replaces manual testing techniques.

Continuous testing is a technique that involves continually and automatically testing software throughout its development and maintenance lifespan. It is a sequential process incorporating testing operations into the software development pipeline, allowing for the early discovery and correction of errors and difficulties. It is also commonly used in Agile and DevOps approaches, emphasizing iterative and collaborative software development with rapid releases and ongoing feedback loops. Its goal is to offer immediate and precise feedback on the quality and dependability of the program under development, allowing for faster releases and guaranteeing that the product satisfies the specified quality requirements.

Depending on the needs of the software being produced, it may entail using various testing techniques such as automated testing, unit testing, integration testing, performance testing, security testing, and other forms of testing. These tests are frequently automated and run in the background as part of the development pipeline, employing tools and frameworks that facilitate automated testing.

Benefits of Continuous Testing

Because the testing process begins in the early phases of development and continues indefinitely, application hazards are discovered early on. In this manner, development teams may avoid these difficulties as they advance through the development cycle, reducing the time and effort spent at the end of the process finding and fixing errors. Continuous testing is becoming increasingly popular, and it makes sense to use it since it can improve the efficiency of existing approaches. Here are some of its main benefits:

Testing Throughout the Pipeline: Testing Throughout the Pipeline (TTTP) is a software testing strategy that entails testing at every stage of the software development process, from design through deployment. It highlights the significance of regular and early testing to discover problems as early as possible, decrease expenses, and improve software quality. Continuous testing is a process that involves running automated tests continually throughout the software development pipeline to offer feedback on the program’s quality. This method enables developers to detect and correct flaws before they become more complex and costly. Developers may spot flaws early in the pipeline and address them before they become more complex and expensive to solve. This strategy can lower total software development costs and improve software quality.
Furthermore, testing throughout the pipeline aids in detecting flaws that traditional testing methods may miss. For example, tests performed during the design process can assist in detecting problems in the software architecture, but tests performed during the deployment phase can assist in detecting defects that only occur in production situations.
Improved Collaboration: Continuous testing guarantees everyone in the software development process is aware of the current status of the product, including flaws or issues discovered during testing. Improved cooperation can assist in identifying and resolving difficulties early in the development process, lowering the chance of serious problems later.
Effective collaboration is critical in software development and testing; continuous testing may aid this process in various ways. They include early problem identification and resolution, greater transparency throughout the software development process, consistent and dependable testing, less manual work, increased efficiency, and improved developer-tester communication and collaboration.
Discrepancy issues: When test automation scripts are performed in multiple environments, discrepancies might occur due to setup changes such as operating systems, browsers, and software versions. These discrepancies can lead to test failures, slowing development and raising expenses. Continuous Testing eliminates differences by providing the same parameters for all test automation scripts. This guarantees that tests are executed consistently across all environments. This uniformity also reduces the possibility of human mistakes. When testers are obliged to configure test environments manually, they are more likely to make mistakes. Continuous testing removes the need for manual configuration and decreases the risk of human errors by providing the same structures for all test automation scripts.
Furthermore, by providing the same parameters for every test automation script, continuous testing helps to increase testing process efficiency. Without spending time creating multiple environments, testers can perform tests more quickly. This can assist in accelerating the development process, allowing for faster software delivery.
Immediate Feedback: Continuous testing relies heavily on direct feedback. It refers to the continuous and timely examination of software quality throughout development, allowing developers to detect and fix any faults or errors swiftly.
Continuous testing requires immediate feedback since it helps detect faults early in development, making resolving them more straightforward and less expensive. It helps to minimize the time and expense of resolving problems while improving the overall quality of the product. Rapid feedback allows developers to iterate quickly and make required code modifications, resulting in a shorter time-to-market for the software product. This can provide businesses with a competitive advantage in the marketplace.

Continuous Testing Process and Phases

Continuous testing is a strategy that reiterates testing promptly, constantly, and throughout the software development lifecycle. The continuous testing process is divided into several phases, which are as follows:

Planning: This phase defines the testing strategy and objectives, as well as the tools and frameworks to be used. The testing team also works with the development team to ensure the program meets the specifications.
Test Design: Test cases and situations are created according to the requirements and design standards during this phase. The test cases should include all potential scenarios and exceptions to guarantee complete testing.
Test Execution: In this step, the tests are executed on the program, and the results are collected. Continuous automated tests are conducted, and manual tests are run as needed.
Test Reporting: The test results are examined in this phase, and reports are prepared. These reports assist in identifying any faults that need to be fixed and provide input on the software’s quality.
Test Maintenance: During this phase, the test cases and scenarios are updated and maintained to stay current and realistic. As the program evolves, the tests must evolve as well.
Continuous testing is a constant cycle throughout software development, from planning to test maintenance. Issues may be found early and fixed quickly by continually testing the program, resulting in higher-quality software and a shorter time-to-market.

Why Continuous Testing is Important in Building High-Quality Software

Read full article on the blog. An article by Olufunso Oladiran.

#TestCulture 🦅 Episode 35 – Variability assumption

Mathilde Lelong — Mon, 05 Jun 2023 09:13:45 +0000

This 3️⃣rd principle in SAFe is the first to address the idea of agility, where expectations can change up to the last moment. It is the direct impact of the second #agile principle described in the manifesto:
“Welcome changes in requirements, even late in the project”.
This assumption implies in particular:
👉🏼 not going too far in the ideation to avoid having to start all over again in case of a change in the needs direction
👉🏼 minimal code so as not to have to throw away too much work
👉🏼 document in detail only the parts that are fixed
Application to test maturity ⬇️
The test should also be designed in the most flexible way possible, for example:
💭 Using intent-based scenarios, e.g. by a briefly described test objective in order to avoid implementation variants
💭 By doing exploratory testing

Read more about this concept:here
A thread on Twitter.

#TestCulture 🦅 Episode 34 – Systemic view

Mathilde Lelong — Mon, 22 May 2023 12:16:35 +0000

SAFe applies this principle to understand software development as a whole because:
1️⃣ the solution is a system in its own right
2️⃣ the company that builds this system is a system in its own right
3️⃣ this company must optimise the entire value stream
4️⃣ if the global system is not managed, it will not manage itself and will end up constituting autonomous but individual, independent parts that will compete with each other.
Each part must therefore be pushed to cooperate.

What is the application of systemic view to test maturity?

Without a global approach, testing is limited to a reactive position and anticipation only leads to a tunnel effect. Agile, with its iterative and short approach, reduces this effect but leaves testers in a situation where they have very little time. 🏃🏼
Leading them to test after the sprint when the Product Owner should have a potentially deliverable Product Increment.

🗞️ Learn more about Systemic View: here

A thread on Twitter.

Impact of Agile Methodology on Software Development

Mathilde Lelong — Tue, 16 May 2023 12:51:48 +0000

What is Software Development?

According to IBM (International Business Machines Corporation), Software development refers to a set of computer science activities dedicated to the process of creating, designing, deploying, and supporting software. The software itself is the set of instructions or programs that tell a computer what to do. It is independent of hardware and makes computers programmable.

Types of Software Development Methodologies

  1. Agile Methodology

This emphasizes flexibility, collaboration, and rapid iteration. It is best suited for projects with rapidly changing requirements or a high degree of uncertainty, like requirement gathering. There are various types of frameworks in the Agile methodology but a few will be listed.

Kanban
Scrum
Extreme Programming (XP)
Crystal
Dynamic Systems Development Method (DSDM)
Feature Driven Development (FDD)‍

  2. Lean Methodology

This explains the elimination of waste and maximizing efficiency by continuously improving the process and people involved.

  3. Waterfall Methodology

This is a traditional, linear methodology that involves completing one phase of development before moving on to the next. It is best suited for projects with well-defined requirements and a fixed scope.

  4. DevOps Methodology

This is a methodology meant to improve work throughout the software development lifecycle. The DevOps process can be visualized as an infinite loop. It comprises the following steps: plan, code, build, test, release, deploy, operate, monitor, and thorough feedback while planning again which resets the loop.

Impact of Agile Methodology on Software Methodology

  1. Quality and Team Involvement

Agile methodology is a widely adopted software development approach that aims to deliver high-quality software in a timely and efficient manner. This is based on a set of principles that prioritizes (1) Adaptability (2) Flexibility (3) Collaboration among team members.

For example, my organization builds software solutions for clients. Here we adopt an agile methodology. Daily stand-up meetings are being conducted to ensure that every member of the development team fully understands what has been done and what is expected. We address issues or contributions in order to decide faster collectively.

N.B: Agile teams work together to meet the customer's needs. This is achieved through regular team meetings called “Scrum” where teams share ideas, discuss progress, and identify issues that need to be addressed. Scrum is a lightweight agile framework that can be used by project managers to control all types of iterative and incremental projects. In Scrum, the product owner creates a product backlog that allows them to work with their team to identify and prioritize system functionality. The product backlog is a list of everything that needs to be accomplished to deliver a successful, working software system: this includes bug fixes, features, and non-functional requirements. Once the product backlog is defined, no additional functionality can be added except by the corresponding team. This close collaboration allows for early identification and resolution of problems, which helps to ensure that software is delivered timely, error-free, and of high satisfaction to customers.

  2. Quick response and transparency for key stakeholders

Read full article on the blog. An article by Olufunso Oladiran.

How Can Developers and Testers Work Better Together?

Mathilde Lelong — Tue, 09 May 2023 12:37:51 +0000

Developers and testers are on the same side – it does not matter if a company puts them in the same (agile) team or in separate teams of developers and testers. It is up to both testers and developers to build a great application. To achieve this goal, they will have to collaborate together in a productive way. To do so and to get their job done better, faster, and easier, there is different practical advice and hands-on advice that can help. I will start with tips and approaches that focus on individual cooperation between a developer and a tester. In the second half of this article, I’ll share advice that will help to improve cooperation on a team level.

Better cooperation on individual level

As a developer, I consider testers as my safety net. I would prefer a bug to be reported by a tester, rather than the end user finding a bug in production.

Generally speaking, people do not feel comfortable when someone criticizes their work. Developers should not think of testers as somebody who is constantly telling them that they did something wrong. Instead, developers should consider testers as partners who are trying to keep end users from criticizing their work. Testers at the same time should be aware that junior developers might feel uncomfortable when they receive a bug report. As they build up experience, developers won't, or at least shouldn't, get defensive when they receive bug reports.

I can tell from my experience, cooperation between a developer and a tester will be better if mutual respect is clearly visible.

Practical approaches to hard to reproduce bugs

Sometimes, a developer cannot reproduce a bug that a tester has reported. In my 17 years of professional experience as a developer, I found that there are a few tips and tricks that can help.

When a tester sends a screenshot to a developer, it is more effective to send a screenshot of the whole application — and not just a piece of the user interface. Sometimes, when a bug is on one part of the UI, I manage to find a clue for reproducing it on the other part of the UI. Simply by sending the screenshot of the complete tested application interface, a tester can facilitate the developer’s work to reproduce a bug.

But what if a screenshot is not enough to reproduce a bug? What if the additional information provided by a tester are not sufficient? Video is a great assistant. Use the screen recording app to record everything that goes on the application UI as part of the test. In my experience, a video is useful because a developer can find a (small) clue for reproducing a bug somewhere between steps that were already mentioned in the description of this bug. A small detail could trigger a bug, and a video helps a developer discover that detail.

Please note: It is not necessary for a tester to speak in his/her recording. Hearing the tester in video was never crucial for me to reproduce a bug. Many testers will feel more comfortable if they are not asked to record themselves commenting on the video.

Managing conflict

In case of a conflict between a tester and a developer, everyone involved must use effective communication, be diplomatic, and not take things personally. Both parts need to look at things from another person's perspective – this other person also has timelines, tasks, priorities, etc.

The aim is to prevent a conflict. In everyday life, there are times when a short message can prevent a misunderstanding and conflict that follows.

Always remember, that we are all on the same side as we build the same application.

Teamwork from scratch

Read full article on the blog. An article by Marko Lohert.

#TestCulture 🦅 Episode 33 – Adopt an economic view

Mathilde Lelong — Mon, 24 Apr 2023 09:11:06 +0000

The first principle that SAFe adopts is the economic vision in its organisation.
This principle does not only concern the estimation of budgets, but also the whole chain of solution delivery and exploitation, notably by deploying as early and often as possible, which is the basis of a Lean/Agile/DevOps organisation in order to limit budgetary drift.
Indeed, the longer a release waits, the more:
➡️ The organisation delays the moment when it will postpone the time when the new features can make money for itself or its customers.
➡️ The planned budget and the actual cost drift.
Google introduces in its vision of DevOps the notion of "error budget"… 💭
It takes into consideration a certain economic vision linked to low quality release and the test helps to estimate the cost linked to non-quality. 🚫
Indeed, testing is first and foremost feedback and the earliest possible release contributes to the implementation of the ISTQB principle "test early"...

Learn more about why it is necessary to adopt an economic view.

Thread on Twitter.