The Modern Developer’s FizzBuzz Quiz Solution

One of the biggest challenges for companies in this day and age is the high cost of software development. Development resources cost a company the same amount of money regardless of the competence level of the engaged development resource. Hiring managers are faced with the responsibility of recruiting competent developers for the Development managers.

Development manages expect resources than can successfully deliver quality code for the solutions they are tasked with delivering for the company’s clients. How can the hiring manager qualify perspective candidates for the development manager while controlling the cost of the company’s software development commitments?

A trend today is to present the candidate with a coding problem during the interview process and then assess the results. The “FizzBuzz Quiz” is a popular interview coding exercise. It tests the candidate’s ability to accept a development task and produce a viable result. The result is then analyzed for the correct result and the candidate’s thought process when creating the task deliverable.

The problem in this scenario is what constitutes a “Correct” result and thought process that created that result.

The Modern Developers FizzBuzz Quiz TDD Process

The FizzBuzz Quiz Question:

“Write a program that prints numbers from 1 to 100.

For multiples of three print “Fizz” instead of the number

For the multiples of five print “Buzz”.

For numbers which are multiples of both three and five print “FizzBuzz”

What constitutes a successful assessment of the candidate being interviewed using the FizzBuzz Quiz?

This seems like a simple question to answer: “The Correct Printed Result in the Most Efficient Manner of Course”.

Maybe not! Let’s remember what the stated goal from the company’s perspective is of this exercise: “To Manage the High Cost of Software Development”. Does simply “The Correct Printed Result” manage the high cost of software development?

It is a common held belief that as much as 80% of the cost of a delivered application or assembly module over its lifetime is not in the solution delivered but in the maintenance of the software entities over the Software Development Life Cycle (SDLC). The deliverables have no life cycle if they do not function in some acceptable fashion.

The high cost of the SDLC is in code that violates Object Oriented Programming (OOP) best practices. Design principles, development patterns and code standards exist for developers to implement quality deliverables for their Client that have a lower Total Cost of Ownership (TCO) and reduces the cost of the software over the SDLC.

FizzBuzz results analysis questions that meet the stated goal of the hiring and development managers:

1. Did the candidate demonstrate a crystal clear understanding of the task?
2. Did the resulting solution meet the defined task criteria?
3. Did the construction of the code clearly define the intent of the code to anyone viewing the solution, anyone developers and non-developers?
4. Did the candidate use useless comments to describe the code when the code itself defined the intent?
5. Did the code not define the intent well enough so that comments were warranted?
6. Did the code demonstrate that the developer understood the language tools available to create an efficient solution?
7. Was the code reasonable elegant?
8. Did the developer’s solution refactored to comply with the Design Principles
   1. Did the Method(s) comply with the Single Responsibility Principle (SLP)
   2. Did the Method(s) comply with the Open/Closed Principle (OCP)
   3. Did the Method(s) comply with the Responsibility and Dependencies Principle (RDP)
   4. Did the Method(s) comply with the Test First Principle (TFP)
   5. Did the developer’s solution refactored to comply with Code Standards
      1. Did the Solution comply with proper Naming Conventions?
      2. Did the Solution implement a proper Namespace?
      3. Did the Solution use proper Access Modifiers?
      4. Did the Solution comply with proper Class conventions?
      5. Did the Class(s) comply with Code Readability guidelines?
      6. Did the Method(s) comply with proper Method guidelines?
      7. Did the Class(s) comply with proper Property conventions?
      8. Did the Method(s) comply with proper Variable conventions?
      9. Did the Class(s) comply with proper Helper Method guidelines?
      10. Did the Class(s) comply with proper Exception Handling conventions?
      11. Was the Test Driven Development process used in the developer’s solution?
          1. Was there a Test Assembly provided?
          2. Did it use the AAA Test Method pattern?
          3. Were the assertions robust enough to test the result completely
          4. Where “Sad Path” tests provided to exercise Exception Handling?

At first glance all the above questions seem to be a Total Overkill! If the success criteria is simple to assess the developer’s ability to solve a code assignment you would be absolutely correct. If the success criteria are to engage a developer who understands TCO and the SDLC costs to their Client then absolutely not overkill.

Every question asked above goes to the following deliverable benefits:

1. Creates a testable solution Today, Tomorrow, Next Week, Next Month and Next YearReduces tight coupling of dependency components
   1. Reduces the cost of debugging the initial development effort
   2. Aids to quick understanding of the Intent of the Software Entities by maintenance developers
   3. Identifies dependency changes that would cause regression testing issues and cost
2. Adds to high cohesiveness of Software Entities
3. Creates readable elegant code in small code blocks than have a single purpose within the delivered solutio
4. Enables modification of the result without the risk of breaking the calling display results method. “Fizz” and “Buzz” could be changed to “Fun” and “Time” without any modification to the display results code
5. Future change requests costs are lowered due to the ability to change only the required code elements: “Every has a Place and Everything in its Place”
6. Single automated validation of solution when changes are implemented will reduce the cost of change
7. Refactoring of consuming client modules can be implemented without the fear of breaking something unknown to the new developer

Obviously the FizzBuzz task is a simply example of what is a very valuable development process in Enterprise Software Development. This example does represent an overkill if the only criteria is a proper print to console result but the stated goal in to reduce the high cost of software development and to that goal this is a valid discussion.

Let your Thoughts be Read. Register and Leave your Comments: Pro and Con

The Modern Developers FizzBuzz Quiz TDD Process