TIdings Volume 2 Number 1, February 1982-
This was the first PAID FOR issue as the prior six were freely issued.
I reported that the first program listing for the TI99/4 was published in the January 1982 issue of Computer and Video Games Magazine, issue three of a magazine which continued in print for many years and still exists as a web publication. The program was written by me and required Extended Basic, which at that time was probably unknown.
I at last received my first TI Disk Drive and Disk Manager module in time for Christmas 1981.
Kays and GUS Mail Order Catalogues were selling the TI99/4, with a cassete cable and Video Games 1 module for GBP 450.

Peter Brooks Graphics Peter Brooks wrote a very long article on using Basic to plot simple graphics (on a screen just 32 x 24 characters remember)- I have extracted the listings which appear below, the first is the actual plotting bit and can be saved to disk in merge format then merged into the other routines.

See Also: TIdings12 for an ExBas improvement by Gary Harding and also Times 27 for a shorter and faster main routine for Extended Basic

Report of how to obtain sound tones below 110Hz:
10 INPUT FREQ
20 CALL SOUND(400,22000,30,2
2000,30,FREQ,30,-4,0)
30 GOTO 10

With FREQ set to under 500, the sound output is not too useful. The sound output is around three octaves below the value of FREQ - still waiting for someone to put a frequency meter on it to tell us the principal tone output.
You can replace the -4 value with a -8 but the sound can only be described as weird.

An odd bit of programming in Extended Basic to consider:
10 CALL CLEAR
20 DEF YES=A$="Y"
30 DISPLAY AT(3,5):"Would you care to input a Y or an N?"
40 ACCEPT BEEP AT(5,5) SIZE(1) VALIDATE("YN"):A$
50 IF YES THEN 50 ELSE 70
60 PRINT "YOU INPUT Y FOR YES"
70 GOTO 30
80 PRINT "YOU INPUT N FOR NO"
90 GOTO 30
The binary value of YES is set to true when the string variable A$ is set to "Y".

My first Extended Basic program printed in Computer and Video Games Magazine was written for the TI99/4, and was causing problems with TI99/4A consoles, which everyone but me had, due to the extended character definitions. When using a sprite made up of four characters it became necessary to make sure that the 2nd 3rd and 4th characters were defined- you could no longer assume some characters started as blanks.

The change required:
CALL CHAR(100,"96FEBA3838BAFEBA")
to become:
CALL CHAR(100,"96FEBA3838BAFEBA"&RPT$("0",48)

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

Return to top of page

Report on importing software from the USA. At this time the Post Office handling charge was a mere two pounds 50p for parcels; and you paid the post man the vat and duty in cash! (No longer the case- the handling charge is now Eight Pounds and you have to go to the collection office to pay it). Also at this stage there was no duty or vat on parcels worth up to fifty pounds- that has now been reduced to 15 pounds, and VAT is now 20%. It costs a lot more to import low value items now than it did in 1982.
Comparitive prices of UK purchases and imports, after paying the handling fee, postage from the US, and VAT at 15%:
U K Price | Final cost
. . . . . | of import . . Item
in pounds |in pounds
. . 19.95.|...13.50....Zero Zap module
. . 29.95.|...13.50....Teach Yourself Extended Basic
. . 24.95.|...16.50....Programming Aids Two on Disk
=============

Group membership now reported as 260.
This was the last issue of TIdings in A4 format, future issues to be photoreduced to A5.
New computer on the market - Sinclair Spectrum, 48k for gbp 175 - it was expected that the 16k TI99/4a price would fall to GBP 200 .

Peter Brooks raised a query regarding TE2 and speech, which he answered in the next issue- and his query was also answered by TI directly also in that issue. To have the computer LIST a program verbally, with TE2 and speech synthesiser, type LIST "SPEECH". There are some restrictions.
Robin Frowd, Product Manager at Texas Instruments Ltd contributed a three page article:
Big price reductions announced (eg TI Invaders from GBP 40 to GBP 20)
Peripheral Expansion Box to be available in the UK from August 1982.
Editor Assmbler coming soon for GBP 90.
The TI99/4a to be shown on stand 220/224 at the Personal Computer World show in London in September 1982.

I was authorised to distribute the programs of PRP Computergraphics in the UK (they never sold) and had 58 programs on sale.

Return to top of page

The big article in this issue was Designs for Fun by Peter Brooks. This list has been modified in line 130 per Pete Brooks October 1982. Here first is the simple TI Basic listing:

In 1990 I (Stephen Shaw) adopted this listing to be used with The Missing Link and Extended Basic.

Here is some of what Peter wrote in 1982:

Designs for Fun

To produce some (I think) startling patterns. An apparently random collection of dots and lines can become highly patterned when vertically- and horizontally-symmetrical images are added.

This particular version makes use of 121 of the 128 ASCII characters available for redefinition, and simply sets up a pattern area in response to your selection, and continuously generates random patterns. The larger the pattern area used, the longer the generation time.

How it's all done

Take an image composed of dots and lines. Place a mirror on the right edge of the image, so that it is reflected. This gives you the Left-Right symmetry (LR). Place another mirror along the bottom edge, so that both images above are reflected, giving you Up-Down symmetry (UD). Now transfer the whole pattern to the screen and duplicate it over the entire display area.

In essence, that is the algorithm (or set of algorithms) which defines the principle of operation of the "Designs For Fun" program.

You define your own shapes using CALL CHAR. To begin with, let's look at how the algorithm could be applied to the 8 × 8 dot matrix of a single character. In order for the finished image to fit within that matrix, the original shape will have to be confined to a quarter of that area: 4 × 4 dots in say the upper left hand corner.

The "source string", which is assigned to S$ in the listing.
In order to exert some small control over the types of design which are produced by the program, I decided to make the program select the hex digits at "random" not from H$ but from another string (S$) so that instead of being able to compose or create designs using the full range of "shapes" possible using the hex digits 0 to F inclusive, the choice could be restricted to a chosen set of particular hex digits. In this way, different types of pattern could be produced, still with some semblance of being random, but falling into what might be termed "categories".
For example, by assigning the digits F, E, C, and 8 to S$, the program can only select the shapes which are equivalent in binary to "1111", "1110", "1100", and "1000". This will tend to produce patterns which are heavy and dark, and on the whole rather angular. However, using 0, 1, 2, 4, and possibly 8, the images will tend to be light and ornate, perhaps too detailed. In addition, there is the factor of pattern area: the larger the pattern area, the more dispersed the shapes tend to be, depending on the source string.

Using a root area of 1 does not do full justice to strings like "12480". The frequency and position of the chosen digits within the source string does also have a large part to play, but there the effects are complicated by the "pseudo-random" number generator used by the 99; in fact, under certain circumstances, the PRNG (pseudo-random number generator) will generate the same series of numbers over and over again, which means that the patterns will also become cyclic; the use of RANDOMIZE without a "seed" should obviate this.

Additional experiments that you can perform involve removing the CALL CHAR in line 640 and placing it in 625, so that shapes change during the process of compilation, rather than after it. Also the sequence of compilation can be slightly changed: by concatenating the contents of A$ in line 620 to SEG$(D$(N),M,2) thus
620 A$=SEG$(D$(N),M,2)&A$
the shapes can be made to appear as though they are "dropping" into place, albeit very slowly. It doesn't make any difference to the pattern being produced. Why?

When you enter or load a program into your Home Computer you do not need to know where in memory it is stored, or how it is stored. It is sufficient if your program RUNs OK! However, if you do know, you can use your knowledge to write programs which use less memory - e.g. get more out of your "16K".

If you have Extended Basic and the Expansion Memory, it is fairly easy to obtain these details (use CALL PEEK from 0 to -24K in -1 steps) - but what if you have only the console? With only the console, only one area of memory is used for everything - string and numeric variables, character definitions, and your program, etc.

Your program in stored in memory in two parts - the line numbers, and in a separate section the line contents.

Thus the Computer needs an index - and has one - to see where the line contents are! This is why a program line takes up 6 bytes before you put anything into it. The index uses four bytes - two bytes for the line number and two bytes for the memory location of its contents.

The length of the program line (in bytes) takes up one byte and an end of line separator takes up another byte. That's 6 bytes and nothing there yet!

If you have a line i.e. 100 REM, how many bytes is that going to take up? The 99/4(A) uses a single byte for Basic commands - such as REM. So this simple line will take up 7 bytes of memory.

If the sample is 100 GOTO 120, how many bytes? GOTO as we have seen uses ONE byte (but if you use GO TO which is two command words, that uses two bytes).

The LINE NUMBER 120 takes up 3 bytes - the first a marker to say "this is a line number" and the next two the actual number (if the first byte is A, the 2nd is B, the line number will be A*256+B). So this line uses up 10 bytes.

If the sample is 100 B=C then B, =, and C each take up one byte, making a line total of 9 bytes.

However 100 B=3456 will take up 14 bytes. B and = use 1 byte. The number 3456 takes up 6 bytes - four for 3456, and one to indicate "number". The other byte says how many characters are in the number. HINT: If memory in tight, replace all numbers used a few times by numeric variables.

String variables are dealt with in a similar manner. One byte says "this is a string", another "this is string length" if you use a quoted string. If you use a string variable, only the characters in your listing take up space, e.g. "TEST" is 6 bytes, "TST$" is 4 bytes.

The CALL routines use what are called UNQUOTED STRINGS - that is the word following CALL is a string, but without quotes. You cannot therefore use CALL A$ - 'cos A$ has quotes.

CALL COLOR uses one byte for CALL and 7 bytes for COLOR, two bytes say "unquoted string" and "length of string".

Using a lot of CALLs can eat into your memory - well worth using GOSUBS if you can.
(100 GOSUB 140 = 10 bytes, remember! )
(150 RETURN = 7 bytes )
The "tokens" which take up one byte of memory to indicate these commands and so on, are numeric values 129 to 254 - but not all are used. The ones used are listed below, Note the same codes are used for Extended Basic as for TI Basic, but some codes cannot be translated by TI Basic and will appear on your screen as funny characters.

PRINT : takes up two bytes in both languages, but PRINT :: also takes up two bytes in Extended Basic, as :: is covered by a one byte token.

The codes for !@P- and !@P+ are not known at present (used in Extended Basic v110). When you use a NUMERIC variable the value resides in its own memory location and uses 8 bytes. If you keep a careful watch on your numeric variables, and don't use more than you really need, you can save worthwhile memory space.

Similarly, if you use DIM, 8 bytes are set aside for each numeric value, e..g DIM B(7,8) sets aside 7*8*8 bytes if you use OPTION BASE 1, or 8*9*8 bytes if you don't.

If you use a two-dimensioned subscript without using DIM, because neither of the values exceeds ten, in OPTION BASE 0 the computer will set aside 11*11*8 bytes. That is a lot of memory gone west if you are not using it.

Hint: Always DIM numeric arrays. Use OPTION BASE 1 if you are not going to use 0 as the subscript.

String arrays are not so heavy on memory, a mere two bytes being set aside for each possible subscript. (Replace 8 with 2 in above examples.)

Incidentally, using the same block of memory for everything CAN cause a lockout if you RUN, EDIT, RUN, EDIT - the lockout occurring much earlier if your program is a long one.

Have you noticed your computer pausing for a second every now and then? When you redefine a variable, the old value remains in memory, taking up space. When you have defined enough times, there is no more memory, and the "rubbish" is kicked out. The 99/4A is remarkably efficient at this process, but it still takes a little time. The old definitions are not kicked out immediately, to give a faster running program.

My notes with my TML version of the Designs for Fun program in 1990 (I can't see it listed in the UK User Group magazine!) were as follows:

During pattern generation:
Press and hold key S to return to main menu.
User prompted pattern change: Any key except S and A for next pattern.
To print: Hold CTRL and FCTN together.
To save in TI-Artist format: Once the pattern is on screen and before the definitions at screen bottom start to change, press and hold key A. Indicate drive number, then file name (up to 8 characters, omit _P). Easier to use if user prompt mode is specified.
Patterns saved in TI-Artist format can then be cut out into Instances and used for texture or repeated over the full screen as required before printing. Can be used for book jackets or fly leaves or even wallpaper (enlarge and use as a crosswork design, etc.).
As listed the equivalent character definitions are given at screen bottom.

The TML version of the program is quite lengthy but I have it as a simple text file DFFTML.TXT which you may be able to copy and paste into a TI99/4a emulator, but note that some program lines extend over two text lines and may require some clean up on pasting. As the lines have maximum compaction you may need to split some long lines to get them in, and as memory is also tight set CALL FILES(1) and possibly remove some lines.... it ran OK in 1990 but TML has since been modified.