This set of projects focuses on using BASIC on different hardware and emulators. For this project, I used the TI-99 home computer, and used the Classic99 emulator.
Part 1
Game – Tone Guessing Game
One of the games included in the TI-99 manual was a tone-guessing game, which provides a specific pitched tone and has the user try to guess what the tone is by inputting the frequency.
The code for this program was as follows:
10 CALL CLEAR
20 TONE=INT(117*RND)+131
30 PRINT "HERE'S THE TONE!"
40 PRINT
50 CALL SOUND(1000M,TONE,2)
60 INPUT "GUESS, PLEASE?":GUESS
70 IF GUESS=TONE THEN 160
80 IG GUESS>TONE THEN 110
90 PRINT "TOO LOW!"
100 GOTO 120
110 PRINT "TOO HIGH!"
120 CALL SOUND(1000,GUESS,2)
130 PRINT "TRY AGAIN."
140 PRINT
150 GO TO 30
160 PRINT "YOU GUESSED IT!"
170 FOR PLAY=1 TO 3
180 CALL SOUND (100,TONE,2)
190 NEXT play
200 FOR DELAY=1 TO 500
210 NEXT DELAY
220 GOTO 10
The video of this code running is here.
Art program – Mountain Generator
This program takes an input character and randomly places that character on the screen. The example program in the book demonstrates this with the * character, but for this video I use the ^ character to generate what looks like a series of mountains.
10 RANDOMIZE
20 INPUT "CHAR CODE?":CODE
30 CALL CLEAR
40 ROW=INT(24*RND)+1
50 COLUMN=INT(32*RND)+1
60 CALL VCHAR(ROW,COLUMN,CODE)
70 GO TO 40
The video of this code running is here.
Part 2
Using the emulator, I retyped each program with a code modification.
Game – Guess the Riddle
On the emulator, I wanted to use the voice module that can be attached to the TI-99. I found that using the emulator in a certain mode enabled it to output speech, with a list of words that can be outputted.
This program asks the user a riddle using text and speech, and has the user guess the answer. If they get it wrong, the program asks the question again.
10 CALL CLEAR
20 ANSWER$="CLOCK"
30 PRINT "I have a riddle for you!"
40 PRINT
45 PRINT "What has a hand but cannot type?"
46 PRINT
50 CALL SAY("WHAT HAS A HAND BUT CAN NOT TYPE")
60 INPUT "Do you know the answer? ":GUESS$
70 IF GUESS$=ANSWER$ THEN 110
90 PRINT "Sorry, try again!"
95 PRINT
100 GO TO 30
110 PRINT "You got it!"
120 CALL SAY("GOOD WORK")
Here’s a video of that in action:
Art Program – Landscape Generator
I decided to take the randomly placed characters one step further by allowing for more characters to be inputted, and restricting where certain characters could be placed via limiting the rows and columns.
10 randomize
20 input "char code 1?":code1
30 call clear
32 input "char code 2?":code2
34 call clear
36 input "char code 3?":code3
38 call clear
40 row1=int(12*rnd)+1
42 row2=int(12*rnd)+12
44 row3=int(12*rnd)+12
50 column1=int(32*rnd)+1
52 column2=int(32*rnd)+1
54 column3=int(32*rnd)+1
60 call vchar(row1,column1,code1)
62 call vchar(row2,column2,code2)
64 call vchar(row3,column3,code3)
70 go to 40
Using char codes 42, 94, and 124 outputs a scene that looks like the following, sort of a desert scene with stars effect:
Part 3
For the last part of the project, I created a pattern generating program and tried to bring it into the analog realm. After talking with Mirek, I decided to make a character generator that I can use to create a map.
The code for the character generator is as follows:
5 CALL CLEAR
10 RANDOMIZE
11 CODE1 = 46 //period
12 CODE2 = 43 //+
13 CODE3 = 94 //^
14 CODE4 = 64 //@
20 ROW1=INT(12*RND)+1
30 ROW2=INT(12*RND)+1
40 ROW3=INT(12*RND)+1
45 ROW4=INT(12*RND)+1
50 COL1=INT(32*RND)+1
60 COL2=INT(32*RND)+1
70 COL3=INT(32*RND)+1
75 COL4=INT(32*RND)+1
80 CALL VCHAR(ROW1,COL1,CODE1)
90 CALL VCHAR(ROW2,COL2,CODE2)
100 CALL VCHAR(ROW3,COL3,CODE3)
110 CALL VCHAR(ROW4,COL4,CODE4)
120 GO TO 20
With the following keycodes:
11 CODE1 = 46 //period
12 CODE2 = 43 //+
13 CODE3 = 94 //^
14 CODE4 = 64 //@
Which generates output images for the map:
I wanted to create a map as part of a story (seen here) about lost machines, and how we can derive meaning from objects that have been lost to time and their purpose forgotten. The story is told from the point of view of a civilization after the apocalypse, where the new rising peoples find pieces of technology from the Old World but don’t quite understand what it is. What if they had found the TI-99 and run programs on there? What meaning would that make? In the story, the researcher assumes that the symbols must be some kind of hidden knowledge, a secret message from the beyond. They interpret the output as a map, trying to force their understanding of the current world onto the symbols being outputted.
. - road
+ - forest
^ - hill
@ - mountain
I wanted there to be some greater barrier to understanding as well, so I made the researcher’s civilization hae their own language, and refer to the language on the TI-99 keyboard as runes or strange symbols. For the future civ, I wrote diary entries and notes on the map in Gregg shorthand to add a backwards layer of indecipherability, something that they would understand that we cannot.
Part 4
Describe the process of typing in the program on actual hardware. What conveniences or inconveniences did you face? What specific constraints or affordances did you encounter? How does it compare to programming on modern platforms? What did you learn about your machine that surprised or interested you?
To begin, I thought that the physical space of the game lab more than anything else made using the TI-99 a bit inconvenient. What I really wanted to do was use it as a desktop computer, with a dedicated work space, desk, etc. that I could use to keep things set up and return back to them, display the manual alongside the keyboard without just dumping everything on the floor. When it came to using the actual machine, I expected the learning curve to be much higher than it was, but it wasn’t so bad. The manual did a fairly good job at scaffolding how the code works, although I would have appreciated a bit more detail in how the actual key functionality works, as it took me a bit to figure out things like how to access certain characters via the function key. I wasn’t able to figure out how to backspace characters even though I’m pretty sure that this is due to be just pressing the delete button wrong, but after I realized I could just rewrite the same fixed code on a new line, this wasn’t really too bad. I think it wasn’t until I was using the emulator that I realized how much easier it was for me to use a regular keyboard to type.
One of the things I thought was really interesting about the TI-99, and that I wanted to explore further, was the fact that the machine can output tones. Part of the manual talks about how to output different tones and noise, but the machine also comes with a speech module that can be used to output vocalizations that sound like natural language for certain words. I wanted to explore this more in emulation.
How did emulation change your relationship to programming? Is there anything lost in the transition? What is gained? Did the emulation feel authentic? Why or why not?
To me, emulation felt too easy. While I wanted to emulator to support a wide range of modern conveniences (like being able to copy/paste code) and this is really nice for things like being able to learn how the code works and make quick prototypes. But I do feel like some kind of embodied action is missing–it just feels too divorced from the original in terms of the mentalities you would use in understanding how to write code and run programs. For instance, being able to run code instantly and make quick modifications feels very different from how one might approach the original device (and certainly different from how I was using it for the first time), and thus the artifacts that one might create in this new, emulated way might be different–maybe more experimental, for instance. Furthermore, emulation gave me access to elements I wasn’t able to access in the original, like the speech module. While this is nice to have at my fingertips, I think it quashes the differences between the original machine and the module, both in terms of their physicality (the module would need to a separate device, physically hooked in) and in terms of the additional cost the module would have had.
How did you choose to change your type-in programs? What did you find interesting about modifying a 30-year old program?
For my program changes, I expanded the art program by including more user inputs and more constraints on how different symbols would be displayed on the screen. This to me seems like more of an extension of the original manual code that would be natural for someone at the time to perform.
My second modification involved using the speech synthesizer because I wanted to play around with it as a modification of the tone-outputting quiz. Finding out how to get the speech synthesizer working on the emulator took much more time than I thought it would, mostly because I couldn’t find any good documentation for it anywhere. I ended up using a special mode on the Classic99 emulator (the XB2.7 Extended BASIC cartridge) in order to get speech output working. It was nice to be able to make modifications quickly and hook up other modules, though I do think this does do something to divorce the kinds of work I’m making now from how I’d interact with the original machine.
Is your chosen platform still relevant to computing today? Why or why not? How does this activity tie into our readings this quarter?
I think my platform is still relevant to computing today. The speech synthesizer seems tie into the still-unsolved problems about natural-language speech synthesis, making digital voices that understand words and can speak to the user (as with personal assistants). It’s also really interesting to look at the words that are included in the manual to be able to be spoken by the system; things like “diskette” and “handheld unit” are included, as well as phrases that were clearly meant to go with games or other interactables like “nice try” or “you win”. I thought it was interesting how technically focused the vocabulary was, as opposed to something for a home or work environment that’s not necessarily technically focused. Inclusions of phrases like “uhoh” are cute and add character, though I’m not quite sure what their intended use was.
I think this especially interesting in thinking about how we continuously try to do new things with technology, then forget about these things, and they come back around as new problems to solve, either without building upon (for lost tech) or not acknowledging the building upon (for “revolutionary” techs) of older technologies. I think it’d be especially interesting to look at the modules that came with the TI-99 as a way of understanding what it was that companies thought people would want to do with this strange new device. The TI-99 manual focuses on games, art, and sound output–I’m not quite sure how this is situated in the history of computing, but I do think that it’s an optimistic focus for the future.