“Pay attention to zeros. If there is a zero, someone will divide by it.” – Dr Cem Kaner

Welcome, readers! Join me on my journey from tester to developer, where I share how my testing experience shaped me into a good developer. This blog provides a focused look at my transition, highlighting key lessons and growth along the way.

A concise guide to software testing

Software testing ensures a product meets the requirements and is free of bugs. It has two main types:

Manual testing, which involves verifying the software without tools, focusing on understanding the project flow and analysing the details.

Automation testing, uses tools and scripts to run predefined tests automatically, reducing repetitive tasks and preventing missed bugs.

Now, let’s explore the most exciting part: My journey from tester to developer, and the lessons I learned along the way.

How Testing Shaped My Development Path

Testing has significantly impacted my development career by helping me anticipate potential errors in code. For instance, consider a financial application where values are converted to percentages. A typical developer might overlook the possibility of a zero divisor, confident that this error won’t occur. However, in real-world scenarios, it can happen.

Here are the key methods, rooted in my testing experience, that transformed my development skills enabling me to write cleaner, more efficient code.

Understanding project flow

Developing reliable code goes beyond isolated tasks. Instead of building multiple APIs for different needs, I learned to design versatile APIs that adapt data based on context, like user roles or request parameters and response data. This approach reduces redundancy, enhances security, increases performance and simplifies maintenance.

How corner cases helped me in developing Good Code

As testers, we often encounter overlooked scenarios, from major issues like password-less logins to minor UI bugs. Testing sharpens our ability to spot corner cases, which leads to writing more resilient code. For example, in an OTP system, if a user closes and reopens the app, bypassing OTP verification to access the dashboard is a critical flaw. Similarly, allowing random OTPs would compromise the entire system’s security.

Evaluation of request-response data

My testing experience has been crucial in assessing request-response data. In some projects, developers designs an API to load all data, including unnecessary or sensitive information, to be reused across multiple pages. This exposes sensitive data and slows performance. A better approach is to create separate components for each page, ensuring data security and faster responses.

Data validation is also key. Missing critical information can break the application. For instance, if a task requires approval with a completion note, both frontend and backend should validate its presence to prevent errors and ensure reliability.

Responsiveness of UI

UI responsiveness hinges on how quickly the interface reacts to various user actions

For instance, loading 500 notifications in one go can slow down the app, affecting performance. A better approach is pagination—loading data in smaller batches (e.g., 10 notifications at a time) to minimize delays and boost responsiveness.

Additionally, in slow network conditions, delayed API calls can leave parts of the dashboard blank, making the app seem broken. Using skeleton loading, which shows placeholder content while data loads, enhances the user experience by keeping the UI visually responsive.

The above image demonstrates how a responsive UI adapts to various screen sizes and aspect ratios, ensuring a seamless user experience across devices. Whether on large desktop screens or smaller mobile displays, the interface adjusts its layout and elements to optimise usability, maintaining functionality and compatibility across all screens

Evolution from a Tester to Developer

The shift from tester to developer requires improving coding skills to produce high-quality, bug-free code. Testers have a unique advantage: our experience spotting bugs helps us anticipate potential issues, enabling us to write more reliable, problem-free code.

Converting logic into code

One of the toughest challenges I faced when transitioning to development was converting complex logic into functional code. While the logic was clear in my mind, translating it into code often led to unexpected results. For instance, I struggled to implement conditional checks based on multiple user inputs, where the code didn’t match the logic I envisioned.

To overcome this, I began breaking the logic into smaller steps and using pseudo-code to outline the flow before writing any actual code. Flowcharts also provided a clear visual guide to follow during coding. Additionally, frequent debugging helped catch errors early, making the process smoother. These techniques turned the challenge into a learning experience, improving my ability to write clean, efficient code.

Strategies and Tools I used to enhance my coding skills

To improve my coding skills, I’ve adopted key strategies, such as breaking complex logic into smaller manageable parts. Instead of tackling everything at once, which often leads to pressure and bugs, I now focus on coding each component individually. This approach boosts efficiency and significantly reduces errors.

To sharpen my problem solving skills, I practice coding on platforms like HackerRank, LeetCode, etc. Generative AI tools like ChatGPT have made converting complex logic easier. For example, instead of writing lengthy nested if-else statements, coding tools helped simplify and optimise the code, improving both its quality and readability.

if data:
    print("Data obtained successfully")
else: 
    print("Data is unavailable")

Instead of writing if-else condition as mentioned, you can also write it using the method below

print("Data obtained successfully" if data else "Data is unavailable")

Conclusion

However, it’s important not to rely solely on AI. When encountering errors, I recommend searching online for explanations and solutions, and most importantly, understanding the root cause of the issue. While AI can help streamline your coding process, it’s essential to develop your problem-solving skills independently. These are the techniques and tools that have significantly improved my coding journey. Remember, the goal is to write code that’s not only functional but also clean and efficient.

Happy coding!