Kids getting their own games out of f3: 
this is kidpop23, getting started with 
with arrays and "doing bubbles" for sorting 
***Adults: you will find instructive programs and 
occasionally useful comments inside the KIDPOPnn series, 
where bits and pieces not discussed in F3DOCS are shown. 
So it has value for you, too! 
Written by Aristo 
***HI KIDS!!! 
Do you know what? If you want to make your own games and  
think clearly and think also funnily -- quickly, seeing 
things in a new way, understanding things quickly -- 
then it is good to know also a little bit about that 
which we call "arrays". You might exclaim, when you see 
three cool cafees beside one another on a map, -- hey, 
that's a whole array of cool cafees! -- and so, by array 
we simply mean something beside one another. Some might 
say a "list", but the word array is finer.
  The PC can do lots of things for you fast. But you 
have to tell it, or somebody has to do it. 
  And when we want the PC to fix on an array of numbers 
so that they are all increasing -- upwards, you know -- 
then we are doing -- or the PC is doing, rather -- what 
we can call "sorting". We get the computer to sort the 
list, oops, I mean array. Array sorting.
  So the simplest way to begin to program the PC to do 
sorting, so that we really see, step by step, how it is 
doing it, is to compare any two numbers beside one 
  And if any two beside one another is in the wrong 
sequence, then we switch the sequence. Alright? We use 
something called %GTSWITCH. The funny little sign in 
front of GTSWITCH, which means, 'switch these two 
numbers in the array if the one on the left is greater 
than the one on the right' -- that funny little sign 
means that we're doing arrays. If you view this inside 
the B9, you know, the place where we make a program and 
fix on it and store it, before running it with IN, then 
the little funny thing before GTSWITCH is shown as a 
nice thingy going up, and spreading like a flower. 
  But when you type in things directly inside F3, to 
test one or other things how they work, without putting 
them all up in a good fine document, there is a 
different look to the letters and the numbers. And also 
this little sign then look like 0/0 or something, -- it 
is by some called "percentage". 
  In any case, when we have a list, I mean an array, 
then we can sort it by going through again and again 
with this %GTSWITCH. For large arrays we have other ways 
of sorting, but you can learn a lot when you are 
starting to learn how to program games by looking at 
various examples of things just with numbers. And so it 
is a good rule to be patient, to learn to love numbers 
but at the same time, don't use these numbers when you 
compare your bodies. Numbers are numbers, bodies are 
bodies, let's not give each other numbers, thank you 
very much. I mention this since you will work a lot lot 
with numbers but only sometimes is it right to give 
these numbers to ourselves. 
  Are you working by yourself right now, or with a 
teacher? The teacher might have put this neat little 
program in a file called BUBSORT.TXT first, so that you 
can test the program, and THEN we talk a little bit 
about how it works. You test it then by typing  
and press ENTER, and you type  
and press ENTER. Then you just follow the flow and watch  
how it works, step by step, until you've seen enough, 
and you press the letter it tells you to press to quit 
the program.
    (( }Hi! For fun, making some numbers..} => POP ))
    (( 20 ; 1000 => %RFFG => & ))
    (( GOLABEL1: ))
    (( # => %SEE ))
    (( }Press B to bubble'em, or X to finish} => POP ))
    (( KEY ; :X => EQ = && ; RAM-REFRESH ; EXIT === ))
    (( 19
        (( N1 ; N1 INC ; # => %GTSWITCH ))
      COUNTUP) ))
    (( GOUP1 ))
  )) OK)
Do you understand what it is to "bubble" the numbers? 
Every time two beside one another are not quite right, 
it switches around these two, and so on, and so the 
littlest numbers travel to the left, while the biggest 
ones travel to the right. The line is a little bit too 
long to show so some numbers might go over the line, but 
that's good when you know it. 
  And, after many like these, the list is no longer 
changing! It is finished, it is sorted, the %GTSWITCH no 
longer switches anything around. And you press X and 
leave it, rather than yet another B to sort it.
  The array COULD have a thousand numbers. And these 
numbers COULD big really big, like a million or even 
hundreds of times bigger than that again, -- still it 
would go fairly fast. Another time we might look at 
other ways of sorting, which allows you to sort not just 
numbers on their own, but, say, also numbers along with 
some text of some kind. All sorts of things like this 
might be useful to know to make your own thoughts clear 
and also to make games and such.
  So don't be too impatient with getting on to really 
game-like programs if you want to learn games: have fun 
in doing things ONLY with numbers and ONLY with letters 
before you add it all up to good games. And as I said, 
it is also about getting to know how your own mind 
works, getting it sharper, better to meditate, better 
energy to your mind. And you learn how to draw for you 
see more clearly new things when you have done your bit 
with programming, say, earlier the day or week.
  So there are all sorts of benefits with programming.
  In any case, before we look at that BUBSORT, how it 
works, let us realize that the PC could do the same with 
much much less of the (( and the )) and the ; and the =>  
for these things are there just to straighten it out, as  
when you put your hair in pigtails. 
  So, just so you know it, the PC could do with 
something like this also -- which is the same bunch as 
above but written like a mess, without lineshifts in the 
proper places, without extra blanks: 
(LET BUBSORT }Hi! For fun, making some numbers..} POP  
20 1000 %RFFG & GOLABEL1: # %SEE  
}Press B to bubble'em, or X to finish} POP KEY :X EQ = &&  
Now the big key to this is (COUNT .. COUNTUP). If you 
count the numbers in the array when it shows them to you 
-- which it does by the %SEE word -- and it has made the  
numbers by the %RFFG word -- you will see that it is 
twenty of them. Each time you do the program there is a 
new array of numbers, different than the earlier, but 
they are all within one and thousand. And you see one 
and thousand, 1 and 1000, are given to %RFFG so whenever 
you see RFFG you should trust that this is a good type 
of coincidence, the FF is for Free Fluctuation, a free 
dance, G is for Generate, or make, and R is for Rather, 
Relative. Anyway, just trust RFFG. The word also exists 
in FUNNYRFFG, another way of doing it. And also we use 
the word FR sometimes, for the same. 
  Anyway, there are twenty of them. So there is a 19, 
one less than twenty, before the (COUNT. This is 
because we want to look at all the neigbours -- all the 
numbers beside one another, and the rightmost pair is 19 
and 20, not 20 and 21, for 21 doesn't here exist in this  
array. Right? So we put 19 before the (COUNT and then 
the N1 inside the (COUNT .. COUNTUP) goes from 1 and up 
to 19. And so we instruct the PC to look at 1 and 2, 
then 2 and 3, then 3 and 4, and up to 19 and 20. So we 
use the word INC -- do you find it? -- for INC means 
increase, get the number up by 1 -- so we give the 
%GTSWITCH the instruction to look at both N1 and also N1 
INC. That's all there is to it. 
  There are some funny letters or what we call them -- 
characters -- there, as well. These are just places to 
store what we are looking at, so we don't have to make a 
new list each time. The # contains as it were the array.  
When we use the & on its own, this sign is also called 
"and", for you can use it English as a quick way of 
writing and, such as when you say: I will walk & then 
swim. So here we use the AND to say, we will store this 
& use it more. It can be an array or it can be a table, 
like a game-board, then we call it "matrix". 
  So that's it. Then & starts the storing of the array, 
after we made it by %RFFG. Then the && tells the PC that 
we are done with the array, otherwise a peculiar number 
will appear when the PC gets the instruction to meditate 
and sleep and have a bath, which is what RAM-REFRESH and  
EXIT does. And in between the & and the && we tell the 
PC to work with the array by the # or "number" symbol.
  What else? Oh yes, the word KEY tells the computer to 
fetch a letter or such from the keyboard, and the :X 
tells the PC to compare with an uppercase X, and the 
word EQ tells the computer to make whatever is typed 
into uppercase (so you can type x not just X) and 
compare it. When EQ -- which is short for EQual texts -- 
gets going hot, then what is inside the = and the === 
gets done. The = is also called 'equals', and three of 
them means that we are done.
  Then GOUP1 tells the PC to do the same type of thing 
over again, but with the new updated number list. It 
goes then faithfully up, just as you ask it, to 
GOLABEL1:. Each program can have up to four such, 
GOLABEL1: to GOLABEL4:, and one such label can have one 
and but one GO to it, and the GO is either GOUP, as 
here, or GOFORWARD, when it is further on.
  What happens to the list of the numbers when the 
program finishes? Nothing is really lost but all gets 
refreshed and gets fresh use, in new programs, -- new 
bodies, as it were, the numbers being a kind of souls 
and spirits. So they get turned around as the new 
programs in the future wants, but such that everything 
important is kept.
  See you soon!!!