Petit Computer Journal #32

Lottery Number Generator

A while ago, I wrote a simple Lottery Number Generator. It may interests you that it has these words in it: "...THEN A MIRACLE OCCURS" Of course, that was done as a joke, but in reality, choosing a bunch of random number isn't rocket science. Especially so, if the programming language provides a built-in random number generator, such as Petit Computer.

All of these talk about the biggest million jackpot ever got me fired up again, and well, I think it's time to update that program. This time, though, I want it to be an actual program that I can use. Speaking of which, there is more than one lottery, so I decided to write a customizable lottery number generator.

1. CLS:CLEAR
2. PNLTYPE "OFF"
3. DIM MN[10]
4. DIM MB[10]
5. 
   
6. @INIT
7. NT=15:'NUMBER OF TICKETS
8. NS=2:'NUMBER OF SLOTS
9. CS=0:'CURRENT SLOT
10. MN[0]=75:'MAXNUM 1-75
11. MB[0]=5:'NUMBER OF BALLS
12. MN[1]=15
13. MB[1]=1
14. SE=0:'SELECTOR
15. SSL=0:'SAVE SLOT
16. DIR=0:'GOSUB @MSL

It's clear that I'm planning to have more than one slot. The old version only has one slot, and this one have more than one. I put in initial value for the most common configuration. Also notice that you can have more than one slot for saving. I do it via MEM$ for saving/loading.

1. @LOOP
2. VSYNC 1:B=BUTTON(1):TS=TCHST:TT=TCHTIME
3. IF TS THEN GOTO @ROLL
4. IF B AND 1 THEN SE=SE-1
5. IF B AND 2 THEN SE=SE+1
6. IF B AND 4 THEN DIR=-1:ON SE GOSUB @MNT,@MNS,@MCS,@MMN,@MMB,@MSL
7. IF B AND 8 THEN DIR=1:ON SE GOSUB @MNT,@MNS,@MCS,@MMN,@MMB,@MSL
8. 
   
9. IF B AND 64 THEN GOSUB @SAVER
10. IF B AND 128 THEN GOSUB @LOADER

That's all for the user interface. There are 6 different actions you can take, and U/D refers to the different action. L/R refers to the value being changed. In truth, there's a simpler 2 dimensional way that you can do this, but I decided to stick with this generic form for now.

1. COLOR 15
2. PNLSTR 0,0,"LOTTERY GENERATOR"
3. PNLSTR 0,1,"(C) 2013 HARRY M. HARDJONO"
4. PNLSTR 0,3,"  NUMBER OF TICKETS: "+STR$(NT)+"   "
5. PNLSTR 0,4,"  NUMBER OF SLOTS: "+STR$(NS)+"   "
6. PNLSTR 0,5,"  CURRENT SLOT: "+STR$(CS)+"   "
7. PNLSTR 0,6,"  MAXNUM  1-"+STR$(MN[CS])+"   "
8. PNLSTR 0,7,"  MAXBALL 1-"+STR$(MB[CS])+"   "
9. PNLSTR 0,8,"  SAVE NAME:"+MM$+"            "
10. PNLSTR 0,20,"  TOUCH SCREEN TO ROLL"
11. PNLSTR 0,21,"(X) TO SAVE   (Y) TO LOAD"
12. PNLSTR 0,23,MID$(MEM$,0,32)
13. 
    
14. SE=(SE+6)%6
15. PNLSTR 0,SE+3,">"
16. GOTO @LOOP

And that's about it for the User Interface. There's really nothing new here. It's just displaying some variables, and that's about it.

1. @MNT
2. NT=(NT+DIR+21)%21
3. RETURN
4. @MNS
5. NS=(NS+DIR+10)%10
6. RETURN
7. @MCS
8. CS=(CS+DIR+NS)%NS
9. RETURN
10. @MMN
11. MN[CS]=(MN[CS]+DIR+100)%100
12. RETURN
13. @MMB
14. MB[CS]=(MB[CS]+DIR+10)%10
15. RETURN
16. @MSL
17. SSL=(SSL+DIR+10)%10
18. MM$="L"+STR$(SSL)+"TTOCFG"
19. RETURN

As you can see, the structure is all the same. Therefore, I can very well use a 2 dimensional array to do the whole thing. Doing it this way is actually more complicated, although it does have the benefit of mindless coding. Ha! Mindless coding. Isn't that an oxymoron? Haha, joking aside, it's true that simply adhering to plan is on the low end of the difficulty scale.

1. @ROLL
2. CLS
3. FOR I=0 TO NT-1
4. COLOR 15
5. ?RIGHT$("  "+STR$(I),2);
6. FOR J=0 TO NS-1
7. CNL$=""
8. IF MB[J]<1 THEN MB[J]=1
9. FOR K=0 TO MB[J]-1
10. IF MN[J]<1 THEN MN[J]=1
11. @THROW
12. NUM$=" "+RIGHT$("00"+STR$(RND(MN[J])+1),2)
13. IF INSTR(CNL$,NUM$)>=0 THEN GOTO @THROW
14. CNL$=CNL$+NUM$
15. NEXT K
16. COLOR 12+FLOOR((I%10)/5)
17. COLOR 4+FLOOR((I%10)/5)
18. ? CNL$+" -";
19. NEXT J
20. ?" "
21. NEXT I
22. GOTO @LOOP

Then a miracle occurs...

In fact, it's just a simple string search. Everytime I roll a number, the number is checked via INSTR whether or not the it exists in the string. If so, roll another number, else add the number to the string. Pretty simple, yet devious at the same time. Normally, you use an array, associative array, or hash, depending on the language you're using.

1. @SAVER
2. MEM$=RIGHT$("00"+STR$(NT),2
3. MEM$=MRM$+RIGHT$(STR$(NS),1)
4. FOR J=0 TO 8:'MAX NS
5. MEM$=MEM$+RIGHT$("00"+STR$(MN[J]),2)
6. MEM$=MRM$+RIGHT$(STR$(MB[J]),1)
7. NEXT J
8. SAVE "MEM:"+MM$
9. RETURN
10.  
11. @LOADER
12. LOAD "MEM:"+MM$
13. NT=VAL(MID$(MEM$,0,2))
14. NS=VAL(MID$(MEM$,2,1))
15. FOR J=0 TO 8:'MAX NS
16. MN[J]=VAL(MID$(MEM$,J*3+3,2))
17. MB[J]=VAL(MID$(MEM$,J*3+3+2,1))
18. NEXT J
19. RETURN

Saving and loading are really just building the string and decoding it. You can see the string on the last line. I made several mistakes here, mainly because I didn't write anything down, and just winging it. I build a long string array because I'm multiplying it by the number of tickets, which is silly because one ticket is the same as the other. Another one is that I multiplied J by 8. Oops. How did that happen?

I was on my bed trying to sleep, so I guess that kind of mistakes can't be helped. Now that I think of it, such mistakes are laughable silly. I guess I shouldn't be programming when I'm trying to sleep. Nah. Who cares? Some people read books on their bed. I'm doing computer programming. That's that.

Book Review #7

Make: Electronics
Charles Platt

This is an excellent book to learn Electronic. By the first chapter, I have learned to lick a battery, blow up a led, and other destructive, yet fun thing to do. I never thought learning electronic circuits can be so much fun! Although the content of the book is nothing special, the presentation is fun, engaging, and clear. I mean, in all electronic books, there is a lesson on how resistors work, how capacitors work, how transistor work. The explanation may not be the most concise available, but they are clear and easy-to-follow. That is the most important thing.

Along the way, I learned not only what different pieces of electronics do, and what tools would be valuable, but also what tools are optional. Breadboard, for one, which I thought was indispensable for trying out electronic circuitry, is actually an optional equipment. You can get by with just using wires and clips all over the place. The book does not mention conductive ink, but it is something I should try sometime in the future.

For the first time in my life, I feel like I truly understand what's going on behind the scene. That is a worthwhile experience, easily worth more than the purchase of the book. Highly recommended.

Petit Computer Journal #1

Petit Computer Journal#1

What is Petit Computer?

If you have been following Nintendo DSi development, then you'd know that SmileBoom has developed a downloadable computer program called Petit Computer. This is a development environment to create your own games on Nintendo DSi using BASIC. The idea is that you will write your own programs, and instead of buying other people software, you just write your own program. It's that easy! No more useless junk!

Why would you want to do that? In the beginning of computer history, there was simply no computer program available. You can either hire expensive professionals, or write your own program. Most people who grew up with early Personal Computer would write their own program. There are old magazines that tells people how to program their computer.

Later in the development of personal computer, softwares have become very complicated. Programming a computer is no longer within the realm of hobbyist computer. I still remember the disbelief that a C development system is 4 Gigabytes. Just how complicated can writing a computer program be? Very, very complicated!

And yet, most people do not need complicated programs. It does not take a rocket scientist to write a simple Blackjack program. Or create a maze. Or word search program. I did Sudoku program in one afternoon.

You don't need ridiculous amount of education in other to write useful program. You don't even need to write one. You can simply read what other people have done, and run their program on your Nintendo DS.

In short, Petit Computer is what Nintendo DSi homebrew, had it officially be done by Nintendo. Notice I said Nintendo DSi. That's because even though it's billed to be compatible with Nintendo 3DS, it doesn't take advantage of that platform. You can of course use Nintendo 3DS to run the program, but it's not necessary. If you don't have the device yet, I suggest the XL version. You won't have to squint at the small screen, and you can actually tap the keys with your fingernails, instead of stylus.

What's the difference between this and other BASIC?

SmileBasic, the BASIC language of Petit Computer, is very different from other BASIC languages. Most people are probably familiar with MS QBasic. Well, the difference between the two is that if you put this command "A=10:A=A/10:PRINT A" into Petit Computer, you'd get a "1". With QBasic, you'd get a "10".

Haha, joking aside, there is quite a big difference with the other BASIC. For one thing, this version of BASIC is very primitive when it comes to program structures. There is only FOR-NEXT loop. There is no such thing as WHILE-WEND, REPEAT-UNTIL, SWITCH-CASE. Rumor has it, you can't even GOTO out of the FOR-NEXT loop because you will corrupt the stack. That is strange. I will need to check for that. I think what happens is that the stack will run out because you cannot nest loops too deep.

Another difference is that SmileBasic is heavily tied into the Nintendo DSi hardware. This means sprites, background pictures, music synthesizers. Very powerful capabilities that is available for your use. You can easily make a Mario level game. Really.

The flip side to it is that if you aspire to make "modern" program such as the ones made by Visual Basic, then you are out of luck. This style of BASIC is old-style. Looking at the keywords of the language, I can't help to think that maybe this version isn't too friendly for beginners. Too much closely resembling Assembly Language/Machine Language. And you know what they say about Machine Language. If you cannot think in terms of Hexadecimal, then you may as well give up.

How hard is it to program a computer?

Paraphrasing an old joke:
Typing the program: $10.
Knowing what to type: $9990.

Computer programming is one of the easiest, if not the easiest job around. The qualification of that is IF YOU KNOW WHAT YOU'RE DOING. Do people know what they're doing? Surprisingly enough, no.

That's actually normal. Unless you're doing routine database programming, you probably will have to dissect the problem enough to come up with a solution. The problem you're solving is unique because if it's a common problem, then other people would have solved it already. Therefore, your problem solving skill must be top-notch.

The good news is, as a beginner, you don't have to be an expert solver. You're just starting out! By definition, other people have trodden the path before you, and you are going through familiar territory. If you get stuck anywhere, a simple question to the appropriate forum will suffice to get you going. There are plenty of tutorials on the Net. I plan to make some myself.

Do you need to be good at Math? No, you don't. I know I'm bucking the convention here, but we're talking about hobbyist computer programming. If you can balance your checkbook, then you can write computer program. If you know how to use spreadsheet program. You definitely have all the skills required. Higher level math is only necessary if you aspire to be a software ENGINEER. For hobbyist level, the most important skill needed is "Show and Tell". Really.


Should I really do this?

Why would you spend your time writing computer program on a very primitive system when you can have the world given to you by the latest and greatest in computer programming technology? How about Python? Ruby? Aren't they so great? Yes, they are, if you want to be productive.

If, however, you want to have fun and make games on Nintendo DSi, then this is the system to use! Not despite it being primitive, but because of it. Remember that old style 8 bit Apple, Atari, Commodore computer are rather primitive, and those computers were very useful. It doesn't take much to write useful programs.

I regularly write programs in Small Basic because it's fun. I will write programs in Smile Basic because it's fun. Remember: computer programming is easy, IF you know what you're doing. So the trick is, to first learn what you need to know in order to write the program, then write the program. By then, it'd be easy.

This is especially true with drag and drop programming. Let's take, for example, Macromedia Director. It's a very powerful platform, to be sure. But do you really learn how to program? Or do you learn to do use the package? Take away Director, and given Basic, can you replicate what you did with Director? Doubt it. Take away Basic, can you replicate what you did with Director? In my case, it took only 2 days, including learning the Director!

I hope I have convinced you to do this. If not, well, there's always Small Basic. :)