Applesoft

New Book is a Modern Day User’s Guide for the Apple II Computer

Lincoln, IL – Jun. 18, 2012 – Author David Finnigan has written and published a paperback book covering the Apple II computer.

The New Apple II User's Guide cover

Before the Macintosh and iPod, Apple Computer became famous for its easy-to-use personal computer. The New Apple II User’s Guide covers everything from setup to programming of this important, early computer. The purpose of the book is to serve as a guide to all models of Apple II, and explain the basics of setup, programming, networking, and other specialized topics.

The first chapters deal with identifying each model of Apple and common peripherals and accessories. The next chapters are a complete introduction and coverage of how to program in BASIC. Further chapters detail advanced programming topics such as screen formatting, graphics, sound, and printing. The later chapters complete the book with specialized topics including the disk system, networking and the Internet, using the low-level machine monitor, and subjects specific to the Apple IIgs. The book is entirely up-to-date and covers all recent developments in the Apple II world.

Many appendices hold miscellaneous information of use to programmers, including a summary of all BASIC and disk commands, error messages, ASCII charts and other tables, repair and troubleshooting tips, and how to use software to transfer disks to a modern computer. The book includes a full glossary and index.

Speaking about the Apple II, Larry M. Keeran, retired Apple Service technician remarked, “It is a very good part of history. Something that is unique.” Pre-publication reviewer Ewen Wannop had praise for the book, stating that it “Fills the gaps in your Apple II knowledge, with practical instruction. A must for every Apple II user.”

The book is 796 pages long and is selling for $25. It is available for purchase at http://macgui.com/newa2guide/

The author, David Finnigan, may be contacted by email at df@macgui.com

Virtual String Memory For Applesoft

If one really thinks about it, text files are a kind of virtual memory.  You can add strings, retrieve strings.  And if the strings are of a fixed length, then you can even replace strings in a text file.

But I found the text file commands of DOS3.3 and Basic.system very slow.  Some recommendations were to save your strings to a BIN file instead. So I combined the two and created a sort of semi-Virtual memory for strings

Applesoft is limited with what it can do with variables.  The maximum value for any dimension is 32767, and the actual string space available for strings is far less.

Using my virtual string array add on, you can define up to 65536 strings including string zero.  And the maximum length of any string is 255 characters (not 256 because string zero cannot be used since it is used as an end of string marker) Strings used this way can reach Prodos’s maximum file size of 16 Mb limit (65536 x 255 = 16711680)

Advantages –
Only one virtual string array variable is created in memory with 255 characters, one master block and one single byte block is also loaded with the pointers  (the 1 block that is loaded with the actual text uses basic.systems buffer so does not take any additional space.  If the string spans 2 blocks, then the first part of the string is moved to the string space, then the 2nd block is loaded)

Text files of Prodos’s maximum files size can be created

Multiple Virtual String Array files can be created and used within the same program

Virtual Array Text files can be created using any Word Processor that can create large files  (I wrote a short applesoft program that creates a header from the text files so any string can be jumped to automatically as if it were the first string in the list)

Disadvantages – every string must be retrieved from disk although with the advent of flash cards has made the speed of drives more tolerable.
One extra file is created for the pointers.

The commands to use

& DEF VA$(0) – creates a virtual string variable and sets its length to $FF (255) and makes space in string space
& GET VA$(0-65535),”Virtual String Array filename” – gets string from file
& STORE X$,”Virtual String Array filename” – appends the string X$ to the end of the file.  If file does not exist then create it.  If file is not a Virtual Array file then return with error

Also a separate short applesoft program was created to make a header for the pointers to every string.  I used a pretty neat trick to compress the header so that only one byte is needed to point to each string instead of three and a one block master header to point to the start of each string block.

Long story short, hopefully.  One block can point to 512 strings.  so only 128 blocks would be needed to point to 65535 strings plus one master block.  The master block holds the two high bytes of the start of each of the 128 blocks so only one master block is needed.  Once one of the 128 blocks has been chosen by a little math (# of the string divided by 512 gives one of the 128 blocks)(coincidently, this same result also points to the hi bytes in the master block), a short search is then made in the found block so that each time the next byte is less than the preceding byte, a counter advances the high bytes until the start of the correct string is found.

Remember, these blocks can point to 512 strings of 255 characters, so the master pointers may also need to be incremented.  There, short and sweet.

A three byte pointer header would take 384 blocks to point to each string to reach the 16 MB limit.

One last thought for a use of Virtual String Arrays.  One String Array can have 65535 strings and multiple Virtual files can be created.

Each file can be designated as a column.  Strings can become formulas.  Are you getting the picture.

A Virtual Spreadsheet with 65535 columns by 65535 rows.  There is a good program in Nibble magazine Vol6 No8.  Dynamic functions.  It puts formulas into a string and then uses redefined DEF and VAL commands to evaluate the formula.

To recap, I have created a couple short programs to turn a Random Access Text File (RATF) into a sequential text file to save space that a RATF would need since each line of text is padded to be all the same
length.  But a sequential file has all of its text lines in a sequential order of varying length and with a terminator character to mark the end of the line.  The only way to get to each line of text is by reading each previous line to get to the line that you may want.

Question:  How do you access each line quickly without the time consuming operation of reading each previous line?

Answer:  With pointers to each line.

This has the advantages of allowing one to create sequential files with a text editor but using the text file as a RATF.  And the file size is substantially reduced due to the removal of padded characters.

To continue on with this topic of creating even smaller RATF files.

A set of short programs can compress a large text file even further.

How, you ask?

Good question.  Here’s how.

By creating a library of words from the text file and having a pointer, called a descriptor, to each word from the library.  The average word length in our English language is between 4-5 characters.  There are only a couple of single letter words  (I and a) and also not too many two letter words. (an at is if as ad ah am be by do go my no so to we).  At the worst even with a 2 byte descriptor, we are basically at a break even point for compression.

Now keep in mind, that the first occurrence of a word is stored in a library, and you don’t get any compression until that word shows up again.  And also a one, two or three byte descriptor takes up memory as well.  So on the first occurrence of a word, you actually may lose a couple of bytes.  If a document only contained one occurrence of each word, then this compression technique would be an utter disaster.

Originally, only one byte is needed to start, to point to up to 256 words from a library.  This would soon be used up as most text documents easily have more than 256 distinct words.  So once the value 255 ($FF) is encountered, this would signal the decompression program that it now requires 2 bytes to point to a word from the library.

This would give us access of up to 65536 words from our library.  This is still pretty good compression if the majority of the words stored in the library are 3 characters or more.

For the most part, a two-byte descriptor and 65536 words should cover most of the words in a reasonable sized text file.  And if needed a third byte can be used with the descriptor to access up to 16,777,216 words in our library.  Even the use of this third byte can generally reduce a file by 25% or more since a three-byte descriptor would be used to point to an average 4 to 5 byte word.

Now, punctuation is a slightly different story.  Punctuation would have to be considered one-byte words due to their usage and they may follow any character of the alphabet or any word in the library.  You can not add punctuation to a word since that would make a new word, and the occurrence of that same word with the added punctuation mark would rarely be used again throughout a document.  So, for the best compression, punctuation should be added to the library first so as to be used by the single-byte descriptor without any loss of hard drive space since a one-byte descriptor uses one byte and the punctuation mark takes up one byte.

But, there may be one boon to saving space with punctuation.

Normally, spaces are not compressed and are not needed since pointers only point to a whole word, and it is assumed that a word is followed by a space.  If a word is followed by a punctuation mark, then that space would have to be recanted and the punctuation mark inserted.

Also, usually, a punctuation mark is followed by one space, and that space would not need to be included as part of the punctuation word either, but some punctuation marks may have 2 or more spaces following it.  Since spaces are not captured as a word unless there is more than one consecutive space, you could then include those extra spaces as part of the punctuation word.  The chance of a re-occurrence of the punctuation mark with extra spaces would be quite high, therefore space can be saved and the punctuation word can be compressed, or at the very least a break even point.

Another instance of repetitive punctuation is at the end of each paragraph.  A period can be combined with one or two carriage returns to form a word. Space savings can be fairly good when punctuation marks are repeated frequently in a document.  A one-byte descriptor with a three-byte punctuation is a 66% savings.

So for the most part, compression of a fair size text document should exceed the 50% mark and may reach as high as 75%.  The document would have to be quite large to recognize any significant savings.  For example, this short lecture would not see that much of a savings in compression but it may be worth to compress even it as there are some quite large words that are used a number of times.  (Compression, characters, descriptor, document, library, punctuation).  If each of these words had a two-byte descriptor would result in 60 – 80% compression for those words.

One last note is with capital letters.  Words that contain capitals would not have to be distinguished apart from its lower case counterpart if the word is at the beginning of a sentence, but if the word falls in the middle of a sentence, and contains any capital letters, then it will have to be added to the library as a separate word.

To recap.
-A RATF file with padded characters and no compression can be quite large.
-Close to a 50% reduction in file size can be recognized by being saved as a sparse file.
-Another 50% or more can be seen by removing padded characters and saving as a sequential file and using pointers.
-And lastly, the text document may be compressed to save another 50-75% by using a library of words and having a one, two or three byte descriptor to describe the word being used from the library.

All-in-all.  A 300 block RATF file could potentially be reduced down to about 30 blocks.  That is a 10 times savings.  A must need on a computer with limited memory or hard drive space.  A lot of information can be stored in a small amount of space.

That’s it for now

NuInput 2.0 is released

NuInput, the replacement package for Applesoft’s INPUT and GET commands has been updated.  Ivan Drucker, the author of NuInput and Slammer has made the latest version 2.0,  available for immediate download from the NuInput website.

NuInput was initially introduced by Ivan at the 2010 rendition of Kansasfest (http://www.kfest.org) as part of a demonstration he did with both NuInput and Slammer. The latest version of NuInput includes a number of new features including:

  • YZ$ (ST$ template) is no longer needed
  • DELETE deletes if at end of entry, backspaces otherwise
  • PEEK(8) contains ASCII value of submit key (ctrl-key, ESC, or CR)
  • PEEK(9) contains cursor position when submitted
  • ability to submit via specifiable control characters in KC$
  • option to disable CR for entry
  • As an alternative to lines 0-19, BRUN NUINPUT.BRUN will also dynamically place NuInput in a safe memory location, and CALL 250 can activate it
  • 498 bytes total, down from 768 (saves over 1K when used with Slammer)

Changed behaviors in NuInput 2.0:

  • POKE 253 and 254 are initialized on CALL 250 if ST$ does not exist
  • uppercase characters in KL$ are case insenstive unless [+1] is set
  • line never wraps to next line on submit, even on CR
  • submitting blank entry via ESC yields empty ST$ [instead of CHR$(27)]
  • DE$ remains in its original case even if lower-to-upper is enabled
  • control characters or DEL in DE$ are displayed as carets (^)
  • if POKE 253 contains 0, it is set to 255

For more information or to download the disk image for the program, go to the NuInput website at :

http://www.ivanx.com/appleii/nuinput/

 

 

Write Applesoft Basic in Virtual Basic

A new way of writing Applesoft Basic programs has been created by Andres Lozano, known in the Apple ][ world as Loz.  Virtual Basic is a complete BASIC with all of the same operators and commands as Applesoft, except that it is written in a style much like other high level languages of the modern era.

The entire system for Virtual Basic is a series of python scripts.   If you are writing Virtual Basic programs, they can written using an external editor such as Textedit or Espresso.   The Virtual Basic website has a complete Virtual Basic to Applesoft converter so you can write your Apple ][ program in Virtual Basic and drop the converted program right into an emulator or onto an actual Apple ][. The Virtual Basic Reference Manual and everything you need is on the site and all of the scripts are free to download, modify and even re-distribute under the copyleft status (Free Art License) of the program.

Examples, manual, and converter is available on the website at http://virtualbasic.org/

Leadlight Adventure Version 1.2 Released

Wade Clarke has released an update for his Leadlight Adventure. The game itself is quite the adventure.  Your are playing a girl Belinda who’s world is slowly falling apart.  According to the Leadlight website, “15-year-old Belinda Nettle is studying at Linville Girls High School in Australia’s Blue Mountains. After falling asleep in the library one afternoon, she wakes from her mundane existence into a nightmare. Her classmates are transformed, nameless terrors seek her out across the schoolgrounds, and traps and tricks threaten her life at every turn.”

The game was originally written as part of a contest two years ago but is now available for all to play. Version 1.2 of the game fixes a number of anomalies in the previous version including:

  • There is now a sequence of moves in the dance room
  • Examining eyes now works properly in the chapel
  • It is no longer possible to accidentally score a point when attacking Maureen

Leadlight is a text adventure game based on a highly modified version of the Eamon Adventure System by Donald Brown.  The game definitely is a blast of nostalgia mixed with a bit of tough adventure.

For more information about leadlight, check out the website at:

http://leadlightgame.com

Tetris in Applesoft

By Mark Phosis

Philip Lord was looking for a basic listing of Tetris in a recent post on Comp.Sys.Apple2 and this was the program listing by Mark Phosis.  The program was written in 1992 and could definitely be optimized to run faster.

The drawing primitives are at lines 200 and 225.  It looks like the subroutine at line 800 does collision detection.

============

10  GOSUB 1000
100 W = W + 1: IF W > LV THEN W =  0: GOSUB 350
110 K =  PEEK (KB): IF K >  = H THEN POKE KC,H:K = K – H: GOSUB 300
190  GOTO 100
200 PY = PY * A2: VLIN PY,PY + A1 AT PX: RETURN
225 PY = PY * A2: HLIN X1,X2 AT PY: HLIN X1,X2 AT PY + A1: RETURN

300  ON E(K) GOTO 30000,330,340,350,360,30100
310  RETURN
330 X = X – 1: GOTO 400
340 X = X + 1: GOTO 400
350 DN = 1:Y = Y + 1: GOSUB 400:DN = 0: RETURN
360 S = S + 1: IF S / 4 =  INT (S / 4) THEN S = S – 4
400  GOSUB 500
410  GOSUB 800: IF F = 0 THEN X = XX:Y = YY:S = SS: GOSUB 420: IF DN
THEN  GOSUB 900
420  COLOR= CF: FOR PP = 1 TO 4:PX = X + X(S,PP):PY = Y + Y(S,PP):
GOSUB 200: NEXT PP:XX =X:YY = Y:SS = S:D = 0: RETURN

500  IF DD THEN  RETURN
510  COLOR= CB: FOR PP = 1 TO 4:PX = XX + X(SS,PP):PY = YY +Y(SS,PP):
GOSUB 200: NEXT PP:DD = 0: RETURN

800 F = 1: FOR PP = 1 TO 4:PY = Y + Y(S,PP): ON ( FN PC(X + X(S,PP)) >
0) GOTO 805: NEXTPP: RETURN
805 F = 0: RETURN
850 F = 1: RETURN
900 P = 10: GOSUB 30300
905 RN = 0:Y = YM
910 X = XL
920 PY = Y: IF  FN PC(X) = CB THEN950
930 X = X + 1: IF X <  = XR THEN920
940 R(RN) = Y:RN = RN + 1
950 Y = Y – 1: IF Y >  = 0 THEN 910
960  IF RN THEN  GOSUB 30400
970 Y = 0
980 X =  INT ((XR – XL) / 2) + XL

985 S =  INT ( RND (1) * NS):CF =C(S):S = S * 4
990  GOSUB 800: IF F THEN  RETURN
995  GOTO 31000

1000  DIM E(127),X(27,4),Y(27,4),R(40)
1010  TEXT : HOME : GR
1011  PRINT “WELCOME…”
1014 LM = 10
1015 XM = 10:YM = 15
1016 XL =  INT ((40 – XM) / 2)
1017 XR = XL + XM – 1
1021 A1 = 1
1022 A2 = 2
1030  DEF  FN PC(X) =  SCRN( X,PY * A2)
1040 CB = 0
1050 XX = 20:YY = 0:SS = 0

1100 KB =  – 16384
1110 KC =  – 16368
1120 H = 128
1129  REM KEYBOARD ACTIONS
1130  REM QUIT
1131 E( ASC (“Q”)) = 1
1132 E( ASC (“Q”) – 64) = 1
1140  REM MOVE LEFT
1141 E(8) = 2
1142 E( ASC (“,”)) = 2
1150  REM MOVE RIGHT
1151 E(21) = 3
1152 E( ASC (“.”)) = 3
1160  REM MOVE DOWN
1161 E(32) = 4
1162 E( ASC (“Z”)) = 4
1170  REM ROTATE
1171 E( ASC (“R”)) = 5
1172 E(13) = 5
1173 E( ASC (“A”)) = 5
1179  REM PAUSE GAME
1180 E( ASC (“P”)) = 6
1181 E( ASC (“P”) – 64) = 6
1185  GOSUB 2000
1186  GOSUB 1300
1190  PRINT “PRESS ANY KEY TO START…”
1191  PRINT
1192  PRINT “PRESS Q TO QUIT.”
1193  GOTO 31020

1299  REM DRAW THE GAME
1300  COLOR= 4: FOR I = 0 TO 19:X1 = 0:X2 = 39:PY = I: GOSUB225: NEXT
1320  COLOR= CB: FOR I = 0 TO YM:X1 = XL:X2 = XR:PY = I: GOSUB225:
NEXT
1350  RETURN

1400  DATA 1
1401  DATA 0,0,1,0,0,1,1,1
1402  DATA 0,0,1,0,0,1,1,1
1403  DATA 0,0,1,0,0,1,1,1
1404  DATA 0,0,1,0,0,1,1,1
1410  DATA 2
1411  DATA 0,1,1,1,2,1,3,1
1412  DATA 1,0,1,1,1,2,1,3
1413  DATA 0,1,1,1,2,1,3,1
1414  DATA 1,0,1,1,1,2,1,3
1420  DATA 12
1421  DATA 1,1,0,1,1,0,2,1
1422  DATA 1,1,0,1,1,0,1,2
1423  DATA 1,1,0,1,2,1,1,2
1424  DATA 1,1,1,0,2,1,1,2
1430  DATA 13
1431  DATA 1,1,0,1,2,1,0,2
1432  DATA 1,1,1,0,1,2,2,2
1433  DATA 1,1,0,1,2,1,2,0
1434  DATA 1,1,1,0,1,2,0,0

1440  DATA 9
1441  DATA 1,1,0,1,2,1,2,2
1442  DATA 1,1,1,0,1,2,2,0
1443  DATA 1,1,0,1,2,1,0,0
1444  DATA 1,1,1,0,1,2,0,2
1450  DATA 3
1451  DATA 1,1,1,0,0,0,2,1
1452  DATA 1,1,1,0,0,1,0,2
1453  DATA 1,1,1,0,0,0,2,1
1454  DATA 1,1,1,0,0,1,0,2
1460  DATA 6
1461  DATA 1,1,0,1,1,0,2,0
1462  DATA 1,1,0,1,0,0,1,2
1463  DATA 1,1,0,1,1,0,2,0
1464  DATA 1,1,0,1,0,0,1,2

1990  DATA -1
2000 X = 0:Y = 0
2010 NS = 0
2020  READ C: IF C <  >  – 1 THENC(NS) = C: FOR J = 0 TO 3: FORI = 1
TO 4: READ X(NS * 4 +J,I): READ Y(NS * 4 + J,I): NEXTI: NEXT J:NS = NS
+ 1: GOTO2020
2030  RETURN
21210 P = 1: RETURN
30000  TEXT : HOME : END
30100  HOME
30110  PRINT “GAME PAUSED.  PRESS P TO CONTINUE…”
30120 P = 1
30130 K =  PEEK (KB): IF K >  = H THEN  POKE KC,H:K = K – H:
GOSUB30200
30140  IF P THEN 30130
30150  HOME
30160  PRINT “SCORE “;SC; TAB( 21);”LEVEL “;LM – LV + 1
30170  RETURN

30200  ON E(K) GOTO 30000,30210,30210,30210,30210,30220
30210  RETURN
30220 P = 0
30230  RETURN

30300 SC = SC + P
30310  VTAB 21: HTAB 7
30320  PRINT SC;
30330  RETURN
30400 RN = RN – 1
30410  FOR C = 0 TO 32
30415  COLOR= C
30420  FOR I = 0 TO RN:X1 = XL:X2 = XR:PY = R(I): GOSUB 225: NEXTI
30430  FOR I = 0 TO 2: NEXT I
30440  NEXT C
30450  FOR I = 0 TO RN
30460 Y = R(I) + I
30470 YP = Y – 1: FOR X = XL TO XR:PY = YP: COLOR=  FN PC(X):PX = X:PY
= Y: GOSUB 200: NEXTX:Y = Y – 1: IF Y > 0 THEN 30470
30480 P = 100: GOSUB 30300
30490  NEXT I
30495  RETURN
31000  VTAB 22: PRINT
31010  PRINT ”              GAME OVER”
31020 P = 1
31030 K =  PEEK (KB): IF K >  = H THEN  POKE KC,H:K = K – H:
GOSUB31200
31040  IF P THEN 31030
31050 D = 1
31060 SC = 0:LV = LM
31070  GOSUB 30150
31080  GOSUB 1300
31090  GOTO 905
31200  ON E(K) GOTO 30000
31210 P = 0: RETURN

===========End of Listing=============

The Program They Said Couldn’t Be Written

The Aldrich brothers strike again.  Remember, folks, you read it first in Call-A.P.P.L.E..  “Convert”, by Ron Aldrich using the disk, will create a text file from an Integer BASIC program listing, call Applesoft, and presto, your program has been converted.   After Conversion, list it out and note all the lines that need to be changed to conform to the Applesoft format.

This means that the Integer commands that are not compatible with Applesoft must be changed.  For example:  TAB must be changed to HTAB and commas in INPUT statements must be changed to semicolons, etc.  The program listing is show below:

o REM “CONVERT” BY RON ALDRICH
1 REM PROGRAM LOADS INTEGER BASIC PROGRAM FROM DISK, SAVES TO A TEXT FILE ON DISK
2 REM THEN EXECUTES THAT FILE IN APPLESOFT
3 REM SOME COHMANDS WHICH ARE LEGAL IN INTEGER BASIC WILL NOT WORK IN APPLESOFT II (TAB,INPUT ••• )
10 POKE 76, PEEK (202): POKE 77, PEEK(203 )
20 DIM A$( 35 ):D$=”” : REM D$=”( CTRL) D”
30 PRINT D$;”NOMON C,I,O”
40 TEXT: CALL -936: VTAB 3: PRINT “A.P.P.L.E. PRESENTS:”: PRINT: PRINT “APPLE INTEGER BASIC – APPLESOFT II” : PRINT “CONVERSION PROGRAM”
50 PRINT: PRINT: INPUT “PROGRAM TO BE CONVERTED ?”,A$
60 PRINT D$;”LOAD “;A$
65 PRINT DS
70 POKE 33,33
80 PRINT D$;”OPEN “;A$;”FILE”: PRINT OS; -WRITE • ;A$; MFILEM
90 LIST
100 PRINT D$;”CLOSE “;A$;”FILE”
105 PRINT D$
110 PRINT D$;”OPEN I-A FILE”: PRINT D$;”WRITE I-A FILE”: PRINT “FP”: PRINT “EXEC “;A$;”FILE”
120 PRINT D$;”CLOSE I-A FILE” : PRINT D$;”EXEC I-A FILE”
130 END

WELL, RANDY???

And Now, The ROM…

By Val J. Golding

Here is a quickie about setting up the APPLESOFT ROM card.  First, as the instructions indicated, this card will function only in Slot #0 of your Apple ][.  This card allows you to make a choice of whether you want Integer BASIC or APPLESOFT to be called with Control-B after you power up.  If the switch is in the down position, APPLESOFT will be selected.  In addition, it is not necessary to change the switch position to call the non-default BASIC.  If the switch is up, hit “reset” and type C081 followed by Control-B to get Integer BASIC.  If the switch is down, hit “RESET” and type c080 followed by Control-B and return to APPLESOFT.

A Disk Utility Program

By Val J. Golding

Perhaps this may be the first disk program published for Apple’s new Disk II. If so, a feather for our cap! The “SAVE” program, listed in column two will ask the user to input the file names of six disk programs, start recording on tape and hit return. SAVE will then consecutively load from disk and save to tape, in one operation, the six named programs. A neat way to make a tape for a friend from your disk collection.

Since this program uses the Basic SAVE command under program control, it is necessary to enter the SAVE commands as something else and then go into memory and change them to SAVEs. If you don’t know how to do this, here is another routine that will do it for you. Just substitute the command TEXT where you see SAVE in the program and then add lines 1100 to 1250 as given below and RUN 1100. This will convert the TEXT commands to SAVE. After this has run, you can DELete 1100 to 1250, as they are no longer required.

This routine can be modified to change any token or ASCII character in memory to another one, and of course, the program SAVE can be modified to save however many programs you would like in one operation by adding or taking away input statements and SAVE and LOAD statements.

Remember in line 1000, Z$=”Dc”. A Control D must be within the quotes for the DOS to recognize a Disk command.

>LIST
10 REM “SAVE” BY VAL GOLDING 7/23/78
20 REM THIS PROGRAM SAVES 6 NAMED DISK FILES TO TAPE IN ONE OPERATION
50 GOTO 1000
60 POKE 0, PEEK (76): POKE 1, PEEK (77 )
70 POKE 76, PEEK (202): POKE 77, PEEK (203)
90 PRINT Z$;”LOAD “;A$
100 SAVE
180 PRINT Z$
190 PRINT Z$;”LOAD “;B$
200 SAVE
280 PRINT Z$
290 PRINT Z$;”LOAD “;C$
300 SAVE
380 PRINT Z$
390 PRINT Z$;”LOAD “;D$
400 SAVE
480 PRINT Z$
490 PRINT Z$;”LOAD “;E$
500 SAVE
580 PRINT Z$
590 PRINT Z$;”LOAD “;F$
600 SAVE
649 REM INSERT 6 CONTROL G WITHIN QUOTES
650 CALL -936: VTAB 10: TAB 10: PRINT “FILES SAVED TO TAPE”
700 POKE 202, PEEK (76): POKE 203, PEEK (77): POKE 76, PEEK (0): POKE 77, PEEK (1): END
999 REM INSERT CONTROL D WITHIN QUOTES
1000 DIM A$( 36 ), B$( 36), C$( 36 ),D$( 36 ), E$(36),F$(36):Z$=””
1010 TEXT : CALL -936: VTAB 4
1020 INPUT” FILE NAME? “,A$
1030 INPUT” FILE NAME? “,B$
1040 INPUT” FILE NAME? “,C$
1050 INPUT” FILE NAME? “,D$
1060 INPUT” FILE NAME? “,E$
1070 INPUT” FILE NAME? “,F$
1080 VTAB 20: PRINT “START RECORDING AND HIT RETURN TO SAVE THE ABOVE LISTED FILES TO TAPE”: CALL -676
1090 GOTO 60

1100 REM PRGM TO CHANGE TOKENS IN MEMORY
1150 REM EN=MEMORY RANGE TO BE SEARCHED
1200 LOCN= PEEK (202)+ PEEK (203)*256 :EN=LOCN+735
1210 REM PEEK AT VALUE OF ORIG TOKEN
1220 IF PEEK (lOCN)=75 THEN 1250:LOCN= LOCN+1: IF lOCN=EN THEN END: GOTO 1220
1240 REM POKE VALUE OF NEW TOKEN
1250 PRINT “CONVERTING “;LOCN: POKE LOCN,5: GOTO 1220

An A.P.P.L.E. Editorial

By Val J. Golding

The big news story of this issue is obviously the arrival in town of Disk II and Applesoft II ROM. Rather than do a review, we have hidden behind the pretext of an editorial to state our feelings on the failings of Disk II and A/S ROM· {I’ve got a feeling I’m failing? (Oh dear! )) Applesoft II ROM for $100 is like buying 10K of memory for less than half price, since it frees that amount of RAM for program use. Unfortunately, according to the documentation, the Applesoft ROM and disk versions are incompatible, although it is relatively easy to convert one to the other.

However, in our estimation, the nuisance factor is of prime importance, since one of the reasons for purchasing either version of Apples oft was to have it instantly accessable. One of the plans for our library was an Applesoft Pak. Now it appears we will have to make a Pak in three different versions, cassette, ROM and disk. (The documentation does not indicate whether the cassette version is compatible with either of the others.

The new Applesoft manual comes cover-less, and commences with eight pages of corrections and additions to the manual. This indicates a lack of planning by Apple Computer in rushing to get the ROM board into production without fully completing and checking the documentation. It is inexcusable for a computer system which is designed to plug in and run, and used by a pure beginner. Additionally, the HIRES color commands we found so helpful in the cassette version, DRAW, XDRAW, ROT=, SHLOAD and SCALE=, are not available in the ROM version. This means that even though one has the ROM card, one must also have the cassette version in order to use those commands.

The ab0ve shortcomings pale, however when one looks at the documentation acc0mpanying the Disk II. While the information is all there, it is arranged in more or less haphazard manner, and concrete examples are missing. Jeff Raskin (who wrote the excellent manual on Integer Basic) where are you? No doubt the instructions can be easily understood by anyone with computer background, but how about all us newcomers, Apple?

Finally, because DOS uses the COUT and KEYIN routines at $36 and $38, it is not possible while the DOS is up, to use the printer driver routine from the red manual. We have an Integral Data IP-225 printer, which works just fine at 1200 baud from the red book routine (modified), but it is not possible to run the printer without first killing the DOS. Of course, we could always get an Apple parallel printer card for $180, and that might solve the problem …

But before you change your mind about buying, let us remind you that all of the above is relatively minor and we believe both the disk and ROM are a wise investment. We would not be without either, having once had the opportunity to use them.