The Power in Powerbasic

Note: the negative and small times for single-precision multiply and divide for QB 4.0 mean that they took less time to execute than a simple assignment. Perhaps there are unnecessary checking or conversion operations going on during the simple assignment. Considering the big slow-down from QB 3.0, that seems likely.

Operation speed QuickBasic 3.0 = 100.0 (Lower numbers are better)

                                   QB 4.0  BASIC 6  BASIC 7     PB
------------------------------------------------------------------

  Empty integer loop                100.0    100.0     99.2  172.7
  Integer assignment:                98.3     98.3     95.7   88.7
  Integer add:                      163.3    166.7     90.0  156.7
  Integer subtract:                 139.4    148.5     48.5  233.3
  Integer multiply:                 127.6    118.2    117.2  144.3
  Integer divide:                   102.1    102.4    116.1  161.0
  String assignment:                101.8    102.5    100.8   94.1
  String MID$ operation:            118.4    121.3    116.0  394.3
  String concatenation:              57.6    100.2    100.3  113.1
  Single-precision assignment:     3524.2    357.3     38.5   34.7
  Single-precision add:             537.5    101.8    177.1  102.9
  Single-precision subtract:        521.6    104.3    176.3  106.2
  Single-precision multiply:        -47.2    103.5    153.2  105.0
  Single-precision divide:            7.4     47.6    180.1  130.7
  Single-precision exponential:     399.3    169.1    170.8  440.0
  Double-precision assignment:     3377.2    368.4     55.8  784.3
  Double-precision add:             313.2    109.3    150.4  151.9
  Double-precision subtract:        304.9    109.2    149.2  147.1
  Double-precision multiply:        240.0    110.3    131.8  103.6
  Double-precision divide:          268.9    144.6    169.3  154.5
  Double-precision exponential:     255.9    122.3    130.1  133.5
  Integer comparison:               124.0    100.0     98.1  112.8
  Single-precision comparison:      402.0    216.4    215.9   73.8
  Double-precision comparison:     2027.0    227.3    227.6  494.3
  Conditional int assignment:       105.8    103.5     52.5   51.2
  Conditional assignment*:          103.4     91.9     36.0   52.3
  Print 1K 70-byte strings**:        37.8     38.0     36.1   36.3

  Unweighted average performance:   500.4    136.4    119.7  176.8

  Operation speed, Basic 6.0 = 100.0

                                      QB 4.0  BASIC 7     PB
------------------------------------------------------------

  Empty long integer loop              101.2     88.2   73.5
  Long integer assignment:              94.7     89.5   97.7
  Long integer add:                    101.4     86.7   76.9
  Long integer subtract:               101.3     89.2   80.3
  Long integer multiply:               101.1     94.3   98.2
  Long integer divide:                 100.3     94.2   76.3
  Fixed string assignment:             100.9     99.5  196.2
  Fixed string MID$ operation:          97.2     98.4  610.0
  Fixed string concatenation:           99.3     84.8  689.5
  Long integer comparison:              98.5     95.4   78.1
  Print 1K 70-byte static strings**:   100.6     95.5   95.0

  Unweighted performance average:       99.7     92.3  197.4

True compilation is faster in PB. With the Microsoft products, any request to create an EXE will result in a call to the command line compiler and the separate linker. PB compiles in memory.

If you ask to create an EXE in memory, the Microsoft products are faster; they're not really compiling but converting the program to a tokenized form. The difference shows when you run the result. PB programs run at EXE speed, even in the environment. PB compiles slower because it's really compiling, but that doesn't mean it's a slug. Where QuickBasic might take 2 seconds to tokenize and start running a program, PB might take 10. The QB program might take 20 seconds to run in the environment, where the PB version might run in 5.

So, who's faster? It depends. If you often need to stop a program and rerun it with minor changes, QB might be best. But if the program is complex enough, PB might give a faster turnaround. The more complex the program, the bigger the advantage for PB. PB permits conditional compilation, too. This is a feature I'd hoped Microsoft would include in Basic 7.0.

PB's editor is much better than Microsoft's. The user interface (in my opinion) hurts the Microsoft products. The QB editor will not get out of the way, and constantly presents dialog boxes telling you of syntax errors while you're doing ordinary editing from line to line.

Another problem is that the QB editor has no line continuation character. Long lines must be viewed in parts or split into sections. This can be a nuisance because the QB editor insists on inserting spaces at nearly every opportunity. Even modestly complex lines can easily become too wide and can't be split. Additionally, the QB editor will not permit the programmer to mark a block of code and write it to a disk file, or to read a block from a disk file into the current program.

By default, the QB editor saves new programs in a special format. The format varies from release to release, and none are backwardly or upwardly compatible.

In contrast, PB works with and saves plain ASCII files, alters nothing you type, permits line continuation characters, and allows block read and write. It's just plain easier and faster to type and edit code with PB.

To be fair, I find the QB help system easier to use than PB's. That may be a factor for beginners. And, QB's instant debugging is probably better for programmers not familiar with Basic. Again, there are definite trade-offs. PB's editor is perhaps better suited to programmers with some experience in Basic.

PB's debugging options are improved over Turbo Basic's, but Microsoft still has a clearly better approach. PB's debugger is competent but clumsier and somewhat more difficult to use.

PB's debugger doesn't permit you to use function calls, but only to change the value of a variable or an expression that evaluates to a variable. Further, PB replaces PRINT USING during debugging with a series of powerful but arcane formatting commands. The result is flexible and more capable than what Microsoft delivers, but I found it confusing. The commands are reminiscent of Fortran with some C conventions. Fortunately, for most debugging sessions you'll never need to worry about formatted print for variables.

Another point that PB has in its favor is the physical size of the compiler environment. PB can be run easily on a floppy disk system. Many beginners don't have hard disks. Even if you installed every PB file on your hard disk, the total would come to just about 700K -- much less than QuickBasic 4.5, and far less than the 6 to 14 Mbytes required for Basic 7.0.

Part of the reason for the size difference: PB lacks support for OS/2 and doesn't have the ISAM file capability of Basic 7.0. Nor does PB come with the equivalent of CodeView. But I have yet to find a use for CodeView when doing Basic programming.

PB doesn't support record or file locking, either. Of all the possible disadvantages I can imagine, this is probably the most serious. While OS/2 is very much a minor market, LANs are everywhere on the increase. So far, though, fewer than 20 percent of MS-DOS machines are part of a network. Of that minority, many do not need shared file access through a user-written program; a large number share files only through networked word processors or the like. Realistically, PB's potential market should not be damaged greatly by the lack of support for shared data files. It is, however, something that I recommend be added soon.

PB's new features are a strong selling point. Its emphasis on genuinely useful enhancements, the nice editor, the faster execution in the environment, and the new data types make it an essential product for anyone seriously interested in Basic.

Neither PB nor Microsoft's Basic 7.0 is the "best" Basic compiler in every area. PB needs support for libraries, file and record locking, larger source files, user-defined types, and a better debugger. Microsoft could benefit from PB's editor and environment, new functions, larger string space, link and meta-command options, conditional compilation, and added data types.

I intend to convert several of my programs from QB and Basic 7.0 to PB. In fact, I began the process soon after getting my review copy of PB. PB's advantages in particular areas make the conversion attractive. Other programs will remain in the Microsoft dialect. I suspect that most Basic programmers will have the same experience.

If you're serious about Basic programming, you really ought to consider having both PB and one of the Microsoft products. And Turbo Basic 1.x owners will find the $59 upgrade is money well spent.

PowerBasic Spectra Publishing 1030-D E. Duane Sunnyvale, CA 94086 408-730-9291 Price: $129 Upgrade for Turbo Basic users $59 Requirements: IBM PC/compatible MS-DOS 2.0 or higher 640K RAM, one floppy drive

_THE POWER IN POWER BASIC_ by Bruce Tonkin

<a name="0189_0012">

DEFLNG A-Z
DIM t!(28)
OPEN "basnewpb.tim" FOR OUTPUT AS #1
MAP x1$$ * 1
MAP x26$$ * 26
MAP x70$$ * 70
MAP x10000$$ * 10000

'time for a raw long integer loop, executed 1,000,000 times.
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  NEXT j
NEXT i
t!(0) = TIMER - t!

'time for 1,000,000 long integer assignments.
y = 5&: z = -5&: PRINT "Long int="
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  x = y
  x = z
  NEXT j
NEXT i
t!(1) = (TIMER - t! - t!(0)) / 2

'time for 1,000,000 long integer adds
PRINT "+"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  x = x + y
  NEXT j
NEXT i
t!(2) = TIMER - t! - t!(1)

'time for 1,000,000 long integer subtracts
x = 0
PRINT "-"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  x = x - y
  NEXT j
NEXT i
t!(3) = TIMER - t! - t!(1)

'time for 1,000,000 long integer multiplies
PRINT "*"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  x = i * j
  NEXT j
NEXT i
t!(4) = TIMER - t! - t!(1)

'time for 1,000,000 long integer divides
PRINT "/"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
  x = i \ j
  NEXT j
NEXT i
t!(5) = TIMER - t! - t!(1)

'time for 100,000 fixed string assignments
PRINT "Fixed string="
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 100
  x26$$ = "abcdefghijklmnopqrstuvwxyz"
  x26$$ = "zyxwvutrsqponmlkjihgfedcba"
  NEXT j
NEXT i
t!(6) = (TIMER - t! - t!(0) / 10) / 2

'time for 100,000 fixed string MID$ operations
k = 17
PRINT "Mid$"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 100
     MID$(x26$$, k, 1) = "d"
  NEXT j
NEXT i
t!(7) = TIMER - t! - t!(0) / 10

'time for 10,000 fixed string "concatenations"
x$ = ""
PRINT "+"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 10000
  MID$(x10000$$, i, 1) = "a"
NEXT i
t!(8) = TIMER - t! - t!(0) / 100

'following are logical comparisons and operators

'time for 1,000,000 long integer comparisons
x = 5&: y = -5&
PRINT "Long int compar"
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  FOR j = 1 TO 1000
    IF i < y THEN x = 1
  NEXT j
NEXT i
t!(23) = TIMER - t! - t!(0)

'screen output: print 1,000 70-byte fixed strings
x70$$ = STRING$(70, 66)
t! = TIMER: WHILE t! = TIMER: WEND: t! = TIMER
FOR i = 1 TO 1000
  PRINT x70$$
NEXT i
t!(28) = TIMER - t! - t!(0) / 1000



'print results of benchmark
PRINT #1, "Raw long integer loop, 1,000,000 iterations:"; TAB(45); t!(0)
PRINT #1, "1,000,000 long integer assignments:"; TAB(45); t!(1)
PRINT #1, "1,000,000 long integer additions:"; TAB(45); t!(2)
PRINT #1, "1,000,000 long integer subtractions:"; TAB(45); t!(3)
PRINT #1, "1,000,000 long integer multiplications:"; TAB(45); t!(4)
PRINT #1, "1,000,000 long integer divisions:"; TAB(45); t!(5)
PRINT #1, "100,000 fixed string assignments:"; TAB(45); t!(6)
PRINT #1, "100,000 fixed string MID$ operations:"; TAB(45); t!(7)
PRINT #1, "10,000 fixed string concatenations:"; TAB(45); t!(8)
PRINT #1, "1,000,000 long integer comparisons:"; TAB(45); t!(23)
PRINT #1, "Print 1,000 70-byte strings to the screen:"; TAB(45); t!(28)
END




<a name="0189_0013"><a name="0189_0013">
<a name="0189_0014">

<a name="0189_0014">

defint a-z
cls
recordlength=152
print"Sample in-memory mailing list program demo for Dr. Dobbs Magazine."
open"r",1,"sample.dat",recordlength
field #1,recordlength as w$

'set up a flex string variable to hold the data fields
map rec$$*recordlength,10 as dte$$,25 as last$$,1 as middle$$,_
   20 as first$$,25 as address1$$,25 as address2$$,25 as city$$,_
   2 as state$$,9 as zip$$,10 as phone$$

total=lof(1)\recordlength      'number of records in the sample file
y=(fre(-1)-32000)\recordlength     'number of records that will fit in memory
if total>y then print"Not enough room for this file.":close:end

dim records$(1:y)      'ordinary string array will hold the records.

print"Please wait:reading the data file.";
propellor$="|/-\":where=pos(9)
for i=1 to total
   locate csrlin,where:print mid$(propellor$,1+i mod 4,1);
   get 1,i
   records$(i)=w$
next i
close 1
current=1

while 1
   cls
   print total;" total records of a maximum of";y
   print"Current record is #";current
   locate 4,1
   rec$$=records$(current)
   print "Date entered: ";dte$$;"     Phone:";phone$$
   print "Name: ";rtrim$(first$$);" ";middle$$;" ";last$$
   print "Address: ";address1$$
   print "Address: ";address2$$
   print "City, state, zip: ";rtrim$(city$$);" ";state$$;" ";zip$$

   locate 12,1
   print"E=enter new record D=delete current record Q=quit without saving"
   print"S=sort records       J=jump to record          X=save and exit"

   while not instat:wend:cmd$=inkey$
   locate 15,1:cmd$=ucase$(cmd$)

   select case cmd$
      case "E"
         gosub entry
      case "D"
         gosub deleterec
      case "Q"
         gosub quit
      case "S"
         gosub sortrecs
      case "J"
         gosub jump
      case "X"
         gosub exitprog
   end select
wend

entry:
   'insert new record at current position
   dte$$=date$
   line input"First name: ";first$$
   line input"Middle initial: ";middle$$
   line input"Last name: ";last$$
   line input"Address #1: ";address1$$
   line input"Address #2: ";address2$$
   line input"City: ";city$$
   line input"State: ";state$$
   line input"Zip: ";zip$$
   w$=rec$$
   array insert records$(current),w$
   total=total+1
   return

deleterec:
   'get rid of current record
   array delete records$(current)
   total=total-1:if total<current then current=total
   if current<1 then current=1
   return

quit:
   end

sortrecs:
   'sort by last name.
   array sort records$(1) for total, from 11 to 35
   return

jump:
   input"Jump to record: ";current
   if current>total then current=total
   if current<1 then current=1
   return

exitprog:
   print"Saving data file. ";
   open"o",1,"sample.dat"
   close 1
   open"r",1,"sample.dat",recordlength
   field #1,recordlength as w$
   where=pos(9)
   for i=1 to total
      lset w$=records$(i)
      put 1,i
      locate csrlin,where:print mid$(propellor$,1+i mod 4,1);
   next i
   close:print
   end