As a self-taught developer, you may have heard of Test-Driven Development or TDD and wonder what it is. A lot of the tutorials that are out there do not talk about TDD and how you can use it to complete your projects. Often tests are overlooked as an item of completion for self-taught developers because many say TDD is dead and often we want to get directly to the tasks at hand and have a completed project under our belt. However, in production code, tests are very important to make sure that the product delivered to the customer works as intended. Learning Test-Driven Development is a great way to show employers that you're not just a weekend warrior coder, but you deliver thoughout code and add value to the business.

What is Test Driven Development?

Test-Driven Development is the process of writing unit tests prior to writing your code. Developers create small test cases for each feature of the application, then create the code for the features of the application. According to Wikipedia Test-Driven Development

"is a software development process relying on software requirements being converted to test cases before software is fully developed, and tracking all software development by repeatedly testing the software against all test cases." - Wikipedia

What Companies use TDD?

TDD is a methodology derived from Agile and Extreme Programming frameworks. So it is a safe bet to say that any companies that implement these development strategies will use some form of TDD. However, it is often said that most companies do not use the practice of TDD as it is designed. This is because of deadlines, having more code to write, and the possibility of constantly adding and updating tests. Despite this, many claim TDD is still alive and well and has its uses in specific projects, in particular, algorithmic features and stable applications.

How TDD Can help you in your coding.

TDD can help you produce production-level code, all the while gaining practice in the software development cycle. These tests allow you to develop code quickly and prevent any new code that you add from breaking your application. This is a practice essential to learn as a self-taught developer, as it is a skill that can be used in industry.

How to implement TDD in your projects.

For this implementation, we will focus on python and a basic project of a calculator. The source code for this calculator can be found here on my Github. TDD uses a total of four steps.

1. Understanding the final product you are looking to produce including all its features.
2. Write unit tests based on each feature needed.
3. Implement feature in code, until tests pass.
4. Refractor code and repeat.

For python, we will implement this using the library unittest, you can find the documentation for unittest here.

So with this code already being written, I will just show the implementation of unittest. We will be implementing this for all four functions of addition, multiplication, subtraction, and division. So we must first understand what we would like each of these functions to do, which in our case is fairly simple. We then can create unit tests to make sure these functions work as intended and pass our unit tests.

Here are the functions we will be testing.

# Addition
def add(first_number, second_number):
    """Adds two given numbers together"""
    total = first_number + second_number
    return total

# Subtraction
def subtract(first_number, second_number):
    """Subtracts two given numbers"""
    total = first_number - second_number
    return total

# Multipliication
def multi(first_number, second_number):
    """Multiplies two given numbers together"""
    total = first_number * second_number
    return total

# Division
def division(first_number, second_number):
    """Divides two given numbers"""
    total = first_number / second_number
    return total

These basic functions from the calculator. py file will allow us to test and understand how to use unittest without worrying about the complication of the individual function.

To test these functions we will import the unittest library and the calculator. py file to be tested. If you notice at the bottom of the file we have the unittest.main() running if the file is called to be run. This prevents us from calling the entire function python -m unittest test_calculator.py in the CLI when we are ready to test. Instead, we can just call the file name as python test_calculator.py

import unittest
import calculator



if __name__ == '__main__':
    unittest.main()

We will then add our test cases in between those lines of code. Start by creating a class that will inherit from the unittest.Testcase class. We will then test our functions starting with the addition function by using assertEqual and passing it the add function from our original calculator. py file. We want to use numbers that we know are correct to ensure the function is working properly. We also want to add any edge cases we can think of like the addition of negatives, floating-point numbers, or zeros. This ensures we fully test the functionality of each function, and we can raise errors when needed.

import unittest
import calculator


class TestCalculator(unittest.TestCase):

    def test_add(self):
        self.assertEqual(calculator.add(60, 40), 100.0)
        self.assertEqual(calculator.add(-60, 40), -20.0)
        self.assertEqual(calculator.add(60.5, 40), 100.5)


if __name__ == '__main__':
    unittest.main()

We can then do this for each of our functions writing test cases for each in the same class. This will show a total of four tests, because unittest views each function as one test.

import unittest
import calculator


class TestCalculator(unittest.TestCase):

    def test_add(self):
        self.assertEqual(calculator.add(60, 40), 100.0)
        self.assertEqual(calculator.add(-60, 40), -20.0)
        self.assertEqual(calculator.add(60.5, 40), 100.5)

    def test_subtract(self):
        self.assertEqual(calculator.subtract(60, 40), 20.0)
        self.assertEqual(calculator.subtract(-60, 40), -100.0)
        self.assertEqual(calculator.subtract(60.5, 40), 20.5)

    def test_multiply(self):
        self.assertEqual(calculator.multi(60, 40), 2400)
        self.assertEqual(calculator.multi(-60, 40), -2400)
        self.assertEqual(calculator.multi(60.5, 40), 2420)

    def test_division(self):
        self.assertEqual(calculator.division(60, 40), 1.5)
        self.assertEqual(calculator.division(-60, 40), -1.5)
        self.assertEqual(calculator.division(60.5, 40), 1.5125)


if __name__ == '__main__':
    unittest.main()

If everything works correctly in our application you should see something like this showing that the tests have passed.

Although this is a very basic application and set of tests, we can see how if we start by designing these tests, if we make any mistakes during coding or addition of code to our codebase. These tests will throw an error, and immediately point us to the location to look to fix the code. This is extremely valuable and allows for faster implementation of features, especially very complicated ones.

In Conclusion

Learning test-driven development most likely will not be the sole reason that you do not get a position at a software company. Most likely you will learn the development cycle and practices that a particular company uses during training. However, as you can see learning TDD will help you implement better code to your projects and help you produce higher-level code. This allows you to stand out from the crowd and show that you're thinking about the entire process of software development.

"50% of workers dislike their job. Of course since how we spend our days is how we spend our lives, that means a lot of workers also don't like their lives."

Employees citied unfair pay, and underappreciation as the leading factors. I believe it doesn't have to be this way, I was in the same scenario before I discovered software engineering. I found that I loved the industry and most importantly loved creating new things through code.

The tech industry is glamorized in movies and pop culture as one with many perks unprecedented to the corporate world. These perks are the things that people gravitate to and contribute to a lot of great talent pushing the industry forward. Because of this many see the tech industry as something that's out of reach and only available to the smartest of humans. I'm here to tell you that this is not the case! I started my journey as a mechanical engineering graduate with little software experience. Sure we worked with some software as students, but nothing close to creating software that enterprises could use. So while I had some basic knowledge I still had a lot to learn before developing even my first hello world print.

Learning Software Development Is A Superpower!

The ability to create things from nothing is an in-demand trait. The Tech industry has a high demand for software developers, and the industry is only growing.

"The employment of software developers is projected to grow 22% between 2019 and 2029." -Bureau of Labor Statistics

What I have learned in becoming a developer has given me the ability to better solve problems in both industry and everyday life. The ability to take something cumbersome or an issue and solve it with technology is empowering. Not only that but you can take that empowerment to the marketplace and be compensated for what you know! Companies are willing to hire developers that can showcase their abilities, without the need for an ivy level degree. Software development can change the trajectory of your life, it surely is a superpower!

Tech Industry Culture.

The amazing thing is, software development is something that is accessible to anyone to learn. Many of the resources out there are available for free! Even the paid resources are very affordable! This lends to almost anyone with the drive and passion to be able to break into the tech industry. Taking their career in a direction that best suits them. I've come to learn that the tech industry is very welcoming to people from all walks of life. Plenty of projects are open source, meaning the original source code is made freely available and may be redistributed and modified. So you can learn collaboration and development for large projects, in almost any area of software you are interested in! This can give you industry experience without being employed by a company, and the ability to use the software in personal projects. This is one of the few industries that I have seen this type of collaboration and is one of the reasons technology has been able to grow at insane rates.

Industry Pay, Perks, & Advancement.

Now to the good stuff, the things that the movies and pop culture glamorize. The tech industry has a reputation for being highly paid, this is because devs solve difficult problems that ultimately end in the advancement of the world.

"The average salary for a software engineer is $117,948 per year in the United States." - Indeed

For reference the average salary of a household in America was $67,521 in 2020. That's an decrease of almost half (42%) of what you can earn as a software developer. While achievable this will take some work, software development is a taxing role. Problem-solving is a major component of developing solutions to the problems that the world face. The good thing is this is a skill that can be learned like any other and creates a dynamic of each day being a new challenge. There are many things to be learned to become a better developer, and for me, that makes my work exciting!

Many companies have great benefits packages, 401k match, gyms, free lunch, the ability to work from home, stock packages, and more. This makes for a fun work environment and allows for much-needed rest if a tough problem comes your way and your brain needs a break. This also fosters collaboration and camaraderie between employees, allowing for better more efficient solutions to the problems faced each day. The main factor for me is the ability to advance one's career in ways I never thought possible. One can go from not knowing anything about software to being chief technology officer. While working doing much of the things that first brought them to software. This is something I've always wanted to be able to do but has always seemed out of reach. Now while it is surely a large goal involving lots of hard work and dedication, there is a path, and that is inspiring! Even if your goal isn't to become a chief officer, the paths for career advancement are many, this is no dead-end career!

Final Thoughts

Software development, if for you, can be a very rewarding career. It is a career path that I have chosen to take to fulfill a lifelong dream of becoming an executive for innovative products. From the perks, pay, and advancements, to the ability to create almost anything, software development could very well be your path to satisfaction in life. I hope this gives you some clarification on if this can be a path for you. If you need a friend along your journey feel free to connect with me on Hashnode or Linkedin. I look forward to meeting you out in the community and seeing what amazing projects you might build!