puppylinux documentation blog (node 01)

howto change the desktop icons

2007-02-03T10:05:00.000-08:00

to change an icon right click and "set icon." to set the icon, drag the desired image from the icons folder (most are in /usr/local/lib/X11/pixmaps or /usr/local/lib/X11/mini-icons) right onto the box in the middle if the set icon window- typing is optional!

to create an icon, drag the script or binary for it (this may be the only needed step...) from /usr/local/bin (or any other folder) right onto the desktop.

to edit an icon image, goto the icons folder from mtpaint and open it, or goto the icons folder in rox and right click... "open with" and open it it mtpaint. (the second method may not always work.)

you can zoom in on your image by pressing "7" on your keyboard, or other numbers, nothing that "4" will go back to regular size.

most icons are xpm or png, you can use the "transparent" color by selecting from the background with [CTRL]+Paint tool, or you can set a new background color by selecting "save as..." from the mtpaint menu, checking "set transparancy index" and selecting the number next to the new color in the palette. you may need to "convert to indexed" from the "image" menu, but you probably won't.

after saving the image to the same file you loaded it from, the icon on the desktop will refresh after you hover the mouse cursor over it, if not sooner.

ktwi: puppy 2.11, *should* work also in 1.07 and most (or all) other versions...

thanks to: amish

puppybasic intro ch. 17 - other useful statements

2007-02-02T15:52:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
other useful statements                                                  
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 17: other useful statements                    
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
2 of 7                                                                   
                                                                         
SHELL calls a dos command. dos of course, is not only capable of         
managing operations with files and folders, it can call other pieces     
of software. running large programs from shell may result in an "out     
of memory" error from dos. (usually not an issue.)                       
                                                                         
here's a nice example for SHELL:                                         
SHELL "dir *.* /a /b > dirfile.txt"                                      
                                                                         
this creates a file called "dirfile.txt" containing a list of all        
files in the current folder. then you can load the list with the OPEN    
command.                                                                 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
3 of 7                                                                   
                                                                         
mode co40 is another useful dos command, but doesn't always (if ever)    
work in windows xp. (for some reason, every time windows makes a new     
dos emulator it does even less of the stuff that dos or the previous     
dos emulator did.)                                                       
                                                                         
it is better still to use mode con cols=40, which works in xp and can    
be used in puppybasic like this:                                             
                                                                         
SHELL "mode con cols=40"                                                 
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
4 of 7                                                                   
                                                                         
this is better than width 40, as it's more likely to work. i knew of     
one project that wouldn't stay in WIDTH 40 unless you first shelled to   
run this dos command, then used WIDTH 40 as well.                        
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
5 of 7                                                                   
                                                                         
COMMAND$                                                                 
                                                                         
quickbasic (compiler) only. reads the arguments typed next to            
a standalone exe's name, from dos or windows, so if your compiled        
program was called appli01.exe and you were to type:                     
                                                                         
c:\winnt\>appli01 New.txt /fs                                            
at the dos prompt (for instance) and you put this at the beginning of    
your program:                                                            
                                                                         
q$=COMMAND$  'then the string q$ would contain: "New.txt /fs"            
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
6 of 7                                                                   
                                                                         
SYSTEM                                                                   
                                                                         
use this instead of END, this is only useful when using the              
interpreter. it ends the program, but if the      
interpreter is running, exits the interpreter also.    
this only works if you've run a program using /run        
[file].bas or /run file... etc. (from a script for instance.)     
                                                                         
an example:                                                              
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
other useful statements                                                  
7 of 7                                                                   
                                                                         
SYSTEM                                                                   
END 'you don't need END here, but it hurts nothing and is easy to spot   
'when other people are reading your code.                                
                                                                         
                                                                         
                         -= end of chapter 17 =-                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 17) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 16 - arrays

2007-02-02T15:50:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
arrays                                                                   
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 16: arrays                                     
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
2 of 7                                                                   
                                                                         
arrays make variables more useful and offer a powerful way to handle     
data. for instance: instead of the following code:                       
                                                                         
READ a                                                                   
READ b                                                                   
READ c                                                                   
READ d                                                                   
READ e: PRINT a;b;c;d;e;                                                 
                                                                         
DATA 52,21,19,45,73                                                      
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
3 of 7                                                                   
                                                                         
you could replace it with this:                                          
FOR q=1 TO 5                                                             
READ ab(q)                                                               
NEXT q                                                                   
                                                                         
FOR q=1 TO 5                                                             
? ab(q);                                                                 
NEXT q                                                                   
                                                                         
...which seems unspectacular until you have a bit more than five         
variables to name.                                                       
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
4 of 7                                                                   
                                                                         
another advantage of arrays is that you don't need to know exactly how   
many items you will be storing. for instance:                            
                                                                         
DIM q$(1 to 100)                                                         
                                                                         
OPEN "file" FOR INPUT AS #1                                              
DO: c=c+1                                                                
LINE INPUT #1, q$(c)                                                     
LOOP UNTIL EOF(1) or c => 99                                             
                                                                         
q$(c+1) = CHR$(26): c=0: close                                           
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
5 of 7                                                                   
                                                                         
will open "file" and store each line in q$(c), c standing for which line 
is stored there. this example limits the possible number of lines to 99, 
and sets the last line to ascii 26 to mark it as the last.               
                                                                         
note the use of DIM(1 to 100) which is required for arrays more than 10  
units in size. it is also necessary to use dim for multidimensional      
arrays:                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
6 of 7                                                                   
                                                                         
DIM twod(1 to 5, 1 to 5) AS INTEGER 'integers let you use wider arrays   
                                                                         
will allocate an array of 5 units, and each unit will also have 5        
subunits:                                                                
                                                                         
twod(1,1) twod(2,1) twod(3,1) twod(4,1) twod(5,1)                        
twod(1,2) twod(2,2) twod(3,2) twod(4,2) twod(5,2)                        
twod(1,3) twod(2,3) twod(3,3) twod(4,3) twod(5,3)                        
twod(1,4) twod(2,4) twod(3,4) twod(4,4) twod(5,4)                        
twod(1,5) twod(2,5) twod(3,5) twod(4,5) twod(5,5)                        
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
arrays                                                                   
7 of 7                                                                   
                                                                         
you may find that although 3-dimensional arrays are possible, but that  
the limitations won't allow a 3d array large enough to be useful all     
that often. (i do know someone who used one for a card game, and you may 
be able to use one for a program to solve rubik's cube... although such  
a program already exists.)                                               
                                                                         
incidently, puppybasic tends to demand that most DIM statements come at  
the beginning of a program, but you can change the limits of some arrays     
using REDIM.                                                             
                                                                         
                         -= end of chapter 16 =-                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 16) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 15 - timing

2007-02-02T15:49:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
timing                                                                   
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 15: timing                                     
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
2 of 7                                                                   
                                                                         
vital to graphics and games, and useful for many other things you'll     
want to do, the following are common functions for accessing the         
timer inside the computer and its clock functions:                       
                                                                         
TIMER                                                                    
(mentioned earlier for use with RANDOMIZE) is a numeric function that    
returns the number of seconds that have elapsed since midnight.          
                                                                         
you can code a delay using TIMER this way...                             
                                                                         
                               ... (only joking, it's on the next page.) 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
3 of 7                                                                   
                                                                         
delay = .5 'delay in seconds, in this case: half of one second           
t = TIMER + delay: DO: LOOP UNTIL TIMER > t or TIMER < t - delay * 1.2   
                                                                         
it is also possible to create a short delay using FOR q=1 TO d: NEXT q   
where d is a large number, but the faster computers get, the more        
useless this method becomes. also it is unreliable in that the delay is  
longer on slower machines, and that the delay it creates can't be        
determined exactly on any machine but the one you try it on.             
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
4 of 7                                                                   
                                                                         
SLEEP                                                                    
                                                                         
makes a program suddenly sit and do absolutely nothing until a key is    
pressed, and if used with a number:                                      
                                                                         
SLEEP 5                                                                  
                                                                         
works the same way, only gives up waiting for a key after that number of 
seconds.                                                                 
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
5 of 7                                                                   
                                                                         
if used enough times in a program, (especially in a loop,) the keyboard  
buffer will fill, which adds up to annoying clicking noises. you can     
clear this buffer using INKEY$, but i think it makes more sense to       
substitute q$=INPUT$(1) for SLEEP, or a variation of the timer code      
example (throw in an INKEY$ function) in this chapter for SLEEP N, and   
i usually only use SLEEP when i'm busy enough doing other things to      
avoid typing parenthesis: (example: SLEEP is very useful during          
debugging.)                                                              
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
6 of 7                                                                   
                                                                         
TIME$                                                                    
has the double use of checking and setting the time.                     
                                                                         
to check the time, let q$=TIME$ which will set q$ to an 8-byte string    
comprised of "hh:mm:ss" with hh being a pair of hour digits, mm being    
minutes, and ss being seconds.                                           
                                                                         
to set the time, create a string in the same 8-byte "hh:mm:ss" format    
and let TIME$=q$                                                         
                                                                         
easy!                                                                    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
timing                                                                   
7 of 7                                                                   
                                                                         
DATE$ works like TIME$ and checks and sets the date with the format      
month-day-year as "mm-dd-yyyy"                                           
                                                                         
note: if your computer is outside the united states, it's possible that  
your OS and thus puppybasic will use a different date display.               
                                                                         
                                                                         
                         -= end of chapter 15 =-                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 15) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 14 - errors

2007-02-02T15:48:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
errors                                                                   
1 of 10                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 14: errors                                     
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
2 of 10                                                                  
                                                                         
you could do well to always trap and handle errors, i almost never       
bother. if you write your program well, you might manage to avoid it.    
this applies less to large programs. of course, sometimes error trapping 
is quite useful.                                                         
                                                                         
whether you use error handling or not, your program, upon encountering   
an error, can tell the user the name of the error. if you do not trap    
your errors, the program will end as well. if you do use error handling, 
you have the option of telling the user a more friendly interpretation   
of the problem:                                                          
                "I'm sorry, no file by that name exists in this folder." 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
3 of 10                                                                  
                                                                         
or even fixing it so the program can continue:                           
                                                                         
"That file does not exist. Create? (Y/N)"                                
                                                                         
you can even trap errors to detect which screen modes don't work. as     
mentioned in the graphics section, there are several screen modes in     
puppybasic, and they start with SCREEN 0, or text-only mode and range   
from 0 to 13. so, you can tell your program to go to all the possible  
screen modes: (none of this is true, this tutorial is being edited.)                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
4 of 10                                                                  
                                                                         
okscreen$ = SPACE$(14)                                                   
ON ERROR GOTO oops                                                       
FOR q = 0 TO 13                                                          
SCREEN q                                                                 
NEXT q: nomorec = 1                                                      
                                                                         
and then when it tries to SCREEN [not an available mode] it will cause   
an error 5, and GOTO the "oops" routine:                                 
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
5 of 10                                                                  
                                                                         
oops:                                                                    
IF nomorec = 0 THEN                                                      
IF ERR = 5 THEN MID$(okscreen$, q + 1) = "x"                             
END IF                                                                   
RESUME NEXT                                                              
                                                                         
which adds an "x" under the part of the variable okscreen$ for that      
mode.                                                                    
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
6 of 10                                                                  
                                                                         
the command RESUME NEXT tells the program "don't worry about that last   
error..." and the program then runs the next line, which is the "NEXT q" 
of the FOR... NEXT loop.                                                 
                                                                         
when you're done trying all the modes, you can go back to SCREEN 0,      
which is the default, and should always work:                            
                                                                         
SCREEN 0: WIDTH 80 'WIDTH 80 should always work, otherwise, remove it.   
                                                                         
then print a guide for the numbers 0 to 13:                              
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
7 of 10                                                                  
                                                                         
PRINT "          1111"                                                   
PRINT "01234567890123"                                                   
                                                                         
and under that:                                                          
                                                                         
PRINT: PRINT okscreen$                                                   
END 'don't forget to put an END statement between                        
'your program and routines.                                              
                                                                         
now your program will put a little "x" under the modes that don't work   
on your computer!                                                        
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
8 of 10                                                                  
                                                                         
if we went over this section too fast: here is a review:                 
                                                                         
ON ERROR... GOTO linelabel                                               
                                                                         
tells the program what routine to goto when an error occurs. there is no 
"ON ERROR... GOSUB."                                                     
                                                                         
IF ERR=n THEN                                                            
                                                                         
will do something in response to the specific error... (you can also use 
"SELECT CASE ERR" for handling this part.)                               
                                                                         
                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
9 of 10                                                                  
                                                                         
RESUME NEXT                                                              
                                                                         
goes back to the part of the program where the error occured, but it     
goes to the first line AFTER the problem.                                
                                                                         
note: error code 5 is "illegal function call" - the error you get when 
you try to change to an unavailable mode, although there are other 
possible causes.  
                                                                         



                                                                         
........................................................................ 

........................................................................ 
errors                                                                   
10 of 10                                                                 
                                                                         
there are at least a couple other commands for error handling, but       
unless you want them enough to look them up, you probably won't ever     
need them.                                                               
                                                                         
                                                                         
                         -= end of chapter 14 =-                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 14) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 13 - working with text files

2007-02-02T15:44:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
working with text files                                          
1 of 8                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 13: working with text files                    
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
2 of 8                                                                   
                                                                         
working with text files is a bit different than working with binary      
files... for one, the way you open the file depends on whether you will  
be reading or writing. for this reason and a few others i prefer to      
handle text files as if they were binaries and open them for binary      
file access. you may find this is easier when you're starting out, you   
may not. often i am too lazy and instead open text files as text files.  
to print the following lines to a file:                                  
this is a line. skip the next one:                                       
                                                                         
okay, this is another line...                                            
this is, too.                                                            
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
3 of 8                                                                   
                                                                         
always OPEN the file:                                                    
                                                                         
OPEN "filename.txt" FOR OUTPUT AS #1                                     
                                                                         
if you do it this way it will start from scratch... that is,             
"filename.txt" will be BLANKED if it wasn't before. for this reason you  
will use APPEND for now. APPEND, instead of erasing the file, adds to    
the end of it. if you are writing to a log, this is exactly what you     
want. if you are only storing the data for a saved game file, this may   
be problematic. in that case you may prefer OPEN... FOR OUTPUT.          
regardless:                                                              
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
4 of 8                                                                   
                                                                         
OPEN "filename.txt" FOR APPEND AS #1                                     
                                                                         
now we'll use the PRINT statement to write our lines to the file. the    
file currently open is #1, so we'll use PRINT #1, q$                     
                                                                         
PRINT #1, "this is a line. skip the next one:"                           
PRINT #1, ""                                                             
PRINT #1, "okay, this is another line..."                                
q$ = "this is, too."                                                     
PRINT #1, q$                                                             
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
5 of 8                                                                   
                                                                         
the last line was printed differently to demonstrate again that a string 
is, after all, a string, and that you can PRINT #1, q$ as well as PRINT  
an expression in quotes. both of these are examples of valid strings.    
                                                                         
always CLOSE the file when you're done working with it:                  
CLOSE #1                                                                 
                                                                         
if you are only working with one file, or if you don't have any other    
files that you need to leave open, using CLOSE with no file numbers:     
CLOSE                                                                    
will close all the files your program has opened.                        
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
6 of 8                                                                   
                                                                         
now to read the file, we open it again, this time for input:             
OPEN "filename.txt" FOR INPUT AS #1                                      
                                                                         
the text file is read one line at a time. one of the most reliable ways  
to do this is to use line input from within a loop:                      
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
7 of 8                                                                   
                                                                         
DO: LINE INPUT #1, q$                                                    
                                                                         
PRINT q$ 'print the line to the screen                                   
                                                                         
the program has to know when to stop looping. EOF(1) is a condition that 
will be true when the end of the file is reached. it can end the LOOP    
this way:                                                                
          LOOP UNTIL EOF(1)                                              
                                                                         
you may find This LOOP superior for reading text files:                  
DO WHILE EOF(1) = 0: LINE INPUT #1, q$: LOOP 'it handles 0-length files. 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with text files                                          
8 of 8                                                                   
                                                                         
if you only wanted to read the first line of course, the loop isn't      
needed, only line input #1, q$                                           
                                                                         
close the file when you're done with it. no files are open that need to  
stay open, so it's alright to just say:                                  
                                                                         
CLOSE                                                                    
                                                                         
                                                                         
                         -= end of chapter 13 =-                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 13) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 12 - looping within the program

2007-02-02T15:41:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
looping within the program                                        
1 of 9                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 12: looping within the program                 
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
2 of 9                                                                   
                                                                         
as promised, here are two ways to remove GOTO from the earlier example:  
                                                                         
x=0                                                                      
alabel:                                                                  
x=x+1                                                                    
IF x > 5 THEN ? x        ' > means "more than"                           
IF < 10 THEN GOTO alabel ' < means "less than"                           
                                                                         
one way is DO... LOOP. it sort of works like this:                       
alabel:                                                                  
goto alabel unless condition is met...                                   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
3 of 9                                                                   
                                                                         
but it's better:                                                         
                                                                         
DO: 'no line label needed!                                               
LOOP UNTIL cndtn=1                                                       
                                                                         
and the example:                                                         
x=0                                                                      
DO                                                                       
x=x+1                                                                    
IF x > 5 THEN ? x                                                        
LOOP UNTIL x >= 10 ' >= means "more than or equal to"                    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
4 of 9                                                                   
                                                                         
if you had a very long version of this:                                  
                                                                         
x = 0                                                                    
DO:                                                                      
x = x + 1: IF INKEY$ = CHR$(27) THEN EXIT DO                             
'stop loop if ESC pressed ^^^^                                           
IF x > 5 THEN PRINT x                                                    
LOOP UNTIL x >= 2 ^ 17 ' >= means "more than or equal to"                
                                                                         
you could stop in the middle with INKEY$!                                
(2 ^ 17 of course, is 2 raised to the 17th power)                        
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
5 of 9                                                                   
                                                                         
as mentioned before, INKEY$ will not wait for a keypress. if you've been 
pressing a key (in this loop, INKEY$ is checked many times each second)  
then INKEY$ will detect it (there are some exceptions, like the CTRL     
key...) but the program just keeps running whether a key is pressed or   
not. it is also possible to pickup the most recent keypress using        
INKEY$, because there is a buffer that tracks recently pressed keys. it  
can get full, especially if you hold a key down, and you can use INKEY$  
to clear it and prevent the computer from beeping at you.                
                                                                         
EXIT DO, as used here, stops the DO... LOOP and moves on to whatever     
part of the program is after that. another way to do this is with OR:    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
6 of 9                                                                   
                                                                         
x = 0                                                                    
DO:                                                                      
x = x + 1                                                                
IF x > 5 THEN PRINT x                                                    
LOOP UNTIL x >= 2 ^ 17 OR INKEY$ = CHR$(32)                              
'the spacebar sends an ascii 32.                                         
                                                                         
                                                                         
FOR... NEXT                                                              
is the way to loop with a number range.                                  
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
7 of 9                                                                   
                                                                         
'this is the shorter loop from before, done with FOR... NEXT             
                                                                         
FOR x=1 TO 10                                                            
IF x>5 THEN ? x                                                          
NEXT x                                                                   
                                                                         
or even:                                                                 
                                                                         
FOR x=5 TO 10                                                            
? x                                                                      
NEXT x                                                                   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
8 of 9                                                                   
                                                                         
to go in increments of less than 1, try STEP:                            
FOR x=5 TO 10 STEP .5                                                    
? x ' will print 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5, 10              
NEXT x                                                                   
                                                                         
it adds .5 instead of 1. and you can go backwards, and over 1 at a time: 
                                                                         
FOR x=10 TO 1 STEP -2                                                    
? x ' will print 10, 8, 6, 4, 2... but not 1, because it will get to 2,  
'and STEP -2 again, which is 0...or less than the range 10 to 1, get it? 
NEXT x                                                                   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
looping within the program
9 of 9                                                                   
                                                                         
to recreate the functionality of INPUT$(1) using INKEY$, use this line:  
                                                                         
DO: q$=INKEY$: LOOP UNTIL q$ <> "" ' <> means "not equal to"             
                                                                         
                                                                         
by the way, you might want to know the Other kind of DO... LOOP:         
                                                                         
DO WHILE condition = true  'makes sense?                                 
LOOP                                                                     
                                                                         
                        -= end of chapter 12 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 12) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 11 - decision making

2007-02-02T15:39:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
decision making                                                          
1 of 9                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 11: decision making                            
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
2 of 9                                                                   
                                                                         
hey, now we make your programs smarter. right now your code does this:   
                                                                         
[do this.]                                                               
                                                                         
but we can make it so smart, it'll know whether to or not!               
                                                                         
[do this... but not unless i want you to.]                               
                                                                         
you just have to be really specific about what you want :D               
                                                                         
here's an example of IF...THEN, using the very naughty GOTO statement :O 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
3 of 9                                                                   
                                                                         
x=0                                                                      
alabel:                                                                  
x=x+1                                             ______________________ 
IF x > 5 THEN ? x          ' > means "more than"  __6___________________ 
IF x < 10 THEN GOTO alabel ' < means "less than"  __7___________________ 
                                                  __8___________________ 
which will PRINT this, on the screen     ->       __9___________________ 
                                                  __10__________________ 
unless x is more than 5, it won't PRINT, and      ______________________ 
when x is 10, it won't go back to alabel.                                
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
4 of 9                                                                   
                                                                         
i'm still using GOTO in these examples, because GOTO is easy to teach.   
sometimes, when it's easier to teach, it's easier to learn... but        
regardless, you will soon learn a couple statements that help to         
eliminate the use of GOTO, and are perfect for the example i just showed 
you. in fact, for what i just showed you, there are TWO perfectly        
acceptable command pairs that can be used just as easily.                
                                                                         
for now, here's another example:                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
5 of 9                                                                   
                                                                         
PRINT "what's your name? - "                    ' *i'm not a chauvinist! 
LINE INPUT q$: q$=LTRIM$(RTRIM$(q$)) 'trim spaces                        
'standard reply                                                          
jim$ = "I am James T. Kirk... (Captain... of) "                          
jim$ = jim$ + "the Starship... Enterprise..."                            
                                                                         
?:? "are you a female alien? (y/n)"                                      
IF LCASE$(q$)=jim$ AND LCASE$(INPUT$(1))="y" THEN GOTO swoonfornoreason  
                                                                         
you see? it doesn't take much to make a program that thinks just like a  
female alien, especially one from the 1960's! (I Said "ALIEN!")*         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
6 of 9                                                                   
                                                                         
that example uses AND, let's try one that uses OR, and throw in ELSE...  
PRINT "what's your name? - "                                             
LINE INPUT q$: q$=LTRIM$(RTRIM$(q$)) 'trim spaces                        
o$=LCASE$(q$)                                                            
                                                                         
IF INSTR(o$,"bones")>0 OR INSTR(o$,"mccoy")>0 THEN                       
? "i need mr. sulu in sickbay, he thinks we";                            
? " really need a pilot to fly this thing!"                              
ELSE                                                                     
? "damnit, " + q$ +", you're not a doctor!"                              
END IF                                                                   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
7 of 9                                                                   
                                                                         
that's an IF... THEN block. if you really want, it works as one long     
line that won't fit the screen:                                          
                                                                         
IF INSTR(o$,"bones")>0 OR INSTR(o$,"mccoy")>0 THEN ? "i need mr. sulu    
in sickbay, he thinks we";: ? " actually need a pilot to fly this        
thing!" ELSE ? "damnit, " + q$ +", you're not a doctor!"                 
                                                                         
but for that to work you have to actually put it all on the same line.   
who would want to? hence, an IF... THEN block is used.                   
                                                                         
here's a way to check many conditions, using SELECT... CASE:             
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
8 of 9                                                                   
                                                                         
? "input a number "; : LINE INPUT q$                                     
SELECT CASE VAL(q$)                                                      
CASE 1 TO 5: ? "your number is one at least, and five at most."          
CASE 6 TO 10                                                             
? "your number is six at least, and ten at most."                        
CASE IS = 15                                                             
? "fifteen? what's that got to do with anything?"                        
CASE IS > 20                                                             
? "more than 20? i quit!" ' no particular reason...                      
CASE ELSE: ? "i don't even understand this answer."                      
END SELECT                                                               
                                                                         
                                                                         
........................................................................ 

........................................................................ 
decision making                                                          
9 of 9                                                                   
                                                                         
"CASE ELSE" of course, runs the code following that line if none of the  
other "CASE" conditions are met. CASE is also really handy for an if     
that uses numerous values:                                               
                                                                         
SELECT CASE LTRIM$(RTRIM$(LCASE$(q$)))                                   
CASE "susie", "janie", "jamie", "josie", "connie", "carrie", "mary"      
? "didn't we used to date?"                                              
CASE ELSE                                                                
? "so what are you doing tuesday?" '* AM NOT! SEE PAGE 5!                
END SELECT                                                               
                        -= end of chapter 11 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 11) 
this content is public domain.                          
........................................................................

click here to go back to the contents page

puppybasic intro ch. 10 - branching within the program

2007-02-02T15:36:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
branching within the program                               
1 of 14                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 10: branching within the program               
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program                               
2 of 14                                                                  
                                                                         
GOTO is easy enough to use, first you'll want a line number:             
                                                                         
90                                                                       
                                                                         
or instead of that, a linelabel:                                         
                                                                         
hey:                                                                     
                                                                         
using similar rules for naming labels that you do for naming variables.  
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
3 of 14                                                                  
                                                                         
you can then tell the program to stop running exactly where it is        
(usually the program runs the first line, then the second line, then the 
third line... not anymore!) and start running at that line number:       
                                                                         
GOTO 90                                                                  
                                                                         
or that linelabel:                                                       
                                                                         
GOTO hey                                                                 
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
4 of 14                                                                  
                                                                         
and the easiest way to use it is to make the program do the same thing   
over and over:                                                           
                                                                         
10 PRINT "not again! ";                                                  
GOTO 10                                                                  
                                                                         
so why are they all multiples of 10? well, no reason these days. about   
100 years ago (20 to 30, actually) you didn't use (by default) a text   
editor like the one you use with puppybasic. you had a program that
simply waited for you to type lines, and then if it started with a line 
number, it added that line to the whole program...                               
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
5 of 14                                                                  
                                                                         
you only saw the lines you were typing, and if you typed LIST and hit    
enter, it would show you the program listing. the trick was listing      
programs that were more than about 20 lines long :)                      
                                                                         
you could make it easier to insert lines by "naming" them multiples of   
10. that way if you wanted a line between 10 and 20 for instance, you    
could just name it 15. you could copy a line to another number by        
displaying it and writing the new number over the old, but if you had a  
50 line program and all the numbers were increments of 1, not 10, the    
need to insert a new line left you in a bad place! :)                    
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
6 of 14                                                                  
                                                                         
now you have a bit of basic history. you youngsters don't know how       
spoiled you are!                                                         
                                                                         
something you'll really want to know if you're going to use goto: when   
you get stuck in a loop, you can stop the program from running by        
holding down CTRL and hitting the C key... failing that-try CTRL + BREAK 
(not now! it might stop this program, too!) this is better than the      
CTRL + ALT + DEL, that will end puppybasic as well, or restart your 
computer.                           
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
7 of 14                                                                  
                                                                         
GOSUB should be used to replace GOTO when possible. by modern standards, 
the regular use of GOTO is not considered good coding. GOSUB is slightly 
more tricky, but much more useful.                                       
                                                                         
the first thing you want to do is make a stopping point between your     
main program and your subroutines. for the purpose of introduction, a    
subroutine is a part of your program that is branched to using GOSUB     
and left by using RETURN. subroutines are like miniature programs        
themselves.                                                              
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
8 of 14                                                                  
                                                                         
for now, put:                                                            
                                                                         
END                                                                      
                                                                         
at the end of your program, to make the program stop. AFTER the END      
statement, put all your subroutines.                                     
                                                                         
for instance, here is a subroutine to clear the screen, greet the user,  
and change the color back to white:                                      
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
9 of 14                                                                  
                                                                         
starting:                                                                
CLS: COLOR 10                                                            
? "**  program that does nothing but start  **"                          
? "    2005 by mennonite"                                                
COLOR 7                                                                  
?                                                                        
RETURN                                                                   
                                                                         
from inside your main program, that is, before the end statement, use:   
                                                                         
GOSUB starting                                                           
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
10 of 14                                                                 
                                                                         
and it will run the code in the subroutine, then come right back to      
where it left off-just after the GOSUB command! you get all that? again: 
                                                                         
GOSUB starting: END                                                      
starting:                                                                
CLS: COLOR 10                                                            
? "**  program that does nothing but start  **"                          
? "    2005 by mennonite"                                                
COLOR 7                                                                  
?                                                                        
RETURN                                                                   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
11 of 14                                                                 
                                                                         
this is one of the most important features of programming in languages   
like puppybasic. make sure you become comfortable, when you write a 
longer program it's almost impossible to do without these subroutines. 
                                                                         
so why did we make the program stop before the subroutines were run? we  
didn't, actually, the subroutine ran... only if your program gets to the 
end and then starts running the subroutines that follow, it will         
encounter the RETURN statement without having any GOSUB calling the      
routine... the program will think: (and this is how stupid computers     
really are...) "RETURN? return to where?!" and have a fit and refuse to  
do more. it's not usually dangerous, but it makes you look incompetent.  
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
12 of 14                                                                 
                                                                         
REM this won't do anything                                               
                                                                         
the old way to add comments to your program code! and it still works...  
but it's even easier to use an apostrophe.                               
                                                                         
' this won't do anything either                                          
                                                                         
REM but more importantly, you can put this '                             
                                                                         
atthe = endof * aline - 1 'instead of                                    
' the beginning of a new one                                             
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
13 of 14                                                                 
                                                                         
' comments are good to use, because when someone else looks at your      
' code, they have a Much easier time figuring out what it all does.      
                                                                         
(and sometimes, when you're looking at a program you wrote a long time   
ago, you'll wish there were comments there.)                             
                                                                         
i usually don't do much with comments until version 2, (0.2 or 0.4 or 5  
if there are betas ;) because if my program is good enough to show       
people, it's good enough to make a version 2 of, and like too many       
people, i'm sort of lazy about comments. please consider the merits of   
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
branching within the program
14 of 14                                                                 
                                                                         
doing what i say, not what i do :) all the same, know you can get flamed 
(that is, people may be uncharitable ;) if rarely, online if you write   
code that's hard for other people to understand without enough comments. 
don't go nuts though, too many comments can be annoying, also. (not as   
many will complain about this.)                                          
                                                                         
of course, a really good rule would be: ALWAYS put a comment at the top  
of your program that at least says what your program does. you'll go far 
that way.                                                                
                                                                         
                        -= end of chapter 10 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                      (chapter 10) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 09 - working with binary files

2007-02-02T15:35:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
working with binary files                                        
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 9: working with binary files                   
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
2 of 7                                                                   
                                                                         
it might be fun at this point to learn how to save and load some data in 
a file, but this will be much more useful when you've learned about      
decision making and loops. in the meantime, here is how to work with     
binary files:                                                            
                                                                         
first of all, be sure to use this statement at the beginning of your     
program:                                                                 
DIM bt AS STRING * 1                                                     
                                                                         
so that you have a one byte string to work with. you can make longer     
strings, but this one will work for any purpose.                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
3 of 7                                                                   
                                                                         
always open the file :)                                                  
                                                                         
OPEN "filename.txt" FOR BINARY AS #1                                     
                                                                         
if you are only going to read the file, you dont strictly need the bt    
variable, and therefore don't need to DIM at the start of your program.  
just INPUT a byte:                                                       
                                                                         
b$=INPUT$(1, #1)                                                         
                                                                         
and that's all there is to that. yes, it IS similar to keyboard input.   
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
4 of 7                                                                   
                                                                         
do it again to read the next byte. usually, you'll probably want to use  
this method instead:                                                     
                                                                         
GET #1, q, bt                                                            
with q being the byte of the file you want to read... if q is 57, then   
it will read the 57th byte of the file.                                  
                                                                         
to write, use:                                                           
PUT #1, q, bt                                                            
where b is a string that's only one byte (or letter) long. it's pretty   
much the same idea. some useful functions for working with files are:    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
5 of 7                                                                   
                                                                         
q = FREEFILE                                                             
                                                                         
sets q to the number of the next filenumber that's free... if you've     
opened a file as #1, and a second file, as #2, then FREEFILE will equal  
3.                                                                       
                                                                         
LOC(n)                                                                   
                                                                         
is the byte you're set to read or write at. if you've used INPUT$(1, #1) 
                                                                         
50 times already, LOC(1) will be 51.                                     
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
6 of 7                                                                   
                                                                         
LOF(n)                                                                   
                                                                         
is worth remembering, LOF(n) is equal to the length of file #n, if you   
open a file as #1 and the LOF(1) is 0, that file is empty.               
                                                                         
always close the file when you're done working with it:                  
                                                                         
CLOSE #1                                                                 
                                                                         
if you are only working with one file, or if you don't have any other    
files that you need to leave open, using close with no file numbers:     
                                                                         
                                                                         
........................................................................ 

........................................................................ 
working with binary files                                        
7 of 7                                                                   
                                                                         
CLOSE                                                                    
                                                                         
will close all files.                                                    
                                                                         
                                                                         
                         -= end of chapter 9 =-                          
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 9) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 08 - strings part ii

2007-02-02T15:30:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
strings part ii:  searching and manipulation                              
1 of 8                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 8: strings part ii                              
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
2 of 8                                                                   
                                                                         
although you could find a better routine to do the same thing, INSTR is  
a very fast and simple way to see if and when a string exists as part of 
a larger string: for instance:                                           
                                                                         
suppose q$ is storing the string:                                        
"the quick brown fox jumped, and stuff."                                 
                                                                         
and you want to know if the string (let's pretend you don't know what q$ 
is; maybe it's from a file or the keyboard.) contains the word "fox" so  
you code:                                                                
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
3 of 8                                                                   
                                                                         
n = INSTR(q$, "fox")                                                     
                                                                         
n will be equal to the number of letters, numbers, and punctuation that  
you have to read before you've started reading "fox"... in this case,    
the "f" in "fox" is the 17th byte in q$, so INSTR will set n to 17. if   
the string "fox" is not found in the string that q$ is storing, n will   
be set to 0.                                                             
                 1                                                       
 123456789012345 7 90123456789012345678                                  
"the quick brown fox jumped, and stuff."                                 
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
4 of 8                                                                   
                                                                         
SPACE$                                                                   
                                                                         
is really, really easy to use. SPACE$(n) is a string of ascii 32 (space) 
that is n bytes long. q$=q$+SPACE$(10) will add 10 spaces to the end of  
q$.                                                                      
                                                                         
LEFT$ and RIGHT$                                                         
                                                                         
are not as powerful or complete as MID$ but are slightly easier to use.  
skipping straight to examples, LEFT$("Seventy",5) is "Seven" and         
RIGHT$("elephant",3) is "ant". MID$ is similar:                          
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
5 of 8                                                                   
                                                                         
the syntax for the MID$ function is:                                     
                                                                         
MID$(q$, whichbytetostartat, howmanybytes)                               
                                                                         
so n$=MID$("hello", 2, 4) would set n$ to "ello" and                     
n$=MID$("yeah, or... something", 14, 2) would set n$ to "om".            
                                                                         
there is a MID$ statement as well, which works the same way, except      
instead of reading a string it will rewrite it:                          
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
6 of 8                                                                   
                                                                         
y$="yeah, or... something"                                               
n$=SPACE$(2)+"no"                                                        
                                                                         
MID$(y$, 13, 4)=n$                                                       
                                                                         
will store "yeah, or...   nothing" in y$. the 4-byte "some" has been     
replaced with 2 spaces and "no", changing "something" to "  nothing".    
whoosh!                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
7 of 8                                                                   
                                                                         
if you do not like the MID$ statement for rewriting, it is totally       
possible to avoid it entirely using only the MID$ "reading" function     
and concatonization of strings.                                          
                                                                         
there are times (especially with code like the first menu routine,       
earlier) when your variable will have leading or trailing spaces that    
you don't want. when you use STR$(n) to convert a numeric variable to a  
string for instance, it will contain a leading space (if it is at least  
zero) for a plus sign, even though the plus sign will never show. if the 
number drops below zero, a negative sign will show, but otherwise, you   
may be stuck with a space you don't want, like this: " 55".              
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part ii:  searching and manipulation                              
8 of 8                                                                   
                                                                         
LTRIM$(STR$(n))                                                          
                                                                         
will remove the leading spaces from a number, and LTRIM$(RTRIM$(q$))     
will remove the spaces from both ends of any string. this is not only    
useful when changing numbers to strings, but also when accepting         
keyboard input or data from files.                                       
                                                                         
                                                                         
                         -= end of chapter 8 =-                          
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 8) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 07 - keyboard and data lines

2007-02-02T15:28:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
keyboard and data lines                                                  
1 of 15                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 7: keyboard and data lines                     
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
2 of 15                                                                  
                                                                         
let's get DATA statements out of the way, since i find them irritating,  
although you'll want to know how they work when you see them in someone  
else's code.                                                             
                                                                         
DATA statements (though as i said, i don't like them) are easy enough to 
use.                                                                     
                                                                         
anywhere in the main module of the program (don't even worry about what  
that is) put the statement DATA followed by the strings or numbers you   
want read, separated by commas:                                          
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
3 of 15                                                                  
                                                                         
DATA ugh., data, statements-, that takes, me back.                       
                                                                         
READ q$: ? q$;  ________________________________________________________ 
READ q$: ? q$;  _ugh.datastatements-that takesme back.__________________ 
READ q$: ? q$;  ________________________________________________________ 
READ q$: ? q$;  ________________________________________________________ 
READ q$: ? q$;                                                           
there are better ways, but this works. if you use DATA statements, you   
may find that you want to put something unique as the last string or     
number so that your routine can "know" when it's done reading, but       
you'll need loops and decision making (covered later) to pull it off.    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
4 of 15                                                                  
                                                                         
if you READ a number of times greater than your number of data entries,  
you get an error and your program stops. to avoid this, don't read a     
greater number of times than your number of entries. (heh.) along with a 
unique last entry, you can reread from the beginning of your data        
statements. (puppybasic looks at all of them together, from the 
beginning of your program to the end, as one long data statement) by 
putting an old fashioned line number (like 20) before your first data 
statement, which then allows you to use the command:                                      
                                                                         
RESTORE 20                                                               
                                                                         
                                                                         

........................................................................ 

........................................................................ 
keyboard and data lines                                                  
5 of 15                                                                  
                                                                         
whenever you want to reread. you can also move to different places (in   
your single virtually continuous data line) but putting line numbers     
between DATA statements:                                                 
                                                                         
RESTORE 70: READ b$: PRINT b$ + ",";: READ b$: PRINT b$; "."             
                                                                         
50                      ________________________________________________ 
DATA 5,6,7,8,9          _ok,that's enough.______________________________ 
70                      ________________________________________________ 
DATA ok, that's enough  ________________________________________________ 
                        ________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
6 of 15                                                                  
                                                                         
i think the most versatile way to get keyboard input is with the INKEY$  
function, but it doesn't wait for input: it just says "hey! keyboard,    
what's happenin'?" and unless a key has been pressed already the         
keyboard just says "..." and INKEY$ returns an empty, 0-length string... 
not even a space, just the nothing between two quotes, side by side: "". 
                                                                         
there's nothing wrong with this, it's just that INKEY$ only works in a   
loop, so i'll demonstrate INKEY$ after showing how loops work. in the    
meantime, INPUT$(n) is similar, and not too shabby. i'll show you that   
momentarily. in order to appreciate the simple beauty of INPUT$(n) you   
have to see the alternatives:                                            
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
7 of 15                                                                  
                                                                         
INPUT "", q$                                                             
                                                                         
you can put stuff in the quotes, and then it's like a PRINT statement,   
but i prefer using PRINT to print and INPUT for input. one advantage of  
separating the two is that you can put the instructions and the visible  
end of the keyboard input on separate lines or different locations on    
the screen. i'm really trying to set a good example here by showing      
INPUT used with a comma - you could use a semicolon:  INPUT ""; q$       
                                                                         
but INPUT "please type your name - "; q$  ______________________________ 
will show up on the screen like this:     _please type your name - ?____ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
8 of 15                                                                  
                                                                         
because as we all know the ONLY way to get information from the user is  
in the form of a full sentence followed by a question mark :|            
                                                                         
ah well. this is why using a comma is better.                            
                                                                         
of course, i don't actually recommend using the INPUT statement, ever.   
LINE INPUT is used the same way you just learned (see? that wasn't in    
vain) but is more reliable. i'll explain:                                
                                                                         
say for instance, you used this code:                                    
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
9 of 15                                                                  
                                                                         
INPUT "enter your name - ", n$     _____________________________________ 
and say for instance, he entered:  _enter your name - smith, john q.____ 
                                   _____________________________________ 
then he would see this message:    _REDO FROM START?____________________ 
                                   _____________________________________ 
great! what?                       _____________________________________ 
                                                                         
it's because he typed a comma. the INPUT statement is designed so that   
you can get more than one piece of data from the same prompt, separated  
by commas, like this:                                                    
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
10 of 15                                                                 
                                                                         
INPUT "please enter three numbers, put commas between the first          
and second, and also between the second and third, and don't forget      
them, and don't put too many, or my input routine will yell at you.      
thanks. ", a, b, c                                                       
                                                                         
assuming your plucky user gets it exactly right, the clever INPUT        
statement will save an extra line of code.                               
                                                                         
                                                                         
Bad Design!                                                              
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
11 of 15                                                                 
                                                                         
so i never use the INPUT statement. ever. instead i use this when i want 
a no fuss, two line method of getting keyboard input (there are better   
ways using INKEY$, remember?)                                            
                                                                         
PRINT "please enter your name. as long as your name has less than 250    
characters and doesn't contain carriage returns, we shouldn't have any   
problems:": ?: line input n$                                             
                                                                         
all this is okay, for typing in a line of data and hitting enter. if you 
have a menu on the other hand:                                           
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
12 of 15                                                                 
                                                                         
1. do something                                                          
                                                                         
2. do something else                                                     
                                                                         
3. do something entirely different                                       
                                                                         
4. exit                                                                  
                                                                         
then the following prompt might seem reasonable:                         
                                                                         
? "please enter your selection - ";: LINE INPUT q$                       
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
13 of 15                                                                 
                                                                         
but i think this is better:                                              
                                                                         
1. do something                                                          
                                                                         
2. do something else                                                     
                                                                         
3. do something entirely different                                       
                                                                         
? "select an option (1-3) or hit [esc] to exit :)": q$=INPUT$(1)         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
14 of 15                                                                 
                                                                         
now q$ will be exactly one byte long and be a 1, or 2, or 3, or esc      
(esc is ascii 27.) it might be something else, but you can check to see  
if it's one of the acceptable options, and repeat until it's a key you   
are looking for. yeah, i'll get to looping.                              
                                                                         
you can also change the "1" in INPUT$(1) to another number, 5 for        
instance, if you want exactly 5 keys input to the program. this too, is  
bad design because the person can't see what they're typing, and can't   
backspace if they hit a wrong key.                                       
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
keyboard and data lines                                                  
15 of 15                                                                 
                                                                         
usually, i'll use INKEY$. in a loop, INKEY$ can act just like INPUT$(n)  
if you want it to and can detect arrow and function keys as well.        
                                                                         
                                                                         
                         -= end of chapter 7 =-                          
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 7) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 06 - more with text

2007-02-02T15:26:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
more with the text screen                                                
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 6: more with text                   
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
more with text                                              
2 of 7                                                                   
                                                                         
with PRINT, COLOR, and CLS already covered, here are some more ways to   
work with the text-only screen:                                          
                                                                         
LOCATE y                                                                 
will tell puppybasic to start printing on row y of the screen.               
                                                                         
or                                                                       
                                                                         
LOCATE y, x                                                              
well tell puppybasic to print at row y, column x. x is usually 1 to 80.      
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
more with text                                               
3 of 7                                                                   
                                                                         
though it flies in the face of cartesian graphs, descartes was a bit of  
a jerk after all, and it makes enough sense to address text as row,      
column. the LOCATE command lets you do this, but you may not be able to  
do anything on the bottom row (this tends to be the 25th one) unless     
your PRINT command uses a semicolon;                                     
                                                                         
LOCATE 25, 1                                                             
PRINT "print with a semicolon on the end to print on the bottom row.";   
                                                                         
________________________________________________________________________ 
_print with a semicolon on the end to print on the bottom row.__________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
more with text                                                
4 of 7                                                                   
                                                                         
also, making the cursor fly back and forth can be sort of annoying, so:  
                                                                         
LOCATE y, x, 0 ...makes it go away and (when you want it to show where   
someone is going to be typing, for instance)                             
                                                                         
LOCATE y, x, 1                                                           
makes it come back. 
                                                                         

                                                                         


                                                                         
........................................................................ 

........................................................................ 
more with text                                                 
5 of 7                                                                   
                                                                         
now that you are thinking in terms of coordinates,                       
                                                                         
CSRLIN                                                                   
represents the row the cursor is on, and                                 
                                                                         
POS(0)                                                                   
represents the column. if you print something to the screen, let         
a = CSRLIN and b = POS(0), LOCATE to some point on the screen (say the   
top lefthand corner,) PRINT something there and then LOCATE a, b, you    
will then pick up where you left off. this sort of thing can be useful   
for status bars.                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
more with text                                                 
6 of 7                                                                   
                                                                         
VIEW PRINT                                                               
                                                                         
is odd but i find it useful: where the text-only screen usually has 25   
rows, you can force smaller ranges. VIEW PRINT 10 to 17 keeps the text   
currently displayed on all 25 lines, but when you print within lines 10  
to 17 it will only scroll within (and change) lines 10 through 17.       
                                                                         
q = SCREEN (y, x)                                                        
will set the variable q to the ascii value of whatever character is at   
position y, x, so that you can not only print to the screen, but read    
from it as well.                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
more with text                                                
7 of 7                                                                   
                                                                         
WIDTH columns, rows                                                      
                                                                         
can be useful, but what you can enter as acceptable values for columns   
and rows depends on what screen mode you're using. in text only mode,    
                                                                         
WIDTH , 50                                                               
gives you twice as much top-down room to work with (try 43 too), but     
                                                                         
WIDTH 40 (horizontal) doesn't work reliably. this is covered later with  
the SHELL command.                                                       
                         -= end of chapter 6 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 6) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 05 - strings part i

2007-02-02T15:21:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
strings part i:  the indispensable                                       
1 of 7                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 5: strings part i                              
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
2 of 7                                                                   
                                                                         
although you need to talk to the computer to write a program, and you    
usually need math to talk to the computer, you usually need strings      
(which may contain plain english) to talk to the person using the        
computer. for this and other reasons, strings are generally as vital to  
your program as numbers. here are some statements to work with strings:  
                                                                         
UCASE$                                                                   
                                                                         
q$=UCASE$(q$) will convert q$ to an all uppercase copy of itself. the    
lowercase version is:                                                    
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
3 of 7                                                                   
                                                                         
LCASE$                                                                   
                                                                         
q$=LCASE$(q$) when you've printed "press q to quit" can be the           
difference between a person being able to exit your program when they    
want to and being able to a bit later (when someone points out that      
their caps lock light is on.) it is possible to turn off someone's caps  
lock for them using program code, but processing strings with LCASE$ is  
easier and more considerate.                                             
                                       _________________________________ 
q$="NAME@PUPPY.Com": PRINT LCASE$(q$)  _name@puppy.com__________________ 
                                       _________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
4 of 7                                                                   
                                                                         
CHR$ is indispensable: there are 256 different ASCII characters, (for    
example, the lowercase letter "a" is ASCII 97, and a space, like from    
the spacebar, is ASCII 32.) including letters, numbers, punctuation, and 
other fun symbols (ASCII 01 is a smiley face. ☺ for the most part, the   
only way to produce some of them is with CHR$. for instance, if you want 
to produce a double quote on the screen, or within a string, you can use 
the following code: (put it all on the same line, of course...)          
? "i have been learning about puppybasic from "+CHR$(34)+"an intro to 
puppybasic"+CHR$(34)+" and it's okay..."                  
                                                                         
...as ASCII 34 is the same double quote you would get from the keyboard. 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
5 of 7                                                                   
                                                                         
+------+---------------------------------------------------------------+ 
| CHR$ | also lets you "print" shadows and lines using text symbols... | 
+------+---------------------------------------------------------------+ 
the reverse of CHR$, the ASC function, gives you the code number for the 
first byte of a string:                                                  
                                                                         
? ASC("a") -3  _________________________________________________________ 
will print:    __94_____________________________________________________ 
               _________________________________________________________ 
                                                                         
as ascii 97, in puppybasic coded as: CHR$(97) is "a", and 97 -3 is 94.       
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
6 of 7                                                                   
                                                                         
LEN... n = LEN(q$) will set n to a number equal to the number of bytes   
in a string - examples: LEN("hello") is equal to 5, LEN("how are you?")  
is equal to twelve. spaces and punctuation count.                        
                                                                         
lastly, as you can convert a string to a number using VAL, you can       
convert a number to a string using STR$ so:                              
                                                                         
sp = 5                                                                   
q$ = "you pressed spacebar" + STR$(sp-1) + "times."                      
                                                                         
will store the string: "you pressed spacebar 4 times." in q$.            
                                                                         
                                                                         
........................................................................ 

........................................................................ 
strings part i:  the indispensable                                       
7 of 7                                                                   
                                                                         
you are well on your way to learning puppybasic! the best thing you can 
do with this tutorial is read it slowly, think about each page and what  
kind of program you could write with each command, and experiment with   
the code in puppybasic (type it in, you learn faster that way, even 
though you *could* cut and paste...) for a feel of what coding is really 
like.  
                                                                         
and never forget to have fun.                                            
                                                                         
                         -= end of chapter 5 =-                          
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 5) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 04 - numbers are key

2007-02-02T15:20:00.001-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
numbers are key                                                          
1 of 14                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 4: numbers are key                             
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
2 of 14                                                                  
                                                                         
noooo! not math!                                                         
                                                                         
seriously, everything a computer does is enumerating and counting;       
math can't be avoided, but most of the time it will not be painful.      
in programming, colors are numbers, sounds are numbers, letters are      
numbers, and numbers are the difference between a program that does      
something and a program that doesn't; so here are some ways to work      
with them...                                                             
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
3 of 14                                                                  
                                                                         
first of all, operations: use of x+y adds the two, use of x-y            
subtracts y from x, x*y gives the product, and a forward slash, "/"      
will divide. exponents use the notation x^y, where x is raised to        
the power of y.                                                          
                                                                         
math works well with variables:                                          
                                                                         
x = 7                                                                    
y = x * 5            ___________________________________________________ 
PRINT "7 times 5 ="; _7 times 5 = 35____________________________________ 
PRINT y              ___________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
4 of 14                                                                  
                                                                         
you can use parentheses in puppybasic the same way you use them in           
equations on paper, (except of course that you will want to enter        
them with a keyboard, not a pencil.)                                     
                                                                         
moving on, ABS(x) automatically converts any value below zero to the     
same value over zero, if you like. yes that's right, it just removes     
the little line from a negative number.                                  
                                                                         
q = ABS((5 / 7) * -1) __________________________________________________ 
PRINT q               __.7142857________________________________________ 
                      __________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
5 of 14                                                                  
                                                                         
INT                                                                      
                                                                         
is similar in its simplicity to ABS but more likely to prove useful,     
INT(x) does nothing to integers at all. if x is not an integer however,  
INT will force it to become one, eliminating the fraction (or decimal).  
chances are, if you stay with puppybasic you will be using this 
function, so go ahead and make yourselves aquainted.                                  
                                                                         
PRINT INT(7 / 3); INT(-4.9); INT(4.9) __________________________________ 
                                      __2_-5__4_________________________ 
                                      __________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
6 of 14                                                                  
                                                                         
MOD                                                                      
                                                                         
is a weird function with a weird name. (it stands for "modulus.") it     
forces a long set of numbers into a smaller set: say you have a number   
like... 42 (and why wouldn't you?) but you want a number in the range    
between 0 and 15, because the number is *supposed to* represent a        
color. you could of course reject any number over 15 and set it as 15,   
or you could instead say 42 MOD 16 (much, much more useful with          
variables, and even loops or counters) which will invariably (heh)       
give you a number in the range 0 to 15. let's illustrate with smaller    
numbers and see if it makes sense:                                       
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
7 of 14                                                                  
                                                                         
              ____________                                               
PRINT 0 MOD 7 __0_________                                               
PRINT 1 MOD 7 __1_________                                               
PRINT 2 MOD 7 __2_________                                               
PRINT 3 MOD 7 __3_________                                               
PRINT 4 MOD 7 __4_________                                               
PRINT 5 MOD 7 __5_________                                               
PRINT 6 MOD 7 __6_________                                               
PRINT 7 MOD 7 __0_________ again!                                        
PRINT 8 MOD 7 __1_________                                               
              ____________                                               
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
8 of 14                                                                  
                                                                         
the most fun you can have with modulus is in graphics routines, while    
its best purpose may be handling (really) long division. if you never    
use it, well, that's one less thing.                                     
                                                                         
i'll follow this odd numeric function with one that could be the hardest 
to avoid using...                                                        
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
9 of 14                                                                  
                                                                         
VAL                                                                      
                                                                         
n = VAL(q$) turns the string q$ into the value n, so the string          
" 0.557" becomes a simple .557, to the program: something which can      
be added to, subtracted from, and otherwise used as a number, which      
strings (otherwise) cannot. this is priceless when working with data     
from files and the keyboard.                                             
                                                                         
q$ = "27a"                                  ____________________________ 
PRINT VAL("hi there"); VAL(q$); VAL("4.91") __0__27__4.91_______________ 
                                            ____________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
10 of 14                                                                 
                                                                         
if you need a sufficiently "random" number, for dice, a "magic"          
8-ball, or just a cool display on the screen, using the RND function     
with INT and the number of "sides" you want:                             
                                                                         
n = INT(RND * 6)                                                         
                                                                         
will return a number 0 to 5, and you can have each number represent      
the side of a die or anything you like.                                  
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
11 of 14                                                                 
                                                                         
prefer 1 to 6? why not?                                                  
                                                                         
n = INT(RND * 6 + 1)                                                     
                                                                         
will return numbers more specifically useful to dice. (you may be        
thinking, "why not 'RND * 7'?", and the simple answer is "'cause it's    
wrong!"                                                                  
                                                                         
the useful answer is that RND * 6 + 1 produces a number of 6 possible    
numbers, with 1 added to that number, but RND * 7 actually creates a     
7-sided die, something i've never seen in my life.)                      
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
12 of 14                                                                 
                                                                         
you will find that even if rolled 100 times, the 100 results you get     
will be the same 100 results every time you use the program. to get      
around this, the code RANDOMIZE TIMER will "seed" the RND function.      
then all you have to do to roll the same dice twice is start at          
precisely the same time of day as last time, to the millisecond,         
accounting also for the fact that the clock circuit in your computer     
is probably not as accurate a timepiece as your digital wristwatch,      
even if you can set it from the atom clock: and good luck to you.        
                                                                         
RANDOMIZE TIMER                                                          
? "this number will be random enough:"; INT(RND * 10)                    
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
13 of 14                                                                 
                                                                         
q = SGN(n)                                                               
                                                                         
will set q to -1 if n is less than 0, set q to 0 if n is 0, and set      
q to 1 if n is more than 0. i've used this, but not that often.          
                                                                         
SQR(n)                                                                   
                                                                         
is the square root of n, and is almost always easier to use than a       
pencil and paper.                                                        
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
numbers are key                                                          
14 of 14                                                                 
                                                                         
i use these to do neat things with graphics, maybe you can find some     
other use for trig. here are some of the trig functions:                 
                                                                         
cosine: COS(n)                                                           
sine: SIN(n)                                                             
tangent: i'm just thrilled with the program i made using this, it...     
                                                                         
sorry, i meant to say TAN(n)                                             
n is the angle in radians. radians are equal to degrees * pi / 180.      
                                                                         
                         -= end of chapter 4 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 4) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 03 - variables

2007-02-02T15:18:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
variables                                                                
1 of 9                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 3: variables                                   
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
2 of 9                                                                   
                                                                         
variables are the easiest way to store data in memory; of course, this   
memory is cleared when the program ends or the machine is turned off,    
but variables are useful when you want data in one part of your program  
to be available to another line in the program.                          
                                                                         
there are two main types of variables: string and numeric.               
                                                                         
string variable names start with a letter and are made of letters and    
numbers.                                                                 
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
3 of 9                                                                   
                                                                         
here is an example of a string variable at work:                         
                                                                         
q$="hello, world!"  ____________________________________________________ 
PRINT q$            _hello, world!______________________________________ 
PRINT q$            _hello, world!______________________________________ 
PRINT q$            _hello, world!______________________________________ 
PRINT q$            _hello, world!______________________________________ 
                    ____________________________________________________ 
                                                                         
this prints the contents of the string variable q$ 4 times.              
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
4 of 9                                                                   
                                                                         
strings, like those used by the PRINT statement, start and end with a    
double quote "like this." you cannot enter a string containing a double  
quote:                                                                   
"like "this example" does,"                                              
                                                                         
later on you'll learn a way around this using the CHR$ function.         
                                                                         
string variables almost always end in a dollar sign, while on the other  
hand, numeric variables often end without in any special symbol, even    
though there are other suffixes for specific types (which you usually    
wont need... but you may want them.)                                     
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
5 of 9                                                                   
                                                                         
all variables may be named with one or more letters, must start with a   
letter, and may include numbers (q2$ or q2 for example) after that.      
also, do not give a variable the same name as a statement or function    
(like "CLS") if you want your program to work.                           
                                                                         
it's worth showing that you can print a mix of strings and numbers, like 
in the example on the next page...                                       
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
6 of 9                                                                   
                          ______________________________________________ 
n=50                      __7 hello, world! 50 times.___________________ 
PRINT 7; q$; n; "times."  ______________________________________________ 
                                                                         
...and you can combine two strings into one with the + sign like this:   
                                                                         
q$="hello"                                                               
q$="oh, "+q$+" there..."                                                 
                                                                         
now the string "oh, hello there..." is stored in the variable q$.        
combining strings this way, with or without variables, is called         
"concatonization" and does not work with numeric variables.              
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
7 of 9                                                                   
                                                                         
there are a couple more things you might want to know before moving on:  
it is often preferable (in the interest of time and effort) to type a    
question mark:  ? "hello."                                               
                                                                         
instead of typing out PRINT, puppybasic will (along with many other          
interpreters and compilers) change it to PRINT for you. it won't stop    
you from using a question mark where you actually want one:              
                                                                         
? "do you want to quit?"                                                 
will change to:                                                          
PRINT "do you want to quit?"                                             
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
8 of 9                                                                   
                                                                         
also, instead of giving each statement its own line, you may often find  
you prefer to combine lines of code using a colon :                      
                                                                         
CLS: PRINT "to whom it may concern"; : PRINT ":"                         
                                                                         
will clear the screen and PRINT the following:                           
                                                                         
________________________________________________________________________ 
_to whom it may concern:________________________________________________ 
________________________________________________________________________ 
________________________________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
variables                                                                
9 of 9                                                                   
                                                                         
COLOR 10: PRINT "dear abby"; : PRINT ","                                 
                                                                         
will print:  ___________________________________________________________ 
             _dear abby,________________________________________________ 
             ___________________________________________________________ 
                                                                         
congratulations! if you have not already, you can now write your first   
puppybasic program. you will be able to do much more after reading the  
next section.                                                                 
                                                                         
                         -= end of chapter 3 =-                          
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 3) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

puppybasic intro ch. 02- learning puppybasic

2007-02-02T15:17:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
learning puppybasic                                                          
1 of 15                                                                  
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                                 
                                                                         
                  chapter 2: learning puppybasic                             
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
2 of 15                                                                  
                                                                         
when learning any programming language, the first thing to look at is a  
good tutorial, if one is available. most tutorials will include some     
variation of a "hello world" program, or a program to simply make the    
computer say "hello, world!" on the screen. the second thing to look at  
when learning a new language is program examples, where "hello, world"   
might be the most simple.                                                
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
3 of 15                                                                  
                                                                         
true to the name, b.a.s.i.c makes pretty easy work of this:                                                       
                                                                         
10 PRINT "hello, world!"  ______________________________________________ 
20 END                    _hello, world!________________________________ 
                          ______________________________________________ 
                          ______________________________________________ 
                          ______________________________________________ 
                          ______________________________________________ 
                                                                         
                                                                         



........................................................................ 

........................................................................ 
learning puppybasic                                                          
4 of 15                                                                  
                                                                         
that was the old way, that is, every line required a line number. in     
puppybasic, line numbers really don't work, and aren't needed.
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         



                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
5 of 15                                                                  
                                                                         
here is a more "modern" version of the code:                             
                                                                         
PRINT "hello, world!"                                                    
END                                                                      
                                                                         
not much difference there, of course you'll need a new way to reference 
a position inside the code, but puppybasic has several, don't worry.    
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
6 of 15                                                                  
                                                                         
the PRINT statement, which should probably be called ECHO, like it is in 
dos, "prints" to the screen. of course, before everyone had crt's (or    
lcd's) attached to their computers, the "screen" was a teletype, or an   
electric printer-keyboard combo similar enough to a typewriter, so maybe 
"print" wasn't too odd a thing to call it.                               
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
7 of 15                                                                  
                                                                         
the statement for printing to a printer incidentally, is LPRINT, of      
course this is essentially part of a dos system; not only does windows   
sometimes create problems when using LPRINT, but without windows, LPRINT 
will not print to some newer models of printers (i saw lexmark abandon   
pure-dos compatibility first, though it could have been someone else)    
and of course, will not print to usb printers. (it is possible to access 
some usb devices from dos without running windows. it is very, very      
tricky.)                                                                 
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
8 of 15                                                                  
                                                                         
the END statement simply ends the program. if there is code after the    
END statement, it will not run unless you specifically tell another part 
of the program to go there.                                              
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
9 of 15                                                                  
                                                                         
if you tell the computer to PRINT again, it will print on the next       
line... so the following code:                                           
                                                                         
PRINT "hello, world!"                                                    
PRINT "how are you?"                                                     
END                                                                      
                                       _________________________________ 
would end up like this on the screen:  _hello, world!___________________ 
                                       _how are you?____________________ 
                                       _________________________________ 
                                       _________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
10 of 15                                                                 
                                                                         
if you don't want it to go to the next line, try putting a semicolon     
outside the quote marks to the line you want to add to:                  
                                                                         
PRINT "hello, world!";                                                   
PRINT "how are you?"                                                     
                                  ______________________________________ 
which will instead produce this:  _hello, world!how are you?____________ 
                                  ______________________________________ 
you can add spaces as you like.   ______________________________________ 
                                  ______________________________________ 
                                  ______________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
11 of 15                                                                 
                                                                         
you may end up with a lot of "hello" on one screen, or you may simply    
want to start fresh. this command:                                       
                                                                         
CLS                                                                      
                                                                         
stands for "clear screen" and is a common way to start a program.        
                                                                         
CLS                                                                      
PRINT "hello!"                                                           
                                                                         
but you want more fun to really appreciate programming. let's add color. 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
12 of 15                                                                 
                                                                         
basic and puppybasic are not limited to text, but text-related functions  
are worth covering first, since they're usually easier to code and since
you can't get away from them all, even if you're writing a gui util. 
                                                                         
changing the color is easy enough, if you know how.                       
let's try this:                                                          
                 _______________________________________________________ 
CLS              _BLUE!_________________________________________________ 
COLOR 1          _______________________________________________________ 
PRINT "BLUE!"    _______________________________________________________ 
                 _______________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
13 of 15                                                                 
                                                                         
and that's what that does. colors are represented by numbers, and in the 
default text-only mode there are about sixteen of them.                  
                                                                         
here's a table:                                                          
                                                                         
0                                                                        
black   1 blue  2 green  3 cyan  4 red  5 magenta  6 brown 7 white       
                                                                         
8       9       10       11      12     13         14      15            
grey    l.blue  l.green  l.cyan  l.red  l.magenta  yellow  bright-white  
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
14 of 15                                                                 
                                                                         
you can even change colors before you go to the next letter:             
COLOR 2                                                                  
PRINT "h";  ____________________________________________________________ 
COLOR 3     _hello______________________________________________________ 
PRINT "e";  ____________________________________________________________ 
COLOR 5     ____________________________________________________________ 
PRINT "l";  ____________________________________________________________ 
COLOR 4     ____________________________________________________________ 
PRINT "l";  ____________________________________________________________ 
COLOR 1     ____________________________________________________________ 
PRINT "o"   ____________________________________________________________ 
                                                                         
                                                                         
........................................................................ 

........................................................................ 
learning puppybasic                                                          
15 of 15                                                                 
                                                                         
so you dont get confused when you see people use it, PRINT without any   
string or number or variable just prints a blank line (or stops adding   
to the end of a PRINT statement with a semicolon on the end.)            
                                                                         
                         -= end of chapter 2 =-                          
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 2) 
this content is public domain.                          
........................................................................

click here to go back to the contents page

puppybasic intro ch. 01 - what exactly is puppybasic?

2007-02-02T15:12:00.000-08:00

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.

........................................................................ 
what exactly is puppybasic?                                                  
1 of 4                                                                   
                                                                         
                                                                         
                                                                         
                                                                         
                  an intro to puppybasic                       
                                                                         
                  chapter 1: what exactly is puppybasic?                     
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
what exactly is puppybasic?                                                  
2 of 4                                                                  
                                                                        
puppybasic is a program interpreter for basic scripts, included with
puppylinux. it was developed from wx-basicscript by mark ulrich and 
jerry muelver, which in turn is based on wxbasic by david cuny.

puppybasic enables the creation of scripts that access the terminal,
files, and gui dialogs in a way that even beginners can toy with.

puppybasic lets almost anyone "write small, simple programs... without 
the elegance of huger languages (but [is so much] easier to use)." 
being mindful of its limitations, it is worth seeing some the 
lightweight utilities created using puppybasic. many of them call more
powerful apps that were written in c, but allow a quick, easy, and even
attractive interface to be built over, or between them.

                                                                         
........................................................................ 

........................................................................ 
what exactly is puppybasic?                                                  
3 of 4                                                                   
                                                                         
it can also be a lot of fun, and this tutorial was greated to help the 
reader get a foot in the door, and learn to have a bit of fun, tweaking
code and telling the computer exactly what to do. 

(a note: this tutorial is currently designed as an intro to programming,
and may not delve into creating gui's. however, a puppybasic tutorial
exists for that very task, elsewhere.)
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
                                                                         
........................................................................ 

........................................................................ 
what exactly is puppybasic?                                                  
4 of 4                                                                   
                                                                         
b.a.s.i.c. itself was designed to make programming more accessible to    
newcomers, and is probably the friendliest programming language there    
is. created at dartmouth college, it is a major part of a decades-long
tradition of hobby programming, and countless books and websites
include b.a.s.i.c. source code for you to try out on your computer.             
while basic has gone through a number of changes over the years, one     
thing is common throughout all good implementations: relative 
simplicity. this tutorial can offer you your first, second, or tenth
taste of basic programming, and help you use some of what you've 
learned, or are learning, in puppylinux.        
                                                                         
                                                                         
                         -= end of chapter 1 =-                          
                                                                         
                                                                         
                                                                         
........................................................................ 
an intro to puppybasic                                       (chapter 1) 
this content is public domain.                          
........................................................................ 

click here to go back to the contents page

an intro to puppybasic

2007-02-02T15:07:00.000-08:00

this is the first stage of a large tutorial for 
programming in basic. it's being reworked for  
puppybasic and was originally written for qbasic.  
this puppybasic tutorial is public domain, and may be  
edited, quoted, and redistributed freely.  

green text is being edited and should not be considered  
relevant to the tutorial. for a while, it will make up  
the bulk of this section.
  
black text has been edited to be more accurate with  
regards to puppybasic.  

█ chapter 01: what exactly is puppybasic?  
• chapter 02: learning puppybasic 
• chapter 03: variables 
• chapter 04: numbers are key 
• chapter 05: strings part i 
• chapter 06: more with text 
• chapter 07: keyboard and data lines 
• chapter 08: strings part ii 
• chapter 09: working with binary files 
• chapter 10: branching within the program 
• chapter 11: decision making 
• chapter 12: looping within the program 
• chapter 13: working with text files 
• chapter 14: errors 
• chapter 15: timing 
• chapter 16: arrays 
• chapter 17: other useful statements

howto upgrade pupwin98 to 2.11

2007-01-22T01:06:00.000-08:00

note: you can in fact get the necessary files to do this without downloading TWO 60-70mb files. pup4dos does what pupwin98 does... but i already have pupwin98 (which is puppy 1.07 so you know) and i still like it a lot. here's how to use it with dos grub (slightly different than pup4dos!) and the 2.11 files:

*assuming you don't have a puppy 2.11 cd:

you'll have to extract the files from the .iso file. in 2.11 (catch 22, but good for future versions?) this can probably be done in iso editor? in windows, 7zip can extract iso files. in puppy 1.07, .iso files can be mounted with qemu or dosbox. see the forum / wiki posts for details.

*assuming you do have a puppy 2.11 cd:

1. if you don't want the win98 screen on
startup anymore, type ECHO. > \logo.sys
in dos.

2. copy the pup_211.sfs on the cd to \

3. rename \puppy\vmlinuz to vmlinuz.1
copy the vmlinuz on the cd to \puppy

4. copy initrd.gz from the cd to \puppy

5. copy menu.lst to menu.txt
open menu.lst in a text editor:
change "image.gz" to "initrd.gz"

that should do it!

so far, the reasons i am considering upgrading my machine from 1.07 to 2.11:

* puppybasic goes from older version to 2.5 (it's a .pup too though i think)
* better hardware support (i have a usb key that didn't work with 1.07)
* the taskbar now includes icons / for show desktop / console / editor
* the taskbar now shows how much free ram (or is it ramdisk?) you have
* iso editor !!!!
* some of the control panel apps have dramatically improved
* new 2.6.x kernel

the newer version IS slightly slower than 1.07. on old hardware, it's something to consider. however, 2.11 will work on a wider variety of newer *and* older hardware... (the kernel in 1.07 may still be better for some older machines.)

ktwi: puppy 1.07 -> 2.11, probably versions of puppy 2.x prior to 2.11 also, but not 2.12 or later (haven't tried this with zdrv yet.)

thanks to: nevermore, amish

change clock from 24hr to 12hr in jwm and fvwm95

2007-01-20T22:06:00.000-08:00

in jwm:

1. open the /root/.jwmrc-tray using a text editor (beaver or leafpad)

2. then modify this tag ---> <Clock>minixcal</Clock>

3. to be like this: <Clock format="%I:%M %p">minixcal</Clock>

in fvwm95:

1. .fvwm95rc has a string like this *FvwmTaskBarShowDateModuleClockFormat.DATE %H:%M

2. edit that so that %H is %I instead: *FvwmTaskBarShowDateModuleClockFormat.DATE %I:%M for a 12 hour clock in FVWM95

ktwi: puppy 2.12 (probably most other puppy versions as well) with the jwm and fvwm95 window managers

thanks to: rarsa, billthefish

puppylinux: screenshot anatomy

2007-01-20T05:48:00.000-08:00

clockwise, from top right: rxvt, dillo, rox-filer, leafpad, mtpaint

rxvt: terminal window

dillo: lightweight web browser (not shown: seamonkey)

rox-filer: file manager

mtpaint: used to make this screenshot

leafpad: you will probably never find a linux app closer to (it's debatably better than) notepad

desktop: rox desktop (part of rox-filer)

taskbar (feature of joe's window manager/jwm) from left: menu button, buttons for "show desktop", rxvt, editor... pager: shows which desktop is active... buttons for each program open on the current desktop...

also on taskbar (right): volume, freememapplet (blue monitor free ramdisk or free savefile), xload (cpu usage) and clock.

ktwi: this is a screenshot of puppylinux 2.11, some of the features on the taskbar aren't available in puppy 1.x. "show desktop" doesn't work properly in version 2.13 with the newer rox-filer 2.5.

thanks to: bloodhound, amish

puppy 2.13 bugs and workarounds

2007-01-17T03:08:00.000-08:00

as with ubuntu, redhat, and certainly windows, puppy doesn't always do exactly what you'd expect it to. sometimes you messed up, and sometimes puppy messed up. it may surprise some people that puppy isn't perfect, because sometimes it comes really close!

and here's a list of niggling things that should possibly, or can easily, be repaired... or at least worked with. when possible, they will be followed by tips to help you (and maybe even devs) tweak, fiddle, and improve with the least effort possible.

thanks to those that contribute, and thanks for your patience. we do it because generally, we love puppy. so here are some bugs, and other bug-like items, (and hopefully workarounds!) found in puppy 2.13. you have to find them to fix them!

"show desktop" feature in jwm incompatible with rox 2.5, button disabled

at a guess, this may mean either that the "show desktop" button on the taskbar will NOT close rox windows, or that using the "show desktop" button will hide the rox desktop icons as well. not yet tried: enabling the button, via /root/.jwmrc-tray (it's still there, but commented out) to see what happens.

if you don't use icons on the desktop, or have removed them, or you don't use rox filer for file management, this "bug" may not affect you.

ktwi: these fixes should apply to puppy 2.13, and some will likely work in other versions.

thanks to: maurelius, amish

puppy 2.12 bugs and workarounds

2007-01-16T00:46:00.000-08:00

as with ubuntu, redhat, and certainly windows, puppy doesn't always do exactly what you'd expect it to. sometimes you messed up, and sometimes puppy messed up. it may surprise some people that puppy isn't perfect, because sometimes it comes really close!

and here's a list of niggling things that should possibly, or can easily, be repaired... or at least worked with. when possible, they will be followed by tips to help you (and maybe even devs) tweak, fiddle, and improve with the least effort possible.

thanks to those that contribute, and thanks for your patience. we do it because generally, we love puppy. so here are some bugs, and other bug-like items, (and hopefully workarounds!) found in puppy 2.12. you have to find them to fix them!

broken links in the help system

The help icon on the desktop leads to several (not all of them, at least) broken online and offline links, in Puppy 2.12 and likely a number of other versions.

Future workaround: alienjeff has started to compile a list of these broken links and provide a workaround when possible.

Meanwhile: all pages that do load properly offline should be available from your browser at: file:///usr/share/doc <- local link, only available within puppylinux

ktwi: these fixes should apply to puppy 2.12, and some will likely work in other versions.

thanks to: alienjeff, amish

changing defaultbrowser or texteditor

2007-01-14T19:47:00.000-08:00

icons on the desktop and commands like "defaultbrowser" on the command line and in scripts rely on default scripts that call the utilities (such as the web browser and text editor) to open them. the thing is, "defaultbrowser" can be changed to any browser you have installed, as can defaulttexteditor.

being able to change the defaults is very useful when for instance, you're right clicking on a text file to open it, or opening a webpage.

1a. opening the file using the terminal:

enter the following:
leafpad /usr/local/bin/defaultbrowser &

or this:
leafpad /usr/local/bin/defaulttexteditor &

making sure there is a space after "leafpad" and a space before "&"

1b. opening the file using rox:

click the "home" icon on the desktop to run rox-filer, then the up arrow (or triangle) icon in the rox toolbar to go to the / directory. click the folder icons for /usr, local, and bin, then find the icon for defaultbrowser. right click, select and "open as text"

(note that you can drag most of these icons onto the desktop.)

2. editing the file:

it will look something like this:

#!/bin/sh
exec opera "$@"

"opera" may be "mozstart" in either case, whatever you type in a terminal to start your browser, for instance:

firefox

should work here as well. so the new file will be:

#!/bin/sh
exec firefox "$@"

save the file and close the editor, and that's it!

for defaulttexteditor:

same as for the browser- the part you should change will probably be geany, beaver, or leafpad. simply replace with the name of the one you want as default, or with the name of whatever alternative you have installed.

most default... scripts work this way. just remember to leave as much of the text intact as possible, only change the part you have to.

still another way:

pizzasgood has created a utility named defaults-wizard to handle defaultscripts like these. it's available at: http://murga-linux.com/puppy/viewtopic.php?t=13429

download this, restart ice window manager or jwm from the shutdown or logoff menu, open it from the menu and click the name of the file you want to change. use the file window to locate the program you want as default.

ktwi: grafpup 104, should work in most versions of grafpup and puppy 1.x, puppy 2.x

thanks to: rarsa, amish

the pupweb

2007-01-13T18:47:00.000-08:00

what is the "pupweb?"

for starters, there is a site at http://pupweb.org providing a convenient "one-stop" url for the biggest sites related to puppylinux.

if the term were to be borrowed from there, it could be applied to all puppylinux sites collectively. and why not?

assuming that has already taken place, the "pupweb" is the collective of all sites related to puppylinux. some have software, some have documentation, some have distros and patches, and some have other things, such as "pawedcasts" - which are soundfiles you can download and listen to, similar (similar enough) to the radio.

if you have a site with puppylinux content, even a single page, please do feel free to post it in a comment below. reviews of puppy are also welcome.

each section below will link to as many sites as possible, and ideally, most sections will have a page on this blog that goes into more detail about each one. for instance: "distros" will attempt to link to all pages that mirror puppy distros, but it would be nice to have a page that even links to images on those mirrors and/or describes the different ones available.

distros** (and mirrors)

http://puppyos.com (the site of puppy creator barry kauler)

http://pupweb.org | http://grafpup.com | http://edupup.org
http://www.puptrix.org

http://puppyfiles.org/isos/ (home to muppy and barelypup 2.13)
ftp://ibiblio.org/pub/linux/distributions/puppylinux/ (main downloads)

forums
http://pupweb.org | http://murga-linux.com/puppy

documentation
http://pupweb.org
puppy linux documentation project: http://puppylinux.org/docs
official wiki: http://www.puppylinux.org/wikka
rhino's video tuts: http://rhinoweb.us
klh's stickwiki: http://www.GreenvilleRoad.com/PuppyGuide-1.html
lobster's docs: http://tmxxine.com/pm and wiki: http://tmxxine.com/Wikka/wikka.php?wakka=PuppyLinux
deutsches handbuch durch oli: (also in english) http://puppy-linux.info
howto section of murga's forum: http://murga-linux.com/puppy/index.php?f=4

software (packages, other downloads)
http://pupweb.org

pawedcasts
http://dotpups.de/podcasts
http://puppylinux.org/wikka/PawCasting

** it's worth noting that "distros" (plural) is being used here to describe multiple versions of puppy, and things based on puppy... some may be "distros" in their own right, and others only in a loose sense of the word, but if it's a version of puppy or based on puppy, or mirrors puppy iso's, it can be listed here.

ktwi: applies to all versions at different times

thanks to: ndujoe, lobstered, alienjeff, amish

bash howto for dos lovers

2007-01-12T07:38:00.000-08:00

the following is aimed at dos users that are not already extremely comfortable with the command line interface (cli) in linux, and also may be useful to linux users that aren't already extremely comfortable with the dos cli, and should be useful without or in xwin.

attrib

examples:
attrib *.*
# shows attributes of all files a h r s (archive hidden readonly system)
attrib *.txt +a
# set all txt files to have archive attribute (*.* applies only to current folder)
attrib *.* -a -h -r -s
# remove all attributes from all files
# (if you cant change attributes in dos the file is locked, or, remove -a -h -r -s at once)

in linux:
chmod
(and/or)
chattr
(and/or)
chown
examples:
chmod 777 hello.sh
# makes it so everyone can read, write, or run a file (as an executable)
# for executable files (binary and scripts) chmod 755 hello.sh is better
# chattr changes some attributes of files (somehow...)
# chown changes the owner of the file

cls

examples:
cls
# clears the screen

in linux:
#where is it? cls? clear? clr? home? cl?
#here it is:
reset
# does the whole scrolly bit over, like closing rxvt and reopening it (that part applies more to xwin of course)

copy

examples:
copy hello.txt hello.bak
# makes a backup of hello.txt
copy a:\*.txt c:\hello
# copies all files ending in .txt in a:\ to a folder called hello on the c: drive, but does not work unless folder exists
# usually, and used from the console, copy will ask before overwriting an existing file. not usually from a script

in linux:
cp hello.txt hello.bak
# same as dos example
cp /mnt/floppy/*.txt /mnt/home/hello
# assumes floppy and c: drive are at the above mount points. will create folder called hello if it doesn't exist
# cp does not ask before overwriting. using cp -i instead of just cp will force interaction (not overwrite without asking)

cd (or) chdir

examples:
a:
cd \
# changes to a drive and folder \
cd ..
# changes to parent folder
cd \hello\there
# changes to hello\there folder from \
cd there
# changes to there from current folder
cd
# displays current folder

in linux:
# virtually the same. in dos, cd/ and cd.. are okay, in linux the space is required: cd / and cd ..
# you have to use cd (instead of chdir)
# cd (nothing else) does not show the current folder in linux. pwd (print working directory) is used instead.
# to change to the "a:" drive in linux (from the gui)
# run mut from xwin (or click the drives icon) and click [scan] on fd0
# click [mount]
# from the console:
cd /mnt/floppy
# when done: click [unmount]
# click [noscan]
# you could also learn how to use mount from the console (sorry, not included in this howto)
# mut is so great, someone should make a console version that uses keys like a b c d e f g h (buttons, not driveletters!)
# (maybe barry or mu or i will make a console version someday? don't know what it entails)

del (or) delete (or) erase

examples
del *.*
del .
# (either one) deletes all files in a folder
del *.txt
# deletes all files ending in .txt
del hello.txt
# deletes hello.txt

in linux:
# be careful with * wildcards!
# if you are going to use a wildcard, use "ls [wildcards]" instead of "rm [wildcards]" to see what may be deleted...
rm *
# deletes files; if someone randomly tells you to type rm -f * or something like that, kick him. hard...
rm *txt
# deletes files ending in txt
# -r is recursive (recursion in dos and linux are not exactly the same, that's why you don't see more notes on it here)

dir

dir *.txt
# list all txt files
dir *.txt /b /a > list.txt
# list all txt files even if they are hidden. /b says just show filenames... send output to list.txt
dir /w
# show files in a multicolumn layout
dir c:\*at* /a /s
# show all files in all folders in the c drive, if the filename contains "at"
dir /?
# show more info on dir. works on many dos commands

in linux:
ls *.txt
# same as in dos, but if there is a folder called something.txt it will show that folder too, etc.
ls *.txt -1 -a > list.txt
# include "hidden" files that start with . (yeah they are hidden) in one column... send output to list.txt
ls
# this is more like dir /w
ls -l
# that's an l like in "linux" not to be confused with -1 (one) from the other example. this outputs more like dir
ls /*at* -a
# show all files containing "at" in the name, but only in the / folder, and any folders recursed that also include "at"
ls --help
# show more info on ls. works on many linux commands
# here's a really good one, thanks to jcoder24 for it:
find / -depth -name *at*
# this is much closer to dir /s /b in dos, and in xwin try it with: | leafpad &

exit

examples:
exit
# closes the console in windows

in linux:
# it's the same, but will close the apps opened from the console too.
# the way around this is to append any command with & for instance:
leafpad hello.txt &
# now hit enter a couple times (or wait a minute)
exit
# right. also, if you click [X] on the window, the & is moot... it closes apps even if they were run with &

echo

examples:
echo
# display if "echo" is on or off
echo.
# echo a blank line (useful in scripts to look nice)
echo cd \ > hello.bat
echo dir *.txt >> hello.bat
# this creates a script called hello.bat that changes to the \ folder and shows the .txt files there.
# > writes to a file (overwrite / create new)
# >> apppends to a file (append / create if not existing)
# to run the script, enter:
hello
# you can type hello.bat but the suffix is required in the name

in linux:
echo
# blank line, same as echo. in dos
echo cd / > hello.sh
echo ls *.txt >> hello.sh
chmod 755 hello.sh
# creates the same script as above and makes the script executable
# to run the script, enter:
./hello.sh
# you must type .sh at the end if it's part if the name, but you don't have to name it that way

fc

examples:
fc hello.txt hello.bak
# show the differences between the two files, if any
fc /b hello.exe hello2.exe
# do a binary comparison of files (shows differences in hex, if any)

in linux:
diff hello.txt hello.bak
# basically the same idea. for binary files, you can try just using diff
# also, you can try this:
md5sum hello
md5sum hello2

usually when two files are different, the single-line md5sum is different. file integrity checking is often done this way

move

examples:
move *.txt a:\hey
# move all .txt files to a:\hey
move hellofolder hello2folder
# rename a folder

in linux:
mv *.txt /mnt/floppy/hey
# same as above, assumes mountpoint at /mnt/floppy
mv hellofolder hello2folder
# rename a folder

md (or) mkdir

examples:
md hello
# create folder named "hello"
mkdir hello
# same thing
md /mnt/home/hello
# create "hello" folder in /mnt/home
mkdir /mnt/home/hello
# same thing

in linux:
# you have to use mkdir (instead of md)

ren (or) rename

examples:
ren hello.txt hello.bak
#rename the file to...

in linux:
mv hello.txt hello.bak

rd (or) rmdir

examples:
rd thisisafolder

in linux:
rm -r thisisafolder
# dos won't usually let you remove a folder that has files in it
# linux usually will

rem

examples:
rem hey look, this does nothing!

in linux:
# this usually does nothing!
# however, the following is used to identify a bash script:
#!/bin/sh
# the following is used to identify a puppybasic script:
#!/usr/bin/wxbasicscript
# you get the idea. technically, it STILL does nothing... but it does, however, change how a script is interpreted
# (or how a file is identified)
# all bash scripts should really start that way you know:
#!/bin/sh
# but my creation of a script using echo without that header still worked

start

examples:
start notepad
start http://pupweb.org
#this is really a windows thing... but a command preceded by "start" sometimes works when it ohterwise would not
start cmd /c dir | more
# opens a new console, runs dir and pipes to more

in linux:
# exec is somewhat, but not exactly, like start. xwin does not need to be running to use it.
# sometimes preceding a command with exec helps in .rc files when you want to run a command
# to open a website, use defaultbrowser:
defaultbrowser http://pupweb.org
# to open a new console:
rxvt &
# to run a command in a new console:
rxvt -e ls | more
# opens a new console, runs dir and pipes to more

time

examples:
time
# shows/sets current time
time 00:00:00
# sets time to midnight
# to do the same with the date:
date

in linux:
date
# shows the time (it also shows the date)

type

examples:
type hello.txt
# displays a text file
type hello.txt | more
# displays a text file with more
more hello.txt
# same as the previous example

in linux:
more hello.txt
# same as dos
less hello.txt
# "less is more" Razz less lets you scroll... (caveat, i forget how to make it stop)
more hello.txt | leafpad
# that one is fun, try with ls or find (does not work with mp)
# this seems to work:
more hello.txt | less
# the idea being more useful with things like ls and find since leafpad isnt available when xwin isn't
# if you don't love any of those, try using cat for type:
cat hello.txt

questions? other tips? ideas? (corrections?) reply!

notes:
want to wiki? lobster made a wiki page and wants to know how it can be better formatted: http://puppylinux.org/wikka/DosCli

gn2 suggests this alternative bash<->dos page: http://www.yolinux.com/TUTORIALS/unix_for_dos_users.html

also, there is a really amazing page on this subject at the linux doc project: http://tldp.org

KTWI: most of these were tried in puppy 2.11 and most should work in 1.07, nohup is available in puppy 2.12 and later.

thanks to: lobster, dougal, gn2, "chandlerman", amish

howto post to this blog

2007-01-12T06:00:00.000-08:00

firstly, please note that anything you submit to this blog is Public Domain and can be used and edited by anyone, even in a commercial project (but also in any free project.) this is easier than using for instance, the gnu fdl license, as not all the projects that benefit from this blog use that license. you can still use content from here, in gnu fdl content.

there are several ways you can post or contribute to this blog:

use the comment feature:

1. suggest a change- this is like a wiki, except you don't have to edit wiki code. all suggestions will be taken seriously, but not all suggestions will be followed. compare to wiki where no suggestions are taken seriously, and many changes are reverted. eh... wiki is good, no- great, but only if you're "in."

unless there is an important reason to remove them, suggestions will be left in place as comments even if they are not used, and they will be removed if they are incorporated into the main post.

2. comment with a url- please note that spam will be treated as spam, and (due to human imperfection and mistakes that are otherwise regretfully made) sometimes even a good url will be treated as spam :) but do feel Quite Free to post a url. if it is yours, say so and the contents will be added to the blog. otherwise, we will consider writing a blog entry ABOUT the url and its contents.

3. write a whole entry! we want to add entries to this blog. at this writing, it's unknown (by the author) how long a comment you can write. don't be bashful.

use murga's forum:

as of this writing, only one post on murga's puppylinux forum contains the string "**docme" - add this to the end of your post on the forum, and your post will be (manually) added here. it's that simple! also, if you add "**docme" to a comment on the forum, about a post you didn't write, it's just like "comment with a url" (above.) PLEASE DO NOT spam murga's forum with a post that says "docme" and contains nothing else, we're not advocating that sort of clutter.

two more things to consider:

1. (in theory) credits go to the contributers of each post- we will do our utmost (which may prove imperfect) to thank everyone involved in each post, at the bottom of each post. "thanks to:" also serves as an "i wrote this" signature:

thanks to: amish, everyone that participates *

*an example "thanks to" line.

2. ktwi: (known to work in...) if you know the version of puppy 1.07 / puppy 2.11 / grafpup 104 / muppy 006 etc, include it. many things here will work across many versions, but it's great to
note what version you are writing about :)

thanks to: amish, and You!

another documentation project? :(

2007-01-12T05:17:00.000-08:00

**another** documentation project? not necessarily, more like another way to contribute to them.

this blog was setup as an idiot-friendly* :) means of contributing and organizing (and searching for) documentation for puppylinux (and derivatives...)

* in this case, the term "idiot" is used to mean: "someone that may not be stupid, but can't be bothered with the technical work of maintaining html, wikis, etc. - similar to the line of books."

all posts may be copied elsewhere, used in your own documentation, and so on. as a result, we must ask you not to post content unless it is your writing- or unless it is already public domain. the exception being url's (web links) to pages on the net, or posts on murga's puppy forum, that you would like to see documented here. you can link to anything, as a request that it be written about.

of course this is all volunteer work, and, we can't and will not be held responsible for what you do with your machine or anyone else's.

to add something, or suggest a change, simply use the comment feature. no special formatting is required, but any special formatting will be considered. don't be shy, either- please feel welcome to donate your posts to our cause, and thanks in advance.

lastly, credits go to the contributers of each post- we will do our utmost (which may prove imperfect) to thank everyone involved in each post, at the bottom of each post, and it is at least recommended that those using this resource do the same.

also, if posssible, consider the "KTWI" (known to work in) notes... if you know the version of puppy 1.07 / puppy 2.11 / grafpup 104 / muppy 006 etc, include it. many things here will work across many versions, but it's great to note what version you are writing about :)

thanks again, and HTH!

- amish