Simpleton Geek Teaches Computer Programming Book 2 ch 10

10. Branching
10.1 Don't use GOTO! Use it!
The students were still stinging from the last lesson. In truth, the students were hurting near every class session. This is because the teacher kept the lesson plan at high-strung level. Think of a waterfall being dumped onto the students. This day was no exception.
“Alright, class! It's obvious to me that your problem solving skills is near non-existent!” The teacher began with dismal performance report as usual. “Therefore, I decided that we should do something about it. Here is a piece of code that output some numbers. I want you to try to find some kind of pattern on it. Whatever it is, try to find it. Some degree of experimentation is necessary.” 
The last sentence was practically a death sentence to the students. They haven't been taught how to properly do experimentation. The lesson will come later, after grading session is over. The student trembled in fear. 
B=21
INPUT N
@LOOP
?N:WAIT 60
N=N*B+1%100
GOTO @LOOP
Inputting the program into the computer isn't a trouble at all. However, none of the students are able to find any discernable pattern whatsoever. The teacher isn't much help, either. “This exercise is to develop your pattern recognition skill! Therefore, I want you to concentrate deeply into the numbering sequence and tell me everything that you notice! Think of it as stream-of-consciousness exercise. You need to write everything that you're thinking. Do not leave anything out.”
“Must we write everything?” asked Nancy.
“There are certain things I'm looking for, and if I don't see them, then you'll get zero. Simple as that.”
The students redoubled their effort, but try as they may, they never did see a pattern forming. Even Peter couldn't do it. However, having seen the teacher after class on daily basis means that he will not give up. In desperation, Peter wrote: “No noticeable pattern except that the numbers are all between 0 and 99.”
He then wrote a simple program to count the numbers, and wrote “The numbers seem to go through the range 0-99 only once, yet completely. Furthermore, the numbers are repeated with the same sequence. Regardless of where the numbers started, it's always the same sequence.”
By that time, the teacher has sensed the students' frustration and he simply collected their papers. Most were blank. “What's the matter? Can't even write what you're thinking? That'll be zero for you!”
He paused at Peter's paper, though. “Same exact sequence, eh? Well, you're right about that. Ah, I see you actually wrote a program to tabulate the result. I think you deserve 100 points for that!” Peter was very happy, and his smile was very wide.
The rest of the students protested. “But teacher! You never said anything about writing another program!”
“True, that I did not. But remember that you need to analyze the numbers. If you cannot do it by hand,” he waved another blank piece of paper, “then, by all means, you should write a little program to help you. Don't be stupid!”
10.2 GOTO as CYOA Pages
“Okay, now who among you have made further progress about the observation exercise yesterday?” The teacher was commenting about total blank pages, being turned in. No student responded. Then Peter said, “If B is anything other than 21, the numbers don't fill the whole range.”
The teacher smiled. “Very astute observation. In fact, this is something that will trip most people. They simply do things without thinking it through. When you have a good solution, you need to find a better one! Therefore, some degree of experimentation is necessary.
“What you have done yesterday is something called 'Linear Congruent theory'. The idea is to have a certain number sequence that cannot be recognized as a pattern. In other words, a random sequence.”
All the students wailed in frustration. The teacher expected them to recognize random numbers? No wonder they couldn't do it!
“There are certain things you need to follow. I did modulus 100. In fact, that number should be as large as possible. I set B as 21. In fact, that number should be a large number ending with x21, with x being an even number. There are some choices there, but if you pick a bad number, then the whole number space would not be filled and you have a bad random number generator.”
The students weren't listening very well. They were still stuck at 'random'.
“If you notice, the sequence is repeatable. Therefore, the algorithm isn't exactly a random number generator, but a pseudo-random number generator. The numbers aren't really random, but repeatable given a certain seed.”
“But what good is it, if the numbers are repeatable?” asked a student. “Isn't this supposed to be random?”
“The repeatability is actually desirable because it mostly being used in simulating experiments, and if it has a surprising result, we want to be able to repeat the experiment, and therefore be able to observe the events in action.
“Now let's say we want to roll a six sided dice. Who can tell me what changes you need to do in order to get 0 to 5 random numbers?”
Nancy raised her hand, “Just divide by 6. So instead of %100, you just do %6! Easy.” The rest of the students didn't say anything. 
The teacher stamped Nancy's head. “Fail! Didn't I just tell you that you need to keep that number as high as possible? What is the matter with you? Can't even listen to your teacher?” He was staring at Nancy with great scary look. Nancy shrank in fear. “Anybody else?” No one else dare ventured a guess.
“Well, obviously, you take N and divide THAT with 6. So, something like this:”
D=N%6
“Therefore, you keep the original value of N, and will not restrict the range at all. Are you kidding me? You can't even see that?” All the students felt embarrassed. Such a simple solution! They should have thought of that.
“Anyway, let's move on. You actually don't need to go to the trouble of calculating the random number unless you want a pseudo random sequence. For normal use, simply use the command RND. Like this:
R=RND(6):'1 six sided dice
R=RND(6)+RND(6):'2 six sided dice
R=RND(100):'Percent dice  
“Let's do a quick show and tell. Who can tell me the snake and ladder game?” asked the teacher.
“It has 100 squares.” said a student.
“You roll a dice to move.”
“Snakes go down. Ladders go up.”
“You win if you reach the last square.”
“Great. I can see that although your pattern recognition skill is still non-existent, at least your show and tell skill is good enough. Now, who thinks they can design the program real quick? As in 5 minutes or less?” No students said anything or even moved. The teacher fumed. “Are you kidding me? Your understanding of it doesn't translate to programming skill? Unbelievable! You guys better take a piece of paper and do it now, or I'll fail all of you.” The students scrambled in panic.
REM SNAKES AND LADDERS
CLS:CLEAR
DIM SQ[150]:'100 SQUARES
DIM P[4]:'NUMBER OF PLAYERS
CP=0:'CURRENT PLAYER
'SNAKES/LADDERS
SQ[RND(80)+10]=RND(80)+10
SQ[RND(80)+10]=RND(80)+10
SQ[RND(80)+10]=RND(80)+10
SQ[RND(80)+10]=RND(80)+10
SQ[RND(80)+10]=RND(80)+10
SQ[RND(80)+10]=RND(80)+10

@LOOP
REM ROLL DICE
D=RND(6)
?”PLAYER “;CP;” ROLLS “;D
P[CP]=P[CP]+D
?”PLAYER “;CP;” MOVES TO SQUARE “;P[CP]
IF SQ[P[CP]]==0 GOTO @LOOP1
IF SQ[P[CP]]<P[CP] THEN ?”SNAKE! MOVE BACK TO “;SQ[P[CP]]
IF SQ[P[CP]]>P[CP] THEN ?”LADDER! MOVE UP TO “;SQ[P[CP]]
  IF SQ[P[CP]]==P[CP] THEN ?”WHEW! FALSE ALARM.”
P[CP]=SQ[P[CP]]
@LOOP1
REM WINNING CONDITION
IF P[CP]>99 THEN ?”PLAYER “;CP;” WINS”:GOTO @END
CP=(CP+1)%4
WAIT 60
GOTO @LOOP

@END
?”GAME OVER”
END
And that's all there is to it. Of course, there are several gotchas. The big one is that Snake/Ladder determination is done randomly, instead of manually. Also, array for the square greatly exceeded the 100 counts. What surprised the students the most, though, is the fact that the game is fully automatic. The player has no chance for input at all. All they do is watch the gameplay unfold before their eyes. They wouldn't have believed it if they didn't see it with their own eyes.
“So, I'm surprised at you guys. Don't you know how the game Snakes and Ladders play by now? Or perhaps you never played the game? Hmmmm?” teased the teacher.
The students were all just speechless!
“Okay guys, since you're all so pathetically stupid, I'm going to repeat the assignment from before. You remember the story telling program? Well, we're going to do it again. Of course, it's not fun if we're doing the exact same thing, so this time, we're going to do it using arrays. Oh, one more thing,” the teacher grinned evilly, “I want you to include the ability to calculate damages, so that it behaves like a simple Role Playing Game (RPG). And it would be nice to have it, so that you can play music and display graphics as well. It's completely optional, but at least there should be hooks into it.”
The students just slumped in resignation. One impossible assignment after another. Even when it's something they have already done, it's still a challenge. It's like a waterfall being dumped on their head. Sometimes, it can be too much.
“Come on, guys. What are you thinking?” The teacher was amused. “You do have notes from back then, right? Why don't you read that a bit?”
The student listlessly turned the pages back. Like sheeps to the slaughter. What difference does it make? They see that they have some things that are necessary. In fact, they realized, the requirements are only a few lines.
The students brightened. A bit. Just a bit, mind you, because the challenge is still great. Then they started thinking, and started to scribble the design anew. 
Just as they're getting good, the teacher threw down another challenge. “Oh, by the way. I forgot to mention. You want the whole top screen to display the page. The bottom screen is used to display the choices. We'll limit the choices to just 7. But you should set the array to 99, just in case. It's just that we won't be using it all.”
The student scribbled in the noted changes. But the teacher isn't finished, yet. “And, I want the user to be able to choose using the DPAD, and the touch screen. With the DPAD, you use button A to make the selection, whereas with the touch screen, you make the selection when the user LIFT UP their stylus, not when it's touching down like before.”
The students all looked up to the teacher. They don't know how to do it, since it wasn't taught to them.
“Now, I know I haven't taught you that skill, but as there is more than one way to do it, I'm sure you'll do just fine in researching the process. After all, there are only 4 different commands regarding touch screen. I'm sure you'll manage.”
Of course, every time the teacher said “You'll manage”, it has been proven that the students could not manage. Well, Peter could sometimes managed, but the rest of the students held no pretension that they can actually manage. It has been their experience that they will try to do their best. Fail, and have the teacher blame them for their incompetence.
The students looked at their teacher for guidance, but he non-chalantly just sit back and relax, and totally not saying anything. He put up his feet on the desk, which is not a teacherly way to do things. As he kept reminding the students: He's not a teacher, but a professional.
The students valiantly tried to do it, but obviously, they needed help. A few minutes before the bell rang, the teacher walked among the students to look over their work. He laughed at some students' work.
“Come on, guys, you can do better than that! Think of Snake and Ladder game. Every turn is the same. Well, on this project, every PAGE is the same! Do it as homework and show me tomorrow!”
10.3 Project: CYOA
GOTO isn't the culprit. It's the programmer. Spaghetti code exists because the computer programmer does not know how to properly use GOTO. The simplest form of GOTO is that of infinite loop. Once the program reached a certain point, simply use GOTO to the beginning of the program. Given enough breakpoints and states, you can actually write a program without having subroutines or functions.
The teacher looked at a few samples of the homework. It is obvious that although they somewhat know what to do, they still do not completely understand the process. As such, there are inefficiencies here and there. Therefore, the teacher decided to adopt “Top-Down” design principle.
“Alright, class, listen up! Do you think that just putting stuff up, and checking off items on your checklist is good enough? You need to think like the user! How would a user use your program? Once you do that, you write down the desired user experience. None of you wrote that, and very few of you actually got it. So, let's do that now. What does a user see in a CYOA program?”
“A title screen. And maybe music.”
“Text screen on top. Choices bottom.”
“Calculator option on data.”
“Pages of text for stories.”
The teacher listened to these things. “So, what happens if you have more than one screen of text?”
“Press 'A' to continue.”
“And how would you implement that? Option one, as a single choice on the bottom screen. Option two, as a pause button for multiple screen. Option three, scrolling text.”
“Which one is better?” asked the student.
“That is for you to try and find out. Each problem must be solved three times. That's how you get a good solution, a better solution, and the best solution.”
“But teacher,” said Nancy, “Why don't you just teach us the best solution?”
The teacher stamped her forehead immediately. “Fail! Didn't I just tell you that you need to find 3 different solutions? How else are you going to find out which one is the best solution if you do only one? Coming up with a good solution is not acceptable! You need to find the best solution possible. That means coming up with 3 different solutions to a problem! You never know which one is the best unless you try them all.”
Of course, the students didn't feel like solving a problem three times. Once is hard enough, thank you very much. Still, they fear the stamps more, so they kept quite on the subject. Only Peter, having been advised on the subject beforehand, nodded his head in approval.
“So, here are the major, overview steps in a CYOA program:”
@INIT
@LOOP
Load/Read Data
Text[P],Pages,Choices,Commands
Display Text[P] on top screen
Display Choices[P] on bottom
Highlight first choice
Wait for inputs
Process Input
Set new P
GOTO @LOOP
“Anybody know what a 'sand-boxing' technique is all about?” asked the teacher. “It's a way to build the code piecemeal so that you don't have to do everything all at once. So, I suggest creating an array for text on top screen, text on bottom screen, and the inputs.”
@INIT
T[0]=”Line of text 1”:'repeated for whole screen
C[0]=”Choice 1”:'repeated 7 times
@LOOP
'Display Text
'Display Choices
S=0: Selection Highlight
@INPUT
'Show Highlight
'Read button/touch screen
'Update S
'If choice is made, goto @PROC else GOTO @INPUT
@PROC
'Process commands
'Set P
'GOTO @LOOP
(See Appendix H)
As simple as that task was, some students were struggling. Especially in the highlighting selection area. The teacher had to explain the math, and after that no problem. Of course, the teacher expressed his displeasure at what he thought was a simple math problem. The students redoubled their effort. At last, even Nancy the perpetual slowpoke, managed to finish, albeit with a lot of help from her fellow students. By this time, the clock was nearing class end time. The teacher sighed.
“Well, for your homework, you need to do a story that will fit this format. That's 24 lines of text, first line title. I also want you to do some kind of calculation. Something like having gold and buying something. So, you substract the amount approriately. Tomorrow, we're going to integrate the calculator into the program. Right under this @PROC subroutine. Also, in addition to the arithmetic and memory bank operations (26 entries for a-z), I also want these operations as well:”
% Modulus aritmetic
< Given M & B, M copies the lower value
> Given M & B, M copies the higher value
# Comparison M<B=0,M==B=1,M>B=2
? B=RND(B)
! Copies B to S0
@ Copies B to PROC$ 
The bell rang. “Make sure you have good and varied story because you'll need it to test your calculator implementation!” The students felt sudden chill descending upon them.
The next day, the students was showing the teacher their incomplete stories. “Ha! Why are you so intent on writing long stories? I just want a simple one so you can test your programs. No need for plot. Also, you need to add a few more data fields in your stories:
1. @PRE code
2. Title Line
3. Story Text
4. Data Line
5. Choices
6. MACRO code
7. @POST code
“Here's a hint,” said the teacher. “You want to separate the code from the data. Also, you want to have a template that you can simply APPEND to existing story line. That way, you don't have to type everything all over again.” Half the students did face palm. “Furthermore,” the teacher continued, “You can initialize the data just before going to the pages. So, you don't have to have long stretches of blank lines in your story.”
Of course, the students were rather disorganized, and it took them the rest of the class period to successfully integrate the calculator function into the story engine. Yet, there are some students who were falling behind. Their homework was obvious: Test the code!
Interestingly enough, since the pages are simply BASIC code, it is a simple matter to integrate BASIC code right there in the pages. However, for convenience, there exists PRE$ and POST$ variables. The idea is that these subroutines would be called in sequence. First, the subroutine PRE$ would be called. Then the display is shown, and the program waits for user input from the choices available. Then any Macro would be executed. Macros, actually string to be fed into the calculator, are simply there for the programming challenged. Otherwise, a simple code implementation would be fine. Then subroutine POST$ would be called. Finally, the program would GOTO to the specified subroutine, and repeat the whole process all over again. 
Fortunately, the addition of the calculator makes it easy to “program” the game. To be honest, the students all have the skills to write the program in BASIC code. However, as an introduction of virtual computer programming, this is as easy as can be. Furthermore, the resulting program will be of wider audience due to the lack of “programming”. In fact, all the calculations are actually optional. There's no rule that says an interactive story must contain calculations. Should that be desired, however, the writer can simply pull a “calculator” and enter the steps (or macro) to the appropriate string in the template.
The reason there's more choice than what is displayed isn't so that the display can be scrolled, but rather for the purpose of decision making. There is a comparison operator, and it will result in 0,1, or 2. This value can then be added to an index, and the appropriate page can be called.
Some students have difficulties in understanding the process involved. That's why it is recommended for them to implement a stand-alone calculator so they can play with it and understand the internals. Of course, the register contents should be displayed as well as the keystroke sequences.
And yet, since this is actually code, the whole power of Petit Computer can be called upon. In fact, you can write a complete game within the framework. Such is the power of this program.
As simple as it is, the program is actually useful. It would be even more useful, had the graphic display capability is implemented, as well as music capability. Although loading up graphic is as simple as “LOAD” command, the required bitmap does take a lot of space, as well as taking a long time to scan the numerous QR codes.
All the students' hard work paid off, though, because in the end, they did have fun in making stories to play. In fact, some students made a habit of expanding their adventure one screen per day. For them, the teacher recommends writing in the notebook all the pages, those that are planned, and those that are implemented. Easily enough done. And before they know it, some actually ended up with a long and enjoyable story.
“Well, that was unexpected,” said the teacher.
“What was?” asked the student.
“That everything went so well! I'd have expected some hiccups. I was ready to whack some heads, but you all did a good job.” The students were happy. Not only they were learning and actually doing something, but they were actually did very well. “Too bad none of this is graded. There would have been a lot of As going on.”
“What? Not graded?” The students were disappointed. They could've had some easy high scores.
“I didn't think it'll come together as neatly and easily as this, so I was planning to do it later. After all, why bother grading it if you're just going to do bad on it? Oh, well, I guess I should've prepared for this unexpected performance!”
Of course, the students were disappointed, but they cannot say anything. What was done cannot be undone. “Can't you create a quiz or something?”
“Like what? Everything is just about review. You already did the story engine, and the calculator. The only thing you do new would be the stories! And well, it won't do when the story is done before the grading was done. Also, it won't do for you to make new stories because it's going to take a long time, and we need to move on.
“Understand that the current program is as good as can be. In fact, better than most amateur effort. However, we're going to improve it even better. Next thing on our agenda would be learning graphics. You like making computer games, right? Well, don't expect to be stuck in text only program!”
“Will we be making Mario games?” asked a student.
“Mario games encompass such a diverse gameplay, so you need to be specific. If you're asking about platformers, then not immediately. I'm thinking more about Turtle Graphics, since it's so easy to do, and then moving on to Backgrounds and Sprites. You'll love the sprite manipulation capabilities on Petit Computer. It's so powerful, you can make quite a lot of sprite-based games simply by setting a few variables. Just like you did in your interactive stories. It's that easy!”
The students were happy. “So, what kind of games will we be making?”
“Lots. But examples of sprite based games would be PONG, Breakout, Galaga, Space Invader, most shoot-em up, and scrollers.”
The students were unfamiliar with the games. These games were before their time. 
“Never mind. You'll see it when the time comes. In the meantime, you'll be making programming tools. Remember that we just made a programming tools for making interactive stories?” The students nodded. “Well, we'll be making tools for making sprite-based games.”
“Teacher, why do we have to make all these tools? Doesn't Petit Computer come with tools already? Why must we made them all over again?” asked Nancy the perpetual whiner.
“Fail! Oh, did I just stamped your head?” He did. “I guess I didn't have to. Must be force of habit.” Nancy was just about to cry. “Never mind that! See, the thing about those tools is that they were already made for you. Certainly you can look through them to see what made them tick, but as long as you are learning how to program the computers, you need to design and implement your own tools. It's the best way to learn!”
The students weren't convinced that's a good solution, but as they were the students, they really didn't have any choice.
10.4 Computer as Data Storage
Peter was consulting with teacher in the office afterschool, per usual. “The way I see it, the program is about 120 lines, but the data is in thousands! That's rather unbelievable!”
“What do you mean 'unbelievable'?” The teacher frowned. “What kind of ratio do you expect?”
“Well, I don't know.” Peter was scrambling. “I would think that computer programs would take longer than 120 lines for it to be good.”
“Ha! That shows how much you know. What kind of computer programs are you looking at anyway?” the teacher sneered.
“Well, I was looking at those computer program repositories. Github and others like it.”
“Oh, that. Well, first of all, most computer language are structured. Half the program size can be eliminated if you don't have to follow such a strict structure! And the other half, well, it boils down to implementation. People are so focused on using fancy techniques that their size is larger than it needs to be.”
“Shouldn't fancy techniques be advanced? Meaning it should be more powerful, which should lead to smaller size?”
“Nope. Not really. If you look at object-oriented technique, there's constructors, destructors, try, and all that. Of course, methods got it's own lines and all. The more functions you have, the more space you use. If you look at our program, we don't use too many subroutines.”
Peter nodded his understanding.
“We're using string as look-up table. Python would use list or tuples. Why would we want that? A simple table would be fine. In fact, there's a saying 'Show me your code and hide me your tables, and I'll continue to be mystified. Show me your tables, and I don't need your code. They'll be obvious.'”
“Who said that?” asked Peter.
“Pascal inventor. Nicholas Wirth.” 
“Oh, so Pascal uses tables?”
“Nah, it's all so structured! The point is that with the correct problem solving approach, the solution can be simple. In fact, that is the approach that Perl uses. I bet this program can be even shorter when written in Perl!”
“Really?”
“Yup. Not that you'll be able to read it afterwards. Gya ha ha ha!”
The joke was lost on Peter, who never bothered to learn Perl. “So, then, you can handle large quantities of data with just a small program?” asked Peter.
“Of course. By the way, you know how big current games are?”
“They're rather big. Most program runs in Megabytes.”
“The graphic library alone can be 5 Megabytes. Unbelievable! We'll be doing something similar, but will only be a couple pages long. Now imagine, if we're using it to render complex graphic. The amount of data it processes would be quite large. It can even be in Mega or Terabytes in size. Yet, the program itself would still be the same size.”
“That's true. Can such program be really that short?”
“I've done Turtle Graphic programming in one hour.”
“You mean, actually programming it? Not just using it?” asked Peter. How can implementing it be a one hour exercise?
“Of course, programming it. You don't think you'll be learning LOGO, do you? Anyway, turtle programming design is only one paragraph. You'll be able to do it easy. In fact, maybe I should do it as an exam! Gya ha ha ha!”