Top Down Design

Top Down Design

Introduction

Top down design is a very good way to program any functional code. It is easier for beginners because you can split the problem down into simple pieces to code and test. The more complex the code the smaller the pieces you should code.

I have designed a script for these posts and pre-coded the program. While my code is Kotlin, the language is irrelevant to the technique and this lesson. Every shown code will be linked so you can read my script and play with its code.

I will be solving the gapful numbers challenge as listed as a link in the script.

[Challenge]

First Step

[Load Starting]

My first step when starting coding is documenting what I'm attempting in comments so, in this case, I place a copy of the challenge to be solved listed in my code for quick reference. I provide the link to it both in my code and in its comments.

Second Step

[Load Main]

Now that I know what I want to do, for my second step, I break the task up into some logical steps. In the case of this problem, I got two activities that need doing. I must get our input first. Then, I must process it. It is likely that your project will have other missing steps discovered as you move forward. Just add them in as stubs first similar to how we are doing with this project.

I completely code the main function and provide stubs for the other functions I call. This lets me test my design. Since my input function must return one or two integers, I use a list initially with one. I make my gapful function display that it got one number or a range.

Commenting the stub functions prior to coding is always a good idea. That will remind you what you planned, if it is days later before you get around to implementing it.

I test this to prove it works correctly. [Run code] It displays my one number message.

Next, I update my input to return a range with two integers in my list. [Edit line 32 as specified by the comment] Once more, I test to get my range message. This completes my testing of the main function and my stubs.

Third Step

[Load Gapful]

Now we have two stubs that need coding. We could choose either one first. I usually like to save the input for last so I can avoid dealing with entering data to the prompt. That makes gapful our third step.

We currently have two different types of inputs: a single number or a range of numbers. Given we don't wish to duplicate code, we need a function that performs our test on a single number. Therefore, we make a stub for test and code our gapful function.

We make test fail everything and run two tests. [Run code] The first being a single number, which outputs our not gapful message.

Our second test case is a range. [Edit line 32 as specified by the comment & run] Given everything failed, we get our nothing gapful error message.

Now, we update test to pass everything and rerun the second test case of a range. [Edit line 44 as specified by the comment & run] Every number in the range is displayed.

Now, we update input to return a single number. [Reset line 32 back to the original & run] We get output that we have a gapful number.

Fourth Step

[Load Digits]

Our fourth step is to code our test function. It has three tasks but they are small enough that we don't need separate functions. Instead, we will code and test each task within our test function. Our first task is to split our number into digits. We will display them to prove it worked.

[Run code] We run the code with our single number and get our expected output.

[Load Divisor]

Our second task is to combine our first and last digits into our divisor. We will add a display of it to prove we got it right. [Run code] We run the code with our single number and get our expected output.

[Load Result]

Our third task is to divide our value by our divisor to return whether or not the number is gapful. We no longer need the display of our first two tasks. [Run code] We run the code with our single number and get our expected output.

Fifth Step

[Load Input]

Our fifth and final step, is dealing with our input. When dealing with user input you must assume it will not be entered correctly. I always place comments stating what input is valid at the top of my code. I always have one or more test cases to process, when I get junk as input. I always test any possible error. I don't normally worry about error messages that instruct the user how to fix their issue, but there are times it should be done.

[Move to input, wait, & run] I run this code with nothing given to the prompt to prove it detects that and processes my default test. This is likely how others will run my code.

[Run with 'a'] I run with a letter to prove I catch the non integer input. Once more I get my default test as expected.

[Run with '1'] I run with a too little integer to prove I catch it. Once more I get my default test.

[Run with '100'] I run with a valid integer to prove it gets used. It displays my one number message.

[Run with '100 a'] I run with valid integer and a letter to prove I catch the bad range. Once more I get my default test.

[Run with '100 1'] I run with valid integer and a too little integer to prove I catch the bad range. Once more I get my default test.

[Run with '100 100'] I run with two identical valid integers to prove I catch that issue. Once more I get my default test.

[Run with '100 102'] I run with two valid integers specifying a range to prove it gets used. It displays the gapful message for the one value that is.

[Run with '100 102 1'] I run with three integers to prove I catch too many values. Once more I get my default test.

Having completed our program, we would put it through its paces making many other test cases. But, I will conclude this introduction to top down design here. I hope you found it interesting and it helps you in your future programs.

gapful mn sy