TDD - My friendly Coding Companion
Ever heard of Test-Driven Development (TDD)? It's like giving your software a GPS—it tells you where to go before you even hit the road. Imagine it as a three-step dance: Red, Green, Refactor. First up, the "Red" phase, where you lay down your tests, purposefully watching them fail. No worries, though—it's all part of the ‘big’ plan. Next comes the "Green," where you swoop in with the simplest fix, just enough to make those tests pass. FYI, it doesn’t have to be some fancy pro fix, at-least not yet. And lastly, the "Refactor," your chance to polish the code to a shine. Amazing, right?
It might seem a bit confusing at first, so let me walk you through an example. Imagine we aim to create a nifty function called isPrime(). This function should take a non-negative integer as input and gracefully tell us whether that number is prime or not by returning a boolean—true if it's prime, false if it's not. Now, here's the TDD twist: we're not diving straight into writing the function. Instead, armed with a list of prime numbers, let's say [2, 3, 5, 7, 11, 13, ...], we start with a single test. Picture this: our first test checks if isPrime(2) gives us the nod of approval with a true. Remember, one test at a time keeps the debugging blues away.
Note: Javascript and Jest are used as the programming language and testing framework respectively
Upon running the test, a `ReferenceError` pops up, reminding us that our `isPrime` function is undefined (Red phase). Some argue that a test like this isn't technically a failure, but I see it as a crucial check to ensure everything is in good order in your workspace. Time to work our magic and conjure up that `isPrime` function (Green phase). Remember, it's all about simple fixes, one at a time. Let's dive in!
Ta-da! Our function is now defined, the error has packed its bags and left. Yet, the test is still failing, expecting "true" but getting hit with an "undefined." Oh, the drama! Now, the crucial question: what's the tiniest band-aid we apply here? Resist the temptation to unleash the entire algorithm—simplicity is the name of the game for now!
Great! One down, many to go. The TDD philosophy in action works best if you introduce a test that's destined to fail. It's like flexing your coding muscles without tearing the whole script apart. If we add a test to ensure our function shouts "true" for the number 3 (a prime number indeed), it'll pass with flying colors given our current setup. But wait, we can't let things get too comfy! The real challenge comes with a test for, say, number 4. Let's toss that into the mix and watch the coding magic unfold.
Expected false, received true. Well, Duh! Now, which simplest fix makes this test pass without upsetting our previous wins? Let’s add that and see what happens.
Voila! Two tests aced, elevating our function's coverage. At this point, there's not a whole lot of refactoring to do. Instead, we forge ahead with more tests, one after another. This should go on in small bits until our function stands a complete, working and refactored solution. For a complete solution for this, follow this link. So now that you have a basic understanding of TDD, let me tell you:
Why TDD Holds a Special Place in My Coding Heart
TDD is like having a friendly guide in the coding world. It helps you build a working solution without getting overwhelmed by the complexity of a complete solution at once. It's perfect for beginners because you focus on one thing at a time – find a solution, make it better.
What's cool about TDD is that it saves time. Imagine you add a new test, add the solution, and boom! It messes up a couple of things that were working fine. With TDD, you pinpoint the issue right away (**whispers** definitely your most recent addition). It's much better than dealing with a bunch of new features and scratching your head about what broke your code. TDD is like a superhero that catches bugs in a flash
I’m happy to call TDD my friendly coding companion now, helping me tackle challenges bit by bit and swiftly catching bugs along the way. Happy coding and see you in my next blog!
