Introduction

Welcome to SLP-BASIC

Welcome to SLP-BASIC v1.2, a faithful implementation of Commodore BASIC V2 for the Emulator.ca modem network. Whether you're returning to 1980s computing or encountering it for the first time, you're about to enter a world where programming is direct, immediate, and rewarding.

This manual is your comprehensive guide to the BASIC language—line-numbered programming, immediate mode execution, and the distinctive experience of Commodore computing. Everything you need to write programs, from your first PRINT statement to sophisticated applications, is covered in these pages.

SLP-BASIC v1.2 brings authentic Commodore BASIC V2 to your terminal, exactly as it appeared on the VIC-20 and Commodore 64. Every command, every function, every quirk has been faithfully recreated. When you type RUN and watch your program execute, you are experiencing computing as millions have come to know and love it.

What is BASIC?

BASIC stands for Beginner's All-purpose Symbolic Instruction Code. Created in 1964 by John Kemeny and Thomas Kurtz at Dartmouth College, BASIC was designed with a revolutionary goal: to make programming accessible to everyone, not just mathematicians and engineers.

Before BASIC, programming required intimate knowledge of machine architecture, complex syntax, and often, stacks of punched cards. BASIC changed everything. Its commands were English-like (PRINT, INPUT, GOTO), its syntax was forgiving, and its feedback was immediate. You could type a command and instantly see the result. For the first time, programming became conversational.

The BASIC Revolution

When microcomputers arrived in the late 1970s, BASIC came with them. The Apple II, the TRS-80, the Commodore PET—every home computer booted directly into BASIC. Turn on the power, and within seconds you saw a READY prompt waiting for your commands. No operating system to load, no applications to launch. The computer was ready to be programmed, and BASIC was the language it spoke.

BASIC became the lingua franca of a generation. Millions learned to program by typing in listings from magazines like COMPUTE! and Creative Computing. Classrooms taught BASIC. Users' groups exchanged BASIC programs on cassette tapes and floppy disks. If you wanted your computer to do something new, you wrote it in BASIC.

Why Commodore BASIC?

Among the many dialects of BASIC, Commodore BASIC V2 holds a special place. Derived from Microsoft's 6502 BASIC, it powered some of the most beloved computers of the 1980s:

• VIC-20 (1980): The first computer to sell over one million units, bringing computing to families worldwide
• Commodore 64 (1982): The best-selling single computer model of all time, with over 17 million units sold

Commodore BASIC V2 struck a perfect balance: powerful enough for serious programming, yet simple enough for beginners. It lacked some features found in other BASICs (no ELSE clause initially, no WHILE loops), but this simplicity was its strength. You learned the core concepts of programming without distraction.

BASIC Today

While BASIC is no longer the dominant language it once was, its influence remains profound. Many concepts that seem obvious today—interactive programming environments, immediate mode execution, English-like syntax—were pioneered by BASIC. Modern languages like Python, with their emphasis on readability and interactivity, are spiritual descendants of BASIC's philosophy.

SLP-BASIC preserves this heritage while taking advantage of modern technology. You get the authentic experience—right down to the character set and memory limits—but with benefits like instant saving, reliable execution, and the ability to run your programs anywhere you have a web browser.

Ready to Begin

You're about to embark on a journey into computing history—but this isn't just nostalgia.

In 1982, a 12-year-old could save up lawn-mowing money, buy a Commodore 64, plug it into the family television, and immediately—within seconds of power-on—have access to a complete programming environment. No installation, no configuration, no operating system to learn. Just READY and a blinking cursor. That child could type 10 PRINT "HELLO" and press RUN, and the computer would obey. The sense of power was intoxicating.

That directness, that immediate feedback, that focus on solving problems rather than managing complexity—these qualities made BASIC revolutionary, and they make it an excellent environment for learning programming concepts that remain relevant today.

The next chapter guides you through connecting to the SLP-BASIC system. Once you see that READY prompt, you'll have access to a complete programming environment—38,911 bytes free, just like the original—waiting for your commands. Let's begin!

Getting Connected

This chapter covers remote computing via modem connection. You'll learn how to establish a connection to the SLP-BASIC v1.2 system, understand the technical details of the RS-232 communication protocol, and master the procedures for maintaining and terminating your session.

The SLP-BASIC system runs on a dedicated server accessible through the public switched telephone network. Whether you're calling from your home computer lab or a remote terminal, the connection process is straightforward and reliable.

What You'll Need

Before dialing in, ensure you have the following:

Hardware Requirements:

• A computer with RS-232 serial port (DB-25 or DB-9 connector)
• Hayes-compatible modem (300, 1200, or 2400 baud)
• Telephone line with dial tone
• Properly configured terminal program

Software Configuration:

• Terminal emulation: VT100 or ANSI
• Data bits: 8
• Parity: None
• Stop bits: 1
• Flow control: RTS/CTS (hardware)

Dialing In

Once your modem is properly configured and connected, you're ready to dial. The SLP-BASIC system is accessible at:

Phone Number: 555-0300

To initiate the connection, enter the following command at your terminal:

ATDT555-0300

Let's break down this command:

• AT - Attention prefix (all Hayes commands start with AT)
• D - Dial command
• T - Tone dialing (use "P" for pulse dialing if necessary)
• 555-0300 - The SLP-BASIC system phone number

The Connection Sequence

Once your modem begins dialing, several events occur in rapid succession. Understanding this sequence helps you diagnose connection problems and appreciate the engineering behind reliable data communication.

Phase 1: Call Establishment Your modem sends dual-tone multi-frequency (DTMF) signals corresponding to each digit. The telephone system routes your call to the SLP-BASIC server.

Phase 2: Answer and Handshake The remote modem answers and both modems negotiate communication parameters—baud rate, modulation type, and error correction. You'll hear a characteristic screech and warble during this negotiation.

Phase 3: Carrier Detection Once negotiation succeeds, both modems establish a carrier signal. Your modem asserts the DCD (Data Carrier Detect) line, informing your computer that a valid connection exists.

Phase 4: Connection Confirmation Your modem displays the connection status:

CONNECT 1200

The number indicates your connection speed in bits per second. Common speeds include:

• 300 baud - 30 characters per second
• 1200 baud - 120 characters per second
• 2400 baud - 240 characters per second

Immediately after connection, the SLP-BASIC system sends its welcome banner.

The Welcome Banner

Upon successful connection, the SLP-BASIC interpreter identifies itself with a welcome banner. The banner you see depends on which computer model the system is emulating.

Commodore 64 Banner (Default):

    **** COMMODORE 64 BASIC V2 ****

 64K RAM SYSTEM  38911 BASIC BYTES FREE

READY.

VIC-20 Banner (Alternate Configuration):

    **** COMMODORE VIC-20 ****

 3583 BYTES FREE

READY.

The banner provides essential information:

1. System Identification - Which computer is being emulated
2. BASIC Version - V2 is Commodore BASIC Version 2
3. Available Memory - How many bytes are free for your programs
4. Ready Status - The "READY." prompt indicates the interpreter awaits input

The SLP-BASIC system defaults to Commodore 64 emulation. The banner you receive confirms your session parameters and available resources.

The READY Prompt

After the banner displays, you'll see:

READY.
█

The READY. prompt is your signal that the interpreter is waiting for input. The blinking cursor (shown here as █) marks where your next character will appear.

This prompt has special significance in Commodore BASIC:

What "READY" Means:

• The interpreter has finished executing (or has no program running)
• All commands and statements are now accepted
• You can enter immediate mode commands or program lines
• The system is idle and waiting for you

The Period Matters: The period (full stop) after "READY" is part of Commodore's distinctive style. It differentiates this prompt from the similar but period-less prompts of other BASIC implementations.

Cursor Behavior: The cursor blinks at approximately 1 Hz (once per second), indicating the system is responsive and ready. If the cursor stops blinking or disappears, the connection may have been interrupted.

RS-232 Signal Protocol

The SLP-BASIC interpreter participates fully in RS-232 hardware handshaking. Understanding these signals helps you diagnose connection issues and appreciate how reliable communication is maintained.

RS-232 defines several control signals beyond the transmit (TX) and receive (RX) data lines. The most important for modem communication are:

Terminology:

• DTE (Data Terminal Equipment) - Your computer
• DCE (Data Communications Equipment) - Your modem

How SLP-BASIC Uses These Signals:

DTR (Data Terminal Ready): The interpreter asserts DTR immediately upon connection, signaling to the modem that it's ready for communication. When you disconnect properly, the interpreter drops DTR, instructing the modem to hang up. This is the primary method for terminating the connection.

RTS (Request To Send): The interpreter asserts RTS when initialized and maintains it throughout the session. This signal, combined with CTS, implements hardware flow control. When the interpreter's input buffer approaches capacity, it could (in theory) deassert RTS to pause incoming data. In practice, at these speeds, buffer overflow is rare.

CTS (Clear To Send): The modem asserts CTS in response to RTS when ready to accept data. If your modem needs to throttle input (because its own buffers are full or the phone line quality degrades), it will deassert CTS. The interpreter monitors this signal and pauses output when CTS is low.

DCD (Data Carrier Detect): The modem asserts DCD when it detects a valid carrier signal from the remote modem. If DCD drops during your session, it indicates carrier loss—usually meaning the remote system hung up or the phone line was interrupted. The interpreter monitors DCD and can initiate cleanup if carrier is lost unexpectedly.

DSR (Data Set Ready): The modem asserts DSR when powered on and ready to operate. This signal confirms your modem is functional before attempting to dial.

Signal Flow During Operation

Here's how these signals interact during a typical session:

    INITIAL CONNECTION SEQUENCE
    ═══════════════════════════

    COMPUTER (DTE)              MODEM (DCE)
         │                           │
    ┌────┤                           │
    │    │  DTR ───────────────────> │  (Terminal ready)
    │    │                           ├────┐
    │    │  <────────────────── DSR  │    │  (Modem ready)
    │    │                           │    │
    │    │  RTS ───────────────────> │    │  (Request to send)
    │    │                           │    │
    │    │  <────────────────── CTS  │    │  (Clear to send)
    │    │                           │    │
    │    │                      ┌────┘    │
    │    │      [DIALING...]    │         │
    │    │                      └────┐    │
    │    │                           │    │
    │    │  <────────────────── DCD  │    │  (Carrier detected)
    │    │                           ├────┘
    │    │                           │
    └───>│  TX ←──────────────→ RX  │  (Data exchange)
         │  RX ←──────────────→ TX  │
         │                           │


    ACTIVE SESSION (ALL SIGNALS ASSERTED)
    ══════════════════════════════════════

    DTR: HIGH  (Interpreter ready)
    RTS: HIGH  (Ready to send)
    CTS: HIGH  (Modem ready to receive)
    DCD: HIGH  (Carrier present)
    DSR: HIGH  (Modem operational)


    NORMAL DISCONNECTION SEQUENCE
    ══════════════════════════════

         │                           │
         │  DTR drop ──────────────> │  (Hangup request)
         │                           │
         │                      [HANGUP]
         │                           │
         │  <────────────── DCD drop │  (Carrier lost)
         │                           │
         ∅                           ∅

Flow Control in Action:

If the modem's transmit buffer fills (perhaps due to a noisy line requiring retransmissions), it will deassert CTS. The interpreter detects this condition and suspends output until CTS returns high. This prevents data loss and maintains reliable communication even under adverse conditions.

Interrupting Execution

Sometimes you'll need to stop a running program—perhaps it's stuck in an infinite loop, generating too much output, or you've simply changed your mind. The SLP-BASIC interpreter provides a clean interrupt mechanism.

The ESC Key:

Press the ESC (Escape) key at any time to interrupt program execution. The interpreter will:

1. Immediately halt the current statement
2. Display ^C to acknowledge the interrupt
3. Return to the READY prompt
4. Preserve all variables and program code in memory

What ESC Does NOT Do:

• Does not disconnect your session
• Does not clear program memory (use NEW for that)
• Does not reset variables (use CLR for that)
• Does not hang up the modem (see next section)

Disconnecting Properly

When you've finished your session, it's important to disconnect properly. This ensures the modem releases the phone line, prevents phantom connections, and maintains clean system logs.

Method 1: The Proper Way (Drop DTR)

The cleanest disconnection method is to instruct your modem to hang up by dropping DTR:

+++
OK
ATH
OK
NO CARRIER

Let's break this down:

Step 1: Enter Command Mode Type three plus signs with one-second pauses before and after: +++

This is the Hayes "escape sequence" that returns the modem to command mode without disconnecting. After a brief pause, the modem responds with OK.

Step 2: Hang Up Type ATH (AT Hang-up) and press RETURN.

The modem drops DTR, terminates the connection, and responds with OK followed by NO CARRIER.

Method 2: Direct Hangup (Most Terminal Programs)

Most terminal programs provide a hangup command:

• Kermit: Press Ctrl-\ C, then type HANGUP
• ProComm: Press Alt-H
• Telix: Press Alt-H
• Commodore 64: Depends on your terminal program

Consult your terminal software documentation for the specific key combination.

Method 3: Modem Power Cycle (Emergency Only)

If the modem becomes unresponsive, you can disconnect by cycling power:

1. Turn off the modem
2. Wait 10 seconds
3. Turn on the modem
4. Wait for DSR to assert (modem ready light)

This method should be reserved for emergencies, as it terminates the connection abruptly without notifying the remote system.

What Happens During Disconnection:

When DTR drops, the following sequence occurs:

1. The interpreter detects DTR deassertion
2. The interpreter halts execution and clears its state
3. The modem terminates the carrier signal
4. The remote modem detects carrier loss
5. Both modems return to idle state
6. The phone line is released

Verifying Disconnection:

You know you've successfully disconnected when:

• Your modem's "CD" (Carrier Detect) light goes off
• Your terminal displays "NO CARRIER"
• Your modem returns to idle state (ready to accept AT commands)
• Dial tone returns on your phone line

Troubleshooting Connection Issues

Even with proper configuration, you may occasionally encounter connection problems. This section covers common issues and their solutions.

Problem: NO DIALTONE Error

Symptoms: After entering ATDT555-0300, your modem immediately responds:

NO DIALTONE

Cause: The modem cannot detect dial tone on the phone line.

Solutions:

1. Verify phone cable is securely connected to both modem and wall jack
2. Test phone line by connecting a telephone and listening for dial tone
3. Check if another device (fax, answering machine) is off-hook on the same line
4. Try: ATX3 before dialing (disables dial tone detection)
5. Verify phone line type (some modems don't work with VoIP or PBX systems)

Problem: NO ANSWER Error

Symptoms: Modem dials successfully but eventually responds:

NO ANSWER

Cause: The remote system didn't answer within the timeout period (typically 30-60 seconds).

Solutions:

1. Verify you're dialing the correct number (555-0300)
2. Check if you need a dialing prefix (9 for outside line, 1 for long distance)
3. Increase answer timeout: ATS7=60 (wait 60 seconds for answer)
4. Try again during off-peak hours (the system may be busy)
5. Verify the remote system is operational (try calling the voice line to confirm)

Problem: CONNECT Followed by Garbage

Symptoms: Modem reports successful connection, but the banner is garbled or you see random characters:

CONNECT 1200
��*@��CO#�MM%�DO��@��@4 B����

Cause: Communication parameters mismatch between your terminal and the remote system.

Solutions:

1. Verify your terminal settings match the requirements:
   • Data bits: 8
   • Parity: None
   • Stop bits: 1
2. Check baud rate—try forcing a specific speed: AT&N6 (lock at 1200 baud)
3. Disable software flow control (XON/XOFF) in your terminal program
4. Enable hardware flow control (RTS/CTS)
5. Reset modem to factory defaults: AT&F then reconfigure

Problem: Connection Drops Randomly

Symptoms: You successfully connect and use SLP-BASIC, but the connection terminates unexpectedly with:

NO CARRIER

Cause: Poor line quality causing excessive errors, or modem timeout.

Solutions:

1. Check for sources of electrical interference:
   • Don't run modem cable parallel to power cables
   • Keep modem away from fluorescent lights, motors
   • Avoid wireless devices near modem cable
2. Try a shorter phone cable (RJ-11) to modem
3. Increase carrier loss timeout: ATS10=20 (wait 2 seconds before declaring carrier lost)
4. Enable error correction: AT&M4 or AT&M5
5. Try a lower baud rate: AT&N5 (lock at 300 baud)
6. Test with a different phone jack (line quality varies)

Problem: Can't Enter Command Mode with +++

Symptoms: Typing +++ doesn't return modem to command mode; it may appear in your SLP-BASIC session instead.

Cause: Incorrect timing on the escape sequence, or the characters are being interpreted as data.

Solutions:

1. Remember the timing: one second pause, three plus signs, one second pause
2. Verify escape character: ATS2? (should return 43, the ASCII code for +)
3. Some modems use different escape sequences—check your modem manual
4. If using a terminal program, use its built-in hangup command instead
5. As last resort, power cycle the modem

Problem: Banner Appears Slowly or Character-by-Character

Symptoms: Each character of the banner appears with a noticeable delay.

Cause: This is actually normal behavior for some configurations—the system may be implementing character-by-character transmission for authentic terminal emulation.

Solutions:

1. This is not necessarily a problem—wait for the complete banner
2. If unacceptably slow, try a higher baud rate:
   • Set modem to 2400: AT&N8
   • Or negotiate highest common speed: AT&N0
3. Verify your modem doesn't have excessive guard time: ATS12? (should be 50 or less)

Problem: Modem Doesn't Respond to AT Commands

Symptoms: You type AT and press RETURN, but see no response.

Cause: Communication problem between computer and modem, or modem not in command mode.

Solutions:

1. Verify serial cable is properly connected
2. Check your terminal program's COM port setting matches physical port
3. Try different baud rates in terminal program (2400, 1200, 300)
4. Enable local echo in terminal program to see what you're typing
5. Reset modem by power cycling
6. Try sending: ATE1 (enable echo) followed by RETURN several times
7. Check if modem has a physical DIP switch configuration—may need to match software settings
8. Consult modem manual for factory reset procedure

Problem: SLP-BASIC Not Responding

Symptoms: Connection successful, banner appears, but keyboard input doesn't produce output:

READY.
PRINT "TEST"[no response]

Cause: Flow control issue, or interpreter has frozen.

Solutions:

1. Check if CTS is deasserted (flow control blocking)—try disabling hardware flow control temporarily
2. Press ESC to attempt interrupt
3. Check Scroll Lock key on your keyboard—it may be pausing output
4. Verify local echo is OFF in your terminal program (or you'll see double characters)
5. Try sending a carriage return (ENTER) alone—may resynchronize
6. As last resort, disconnect and reconnect

Problem: Cursor Not Visible

Symptoms: You can type and see output, but there's no visible cursor.

Cause: Terminal emulation mismatch—the cursor control codes aren't supported by your terminal.

Solutions:

1. This doesn't affect functionality—the cursor position is tracked internally
2. Try different terminal emulation: VT100, ANSI, or TTY
3. Some terminals have a cursor enable/disable setting—check your terminal program
4. Not all emulation modes support blinking cursors—steady cursor or no cursor may be normal

Connection Best Practices

Follow these guidelines for reliable, pleasant SLP-BASIC sessions:

Before Connecting:

• Test your modem with AT command before dialing
• Verify phone line quality (no static on voice calls)
• Close other programs that might use the serial port
• Ensure adequate lighting to read your screen comfortably

During Connection:

• Don't touch the phone cable while connected (may introduce noise)
• If the connection seems slow, wait—don't repeatedly press keys
• Save your programs frequently using SAVE (covered in Chapter 12)
• Use ESC to interrupt runaway programs rather than disconnecting
• Keep a written log of your session time for phone billing purposes

After Disconnecting:

• Always use proper hangup procedure (drop DTR via ATH or terminal command)
• Verify "NO CARRIER" message before walking away
• Reset modem to clear settings: ATZ
• Log your session (programs created, problems encountered, solutions)

Etiquette and Usage:

• During peak hours, limit sessions to reasonable duration to share system access
• Don't leave your terminal connected but idle for extended periods
• If you encounter system problems, note exact error messages for reporting
• Be patient with connection times—analog modems are inherently slower than modern internet

Understanding Connection Costs

If you were connecting to a real remote system in 1983, you'd consider:

Telephone Charges:

• Local calls: Often included in monthly service fee (flat rate)
• Long distance: Significant per-minute charges, especially during business hours
• Timing: Evenings and weekends usually had lower rates

System Access Fees: Many timesharing systems charged for connect time:

• $5-$20 per hour was typical for personal systems
• Commercial services (CompuServe, The Source) charged $5-$25 per hour
• Premium rates for high-speed connections (1200/2400 baud)
• Storage fees for saved programs

Cost Management Strategies:

1. Compose programs offline in a text editor
2. Upload quickly using protocol transfers (XMODEM, Kermit)
3. Download results and disconnect promptly
4. Use off-peak hours for development work
5. Keep detailed logs of connect time for budgeting

The SLP-BASIC emulator frees you from these concerns—connect as long as you like, experiment freely, and learn without watching the clock!

What's Next

Now that you've successfully connected to SLP-BASIC and understand the communication protocols involved, you're ready to start programming!

In Chapter 3, you'll learn about Immediate Mode, where you can use BASIC as an interactive calculator and test commands before adding them to programs. You'll discover that the READY prompt isn't just waiting for programs—it's your gateway to instant computation and experimentation.

Before continuing, practice the connection procedure several times:

1. Dial in to SLP-BASIC
2. Verify you see the proper banner
3. Type PRINT "HELLO" and press RETURN to confirm communication
4. Disconnect properly using the ATH command
5. Verify successful disconnection

Comfort with these procedures ensures smooth sailing throughout your SLP-BASIC journey!

Key Points to Remember:

• Phone number: 555-0300 (ATDT555-0300 to dial)
• Connection speed: 300-2400 baud (typically 1200)
• Welcome banner: Confirms system type and available memory
• READY prompt: Indicates interpreter is waiting for input
• RS-232 signals: DTR, RTS, CTS, DCD, DSR maintain reliable communication
• ESC key: Interrupts program execution without disconnecting
• Proper disconnect: Use ATH command to drop DTR and hang up
• Troubleshooting: Start simple—check cables, power cycle, verify settings

With solid connection fundamentals under your belt, you're prepared to explore the full power of SLP-BASIC v1.2!

Immediate Mode

What is Immediate Mode?

One of BASIC's most powerful features is something so simple you might overlook it: immediate mode. It's the ability to type a command and see the result instantly, without writing a program at all.

The secret is the line number—or rather, the lack of one. Any command you type without a line number executes immediately:

PRINT "HELLO, WORLD!"

That's it. No RUN command needed, no program to save. Just type and press Enter. BASIC executes the command and shows you the result right away.

Compare this to program mode, where commands are stored for later execution:

10 PRINT "HELLO, WORLD!"
20 PRINT "THIS IS A PROGRAM"
RUN

See the difference? The line with "10" doesn't execute when you type it—it's stored. Only when you type RUN does BASIC execute line 10, then line 20, in order.

Immediate mode is what happens when you skip the line number. The command executes immediately, as soon as you press Enter. This simple feature transforms BASIC from a programming language into an interactive environment where you can explore, experiment, and test ideas without ceremony.

Why Immediate Mode Matters

In most programming languages, testing a simple idea requires creating a file, writing a function, compiling or running the program, and checking the output. In BASIC, you just type the command. Want to know what 125 times 37 equals? Type it:

PRINT 125 * 37

Instant answer. No ceremony, no overhead, no waiting. This immediacy makes BASIC uniquely suited for exploration and learning. You're never more than one command away from discovering something new.

BASIC as a Calculator

The simplest use of immediate mode is as a calculator. BASIC handles arithmetic with precision and power that would have seemed miraculous in the 1980s—and it's still remarkably handy today.

Simple Arithmetic

PRINT 2 + 2

PRINT 100 - 37

PRINT 15 * 8

PRINT 100 / 3

Notice that division produces a decimal result. BASIC uses floating-point arithmetic, so you get precise fractional answers.

Complex Expressions

BASIC follows standard mathematical operator precedence: multiplication and division before addition and subtraction. Parentheses override this order:

PRINT 5 * 7 + 3

PRINT 5 * (7 + 3)

Same numbers, different results. The parentheses make BASIC add first, then multiply. Without them, BASIC multiplies first (5 × 7 = 35), then adds 3.

Exponentiation

The ^ operator raises numbers to powers:

PRINT 2 ^ 8

PRINT 10 ^ 6

PRINT 1.5 ^ 3

This works for fractional exponents too—useful for roots:

PRINT 16 ^ 0.5

That's the square root of 16! Raising a number to the 0.5 power is equivalent to taking its square root.

Practical Calculations

Immediate mode shines for quick real-world calculations:

PRINT 19.99 * 1.13

That's a $19.99 item with 13% tax. Or:

PRINT 127 / 2.54

Converting 127 centimeters to inches. You don't need to write a program, save it, and run it. Just type the calculation and get your answer.

Instant Feedback with PRINT

The PRINT command is your window into what BASIC is thinking. In immediate mode, it shows you the result of any expression:

PRINT 123 * 456

PRINT "THE ANSWER IS 42"

PRINT 7 > 5

Wait—what's that last one? BASIC uses -1 to represent "true" and 0 to represent "false." The expression 7 > 5 is true, so BASIC prints -1. This becomes important when you write programs with conditions.

The ? Shorthand

Here's a secret that will save you countless keystrokes: ? is shorthand for PRINT. They're completely identical:

? 2 + 2

? "HELLO"

? 100 / 3

Most experienced BASIC programmers use ? in immediate mode because it's faster to type. PRINT and ? work identically in programs too, though PRINT is more readable in program listings.

Multiple Values

PRINT can display multiple values separated by commas or semicolons:

PRINT 10; 20; 30

PRINT "VALUE:"; 123

Semicolons pack values tightly together. Commas create wider spacing (tab zones). We'll explore formatting in detail in Chapter 8, but for now, know that you can print multiple things with one PRINT command.

Variables in Immediate Mode

Variables work in immediate mode just as they do in programs. You can create them, assign values, and check their contents—all without writing a program.

Creating and Using Variables

A = 42
PRINT A

NAME$ = "ALICE"
PRINT NAME$

X = 10
Y = 20
PRINT X + Y

Notice the $ suffix on NAME$—that makes it a string variable (text). Variables without suffixes hold numbers. This distinction is crucial in BASIC.

Variables Persist

Here's something important: variables you create in immediate mode persist until you clear them. They don't disappear when the command finishes:

SCORE = 100
PRINT SCORE
SCORE = SCORE + 50
PRINT SCORE

The variable SCORE remembers its value between commands. You can use it again and again:

SCORE = 1000
PRINT SCORE
PRINT SCORE * 2
PRINT SCORE + 500

This persistence makes immediate mode perfect for testing and debugging. You can set up variables, try operations, check results, and refine your logic—all interactively.

String Operations

String variables hold text and can be manipulated:

FIRST$ = "HELLO"
LAST$ = "WORLD"
PRINT FIRST$ + " " + LAST$

The + operator concatenates (joins) strings. You can build complex text from simple pieces:

MSG$ = "THE ANSWER IS "
NUM = 42
PRINT MSG$ + STR$(NUM)

Notice STR$(NUM)—that converts the number to a string so it can be concatenated. We'll cover string functions in Chapter 10, but immediate mode is perfect for experimenting with them.

Integer Variables

Variables ending with % hold integers (whole numbers from -32768 to 32767):

COUNT% = 100
PRINT COUNT%
PRINT COUNT% * 2

Integer arithmetic is faster than floating-point, though you rarely notice on modern hardware. Use integers when you know values will always be whole numbers.

Testing Commands Before Programming

Immediate mode's greatest strength is risk-free experimentation. You can test any command, try any function, check any expression—without affecting your program.

Try It First

Suppose you're writing a program that needs to find the square root of a number. You remember there's a function, but you're not sure of the exact syntax. Try it in immediate mode:

PRINT SQR(16)

PRINT SQR(2)

PRINT SQR(144)

Perfect—SQR() takes a number and returns its square root. Now you're confident adding it to your program:

10 INPUT "ENTER A NUMBER"; N
20 PRINT "SQUARE ROOT IS"; SQR(N)
RUN

Testing String Functions

String functions can be tricky. Test them before committing:

TEXT$ = "HELLO WORLD"
PRINT LEFT$(TEXT$, 5)

PRINT RIGHT$(TEXT$, 5)

PRINT MID$(TEXT$, 7, 5)

LEFT$ extracts characters from the left, RIGHT$ from the right, and MID$ from the middle. Playing with them in immediate mode clarifies exactly how they work.

Testing Conditions

When writing IF statements, test the conditions first:

A = 10
B = 20
PRINT A > B

PRINT A < B

PRINT A = B

Remember: -1 means true, 0 means false. Once you understand how the comparison works, write the IF statement with confidence.

Building Complex Expressions

Test parts of complex expressions separately:

PRICE = 19.99
TAX = 0.13
PRINT PRICE * TAX

PRINT PRICE + (PRICE * TAX)

PRINT INT(PRICE + (PRICE * TAX) + 0.5)

That last one rounds to the nearest whole number. By testing each step, you build confidence that the final expression does what you intend.

Practical Debugging Uses

When your program doesn't work as expected, immediate mode becomes your debugging workshop. You can inspect variables, test logic, and identify problems without modifying your program.

Checking Variable Values

After a program runs (or stops with an error), variables retain their values. You can examine them:

10 FOR I = 1 TO 10
20 TOTAL = TOTAL + I
30 NEXT I
40 PRINT "TOTAL:"; TOTAL
RUN

Now check the variables:

PRINT I

PRINT TOTAL

The loop ran completely (I is 11, past the limit of 10), and TOTAL holds the sum. If these values seem wrong, you've found your bug.

Testing Logic Interactively

Suppose a program's IF statement isn't working. Set up the conditions manually and test:

SCORE = 85
GRADE$ = ""
IF SCORE >= 90 THEN GRADE$ = "A"
IF SCORE >= 80 AND SCORE < 90 THEN GRADE$ = "B"
PRINT GRADE$

Does it assign the right grade? Try different scores:

SCORE = 92
IF SCORE >= 90 THEN GRADE$ = "A"
PRINT GRADE$

This interactive testing helps you understand exactly when conditions trigger and what values result.

Simulating Program Lines

You can execute any program line in immediate mode by typing it without the line number:

10 LET X = 10
20 PRINT X * 2
LIST

Now execute line 20 directly:

PRINT X * 2

This helps you test individual lines without running the entire program. Set up the conditions (assign variables), then execute the line to see what happens.

Quick Calculations During Development

Often while programming you need quick answers. How many elements in a 10×10 array? Check immediately:

PRINT 10 * 10

What's the midpoint of a 640-pixel screen?

PRINT 640 / 2

These micro-calculations happen constantly during development. Immediate mode means you never leave BASIC to find a calculator.

The INPUT Command in Immediate Mode

INPUT works in immediate mode, prompting you for values just as it would in a program:

INPUT "ENTER YOUR NAME"; NAME$

Type a name and press Enter. Then:

PRINT "HELLO, "; NAME$

The variable NAME$ persists, holding the value you entered. This is handy for setting up test data:

INPUT "AGE"; AGE
PRINT AGE * 365

That estimates days lived (simplified—no leap years). You can test INPUT prompts to ensure they're clear and that the resulting variables work correctly.

Testing INPUT Validation

Suppose your program needs to ensure users enter valid data. Test the validation logic:

INPUT "ENTER A NUMBER (1-10)"; N
IF N < 1 OR N > 10 THEN PRINT "INVALID!"
IF N >= 1 AND N <= 10 THEN PRINT "VALID!"

Try various inputs to confirm the validation works. Once satisfied, add line numbers and incorporate it into your program.

Advanced Immediate Mode Techniques

As you become comfortable with immediate mode, you'll discover advanced techniques that experienced BASIC programmers use daily.

Multi-Statement Lines

You can combine multiple statements on one line with colons:

A = 5 : B = 10 : PRINT A + B

This works in both immediate mode and programs. It's handy for quick setup:

NAME$ = "BOB" : SCORE = 100 : PRINT NAME$; " SCORED"; SCORE

Use this judiciously—too many statements on one line becomes hard to read.

Function Testing

Test built-in functions with different inputs:

PRINT INT(7.8)

PRINT INT(-7.8)

PRINT ABS(-42)

PRINT SGN(-5)

PRINT SGN(5)

Understanding exactly how functions behave prevents surprises in programs. INT() truncates toward zero, ABS() returns absolute value, SGN() returns the sign (-1, 0, or 1).

Random Number Testing

The RND function generates random numbers. Test it interactively:

PRINT RND(1)

PRINT INT(RND(1) * 6) + 1

That second line simulates a six-sided die (1-6). Run it several times to see different results:

PRINT INT(RND(1) * 6) + 1
PRINT INT(RND(1) * 6) + 1
PRINT INT(RND(1) * 6) + 1

Clearing Variables

The CLR command erases all variables without affecting your program:

A = 100
B$ = "TEST"
PRINT A; B$
CLR
PRINT A; B$

After CLR, numeric variables become 0 and string variables become empty. This is useful when you want fresh variables without clearing your program (NEW clears both).

Immediate Mode Best Practices

To make the most of immediate mode, follow these practices developed by generations of BASIC programmers.

Use It Constantly

Don't save immediate mode for special occasions. Use it constantly:

• Quick calculations while programming
• Testing new functions before using them
• Checking variable values during debugging
• Experimenting with syntax you're unsure about
• Verifying expressions before adding to programs

The READY prompt isn't just waiting for programs—it's waiting for questions. Ask them freely.

Build Understanding Incrementally

When learning new commands, start simple and add complexity:

PRINT "HELLO"

PRINT "HELLO"; " "; "WORLD"

A$ = "HELLO"
B$ = "WORLD"
PRINT A$; " "; B$

Each step adds one concept. By building incrementally, you isolate exactly what each piece does.

Document Your Discoveries

When you discover something useful in immediate mode, immediately turn it into a program line before you forget:

PRINT INT(RND(1) * 100) + 1

That generates random numbers 1-100. Make it permanent:

100 REM GENERATE RANDOM NUMBER 1-100
110 R = INT(RND(1) * 100) + 1
LIST 100-110

Now it's saved in your program for future use.

Combine with LIST

Use immediate mode to test changes before making them permanent. Suppose line 50 isn't working:

10 A = 10
20 B = 20
50 PRINT A + B * 2
LIST

Test the fix in immediate mode first:

PRINT (A + B) * 2

That's what you wanted. Now update the program:

50 PRINT (A + B) * 2
LIST

Testing before modifying prevents replacing one bug with another.

The Immediate Mode Mindset

Learning BASIC is learning to think interactively. Every question has an immediate answer. Every hypothesis can be tested instantly. This creates a unique programming experience—one where the line between learning and doing dissolves.

In most languages, you write code, then test it. In BASIC, testing is writing. Every experiment in immediate mode teaches you something. Every successful test becomes part of your program. The process is fluid, conversational, and deeply satisfying.

When you sit down to program in BASIC, you're not just writing code that will run later. You're having a conversation with the computer right now. You ask questions (PRINT 2+2), get answers (4), refine your questions (PRINT (2+2)*5), and build understanding incrementally.

This is what made BASIC revolutionary in the 1980s and what makes SLP-BASIC special today: it removes the barriers between thought and execution. You think of something, you type it, you see the result. No compilation, no setup, no ceremony. Just pure, immediate feedback.

Immediate mode isn't just a feature of BASIC. It's the heart of the BASIC experience. Master it, use it constantly, and you'll find programming in BASIC more intuitive and enjoyable than you imagined possible.

End of Chapter 3

Proceed to Chapter 4: Your First Program to learn how to transform immediate mode experiments into structured programs.

Your First Program

You've mastered immediate mode—entering commands and seeing instant results. Now it's time to take the next step: writing programs that you can save, edit, and run again and again. This is where BASIC transforms from a powerful calculator into a true programming language.

In this chapter, you'll write your first complete program, learn how BASIC organises code, and discover the tools for editing and managing your programs. By the end, you'll be a programmer—not just someone who types commands, but someone who creates software.

Take your time with each section. Every concept builds on the previous one, and mastering these fundamentals will make everything that follows much easier.

Understanding Line Numbers

Unlike modern programming languages where code runs from top to bottom in the order you type it, BASIC programs are organised by line numbers. Every line of your program begins with a number, and BASIC uses these numbers to determine the order of execution.

Line numbers in SLP-BASIC can range from 0 to 65535. That's a lot of lines! In practice, you'll rarely need more than a few hundred lines for most programs.

The Convention: Counting by Tens

While you could number your lines 1, 2, 3, 4, 5..., experienced BASIC programmers use a different convention: increment by 10.

10 First line
20 Second line
30 Third line
40 Fourth line

Why skip numbers? Because later, when you're improving your program, you might need to add a line between two existing lines. If you have:

10 PRINT "HELLO"
20 PRINT "GOODBYE"

And you want to add a line between them, you can use any number from 11 to 19:

10 PRINT "HELLO"
15 PRINT "HOW ARE YOU?"
20 PRINT "GOODBYE"

Why Line Numbers Matter

Line numbers serve three critical purposes:

1. Execution Order: BASIC runs lines from lowest to highest number
2. Jump Targets: Commands like GOTO and GOSUB use line numbers to direct program flow
3. Editing: You reference lines by number when making changes

Your First Program: Hello World

Every programmer's journey begins with the same program: "Hello World." This simple program does one thing—displays a greeting on the screen. Let's write it together, step by step.

Step 1: Clear Your Workspace

First, make sure you're starting fresh. Type:

NEW

Press ENTER.

The NEW command clears any program currently in memory. You should see the READY. prompt again, indicating BASIC is ready for your first line.

Step 2: Enter Your First Line

Now type this exactly as shown:

10 PRINT "HELLO, WORLD!"

Press ENTER.

Let's break down what you just typed:

• 10 — The line number (we started at 10, following convention)
• PRINT — A BASIC command that displays text
• "HELLO, WORLD!" — The text to display (must be in quotes)

You should see the READY. prompt again. BASIC accepted your line and stored it in memory.

Step 3: Enter Your Second Line

Type:

20 END

Press ENTER.

The END command tells BASIC your program is finished. It's good practice to end every program with END.

Step 4: View Your Program

Type:

LIST

Press ENTER.

Congratulations! You just entered your first complete program. The LIST command displays all the lines in memory, sorted by line number.

Step 5: Run Your Program

Now execute your program. Type:

RUN

Press ENTER.

You did it! Your first program executed successfully. You told the computer to print a message, and it obeyed. This might seem simple, but you've just learned the fundamental cycle of programming:

1. Write code (enter lines)
2. Review code (LIST)
3. Execute code (RUN)
4. See results (output appears)

Try It Yourself

Here's an interactive version where you can experiment:

10 PRINT "HELLO, WORLD!"
20 END

How BASIC Sorts Your Program

One of BASIC's most helpful features is automatic line sorting. You don't have to enter lines in order—BASIC will organise them for you.

Let's prove it. Try this experiment:

Entering Lines Out of Order

Type these lines (yes, in this "backwards" order):

NEW
50 PRINT "LINE FIVE"
30 PRINT "LINE THREE"
10 PRINT "LINE ONE"
40 PRINT "LINE FOUR"
20 PRINT "LINE TWO"

Now type:

LIST

Look at that! Even though you entered lines 50, 30, 10, 40, 20, BASIC displays them as 10, 20, 30, 40, 50.

Now type RUN:

BASIC executed the lines in numerical order, not the order you typed them. This is incredibly useful—you can add lines anywhere in your program without worrying about reorganizing everything.

Why This Matters

Imagine you've written a 50-line program and realize you need to add something near the beginning. Without automatic sorting, you'd have to retype everything. With BASIC, just insert a new line number between existing ones:

10 PRINT "FIRST"
15 PRINT "INSERTED LATER"
20 PRINT "SECOND"

50 PRINT "LINE FIVE"
30 PRINT "LINE THREE"
10 PRINT "LINE ONE"
40 PRINT "LINE FOUR"
20 PRINT "LINE TWO"
60 END

Type LIST to see how BASIC sorted these lines. Then type RUN to see execution order match line number order.

The LIST Command

The LIST command is your window into program memory. It shows you what BASIC has stored, formatted and organised. You've already used the basic form, but LIST has several powerful variations.

LIST (Display Everything)

The simplest form displays your entire program:

LIST

This shows every line from lowest to highest line number.

LIST n (Display One Line)

To see a single line, type LIST followed by the line number:

LIST 20

This is useful when you want to check the contents of a specific line without scrolling through your entire program.

LIST n-m (Display a Range)

To see several consecutive lines, specify a range:

LIST 10-30

The format is starting_line-ending_line. BASIC displays all lines from the start through the end, inclusive.

LIST -n (Display From Beginning)

To see everything from the start of your program up to a specific line:

LIST -30

This shows line 30 and everything before it.

LIST n- (Display to End)

To see everything from a specific line to the end:

LIST 20-

This shows line 20 and everything after it.

10 PRINT "LINE TEN"
20 PRINT "LINE TWENTY"
30 PRINT "LINE THIRTY"
40 PRINT "LINE FORTY"
50 PRINT "LINE FIFTY"
60 END

Try all the LIST variations:

• LIST (shows everything)
• LIST 30 (shows just line 30)
• LIST 20-40 (shows lines 20, 30, 40)
• LIST -30 (shows lines 10, 20, 30)
• LIST 40- (shows lines 40, 50, 60)

Running Your Program

You've learned to enter programs and view them with LIST. Now let's explore how to execute them with RUN.

The RUN Command

Type RUN and press ENTER to execute your program:

RUN

BASIC immediately:

1. Jumps to the lowest line number
2. Executes that line
3. Moves to the next higher line number
4. Continues until it reaches END or runs out of lines

RUN From Immediate Mode

RUN always works in immediate mode (when you see the READY. prompt). You can run your program as many times as you want:

RUN
(output appears)
READY.
RUN
(output appears again)
READY.

Each time you type RUN, BASIC starts fresh from the beginning.

What Happens During RUN

Let's trace execution step by step for this program:

10 PRINT "ONE"
20 PRINT "TWO"
30 PRINT "THREE"
40 END

1. START: BASIC finds the lowest line (10)
2. LINE 10: Executes PRINT "ONE", displays ONE
3. LINE 20: Executes PRINT "TWO", displays TWO
4. LINE 30: Executes PRINT "THREE", displays THREE
5. LINE 40: Executes END, stops program
6. FINISH: Returns to READY. prompt

The Importance of END

While not strictly required, ending your programs with END is good practice:

10 PRINT "HELLO"
20 END

END tells BASIC "stop here." Without it, BASIC stops when it runs out of lines—but using END makes your intent clear and prevents errors if you add lines later.

10 PRINT "COUNTING..."
20 PRINT "1"
30 PRINT "2"
40 PRINT "3"
50 PRINT "DONE!"
60 END

Type RUN to execute this counting program. Try running it multiple times—each execution is independent and starts fresh.

Editing Lines

You'll frequently want to change parts of your program. BASIC makes editing simple: just re-enter the line number with new content.

How Editing Works

When you type a line number that already exists, BASIC replaces the old line with your new one.

Let's say you have:

10 PRINT "HELLO"
20 END

To change line 10, type:

10 PRINT "GOODBYE"

Now LIST shows:

The old PRINT "HELLO" is gone, replaced by PRINT "GOODBYE".

Complete Replacement

Important: BASIC replaces the entire line, not just part of it. You must retype the complete new line:

Editing Step by Step

Let's practice editing with a complete example:

Step 1: Enter this program:

NEW
10 PRINT "MY NAME IS BOB"
20 PRINT "I AM 25 YEARS OLD"
30 END

Step 2: Run it:

RUN
MY NAME IS BOB
I AM 25 YEARS OLD

READY.

Step 3: Change line 10:

10 PRINT "MY NAME IS ALICE"

Step 4: Change line 20:

20 PRINT "I AM 30 YEARS OLD"

Step 5: Check your changes:

LIST
10 PRINT "MY NAME IS ALICE"
20 PRINT "I AM 30 YEARS OLD"
30 END
READY.

Step 6: Run the edited program:

RUN
MY NAME IS ALICE
I AM 30 YEARS OLD

READY.

10 PRINT "THE SKY IS RED"
20 PRINT "GRASS IS PURPLE"
30 PRINT "WATER IS YELLOW"
40 END

This program has wrong colors! Edit it to fix them:

• Type 10 PRINT "THE SKY IS BLUE"
• Type 20 PRINT "GRASS IS GREEN"
• Type 30 PRINT "WATER IS BLUE"
• Type RUN to see your corrected program

Deleting Lines

Sometimes you need to remove a line entirely from your program. BASIC makes this easy: type the line number by itself, with nothing after it.

How to Delete a Line

To delete line 20:

20

Just the number, then ENTER. That's it!

Line 20 is gone. Notice that line numbering doesn't change—line 10 is still 10, line 30 is still 30. You now have a gap where line 20 used to be.

Deleting Multiple Lines

Delete lines one at a time:

10
20
30

Why Delete Lines?

Common reasons to delete lines:

• Removing debug code: You added PRINT statements to find a problem; delete them when done
• Simplifying logic: You found a better way and don't need old code
• Fixing mistakes: You added a line you don't want

Delete vs. Edit

Remember the difference:

• Edit a line: Type the line number + new content
• Delete a line: Type the line number only

10 PRINT "KEEP THIS"
20 PRINT "DELETE ME"
30 PRINT "KEEP THIS"
40 PRINT "DELETE ME TOO"
50 PRINT "KEEP THIS"
60 END

Practice deleting lines:

• Type 20 to delete line 20
• Type 40 to delete line 40
• Type LIST to see what remains
• Type RUN to execute the cleaned-up program

Starting Fresh with NEW

The NEW command clears everything from memory—your entire program and all variables disappear. It's like wiping a chalkboard clean so you can start over.

When to Use NEW

Use NEW when you want to:

• Start writing a completely different program
• Clear out old code before typing in a new program
• Get a fresh start after experimenting

How NEW Works

Simply type:

NEW

Press ENTER. BASIC immediately:

1. Deletes all program lines
2. Clears all variables
3. Resets to a clean state
4. Shows the READY. prompt

Notice that LIST shows nothing—the program is completely gone.

NEW Is Permanent

Protecting Your Work

Before using NEW, make sure:

1. You don't need your current program anymore
2. You've saved anything important (we'll learn SAVE in Chapter 12)
3. You're ready to start completely fresh

NEW vs. Delete

Compare these approaches:

Delete individual lines:

10
20
30
(Specific lines removed)

Clear everything:

NEW
(All lines removed)

Use individual deletion when editing. Use NEW when starting completely fresh.

10 PRINT "OLD PROGRAM"
20 PRINT "ABOUT TO BE CLEARED"
30 END

See NEW in action:

• Type LIST to see the current program
• Type NEW to clear everything
• Type LIST again (nothing will appear)
• Enter a new program: 10 PRINT "NEW PROGRAM"
• Type LIST to see your fresh start

Your Second Program: Name Greeter

Now that you know the basics of program management, let's write a more interactive program. This one will ask for your name and then greet you personally.

Introducing INPUT

We need a new command: INPUT. This tells BASIC to pause and wait for you to type something:

INPUT A$

The A$ is a string variable—a place to store text. The $ means "text" (we'll learn more about variables in Chapter 5).

The Program

Let's build this program together:

Step 1: Start fresh:

NEW

Step 2: Enter the program:

10 PRINT "HELLO! WHAT IS YOUR NAME?"
20 INPUT A$
30 PRINT "NICE TO MEET YOU, "; A$
40 PRINT "WELCOME TO BASIC PROGRAMMING!"
50 END

Step 3: Check your work:

LIST

Make sure all five lines appear correctly.

Step 4: Run the program:

RUN

When you see the ? prompt, type your name and press ENTER. The program uses your input!

How It Works

Let's examine each line:

Line 10: PRINT "HELLO! WHAT IS YOUR NAME?"

• Displays a question to the user

Line 20: INPUT A$

• Pauses and waits for input
• Shows a ? prompt
• Stores whatever you type in the variable A$

Line 30: PRINT "NICE TO MEET YOU, "; A$

• Prints text followed by the contents of A$
• The semicolon (;) combines text and variable without adding extra spaces

Line 40: PRINT "WELCOME TO BASIC PROGRAMMING!"

• Prints another message

Line 50: END

• Ends the program

Try It Yourself

10 PRINT "HELLO! WHAT IS YOUR NAME?"
20 INPUT A$
30 PRINT "NICE TO MEET YOU, "; A$
40 PRINT "WELCOME TO BASIC PROGRAMMING!"
50 END

Type RUN and enter your name when prompted. Run it multiple times with different names!

Challenge: Can you edit line 30 to say "HI" instead of "NICE TO MEET YOU"?

Progressive Practice

Let's write a few more programs, each slightly more complex than the last. This will reinforce what you've learned and introduce new concepts gradually.

Program 3: Simple Calculator

This program asks for two numbers and adds them:

NEW
10 PRINT "SIMPLE CALCULATOR"
20 PRINT "ENTER FIRST NUMBER:"
30 INPUT A
40 PRINT "ENTER SECOND NUMBER:"
50 INPUT B
60 PRINT "THE SUM IS:"; A + B
70 END

New Concepts:

• A and B are numeric variables (no $ because they hold numbers, not text)
• You can do math directly in a PRINT statement: PRINT A + B
• Multiple INPUT statements let you gather several pieces of information

10 PRINT "SIMPLE CALCULATOR"
20 PRINT "ENTER FIRST NUMBER:"
30 INPUT A
40 PRINT "ENTER SECOND NUMBER:"
50 INPUT B
60 PRINT "THE SUM IS:"; A + B
70 END

Try the calculator. Then challenge yourself: Can you add a line that multiplies the numbers too? (Hint: PRINT "THE PRODUCT IS:"; A * B)

Program 4: Multiple Greetings

This program shows how spacing and formatting affect output:

NEW
10 PRINT "================================"
20 PRINT "     WELCOME TO MY PROGRAM"
30 PRINT "================================"
40 PRINT
50 PRINT "WHAT IS YOUR NAME?"
60 INPUT N$
70 PRINT
80 PRINT "HELLO, "; N$; "!"
90 PRINT "IT'S GREAT TO MEET YOU!"
100 PRINT
110 PRINT "HAVE A WONDERFUL DAY!"
120 END

New Concepts:

• PRINT with no text prints a blank line (lines 40, 70, 100)
• Multiple semicolons let you combine several pieces: "HELLO, "; N$; "!"
• Spaces in quotes create visual structure (line 20)
• Drawing with characters creates borders (lines 10, 30)

10 PRINT "================================"
20 PRINT "     WELCOME TO MY PROGRAM"
30 PRINT "================================"
40 PRINT
50 PRINT "WHAT IS YOUR NAME?"
60 INPUT N$
70 PRINT
80 PRINT "HELLO, "; N$; "!"
90 PRINT "IT'S GREAT TO MEET YOU!"
100 PRINT
110 PRINT "HAVE A WONDERFUL DAY!"
120 END

Run this program and notice the spacing. Try editing it to add more blank lines or change the border characters.

Program 5: Age Calculator

This program does simple math with your input:

NEW
10 PRINT "AGE CALCULATOR"
20 PRINT
30 PRINT "WHAT YEAR WERE YOU BORN?"
40 INPUT Y
50 PRINT "IN 1985, YOU WILL BE:"; 1985 - Y; "YEARS OLD"
60 PRINT "IN 2030, YOU WILL BE:"; 2030 - Y; "YEARS OLD"
70 PRINT "IN 2050, YOU WILL BE:"; 2050 - Y; "YEARS OLD"
80 END

New Concepts:

• You can perform calculations with input: 1985 - Y
• The same variable can be used multiple times (lines 50, 60, 70)
• BASIC does the math before printing the result

10 PRINT "AGE CALCULATOR"
20 PRINT
30 PRINT "WHAT YEAR WERE YOU BORN?"
40 INPUT Y
50 PRINT "IN 1985, YOU WILL BE:"; 1985 - Y; "YEARS OLD"
60 PRINT "IN 2030, YOU WILL BE:"; 2030 - Y; "YEARS OLD"
70 PRINT "IN 2050, YOU WILL BE:"; 2050 - Y; "YEARS OLD"
80 END

Try the age calculator with different birth years. Notice how BASIC automatically performs the subtraction.

Common Beginner Mistakes

Every programmer makes mistakes—it's a normal part of learning! Here are the most common errors beginners encounter, and how to fix them.

Mistake 1: Forgetting Line Numbers

Problem: You typed a command without a line number.

What BASIC thinks: "Is this immediate mode or program mode? No line number, so it must be immediate mode. But PRINT "HELLO" by itself is fine in immediate mode..."

Actually, this works! But if you meant to add it to your program, you need:

10 PRINT "HELLO"

Fix: Always start program lines with a number.

Mistake 2: Typos in Keywords

Problem: You typed PRNT instead of PRINT.

Fix: BASIC keywords must be spelled exactly right. Double-check spelling!

Common typos:

• PRNT → Should be PRINT
• INPT → Should be INPUT
• GOTO → (This one is correct, but people often write GO TO)

Mistake 3: Missing Quotes

Problem: Text must be in quotes.

Fix:

10 PRINT "HELLO WORLD"

Rule: When printing literal text, surround it with quote marks. When printing variables, don't use quotes:

10 A$ = "BOB"
20 PRINT A$         (Correct: prints BOB)
30 PRINT "A$"       (Wrong: prints A$)

Mistake 4: Reusing Line Numbers Accidentally

Problem: You accidentally reused line 10, erasing your original line 10.

Fix: Be careful with line numbers! Check with LIST frequently to make sure you haven't overwritten something important.

Prevention: Use increments of 10 and always check what line number you're typing.

Mistake 5: Forgetting END

This isn't technically an error—BASIC will run programs without END—but it's a best practice:

10 PRINT "HELLO"
(Where's the END?)

Better:

10 PRINT "HELLO"
20 END

Why it matters: Without END, if you add more lines later, they might execute when you don't expect them to.

Mistake 6: Wrong Variable Type

Problem: A$ stores text, but you're trying to add a number to it.

Fix: Use A (without $) for numbers:

10 INPUT A
20 PRINT A + 5

Rule:

• Variables ending in $ are for text (strings)
• Variables without $ are for numbers

One More Thing: The LIST-RUN-FIX Cycle

Experienced programmers use this rhythm:

1. WRITE some lines
2. LIST to check what you entered
3. RUN to test your program
4. FIX any errors
5. Repeat until it works

This cycle is the heart of programming. You won't get everything perfect the first time—nobody does! The key is catching and fixing errors quickly.

Chapter Summary: You're a Programmer Now!

Congratulations! You've reached the end of Chapter 4, and you've accomplished something remarkable: you've become a programmer.

Let's review what you now know:

Line Numbers and Program Organization

• Programs consist of numbered lines (0-65535)
• Convention: start at 10, increment by 10
• BASIC automatically sorts lines by number
• Execution flows from lowest to highest line number

Essential Commands

• NEW — Clear memory and start fresh
• LIST — Display program (with range options: LIST 10-30, LIST -30, LIST 30-)
• RUN — Execute your program from start to finish
• END — Mark the end of a program

Editing Techniques

• Re-enter a line — Type line number + new content (replaces old)
• Delete a line — Type line number only
• Insert a line — Use a number between existing lines (e.g., 15 between 10 and 20)

Programming Concepts

• PRINT — Display text and numbers
• INPUT — Ask the user for information
• Variables — Store data (A$ for text, A for numbers)
• Semicolons — Combine output without extra spaces
• Blank lines — Use PRINT alone to add spacing

What You've Built

You've written five working programs:

1. Hello World — Your first program
2. Name Greeter — Interactive input and personalized output
3. Simple Calculator — Math with user input
4. Multiple Greetings — Formatted output with spacing
5. Age Calculator — Using variables in calculations

Each program taught you new skills, building on the previous one.

The Programming Mindset

Most importantly, you've learned the fundamental programming workflow:

Write code → Review code → Run code → Fix errors → Repeat

This cycle is the same whether you're writing a 10-line BASIC program or a million-line application. You've mastered the essentials!

What's Next

You're ready to explore BASIC more deeply. The remaining chapters will teach you:

• Chapter 5 — Variables and data types in detail
• Chapter 6 — Operators for calculations and comparisons
• Chapter 7 — Program flow control (loops, conditions, jumps)
• Chapter 8 — Advanced input and output formatting
• Chapter 9 — Arrays for handling collections of data
• Chapter 10 — Built-in functions for math and strings

But you already have everything you need to experiment and create. Don't wait—start writing programs now! The best way to learn programming is by doing.

One Final Interactive Challenge

Here's a blank slate. Write a program from scratch that:

1. Asks for two pieces of information (name and favorite number)
2. Displays a personalized message using both
3. Performs a calculation with the number (multiply by 2, add 10, etc.)

Start with NEW, then build your program line by line. Use everything you learned in this chapter. There's no "right" answer—be creative!

You've completed Chapter 4. You're no longer just learning about programming—you're a programmer.

Welcome to the community. Keep exploring, keep building, and keep learning.

Variables and Data Types

Introduction to Variables

Variables are the foundation of programming. They're named storage locations where your program keeps data—numbers, text, results of calculations—for later use. Think of variables as labeled boxes: you put values into them, retrieve those values when needed, and update them as your program runs.

In BASIC, variables are created automatically the moment you use them. No declaration is needed (except for arrays, which we'll cover in Chapter 9). Simply assign a value to a name, and that variable exists:

A = 10
NAME$ = "ALICE"
COUNT% = 0

Three variables now exist: A holds the number 10, NAME$ holds the text "ALICE", and COUNT% holds the integer 0.

SLP-BASIC supports three fundamental data types, each optimized for different kinds of data:

• Numeric variables (floating-point): For general-purpose numbers with decimal precision
• Integer variables (% suffix): For whole numbers requiring faster arithmetic
• String variables ($ suffix): For text and character data

The type suffix—or lack thereof—determines how BASIC treats your variable. A, A%, and A$ are three completely different variables. The suffix is part of the name, indicating the type of data the variable holds.

Understanding when to use each type is crucial for writing efficient, bug-free programs. This chapter covers everything you need to know about variables: naming rules, type characteristics, assignment syntax, and type mixing behavior.

Variable Naming Rules

BASIC variable names follow straightforward rules, but there's one critical quirk inherited from Commodore BASIC V2 that surprises programmers: only the first two characters are significant.

Basic Naming Rules

Variable names must:

1. Start with a letter (A-Z, case-insensitive)
2. Contain letters and numbers after the first character
3. End with a type suffix (% for integer, $ for string, nothing for numeric)

Valid variable names:

A                    ' Single-letter numeric variable
COUNT                ' Multi-character numeric variable
INDEX%               ' Integer variable
NAME$                ' String variable
X1                   ' Variable with number
TOTAL99              ' Variable with multiple numbers

Invalid variable names:

9LIVES               ' Cannot start with number
FIRST-NAME$          ' Hyphens not allowed
COUNT TOTAL          ' Spaces not allowed
MY.VALUE             ' Periods not allowed

The Two-Character Significance Rule

Here's the crucial detail: BASIC only looks at the first two characters of a variable name. Everything after the first two characters is ignored. This means:

COUNT = 10
COUNTER = 20
COUNTRY = 30
PRINT COUNT          ' Prints 30!

All three variable names start with "CO", so BASIC treats them as the same variable. The last assignment (COUNTRY = 30) overwrites the previous values. Only COUNT (or COUNTER, or COUNTRY—they're identical to BASIC) exists, and it holds 30.

This behavior is authentic to Commodore BASIC V2 and was a memory-saving measure in the 1980s. Modern programmers find it surprising, but it's preserved in SLP-BASIC for compatibility.

Practical Naming Strategies

Given the two-character limitation, effective variable naming requires planning:

Single-letter names for simple programs:

A = 5
B = 10
C = A + B

Two-letter names for clarity:

SC = 0              ' SCore
HP = 100            ' Hit Points
LV = 1              ' LeVel

Longer names for readability (remembering only first two matter):

NAME$ = "ALICE"     ' NA is the key
ADDRESS$ = "123"    ' AD is the key
NOTES$ = "HELLO"    ' NO is the key

The long names make your code more readable, but you must ensure the first two letters are unique across all variables of the same type.

Type Suffix Separation

The type suffix (%, $) creates separate namespaces. These are three different variables:

COUNT = 42          ' Numeric variable CO
COUNT% = 100        ' Integer variable CO%
COUNT$ = "MANY"     ' String variable CO$

Even though all three start with "CO", the suffix makes them distinct. You can have a numeric A, an integer A%, and a string A$ simultaneously without conflict.

Case Insensitivity

BASIC doesn't distinguish between uppercase and lowercase letters:

Name$ = "ALICE"
name$ = "BOB"
NAME$ = "CHARLIE"
PRINT name$         ' Prints CHARLIE

All four references are to the same variable. BASIC internally treats everything as uppercase, so Name$, name$, NAME$, and nAmE$ all refer to the same string variable.

This manual shows variable names in lowercase or mixed case for readability, but you can type them in any case you prefer.

Reserved Words

You cannot use BASIC keywords as variable names, but you can embed them:

FOR = 10            ' Error: FOR is a keyword
FORGET = 10         ' OK: Starts with FO
IFFY = 20           ' OK: Starts with IF

Since only the first two characters matter, FORGET and FOR would conflict anyway (both start with FO). Choose names that don't begin with keyword prefixes: avoid FO, NE, IF, GO, etc.

Numeric Variables

Numeric variables are BASIC's default variable type. When you use a variable name without a type suffix, you get a numeric variable. Numeric variables store floating-point numbers—numbers with decimal points and wide range.

Declaration and Assignment

Numeric variables are created automatically on first use:

X = 5               ' Create X, assign 5
PI = 3.14159        ' Create PI, assign π
TEMP = -40          ' Negative numbers work
HUGE = 1.7E38       ' Scientific notation

No declaration is needed. The moment you assign to a previously unused name, that variable exists and holds the assigned value.

IEEE 754 Single-Precision Format

SLP-BASIC uses IEEE 754 single-precision floating-point format for numeric variables. This is the same format used by most modern programming languages for their "float" type. The format provides:

Range: Approximately ±1.7 × 10^±38

• Smallest positive: ~1.2 × 10^-38
• Largest positive: ~3.4 × 10^38
• Symmetric negative range

Precision: Approximately 7 decimal digits

• 6-7 significant figures in most cases
• Precision decreases for very large or very small numbers
• Not suitable for financial calculations requiring exact decimal representation

This means you can represent huge numbers (1000000000) and tiny numbers (0.0000001), but you can't rely on exact representation beyond about 7 digits:

A = 1234567         ' Stored exactly
B = 12345678        ' Some precision lost
C = 123456789       ' More precision lost
PRINT C             ' May not print exactly 123456789

For most BASIC programs—games, educational software, scientific calculations—this precision is more than adequate. The Commodore 64 used a slightly different floating-point format with similar characteristics, so this behavior is authentic to the BASIC experience.

When to Use Numeric Variables

Use numeric variables when you need:

• Decimal values: 3.14, 0.5, -2.718
• Large numbers: Beyond ±32767 (integer range)
• Scientific notation: 1.23E-5, 6.022E23
• Division results: 10 / 3 = 3.333... (not an integer)
• Trigonometric functions: SIN, COS, TAN return floating-point
• Default behavior: When you're not sure, numeric works

Numeric variables are versatile but slower than integer variables for whole-number arithmetic. If you're only using whole numbers in a performance-critical loop, consider integer variables instead.

Numeric Variable Examples

<BasicCode>
PRINT "CALCULATING CIRCLE AREA"
RADIUS = 5
PI = 3.14159
AREA = PI * RADIUS * RADIUS
PRINT "RADIUS: "; RADIUS
PRINT "AREA: "; AREA
</BasicCode>

Common uses:

PRICE = 19.95       ' Money (note precision limits)
ANGLE = 45          ' Degrees (convert to radians for trig)
AVERAGE = 87.3      ' Statistical result
RATIO = 0.618       ' Proportions
DISTANCE = 1.5E8    ' Scientific: 150,000,000 km

Initialization Values

Newly created numeric variables automatically initialize to 0:

PRINT X             ' Prints 0 (X didn't exist before)
X = 10
PRINT X             ' Prints 10

This differs from some languages where uninitialized variables contain garbage. In BASIC, all variables start with a sensible default: 0 for numeric, 0 for integer, empty string for string.

Integer Variables

Integer variables, indicated by the % suffix, store whole numbers in a restricted range but offer significantly faster arithmetic. For programs with intensive calculations using only whole numbers, integers can noticeably improve performance.

Declaration and Assignment

Add % to the variable name to create an integer variable:

COUNT% = 0          ' Integer counter
INDEX% = 1          ' Array index
SCORE% = 1000       ' Game score
LIVES% = 3          ' Remaining lives

The % is part of the variable name. COUNT and COUNT% are completely different variables—one numeric (floating-point), one integer.

16-Bit Signed Integer Format

Integer variables use 16-bit signed integer format:

Range: -32768 to 32767

• Exactly 65536 possible values
• Stored as two bytes in memory
• Fixed range with no precision loss

Attempting to store values outside this range causes overflow:

BIG% = 40000        ' Error: overflow
SMALL% = -40000     ' Error: overflow
MAX% = 32767        ' OK: maximum value
MIN% = -32768       ' OK: minimum value

Unlike numeric variables that can represent huge numbers, integers have a hard limit. Know your data range before choosing integer variables.

Arithmetic Behavior

Integer arithmetic is exact for results within range:

A% = 100
B% = 200
C% = A% + B%        ' C% = 300 (exact)
D% = 10 / 3         ' D% = 3 (truncated, not rounded)

Division truncates toward zero (fractional parts are discarded):

X% = 10 / 3         ' X% = 3
Y% = 10 / 4         ' Y% = 2
Z% = -10 / 3        ' Z% = -3

This truncation can surprise beginners. If you need the remainder, use modulo arithmetic:

QUOTIENT% = 10 / 3  ' 3
REMAINDER% = 10 - (QUOTIENT% * 3)  ' 1

Performance Advantage

Integer arithmetic is faster than floating-point arithmetic—often 2-3 times faster on modern processors, and even more significant on the original 6502 hardware. For loops and counters, this adds up:

FOR I% = 1 TO 10000     ' Faster with I%
    TOTAL% = TOTAL% + 1
NEXT I%

Versus:

FOR I = 1 TO 10000      ' Slower with floating-point I
    TOTAL = TOTAL + 1
NEXT I

On a 1MHz Commodore 64, this difference was dramatic. In SLP-BASIC's WebAssembly implementation, it's less noticeable but still measurable in tight loops.

When to Use Integer Variables

Use integer variables when:

• Counting: Loop counters, iteration indices
• Whole numbers only: No decimals needed
• Range fits: Values guaranteed within ±32767
• Performance matters: Tight loops, intensive calculations
• Array indices: DIM A(100): FOR I%=0 TO 100: A(I%)=0: NEXT

Don't use integer variables when:

• Division produces fractions: 10 / 3 = 3.333... (lost in integer)
• Range uncertain: User input might exceed ±32767
• Decimal precision required: Money, measurements, scientific data
• Mixed with floating-point: Type conversions slow down performance

Integer Variable Examples

<BasicCode>
PRINT "INTEGER ARITHMETIC DEMO"
A% = 10
B% = 3
PRINT "A% = "; A%
PRINT "B% = "; B%
PRINT "A% + B% = "; A% + B%
PRINT "A% - B% = "; A% - B%
PRINT "A% * B% = "; A% * B%
PRINT "A% / B% = "; A% / B%
PRINT "(TRUNCATED, NOT ROUNDED)"
</BasicCode>

Common integer uses:

SCORE% = 0          ' Game score
LIVES% = 3          ' Player lives
LEVEL% = 1          ' Current level
COUNT% = 0          ' Items counted
INDEX% = 0          ' Array position
YEAR% = 1985        ' Year (within range)
DAY% = 15           ' Day of month
TRIES% = 10         ' Attempts remaining

String Variables

String variables, indicated by the $ suffix, store text data—characters, words, sentences, or any sequence of characters up to 255 bytes in length. Strings are fundamental to interactive programs that display text and accept user input.

Declaration and Assignment

Add $ to the variable name to create a string variable:

NAME$ = "ALICE"
MESSAGE$ = "HELLO, WORLD!"
EMPTY$ = ""
LETTER$ = "X"

Strings are enclosed in double quotes. The quotes delimit the string but aren't part of the stored value—NAME$ contains ALICE, not "ALICE".

String Length Limit

SLP-BASIC strings can hold up to 255 characters:

SHORT$ = "HI"       ' 2 characters
LONG$ = STRING$(255, "X")  ' 255 X's
TOOLONG$ = STRING$(300, "X")  ' Error: string too long

This limit is generous for most purposes. A full screen of C64 text (40×25 = 1000 characters) exceeds it, but typical strings—names, messages, input—fit easily.

The 255-character limit comes from using a single byte to store string length internally, a common design in 1980s BASIC implementations.

UTF-8 Encoding (Modern Enhancement)

Unlike original Commodore BASIC (which used PETSCII encoding), SLP-BASIC uses UTF-8 encoding for strings. This means you can use Unicode characters:

SMILE$ = "😊"       ' Emoji (if your terminal supports it)
ACCENT$ = "café"    ' Accented characters
GREEK$ = "π ≈ 3.14" ' Mathematical symbols

This is a modern enhancement for international text support. Be aware that multi-byte UTF-8 characters count toward the 255-byte limit based on their encoded size, not their visual character count.

String Operations

Strings can be concatenated (joined) with the + operator:

FIRST$ = "HELLO"
LAST$ = "WORLD"
FULL$ = FIRST$ + " " + LAST$
PRINT FULL$         ' Prints: HELLO WORLD

Strings can be compared with relational operators:

A$ = "APPLE"
B$ = "BANANA"
IF A$ < B$ THEN PRINT "A COMES FIRST"  ' True: alphabetically earlier

String comparison is case-sensitive and follows ASCII/UTF-8 ordering. Chapter 10 covers string functions (LEFT$, RIGHT$, MID$, LEN, etc.) in detail.

When to Use String Variables

Use string variables for:

• User input: Names, messages, commands
• Text display: Labels, prompts, output
• Character data: Single letters, codes
• Formatting: Building formatted output
• Parsing: Breaking down input into components

Essentially, if your data is text rather than numbers, use a string variable.

Empty Strings

The empty string ("") is a string containing zero characters:

EMPTY$ = ""
IF EMPTY$ = "" THEN PRINT "NOTHING HERE"  ' True
IF LEN(EMPTY$) = 0 THEN PRINT "LENGTH ZERO"  ' True

Empty strings are useful for initializing string variables, testing for input, and building strings character by character.

Initialization Values

Newly created string variables automatically initialize to the empty string:

PRINT LEN(NEWVAR$)  ' Prints 0 (NEWVAR$ didn't exist, now empty)
NEWVAR$ = "HELLO"
PRINT LEN(NEWVAR$)  ' Prints 5

Like numeric variables initializing to 0, string variables initialize to "", ensuring predictable behavior.

String Variable Examples

<BasicCode>
PRINT "STRING OPERATIONS"
FIRST$ = "HELLO"
LAST$ = "WORLD"
FULL$ = FIRST$ + " " + LAST$
PRINT FULL$
PRINT "LENGTH: "; LEN(FULL$)
PRINT "FIRST 5 CHARS: "; LEFT$(FULL$, 5)
</BasicCode>

Common string uses:

NAME$ = "ALICE"         ' User name
PROMPT$ = "ENTER NAME"  ' Input prompt
ANSWER$ = "YES"         ' User response
LINE$ = ""              ' Build string dynamically
MENU$ = "1) PLAY"       ' Menu option
ERROR$ = "INVALID"      ' Error message
CODE$ = "X1B2"          ' Alphanumeric code

Variable Assignment

Variable assignment stores a value in a variable. BASIC provides two syntaxes for assignment: with the optional LET keyword and without it. Both forms are equivalent; LET is a historical artifact preserved for compatibility.

Assignment Without LET

The modern, preferred syntax omits LET:

X = 10              ' Assign 10 to X
NAME$ = "ALICE"     ' Assign "ALICE" to NAME$
COUNT% = 0          ' Assign 0 to COUNT%

This is clear, concise, and matches most modern programming languages. The equals sign (=) is the assignment operator: the variable on the left receives the value on the right.

Assignment With LET

The traditional BASIC syntax includes the LET keyword:

LET X = 10
LET NAME$ = "ALICE"
LET COUNT% = 0

LET explicitly indicates assignment and was required in early BASIC dialects. By the time of Commodore BASIC V2, LET was optional. Most programmers omit it, but you'll see it in vintage program listings and old books.

SLP-BASIC accepts both forms. Choose whichever you prefer, but be consistent within your programs.

Assignment Expressions

The right side of an assignment can be any expression—literal values, variables, calculations, function calls:

A = 5               ' Literal number
B = A               ' Copy another variable
C = A + B           ' Arithmetic expression
D = SQR(C)          ' Function result
E = (A + B) * 2     ' Complex expression

The expression is evaluated first, then the result is stored in the variable:

X = 10
X = X + 1           ' Read X (10), add 1, store result (11) back in X
PRINT X             ' Prints 11

This pattern—reading a variable, modifying its value, storing the result back—is fundamental to programming. It looks strange mathematically (x = x + 1 has no solution!), but it makes perfect sense in programming: "take the current value of X, add 1, and make that the new value of X."

Multiple Assignments

BASIC doesn't support multiple assignment in one statement. You must assign variables one at a time:

A = 5               ' OK
B = 10              ' OK
A = B = 5           ' Not supported: syntax error

However, you can use multiple statements on one line with the colon separator:

10 A = 5: B = 10: C = 15

This is purely a space-saving technique. It doesn't execute faster or change program behavior.

Assignment vs. Comparison

The equals sign (=) serves two purposes in BASIC:

• Assignment (in statements): X = 10 stores 10 in X
• Comparison (in expressions): IF X = 10 tests whether X equals 10

Context determines which meaning applies:

X = 10              ' Assignment: store 10 in X
IF X = 10 THEN ...  ' Comparison: test if X equals 10
Y = (X = 10)        ' Comparison: Y gets -1 (true) or 0 (false)

This dual use can be confusing initially, but you'll quickly learn to recognise assignment (on its own) versus comparison (inside IF, WHILE, or an expression).

Assignment Examples

<BasicCode>
PRINT "ASSIGNMENT DEMONSTRATION"
X = 5
PRINT "X = "; X
X = X + 10
PRINT "X = X + 10"
PRINT "X NOW = "; X
Y = X * 2
PRINT "Y = X * 2"
PRINT "Y = "; Y
</BasicCode>

The CLR Command

The CLR command (short for "clear") erases all variables from memory while preserving your program. It's useful for resetting your program's state without retyping the entire program.

Syntax

CLR

CLR takes no parameters and returns nothing. It's a command, not a statement—you typically execute it in immediate mode or at the beginning of a program.

What CLR Does

CLR performs these actions:

1. Erases all variables: Numeric, integer, and string variables are removed
2. Erases all arrays: Arrays declared with DIM are removed
3. Resets DATA pointer: RESTORE to the first DATA statement
4. Clears user-defined functions: DEF FN definitions are erased
5. Preserves program: Your program lines remain intact

After CLR, it's as if you just loaded the program—no variables exist, but the program is ready to run.

When to Use CLR

Use CLR when:

• Testing a program repeatedly: Run, see results, CLR, modify, run again
• Program initialization: Some programs start with CLR to ensure clean state
• Debugging: Clear variables to test with fresh values
• After errors: If variables are in an inconsistent state, CLR resets everything

Don't use CLR if:

• You need variable values: CLR is destructive—variables are gone
• Program is running: CLR during execution may cause unpredictable behavior

CLR vs. NEW

Understand the difference:

• CLR: Erases variables, preserves program
• NEW: Erases variables AND program—total memory wipe

NEW is for starting fresh with a new program. CLR is for resetting variable state while keeping your program.

NEW                 ' Everything gone: program + variables
CLR                 ' Only variables gone: program remains

CLR in Programs

You can include CLR in a program line, typically at the beginning:

10 CLR
20 PRINT "VARIABLES CLEARED"
30 REM ... rest of program

This ensures a clean state every time the program runs. However, most programs don't need this—variables initialize to sensible defaults (0, 0%, "", or empty array) automatically.

Example: Using CLR

<BasicCode>
X = 10
NAME$ = "ALICE"
COUNT% = 5
PRINT "X = "; X
PRINT "NAME$ = "; NAME$
PRINT "COUNT% = "; COUNT%
CLR
PRINT "AFTER CLR:"
PRINT "X = "; X
PRINT "NAME$ = "; NAME$
PRINT "COUNT% = "; COUNT%
</BasicCode>

After CLR, all variables revert to their initial values: 0 for numeric, 0 for integer, empty string for string.

Type Mixing and Conversion

BASIC's three variable types—numeric, integer, and string—are distinct and incompatible in direct operations. Understanding how BASIC handles (or refuses to handle) type mixing is crucial for avoiding errors and writing correct programs.

Type Strictness

Each variable type is separate:

A = 10              ' Numeric variable
A% = 20             ' Integer variable (different from A)
A$ = "30"           ' String variable (different from both)

These three variables coexist independently. Changing one doesn't affect the others. The type suffix creates separate namespaces.

Automatic Type Conversion

BASIC automatically converts between numeric and integer types in expressions:

X = 10              ' Numeric
Y% = 20             ' Integer
Z = X + Y%          ' Z = 30 (numeric result)
W% = X + Y%         ' W% = 30 (integer result, X converted to integer)

Numeric and integer values mix freely in arithmetic. The result type depends on the receiving variable:

• Assigning to numeric variable: Result is floating-point
• Assigning to integer variable: Result is truncated to integer

Truncation happens automatically:

X = 10.7
Y% = X              ' Y% = 10 (truncated, not rounded)

This conversion is usually what you want, but be aware of truncation in integer assignments.

String Conversions Are Explicit

Strings do not automatically convert to or from numbers. You must use conversion functions:

• STR$(n): Convert number to string
• VAL(s$): Convert string to number

Attempting to mix types without conversion causes an error:

X = 10
NAME$ = "ALICE"
RESULT = X + NAME$  ' ERROR: TYPE MISMATCH

This error protects you from nonsensical operations. What would it mean to add 10 to "ALICE"? BASIC refuses to guess.

Explicit Conversion Examples

Convert number to string:

SCORE = 1000
MESSAGE$ = "YOUR SCORE: " + STR$(SCORE)
PRINT MESSAGE$      ' Prints: YOUR SCORE:  1000

Note: STR$ adds a leading space for positive numbers (for alignment with negative numbers, which have a - sign). This is authentic BASIC behavior.

Convert string to number:

INPUT "ENTER AGE"; A$
AGE = VAL(A$)       ' Convert string input to number
IF AGE < 18 THEN PRINT "TOO YOUNG"

VAL converts a string to its numeric value. If the string isn't a valid number, VAL returns 0:

X = VAL("123")      ' X = 123
Y = VAL("12.5")     ' Y = 12.5
Z = VAL("HELLO")    ' Z = 0 (not a number)

Type Mismatch Errors

The most common type-related error is ?TYPE MISMATCH ERROR, which occurs when:

• Assigning wrong type: Numeric to string variable
• Mixing incompatible types: String arithmetic
• Wrong argument type: Function expecting number receives string

Examples:

X = "HELLO"         ' Error: string assigned to numeric variable
NAME$ = 100         ' Error: number assigned to string variable
Y = 10 + "5"        ' Error: can't add number and string

Always match types: numeric/integer to numeric/integer variables, strings to string variables. Use conversion functions when crossing type boundaries.

Type Checking Best Practices

To avoid type errors:

1. Use clear naming conventions: Suffix string variables with $ and integer variables with %
2. Convert explicitly: Never rely on implicit string conversion (there isn't any)
3. Check input types: After INPUT to string variable, use VAL if you need a number
4. Test boundary cases: Try invalid input to see how your program handles it

Mixed-Type Expression Example

<BasicCode>
PRINT "TYPE CONVERSION DEMO"
X = 10
Y% = 3
PRINT "X (NUMERIC) = "; X
PRINT "Y% (INTEGER) = "; Y%
PRINT "X + Y% = "; X + Y%
PRINT "X / Y% = "; X / Y%
PRINT ""
S$ = "100"
PRINT "S$ (STRING) = "; S$
N = VAL(S$)
PRINT "VAL(S$) = "; N
PRINT "N + X = "; N + X
</BasicCode>

Summary Table of Variable Types

Common Mistakes and Gotchas

Learning BASIC's variable system involves avoiding several common pitfalls. This section documents the mistakes beginners (and experienced programmers new to BASIC) frequently make.

Mistake 1: Forgetting Two-Character Significance

The most surprising rule: only the first two characters of a variable name matter.

COUNTER = 10
COUNT = 20
PRINT COUNTER       ' Prints 20, not 10!

Solution: Plan variable names carefully. Use a prefix system (AA, AB, AC...) or check the first two characters of every variable in your program.

Mistake 2: Case Confusion

BASIC is case-insensitive. Name$ and NAME$ are the same variable.

Name$ = "ALICE"
PRINT name$         ' Prints ALICE (same variable)

This isn't usually a problem, but it surprises programmers from case-sensitive languages.

Solution: Pick one case style and stick with it. This manual uses lowercase or PascalCase for readability.

Mistake 3: Type Mismatch in Assignment

Assigning the wrong type to a variable causes errors:

X = "HELLO"         ' Error: string to numeric variable
NAME$ = 100         ' Error: number to string variable

Solution: Match types or use conversion functions (STR$, VAL). INPUT to string first, then convert to number if needed.

Mistake 4: String Arithmetic

You can't do arithmetic on strings without converting first:

A$ = "10"
B$ = "20"
C = A$ + B$         ' Error: TYPE MISMATCH

Solution: Convert with VAL:

C = VAL(A$) + VAL(B$)  ' C = 30

Mistake 5: Integer Overflow

Integer variables have a limited range (-32768 to 32767):

BIG% = 40000        ' Error: overflow

Solution: Use numeric variables for large numbers, or ensure your data fits the integer range.

Mistake 6: Integer Division Truncation

Integer division truncates, which can surprise:

X% = 10
Y% = 3
Z% = X% / Y%        ' Z% = 3, not 3.333...

The fractional part is discarded, not rounded.

Solution: Use numeric variables if you need decimal results:

Z = X% / Y%         ' Z = 3.333... (floating-point)

Mistake 7: Uninitialized Variable Assumptions

Assuming a variable has a specific value without initializing it:

10 TOTAL = TOTAL + 10
20 PRINT TOTAL
RUN

This works (TOTAL starts at 0, becomes 10), but if TOTAL already existed from a previous run, it starts with that value instead.

Solution: Always initialize variables explicitly:

10 TOTAL = 0
20 TOTAL = TOTAL + 10
30 PRINT TOTAL

Or use CLR at the program start to ensure clean state.

Mistake 8: Confusing A, A%, and A$

These are three completely different variables:

A = 10
A% = 20
A$ = "30"
PRINT A             ' Prints 10
PRINT A%            ' Prints 20
PRINT A$            ' Prints 30

Solution: Use distinct base names for different purposes. Don't rely on type suffixes to differentiate logically unrelated variables.

Mistake 9: Forgetting String Length Limit

Strings are limited to 255 characters:

LONG$ = STRING$(300, "X")  ' Error: string too long

Solution: Check string length with LEN before operations that might exceed 255 characters. Split long text into multiple variables if needed.

Mistake 10: Assuming String = Empty Means False

In BASIC, comparisons return -1 (true) or 0 (false), not boolean types:

A$ = ""
IF A$ = "" THEN PRINT "EMPTY"  ' Correct
IF A$ THEN PRINT "NOT EMPTY"   ' Wrong: doesn't work as expected

BASIC doesn't treat empty string as false in boolean context.

Solution: Always use explicit comparisons: IF A$ = "" or IF LEN(A$) = 0.

Summary

Variables are the foundation of BASIC programming. This chapter covered:

• Variable naming rules: Start with letter, first two characters significant, case-insensitive
• Numeric variables: IEEE 754 single-precision, ±1.7E±38 range, ~7 digits precision
• Integer variables: % suffix, -32768 to 32767, faster arithmetic, exact for whole numbers
• String variables: $ suffix, up to 255 characters, UTF-8 encoded
• Assignment syntax: With or without LET (LET is optional and typically omitted)
• CLR command: Erases variables, preserves program
• Type conversion: Automatic between numeric/integer, explicit (STR$/VAL) for strings
• Common mistakes: Two-character significance, type mismatches, integer overflow

Key takeaways:

1. Plan variable names carefully: The two-character significance rule requires thoughtful naming
2. Choose the right type: Numeric for decimals and large numbers, integer for fast whole-number math, string for text
3. Convert explicitly: Always use STR$ and VAL when crossing the number/string boundary
4. Initialize variables: Don't assume initial values (even though they're predictable)
5. Match types: Keep numeric with numeric, string with string, to avoid TYPE MISMATCH errors

With solid understanding of variables and data types, you're ready to explore operators (Chapter 6) and program flow control (Chapter 7)—the tools that turn static data into dynamic programs that calculate, decide, and respond to user input.

End of Chapter 5

Proceed to Chapter 6: Operators to learn how to manipulate variables with arithmetic, comparison, and logical operators.

Operators

Understanding Operators

Operators are the symbols that tell BASIC how to combine, compare, and manipulate values. They're the mathematical and logical machinery that transforms static data into dynamic computation. Whether you're adding two numbers, comparing values for equality, or combining logical conditions, operators are your tools.

BASIC provides five categories of operators:

Arithmetic Operators: Perform mathematical calculations (+, -, *, /, ^)

Comparison Operators: Compare values and return true or false (=, <>, <, >, <=, >=)

Logical Operators: Combine and invert logical conditions (AND, OR, NOT)

String Operator: Concatenate strings together (+)

Parentheses: Group operations and override default precedence

Understanding operator precedence—the order in which operations execute—is essential for writing correct programs. BASIC follows mathematical conventions but adds logical operators that require attention. This chapter provides the comprehensive reference you need to master operators and write clear, correct expressions.

Arithmetic Operators

Arithmetic operators perform mathematical calculations. BASIC supports the five fundamental operations: addition, subtraction, multiplication, division, and exponentiation.

Addition (+)

The addition operator adds two numeric values:

PRINT 5 + 3
 8

Addition works with any numeric type—floating-point, integer, or combinations:

A = 10
B% = 5
PRINT A + B%
 15

Subtraction (-)

The subtraction operator subtracts the right value from the left value:

PRINT 10 - 3
 7

Subtraction can produce negative results:

PRINT 5 - 10
-5

Multiplication (*)

The multiplication operator multiplies two values:

PRINT 6 * 7
 42

Use multiplication for repeated addition, area calculations, and scaling:

PRICE = 19.95
QUANTITY = 3
TOTAL = PRICE * QUANTITY
PRINT TOTAL
 59.85

Division (/)

The division operator divides the left value by the right value:

PRINT 20 / 4
 5

Division always produces a floating-point result, even when dividing integers evenly:

PRINT 10 / 2
 5

Example of safe division:

10 INPUT "ENTER DIVISOR"; D
20 IF D = 0 THEN PRINT "CANNOT DIVIDE BY ZERO": GOTO 10
30 PRINT "RESULT: "; 100 / D

Exponentiation (^)

The exponentiation operator raises the left value to the power of the right value:

PRINT 2 ^ 3
 8

This is equivalent to 2 × 2 × 2. Exponentiation is useful for squares, cubes, and exponential growth:

PRINT 5 ^ 2
 25

PRINT 10 ^ 3
 1000

PRINT 2 ^ 10
 1024

Exponentiation supports fractional exponents for roots:

PRINT 16 ^ 0.5
 4

This calculates the square root (16^0.5 = √16 = 4).

Negative exponents produce reciprocals:

PRINT 2 ^ -3
 0.125

This is equivalent to 1/(2^3) = 1/8 = 0.125.

Unary Minus

The minus sign can also be used as a unary operator to negate a value:

A = 10
PRINT -A
-10

Unary minus has higher precedence than binary operators (except exponentiation), so:

PRINT -2 ^ 2
-4

This calculates -(2^2) = -4, not (-2)^2 = 4. Use parentheses for the latter:

PRINT (-2) ^ 2
 4

Operator Precedence

When an expression contains multiple operators, BASIC evaluates them in a specific order called precedence. Understanding precedence ensures your expressions calculate correctly.

Precedence Table

From highest precedence (evaluated first) to lowest (evaluated last):

Operators with equal precedence are evaluated left-to-right (except exponentiation, which is right-to-left).

Precedence Examples

Multiplication before addition:

PRINT 2 + 3 * 4
 14

Calculation: 3 * 4 = 12, then 2 + 12 = 14, not (2 + 3) * 4 = 20.

Exponentiation before multiplication:

PRINT 2 * 3 ^ 2
 18

Calculation: 3 ^ 2 = 9, then 2 * 9 = 18, not (2 * 3) ^ 2 = 36.

Division and multiplication left-to-right:

PRINT 20 / 4 * 2
 10

Calculation: 20 / 4 = 5, then 5 * 2 = 10, not 20 / (4 * 2) = 2.5.

Unary minus before exponentiation:

PRINT -2 ^ 2
-4

Calculation: 2 ^ 2 = 4, then -(4) = -4, not (-2) ^ 2 = 4.

Parentheses override precedence:

PRINT (2 + 3) * 4
 20

Calculation: (2 + 3) = 5, then 5 * 4 = 20.

When Precedence Matters

Precedence errors are common sources of bugs. Consider calculating a temperature conversion:

Incorrect (precedence error):

10 INPUT "CELSIUS"; C
20 F = C * 9 / 5 + 32
30 PRINT "FAHRENHEIT: "; F

This works correctly because multiplication and division happen before addition (left-to-right). But if written differently:

Also correct:

20 F = 9 / 5 * C + 32

This also works: 9 / 5 = 1.8, then 1.8 * C, then + 32.

Incorrect (if you forget precedence):

20 F = 9 * C / 5 + 32

This looks different but is actually correct due to left-to-right evaluation. The key is understanding what's happening:

• 9 * C is calculated first
• Result / 5 is calculated next
• Result + 32 is calculated last

When in doubt, use parentheses for clarity:

20 F = (C * 9 / 5) + 32

Or even more explicit:

20 F = ((C * 9) / 5) + 32

Extra parentheses don't hurt performance, and they make your intention crystal clear.

Comparison Operators

Comparison operators compare two values and return a logical result. In BASIC, these operators return numeric values: -1 for true and 0 for false. This is different from many modern languages but consistent with Commodore BASIC V2.

The Six Comparison Operators

Equal (=): Returns true if both values are equal:

PRINT 5 = 5
-1

PRINT 5 = 6
 0

Not Equal (<>): Returns true if values are different:

PRINT 5 <> 6
-1

PRINT 5 <> 5
 0

Less Than (<): Returns true if left value is less than right value:

PRINT 3 < 5
-1

PRINT 5 < 3
 0

Greater Than (>): Returns true if left value is greater than right value:

PRINT 5 > 3
-1

PRINT 3 > 5
 0

Less Than or Equal (<=): Returns true if left value is less than or equal to right value:

PRINT 3 <= 5
-1

PRINT 5 <= 5
-1

PRINT 6 <= 5
 0

Greater Than or Equal (>=): Returns true if left value is greater than or equal to right value:

PRINT 5 >= 3
-1

PRINT 5 >= 5
-1

PRINT 3 >= 5
 0

Using Comparisons in IF Statements

Comparisons are most commonly used in conditional statements:

10 INPUT "ENTER AGE"; AGE
20 IF AGE >= 18 THEN PRINT "ADULT"
30 IF AGE < 18 THEN PRINT "MINOR"

The IF statement evaluates the comparison. If the result is non-zero (true), the THEN clause executes.

Comparing Strings

Comparison operators work with strings, using alphabetical (lexicographic) order:

PRINT "APPLE" < "BANANA"
-1

PRINT "ZEBRA" > "AARDVARK"
-1

PRINT "CAT" = "CAT"
-1

PRINT "cat" = "CAT"
-1

String comparisons are case-insensitive in BASIC. "CAT" and "cat" are considered equal.

String comparison compares character by character:

PRINT "ABC" < "ABD"
-1

The first two characters match, but "C" < "D", so "ABC" < "ABD".

True and False Values

Because true is -1 and false is 0, you can use comparison results in arithmetic:

A = 5
B = 10
RESULT = (A < B) * 100
PRINT RESULT
 100

Since A < B is true (-1), the result is -1 * 100 = -100. Wait, that's not right! Let's reconsider:

Actually, the result is indeed -100 due to -1 representing true. To get 100, use:

RESULT = -(A < B) * 100

The negation converts -1 to 1, yielding 100.

More commonly, comparisons are used in logical contexts where the -1/0 distinction doesn't matter:

10 IF SCORE >= 90 THEN GRADE$ = "A"
20 IF SCORE >= 80 AND SCORE < 90 THEN GRADE$ = "B"

id="basic-comparison-examples"
  title="Comparison Operator Examples"
  language="basic"
  preload="PRINT \"5 = 5: \"; 5 = 5
PRINT \"5 <> 6: \"; 5 <> 6
PRINT \"3 < 5: \"; 3 < 5
PRINT \"5 > 3: \"; 5 > 3
PRINT \"5 <= 5: \"; 5 <= 5
PRINT \"5 >= 5: \"; 5 >= 5
PRINT
PRINT \"String comparisons:\"
PRINT \"APPLE < BANANA: \"; \"APPLE\" < \"BANANA\"
PRINT \"cat = CAT: \"; \"cat\" = \"CAT\""

Logical Operators

Logical operators combine or invert logical conditions. BASIC provides three logical operators: AND, OR, and NOT. These operators work on numeric values, treating 0 as false and any non-zero value (particularly -1) as true.

AND Operator

The AND operator returns true only if both operands are true:

PRINT -1 AND -1
-1

PRINT -1 AND 0
 0

PRINT 0 AND -1
 0

PRINT 0 AND 0
 0

AND Truth Table

Practical use: Combining conditions that must all be true:

10 INPUT "ENTER AGE"; AGE
20 INPUT "HAVE LICENSE (1=YES, 0=NO)"; LIC
30 IF AGE >= 16 AND LIC = 1 THEN PRINT "CAN DRIVE"
40 IF AGE < 16 OR LIC = 0 THEN PRINT "CANNOT DRIVE"

OR Operator

The OR operator returns true if either or both operands are true:

PRINT -1 OR -1
-1

PRINT -1 OR 0
-1

PRINT 0 OR -1
-1

PRINT 0 OR 0
 0

OR Truth Table

Practical use: Allowing multiple conditions where any can satisfy:

10 INPUT "ENTER DAY"; DAY$
20 IF DAY$ = "SATURDAY" OR DAY$ = "SUNDAY" THEN PRINT "WEEKEND"
30 IF DAY$ <> "SATURDAY" AND DAY$ <> "SUNDAY" THEN PRINT "WEEKDAY"

NOT Operator

The NOT operator inverts a logical value—true becomes false, false becomes true:

PRINT NOT -1
 0

PRINT NOT 0
-1

NOT Truth Table

Practical use: Inverting conditions:

10 INPUT "CONTINUE (1=YES, 0=NO)"; CONT
20 IF NOT CONT THEN END
30 PRINT "CONTINUING..."

Combining Logical Operators

Logical operators can be combined for complex conditions:

10 INPUT "AGE"; AGE
20 INPUT "INCOME"; INC
30 INPUT "CITIZEN (1/0)"; CIT
40 IF (AGE >= 18 AND AGE <= 65) AND (INC > 20000 OR CIT = 1) THEN PRINT "ELIGIBLE"

Remember precedence: NOT is evaluated before AND, which is evaluated before OR. Use parentheses generously:

' Without parentheses (may be ambiguous)
IF A = 1 OR B = 2 AND C = 3 THEN PRINT "YES"

' With parentheses (clear intention)
IF A = 1 OR (B = 2 AND C = 3) THEN PRINT "YES"

Bitwise Behavior

AND and OR are actually bitwise operators in BASIC. They operate on the binary representation of integers:

PRINT 5 AND 3
 1

Why? In binary:

• 5 = 0101
• 3 = 0011
• AND = 0001 = 1

PRINT 5 OR 3
 7

In binary:

• 5 = 0101
• 3 = 0011
• OR = 0111 = 7

For logical conditions using comparisons (which return -1 or 0), bitwise behavior doesn't matter. But if you're working with numeric flags or bit manipulation, understand that AND/OR operate on bits.

String Concatenation

While most operators work with numbers, the addition operator (+) also concatenates (joins) strings when both operands are strings:

FIRST$ = "HELLO"
LAST$ = "WORLD"
RESULT$ = FIRST$ + LAST$
PRINT RESULT$
HELLOWORLD

Notice there's no space between the words. To add a space:

RESULT$ = FIRST$ + " " + LAST$
PRINT RESULT$
HELLO WORLD

Building Strings Incrementally

String concatenation is useful for building output:

10 INPUT "FIRST NAME"; F$
20 INPUT "LAST NAME"; L$
30 FULL$ = F$ + " " + L$
40 GREETING$ = "HELLO, " + FULL$ + "!"
50 PRINT GREETING$

If you enter "JOHN" and "DOE":

HELLO, JOHN DOE!

Concatenating Multiple Strings

You can chain multiple concatenations:

A$ = "THE "
B$ = "QUICK "
C$ = "BROWN "
D$ = "FOX"
RESULT$ = A$ + B$ + C$ + D$
PRINT RESULT$
THE QUICK BROWN FOX

Concatenation Limits

Strings in BASIC are limited to 255 characters. If concatenation exceeds this limit, the result is truncated:

A$ = STRING$(200, "A")  ' 200 A's
B$ = STRING$(100, "B")  ' 100 B's
C$ = A$ + B$           ' Would be 300 chars
PRINT LEN(C$)
 255

Wait—STRING$ isn't a standard BASIC V2 function. Let me correct that example:

' Building a long string
A$ = ""
FOR I = 1 TO 200
  A$ = A$ + "A"
NEXT I
PRINT LEN(A$)
 200
' Adding more would be truncated at 255 total

Practical String Concatenation

10 SCORE% = 95
20 MSG$ = "YOUR SCORE: " + STR$(SCORE%) + " POINTS"
30 PRINT MSG$
YOUR SCORE:  95  POINTS

Notice STR$ adds a leading space for positive numbers. To remove it:

20 MSG$ = "YOUR SCORE: " + MID$(STR$(SCORE%), 2) + " POINTS"

Using MID$ to skip the first character (the space).

Using Parentheses

Parentheses override operator precedence, allowing you to control the order of evaluation. When an expression contains parentheses, BASIC evaluates the innermost parentheses first, working outward.

Basic Grouping

Force addition before multiplication:

PRINT 2 + 3 * 4
 14

PRINT (2 + 3) * 4
 20

Without parentheses: 3 * 4 = 12, then 2 + 12 = 14 With parentheses: 2 + 3 = 5, then 5 * 4 = 20

Nested Parentheses

Parentheses can be nested to any depth:

PRINT ((2 + 3) * (4 + 5)) / 3
 15

Evaluation order:

1. (2 + 3) = 5
2. (4 + 5) = 9
3. 5 * 9 = 45
4. 45 / 3 = 15

Clarifying Complex Expressions

Even when parentheses aren't strictly necessary, they improve readability:

Unclear:

10 RESULT = A * B + C / D - E ^ F

Clear:

10 RESULT = (A * B) + (C / D) - (E ^ F)

Both calculate the same value, but the second makes the order obvious.

Logical Grouping

Parentheses are essential for complex logical conditions:

10 INPUT "AGE"; AGE
20 INPUT "STUDENT (1/0)"; STU
30 INPUT "SENIOR (1/0)"; SEN
40 IF (AGE < 18 OR STU = 1) AND NOT SEN THEN PRINT "DISCOUNT"

Without parentheses around "AGE < 18 OR STU = 1", precedence would evaluate differently:

' Wrong: IF AGE < 18 OR (STU = 1 AND NOT SEN)

Mathematical Formulas

Complex formulas often require careful parenthesization:

Quadratic formula: x = (-b ± √(b² - 4ac)) / 2a

10 INPUT "A, B, C"; A, B, C
20 DISC = B ^ 2 - 4 * A * C
30 IF DISC < 0 THEN PRINT "NO REAL ROOTS": END
40 X1 = (-B + SQR(DISC)) / (2 * A)
50 X2 = (-B - SQR(DISC)) / (2 * A)
60 PRINT "X1 = "; X1
70 PRINT "X2 = "; X2

Note the parentheses around (2 * A) to ensure the entire numerator is divided by 2A, not just divided by 2 then multiplied by A.

Comparison Grouping

When using comparisons with logical operators, parentheses clarify intention:

' Check if value is in range 10-20 or 30-40
IF (X >= 10 AND X <= 20) OR (X >= 30 AND X <= 40) THEN PRINT "IN RANGE"

Without the outer parentheses, this still works due to AND having higher precedence than OR. But the parentheses make it obvious.

Practical Examples

Let's apply operators to real-world programming scenarios, demonstrating how arithmetic, comparison, logical, and string operators work together.

Example 1: Loan Payment Calculator

Calculate monthly loan payment using the formula: Payment = P × (r(1+r)^n) / ((1+r)^n - 1)

10 PRINT "LOAN PAYMENT CALCULATOR"
20 PRINT
30 INPUT "LOAN AMOUNT"; P
40 INPUT "ANNUAL INTEREST RATE (%)"; R
50 INPUT "LOAN TERM (YEARS)"; Y
60 R = R / 100 / 12  ' Convert to monthly decimal rate
70 N = Y * 12        ' Convert years to months
80 IF R = 0 THEN PMT = P / N: GOTO 110
90 T = (1 + R) ^ N
100 PMT = P * (R * T) / (T - 1)
110 PRINT
120 PRINT "MONTHLY PAYMENT: $"; INT(PMT * 100 + 0.5) / 100

What's happening:

• Line 60: Multiple divisions for rate conversion
• Line 70: Multiplication for term conversion
• Line 80: Comparison and division for zero-interest case
• Line 90: Exponentiation for compound interest factor
• Line 100: Complex arithmetic expression with proper parentheses
• Line 120: Multiplication, addition, division for rounding

Example 2: Grade Calculator

Determine letter grade based on numeric score with complex conditions:

10 INPUT "ENTER SCORE (0-100)"; S
20 IF S < 0 OR S > 100 THEN PRINT "INVALID": GOTO 10
30 IF S >= 90 THEN G$ = "A": GOTO 100
40 IF S >= 80 THEN G$ = "B": GOTO 100
50 IF S >= 70 THEN G$ = "C": GOTO 100
60 IF S >= 60 THEN G$ = "D": GOTO 100
70 G$ = "F"
100 PRINT "GRADE: "; G$
110 IF G$ = "A" OR G$ = "B" THEN PRINT "EXCELLENT WORK!"
120 IF G$ = "C" THEN PRINT "SATISFACTORY"
130 IF G$ = "D" OR G$ = "F" THEN PRINT "NEEDS IMPROVEMENT"

What's happening:

• Line 20: OR operator with comparisons for validation
• Lines 30-70: Sequential comparisons for grade determination
• Lines 110-130: OR operators for grouped feedback

Example 3: Tax Calculator

Calculate tax with progressive brackets:

10 INPUT "TAXABLE INCOME"; INC
20 TAX = 0
30 IF INC <= 10000 THEN TAX = INC * 0.1: GOTO 100
40 TAX = 10000 * 0.1
50 IF INC <= 40000 THEN TAX = TAX + (INC - 10000) * 0.2: GOTO 100
60 TAX = TAX + 30000 * 0.2
70 TAX = TAX + (INC - 40000) * 0.3
100 PRINT "TAX: $"; INT(TAX * 100 + 0.5) / 100
110 PRINT "EFFECTIVE RATE: "; INT(TAX / INC * 10000 + 0.5) / 100; "%"

What's happening:

• Comparisons determine which bracket applies
• Subtraction calculates amount in each bracket
• Multiplication applies bracket rate
• Accumulation through addition
• Division for percentage calculation

Example 4: Distance Calculator

Calculate distance between two points: d = √((x₂-x₁)² + (y₂-y₁)²)

10 PRINT "DISTANCE CALCULATOR"
20 INPUT "X1, Y1"; X1, Y1
30 INPUT "X2, Y2"; X2, Y2
40 DX = X2 - X1
50 DY = Y2 - Y1
60 DIST = SQR(DX ^ 2 + DY ^ 2)
70 PRINT "DISTANCE: "; DIST

What's happening:

• Line 40-50: Subtraction for delta values
• Line 60: Exponentiation for squares, addition, then SQR
• Parentheses not needed due to precedence (^ before +, SQR operates on entire result)

But for clarity, could write:

60 DIST = SQR((DX ^ 2) + (DY ^ 2))

Example 5: Leap Year Detector

A year is a leap year if divisible by 4, except centuries (divisible by 100) unless also divisible by 400:

10 INPUT "ENTER YEAR"; Y
20 IF Y MOD 400 = 0 THEN PRINT "LEAP YEAR": GOTO 100
30 IF Y MOD 100 = 0 THEN PRINT "NOT LEAP YEAR": GOTO 100
40 IF Y MOD 4 = 0 THEN PRINT "LEAP YEAR": GOTO 100
50 PRINT "NOT LEAP YEAR"
100 END

Wait—MOD isn't available in Commodore BASIC V2. Let me rewrite using subtraction:

10 INPUT "ENTER YEAR"; Y
20 ' Check if divisible by 400
30 IF Y / 400 = INT(Y / 400) THEN PRINT "LEAP YEAR": GOTO 200
40 ' Check if divisible by 100
50 IF Y / 100 = INT(Y / 100) THEN PRINT "NOT LEAP YEAR": GOTO 200
60 ' Check if divisible by 4
70 IF Y / 4 = INT(Y / 4) THEN PRINT "LEAP YEAR": GOTO 200
80 PRINT "NOT LEAP YEAR"
200 END

What's happening:

• Division and INT comparison checks divisibility
• Comparison operators test equality
• Sequential IF statements implement logical priority

Example 6: String Formatter

Build formatted output with string concatenation:

10 INPUT "FIRST NAME"; F$
20 INPUT "LAST NAME"; L$
30 INPUT "AGE"; A
40 INPUT "CITY"; C$
50 FULL$ = F$ + " " + L$
60 INFO$ = FULL$ + ", AGE " + STR$(A) + ", FROM " + C$
70 PRINT
80 PRINT "PROFILE:"
90 PRINT INFO$
100 PRINT
110 BORDER$ = ""
120 FOR I = 1 TO LEN(INFO$)
130   BORDER$ = BORDER$ + "="
140 NEXT I
150 PRINT BORDER$

What's happening:

• String concatenation builds full name and info string
• STR$ converts numeric age to string for concatenation
• Loop with concatenation builds border of equal signs

id="basic-practical-operators"
  title="Practical Operator Examples"
  language="basic"
  preload="10 REM DISTANCE CALCULATOR
20 X1=0: Y1=0: X2=3: Y2=4
30 DX = X2 - X1
40 DY = Y2 - Y1
50 DIST = SQR(DX^2 + DY^2)
60 PRINT \"DISTANCE: \"; DIST
70 PRINT
80 REM GRADE CALCULATOR
90 S = 85
100 IF S >= 90 THEN G$ = \"A\"
110 IF S >= 80 AND S < 90 THEN G$ = \"B\"
120 IF S >= 70 AND S < 80 THEN G$ = \"C\"
130 PRINT \"SCORE \"; S; \" = GRADE \"; G$
RUN"

Common Mistakes and How to Avoid Them

Operators seem simple, but certain patterns consistently cause problems. Here are the most common mistakes and how to avoid them.

Mistake 1: Forgetting Operator Precedence

Problem:

10 PRINT "TOTAL: $"; PRICE + TAX * 1.08

If PRICE = 100 and TAX = 10, this prints 110.8, not 118.8, because TAX * 1.08 is calculated first (10.8), then added to PRICE (100 + 10.8 = 110.8).

Solution: Use parentheses to make intent clear:

10 PRINT "TOTAL: $"; (PRICE + TAX) * 1.08

Mistake 2: Confusing = in Comparisons

Problem:

10 IF A = B = C THEN PRINT "ALL EQUAL"

This doesn't check if A, B, and C are all equal. It evaluates as:

1. A = B produces -1 or 0
2. That result is compared to C

Solution: Use AND to combine comparisons:

10 IF A = B AND B = C THEN PRINT "ALL EQUAL"

Mistake 3: Division by Zero

Problem:

10 INPUT "DIVISOR"; D
20 PRINT 100 / D

If user enters 0, you get ?DIVISION BY ZERO ERROR and program halts.

Solution: Always validate divisors:

10 INPUT "DIVISOR"; D
20 IF D = 0 THEN PRINT "CANNOT DIVIDE BY ZERO": GOTO 10
30 PRINT 100 / D

Mistake 4: Mixing Strings and Numbers

Problem:

10 NAME$ = "SCORE: " + 95

This produces ?TYPE MISMATCH ERROR because + can't concatenate string and number directly.

Solution: Convert number to string:

10 NAME$ = "SCORE: " + STR$(95)

Mistake 5: Incorrect Exponentiation Order

Problem:

10 PRINT 2 ^ 3 ^ 2

Expecting (2^3)^2 = 8^2 = 64, but getting 512 because exponentiation is right-associative: 2^(3^2) = 2^9 = 512.

Solution: Use parentheses for left-to-right evaluation:

10 PRINT (2 ^ 3) ^ 2

Mistake 6: Unary Minus with Exponentiation

Problem:

10 PRINT -2 ^ 2

Expecting 4 (negative two squared), but getting -4 because it calculates -(2^2).

Solution: Parenthesize the negative number:

10 PRINT (-2) ^ 2

Mistake 7: Assuming Boolean Short-Circuit

Problem:

10 IF D <> 0 AND 100 / D > 5 THEN PRINT "VALID"

In some languages, if D = 0, the second condition isn't evaluated (short-circuit). But BASIC evaluates both sides, causing ?DIVISION BY ZERO ERROR.

Solution: Use nested IF statements:

10 IF D <> 0 THEN IF 100 / D > 5 THEN PRINT "VALID"

Or separate lines:

10 IF D = 0 THEN GOTO 100
20 IF 100 / D > 5 THEN PRINT "VALID"
100 REM Continue

Mistake 8: Confusing -1 and 1 for True

Problem:

10 A = 5 > 3  ' A = -1 (true)
20 PRINT A * 10  ' Expecting 10, get -10

Solution: If using comparison results arithmetically, negate or adjust:

10 A = -(5 > 3)  ' A = 1
20 PRINT A * 10  ' Prints 10

Or better, avoid arithmetic on boolean results:

10 IF 5 > 3 THEN A = 1 ELSE A = 0

Wait, ELSE isn't in Commodore BASIC V2:

10 A = 0
20 IF 5 > 3 THEN A = 1
30 PRINT A * 10

Summary

Operators are the computational heart of BASIC, transforming static values into dynamic calculations and logical decisions. This chapter covered all operator categories:

Arithmetic Operators (+, -, *, /, ^) perform mathematical calculations following standard mathematical conventions, with exponentiation as the highest-precedence arithmetic operator and right-associative behavior.

Operator Precedence determines evaluation order: parentheses first, then exponentiation, then multiplication/division, then addition/subtraction, then comparison, then logical operators (NOT, AND, OR). When in doubt, use parentheses to clarify.

Comparison Operators (=, <>, <, >, <=, >=) compare values and return -1 for true, 0 for false—a Commodore BASIC convention that differs from modern languages but enables consistent logical operations.

Logical Operators (AND, OR, NOT) combine and invert logical conditions. They're bitwise operators working on integer representations, but for comparisons returning -1/0, they behave as expected logical operators.

String Concatenation (+) joins strings together, building formatted output and dynamic text. Remember to convert numbers to strings with STR$ before concatenation.

Parentheses override precedence and clarify intention. Use them liberally—clarity is more valuable than brevity.

Understanding operators is essential for writing correct BASIC programs. The precedence rules, while straightforward, require attention in complex expressions. When combined with variables (Chapter 5) and flow control (Chapter 7), operators enable sophisticated programs that process data, make decisions, and solve real problems.

Practice with operators in immediate mode before using them in programs. Test expressions, verify precedence, and confirm your understanding. The InteractiveREPL examples throughout this chapter provide hands-on practice—use them to experiment and learn.

End of Chapter 6

Proceed to Chapter 7: Program Flow Control to learn how to make decisions and create loops using the operators you've mastered.

Program Flow Control

The heart of BASIC programming isn't data or variables—it's control. The ability to make decisions, repeat actions, and jump to different parts of your program transforms a simple list of statements into an intelligent system that responds, adapts, and solves problems.

In this chapter, you'll master the commands that control program execution flow. You'll start with the simplest form—unconditional jumps—and progress to sophisticated structures like nested loops and computed branching. By the end, you'll understand how flow control turns linear code into programs that think.

Why Flow Control Matters

Without flow control, programs execute one line at a time, from lowest to highest line number, always in the same order. That's useful for simple calculations, but real programs need to:

• Make decisions — Different actions based on conditions (IF statements)
• Repeat actions — Perform the same operation multiple times (loops)
• Organise code — Break complex tasks into reusable subroutines (GOSUB)
• Handle choices — Select from multiple options (ON...GOTO menus)

Every non-trivial program uses flow control. Games loop until the player wins or loses. Data entry programs validate input with IF statements. Scientific calculations repeat formulas across datasets with FOR loops. Mastering these commands is mastering programming itself.

The Simplest Jump: GOTO

The most basic flow control command is GOTO. It does exactly what its name suggests: go to a specific line number.

10 PRINT "START"
20 GOTO 50
30 PRINT "YOU'LL NEVER SEE THIS"
40 PRINT "OR THIS"
50 PRINT "END"
RUN

When line 20 executes, BASIC immediately jumps to line 50, skipping lines 30 and 40 entirely. The program prints:

START
END

GOTO is unconditional—it always jumps, no questions asked. This makes it powerful but also dangerous. Used carelessly, GOTO creates "spaghetti code" where execution jumps all over the place, making programs nearly impossible to understand or debug.

Infinite Loops with GOTO

10 PRINT "HELLO"
20 GOTO 10
RUN

This program prints "HELLO" forever. Line 20 jumps back to line 10, which prints "HELLO" again, then jumps back again, endlessly. Press ESC to stop it.

Infinite loops aren't always mistakes—game main loops, animation systems, and server programs all use controlled infinite loops. But accidentally creating one is a common beginner error.

Forward and Backward Jumps

GOTO can jump forward (to a higher line number) or backward (to a lower one):

10 X = 0
20 X = X + 1
30 PRINT X
40 IF X < 5 THEN GOTO 20
50 PRINT "DONE"
RUN

This prints numbers 1 through 5. Line 40 creates a loop by jumping backward to line 20—but only while X < 5. When X reaches 5, the IF condition becomes false, the GOTO doesn't execute, and the program continues to line 50.

This pattern—a counter, a print statement, and a conditional backward GOTO—is how BASIC programmers created loops before FOR...NEXT existed. It works, but FOR...NEXT (covered later) is cleaner and less error-prone.

Making Decisions: IF...THEN

GOTO always jumps. IF...THEN jumps conditionally—only when a condition is true.

The basic syntax is:

IF condition THEN line_number

10 INPUT "ENTER YOUR AGE"; A
20 IF A >= 18 THEN GOTO 50
30 PRINT "YOU ARE A MINOR"
40 GOTO 60
50 PRINT "YOU ARE AN ADULT"
60 PRINT "THANK YOU"
RUN

If the user enters 25, the program jumps to line 50 and prints "YOU ARE AN ADULT". If they enter 12, line 20's condition is false, so execution continues to line 30, printing "YOU ARE A MINOR".

Notice line 40: after printing the minor message, we GOTO 60 to skip the adult message. Without this jump, both messages would print—clearly wrong. Managing these jumps is tedious, which is why ELSE (covered next) is so valuable.

IF...THEN with Statements

Instead of jumping to a line number, IF...THEN can execute a single statement directly:

10 INPUT "TEMPERATURE (F)"; T
20 IF T > 100 THEN PRINT "TOO HOT!"
30 IF T < 32 THEN PRINT "FREEZING!"
40 PRINT "TEMPERATURE: "; T
RUN

This is cleaner for simple one-line responses. Each IF checks a condition and prints a warning if true. Line 40 always executes—it's not part of either IF statement.

You can use any statement after THEN: PRINT, assignment, GOSUB, even END to immediately terminate the program:

10 INPUT "ENTER PASSWORD"; P$
20 IF P$ <> "SECRET" THEN END
30 PRINT "ACCESS GRANTED"
RUN

If the password is wrong, line 20 ends the program immediately—no error message, no further execution. This pattern is common in vintage BASIC programs for simple security checks.

Binary Choice: IF...THEN...ELSE

Original Commodore BASIC V2 lacked ELSE—you had to manage skips manually with GOTO. SLP-BASIC includes ELSE for cleaner, more readable code:

IF condition THEN true_action ELSE false_action

10 INPUT "GUESS A NUMBER (1-10)"; G
20 IF G = 7 THEN PRINT "CORRECT!" ELSE PRINT "WRONG!"
RUN

When G equals 7, BASIC executes the PRINT after THEN. When G is anything else, it executes the PRINT after ELSE. No manual GOTO needed—BASIC handles the branching automatically.

ELSE with Line Numbers

ELSE works with GOTO too:

10 INPUT "CONTINUE (Y/N)"; A$
20 IF A$ = "Y" THEN GOTO 50
30 PRINT "GOODBYE"
40 END
50 PRINT "CONTINUING..."
RUN

Can be written more cleanly as:

10 INPUT "CONTINUE (Y/N)"; A$
20 IF A$ = "Y" THEN PRINT "CONTINUING..." ELSE PRINT "GOODBYE"
RUN

The second version is shorter and clearer. ELSE eliminates the need for manual jump management, reducing bugs and improving readability.

Compound Conditions

Use AND, OR, and NOT to build complex conditions:

10 INPUT "TEMPERATURE (F)"; T
20 IF T >= 60 AND T <= 75 THEN PRINT "COMFORTABLE" ELSE PRINT "UNCOMFORTABLE"
RUN

10 INPUT "DAY (1-7)"; D
20 IF D = 1 OR D = 7 THEN PRINT "WEEKEND" ELSE PRINT "WEEKDAY"
RUN

10 INPUT "READY (Y/N)"; R$
20 IF NOT (R$ = "Y") THEN PRINT "NOT READY" ELSE PRINT "READY"
RUN

Parentheses control evaluation order. NOT (R$ = "Y") is clearer than R$ <> "Y" for some programmers, though both work identically.

Repeating Actions: FOR...NEXT

The most powerful and commonly used flow control structure in BASIC is the FOR...NEXT loop. It repeats a block of code a specific number of times, automatically managing a counter variable.

Basic FOR...NEXT Syntax

FOR variable = start TO end
  statements
NEXT variable

10 FOR I = 1 TO 5
20   PRINT "LOOP "; I
30 NEXT I
40 PRINT "DONE"
RUN

This prints:

LOOP 1
LOOP 2
LOOP 3
LOOP 4
LOOP 5
DONE

Here's what happens:

1. Line 10 sets I = 1 (start value)
2. Lines 20 executes (prints "LOOP 1")
3. Line 30 (NEXT) increments I to 2
4. BASIC checks: is I ≤ 5? Yes → jump back to line 20
5. Repeat steps 2-4 until I > 5
6. When I exceeds 5, exit loop and continue to line 40

The loop variable (I) is just a regular variable—you can use it in calculations, print it, even modify it (though that's usually a bad idea).

Counting Down with STEP

By default, FOR increments the counter by 1. The STEP keyword lets you specify a different increment—including negative values for countdown loops:

10 FOR I = 10 TO 1 STEP -1
20   PRINT I
30 NEXT I
40 PRINT "BLASTOFF!"
RUN

This counts down from 10 to 1, then prints "BLASTOFF!". STEP -1 decrements I by 1 each iteration.

You can use any STEP value:

10 FOR I = 0 TO 100 STEP 25
20   PRINT I
30 NEXT I
RUN

This prints 0, 25, 50, 75, 100—every 25th number from 0 to 100.

10 FOR X = 0 TO 3.14 STEP 0.5
20   PRINT X
30 NEXT X
RUN

STEP works with floating-point values too. This prints values from 0 to π in 0.5 increments.

Practical FOR...NEXT Examples

Multiplication Table:

10 INPUT "WHICH TABLE"; N
20 FOR I = 1 TO 10
30   PRINT N; " X "; I; " = "; N * I
40 NEXT I
RUN

Sum of Numbers:

10 S = 0
20 FOR I = 1 TO 100
30   S = S + I
40 NEXT I
50 PRINT "SUM 1-100: "; S
RUN

This calculates 1+2+3+...+100 = 5050 (Gauss would be proud).

Drawing Patterns:

10 FOR I = 1 TO 10
20   FOR J = 1 TO I
30     PRINT "*";
40   NEXT J
50   PRINT
60 NEXT I
RUN

This draws a triangle of asterisks, demonstrating nested loops (covered next).

Nested Loops

You can place one FOR...NEXT loop inside another. The inner loop completes all its iterations for each iteration of the outer loop.

10 FOR I = 1 TO 3
20   FOR J = 1 TO 4
30     PRINT I; ","; J; " ";
40   NEXT J
50   PRINT
60 NEXT I
RUN

This prints:

1,1  1,2  1,3  1,4
2,1  2,2  2,3  2,4
3,1  3,2  3,3  3,4

The outer loop (I) runs 3 times. For each I value, the inner loop (J) runs 4 times completely. Total iterations: 3 × 4 = 12.

Multiplication Table Grid

10 FOR I = 1 TO 10
20   FOR J = 1 TO 10
30     PRINT I * J;
40     IF I * J < 10 THEN PRINT " ";
50     PRINT " ";
60   NEXT J
70   PRINT
80 NEXT I
RUN

This creates a complete 10×10 multiplication table. Lines 40-50 handle spacing so single-digit products align properly with double-digit ones.

Important Nesting Rules

1. Inner loop must complete inside outer loop — You can't start a FOR in one loop and NEXT it in another.

2. NEXT in reverse order — The innermost loop NEXTs first:

10 FOR I = 1 TO 5
20   FOR J = 1 TO 3
30     PRINT I; J
40   NEXT J     ← Inner NEXT first
50 NEXT I       ← Outer NEXT second

3. Don't cross loop boundaries — This is wrong:

10 FOR I = 1 TO 5
20   FOR J = 1 TO 3
30 NEXT I       ← ERROR: Crossing boundaries!
40 NEXT J

BASIC will generate a "NEXT WITHOUT FOR" error.

Nested Loop Performance

Nested loops multiply iteration counts. Three levels deep can execute thousands of times:

10 C = 0
20 FOR I = 1 TO 10
30   FOR J = 1 TO 10
40     FOR K = 1 TO 10
50       C = C + 1
60     NEXT K
70   NEXT J
80 NEXT I
90 PRINT "ITERATIONS: "; C
RUN

This runs 10 × 10 × 10 = 1,000 iterations. At 4 loops deep, you'd hit 10,000 iterations—enough to slow down even modern computers if the loop body is complex.

Breaking Out Early

Sometimes you want to exit a FOR loop before it completes naturally. Commodore BASIC doesn't have a BREAK or EXIT command, but you can use GOTO:

10 FOR I = 1 TO 100
20   PRINT "CHECKING "; I
30   IF I * I = 144 THEN GOTO 60
40 NEXT I
50 PRINT "NOT FOUND"
60 PRINT "FOUND: "; I
RUN

This searches for a number whose square is 144. When found (I=12), line 30 jumps to 60, exiting the loop early. Without the match, the loop completes and line 50 prints "NOT FOUND".

Subroutines: GOSUB and RETURN

Before structured programming and functions, BASIC had subroutines—blocks of code you could call from multiple places. GOSUB (GO to SUBroutine) jumps to a line number, executes code there, then RETURN jumps back to the line after the GOSUB.

10 PRINT "START"
20 GOSUB 100
30 PRINT "MIDDLE"
40 GOSUB 100
50 PRINT "END"
60 END
100 PRINT "*** SUBROUTINE ***"
110 RETURN
RUN

This prints:

START
*** SUBROUTINE ***
MIDDLE
*** SUBROUTINE ***
END

Line 20 calls the subroutine at 100, which prints its message then RETURNs to line 30. Line 40 calls the same subroutine again, demonstrating code reuse—the subroutine is written once but executed twice.

How GOSUB Works Internally

GOSUB is smarter than GOTO. It remembers where it came from:

1. GOSUB saves the current line number on a return stack
2. Jumps to the target line
3. RETURN pops the saved line from the stack and jumps back

This means subroutines can call other subroutines (nesting):

10 GOSUB 100
20 END
100 PRINT "SUB A START"
110 GOSUB 200
120 PRINT "SUB A END"
130 RETURN
200 PRINT "SUB B"
210 RETURN
RUN

Execution flow:

• Line 10 → GOSUB 100 (save return address: line 20)
• Line 100-110 → GOSUB 200 (save return address: line 120)
• Line 200-210 → RETURN (go back to line 120)
• Line 120-130 → RETURN (go back to line 20)
• Line 20 → END

The stack allows arbitrary nesting depths—limited only by memory.

Passing Information to Subroutines

BASIC has no formal parameter passing, so subroutines use global variables:

10 N = 5: GOSUB 100: PRINT "RESULT: "; R
20 N = 8: GOSUB 100: PRINT "RESULT: "; R
30 END
100 REM SQUARE SUBROUTINE
110 R = N * N
120 RETURN
RUN

This subroutine squares N and stores the result in R. The caller sets N before GOSUB, then reads R after RETURN.

Use consistent naming conventions to track which variables are inputs, outputs, or internal to subroutines. Many vintage BASIC programmers used comments like:

100 REM SQUARE SUBROUTINE
110 REM INPUT: N  OUTPUT: R

Common Subroutine Patterns

Initialization:

10 GOSUB 1000: REM INITIALIZE
20 REM ... MAIN PROGRAM ...
1000 REM INITIALIZATION
1010 DIM A(100), B$(50)
1020 PI = 3.14159
1030 RETURN

Input Validation:

10 INPUT "AGE"; A
20 GOSUB 2000: REM VALIDATE
30 IF V = 0 THEN PRINT "INVALID": GOTO 10
2000 REM VALIDATE AGE
2010 V = 1
2020 IF A < 0 OR A > 120 THEN V = 0
2030 RETURN

Drawing/Display:

100 GOSUB 3000: REM DRAW BORDER
3000 REM DRAW BORDER
3010 FOR I = 1 TO 40: PRINT "*";: NEXT I
3020 PRINT
3030 RETURN

RETURN Without GOSUB

RETURN without a matching GOSUB generates an error:

10 PRINT "HELLO"
20 RETURN
RUN

This produces "RETURN WITHOUT GOSUB ERROR"—there's no saved return address on the stack.

This error also occurs if you GOTO into a subroutine:

10 GOTO 100
100 PRINT "SUB"
110 RETURN    ← ERROR! No GOSUB called us

The correct pattern is GOSUB to enter, RETURN to exit. GOTO bypasses the return address setup.

Computed Branching: ON...GOTO

When you need to jump to different line numbers based on a numeric value, ON...GOTO provides cleaner code than multiple IF statements.

Basic ON...GOTO Syntax

ON variable GOTO line1, line2, line3, ...

10 PRINT "MENU:"
20 PRINT "1. HELLO"
30 PRINT "2. GOODBYE"
40 PRINT "3. STATUS"
50 INPUT "CHOICE"; C
60 ON C GOTO 100, 200, 300
70 PRINT "INVALID CHOICE"
80 END
100 PRINT "HELLO!": GOTO 80
200 PRINT "GOODBYE!": GOTO 80
300 PRINT "STATUS: OK": GOTO 80
RUN

If C=1, jump to line 100. If C=2, jump to 200. If C=3, jump to 300. If C is 0, negative, or greater than 3, execution continues to line 70 (no jump).

This is equivalent to:

60 IF C = 1 THEN GOTO 100
70 IF C = 2 THEN GOTO 200
80 IF C = 3 THEN GOTO 300
90 PRINT "INVALID CHOICE"

ON...GOTO is much shorter and clearer for multiple choices.

ON...GOSUB for Subroutine Dispatch

ON...GOSUB works identically but calls subroutines instead of jumping:

10 PRINT "CALCULATOR:"
20 PRINT "1. ADD"
30 PRINT "2. SUBTRACT"
40 PRINT "3. MULTIPLY"
50 INPUT "OPERATION"; OP
60 INPUT "FIRST NUMBER"; A
70 INPUT "SECOND NUMBER"; B
80 ON OP GOSUB 100, 200, 300
90 PRINT "RESULT: "; R
95 END
100 R = A + B: RETURN
200 R = A - B: RETURN
300 R = A * B: RETURN
RUN

Each operation is a subroutine. After RETURN, execution continues at line 90 to print the result. This pattern is perfect for menu-driven programs.

Boundary Behavior

If the ON variable is fractional, BASIC truncates to an integer:

10 X = 2.7
20 ON X GOTO 100, 200, 300
100 PRINT "JUMPED TO 100": END
200 PRINT "JUMPED TO 200": END
300 PRINT "JUMPED TO 300": END
RUN

X=2.7 truncates to 2, so this jumps to line 200.

If the value is out of range (≤0 or greater than the number of targets), no jump occurs:

10 X = 5
20 ON X GOTO 100, 200
30 PRINT "NO JUMP - CONTINUED HERE"
100 PRINT "FIRST": END
200 PRINT "SECOND": END
RUN

X=5 but there are only 2 targets, so execution continues to line 30.

Program Termination: END, STOP, CONT

BASIC provides several ways to halt execution, each with different behavior.

END - Clean Termination

END stops program execution and closes files:

10 PRINT "RUNNING..."
20 END
30 PRINT "NEVER EXECUTED"
RUN

After END, you cannot CONT (continue). The program has cleanly terminated. You must RUN again to restart.

Best practice: place END at the end of your main program, before subroutines:

10 REM MAIN PROGRAM
20 GOSUB 1000
30 GOSUB 2000
40 END
1000 REM SUBROUTINE 1
1010 RETURN
2000 REM SUBROUTINE 2
2010 RETURN

Without END, execution would "fall through" into subroutine 1000, then hit RETURN without GOSUB—error!

STOP - Suspended Execution

STOP also halts execution, but leaves the program in a suspended state:

10 FOR I = 1 TO 10
20   PRINT I
30   IF I = 5 THEN STOP
40 NEXT I
RUN

This prints 1-5 then stops. The program shows "BREAK IN LINE 30" (or similar).

After STOP, you can:

• Type CONT to resume execution from the next line
• Type LIST to review your code
• Type PRINT to check variable values
• Type RUN to restart from the beginning

CONT

This continues from line 40, printing 6-10.

STOP is invaluable for debugging. Place STOP at suspicious locations, run the program, then examine variables to understand what's happening.

CONT - Continue After STOP

CONT (continue) resumes execution after a STOP. It picks up at the line after the STOP:

10 PRINT "BEFORE"
20 STOP
30 PRINT "AFTER"
RUN
BEFORE
BREAK IN 20
CONT
AFTER

CONT only works after STOP. After END or an error, CONT fails with "CAN'T CONTINUE ERROR".

When Programs Stop Automatically

Besides END and STOP, programs halt on:

1. Syntax Errors - Invalid code generates an error and stops
2. Runtime Errors - Division by zero, array bounds, type mismatch, etc.
3. User Interrupt - Pressing ESC (in SLP-BASIC) or STOP key (on hardware)

After runtime errors, you usually cannot CONT—the error condition must be fixed first.

Putting It All Together

Let's build a complete program using every flow control structure from this chapter:

10 REM NUMBER GUESSING GAME
20 REM USES: IF/THEN/ELSE, FOR/NEXT, GOSUB/RETURN, END
30 GOSUB 1000: REM INITIALIZE
40 GOSUB 2000: REM PLAY GAME
50 INPUT "PLAY AGAIN (Y/N)"; A$
60 IF A$ = "Y" THEN GOTO 30
70 PRINT "THANKS FOR PLAYING!"
80 END
1000 REM INITIALIZE
1010 S = INT(RND(1) * 100) + 1
1020 T = 0
1030 RETURN
2000 REM PLAY GAME
2010 FOR I = 1 TO 10
2020   INPUT "GUESS (1-100)"; G
2030   T = T + 1
2040   IF G = S THEN GOSUB 3000: RETURN
2050   IF G < S THEN PRINT "TOO LOW!"
2060   IF G > S THEN PRINT "TOO HIGH!"
2070 NEXT I
2080 PRINT "OUT OF TRIES! IT WAS "; S
2090 RETURN
3000 REM WIN
3010 PRINT "CORRECT IN "; T; " TRIES!"
3020 RETURN
RUN

This program demonstrates:

• GOSUB/RETURN - Organised into subroutines (init, play, win)
• FOR/NEXT - 10-attempt loop
• IF/THEN - Checking guess against secret number
• IF/THEN with GOSUB - Calling win subroutine when correct
• IF with statement - Simple prints for too-high/too-low
• GOTO - Play-again loop (line 60)
• END - Clean termination

The program structure is clean: main logic (lines 10-80), subroutines (1000+), clear separation with END.

Flow Control Best Practices

After working through all these commands, here are key principles for writing maintainable BASIC code:

1. Minimize GOTO Usage

GOTO is powerful but makes code hard to follow. Prefer:

• FOR...NEXT for loops
• IF...THEN...ELSE for decisions
• GOSUB/RETURN for code reuse
• ON...GOTO only for multi-way branching (menus)

Use GOTO only when necessary (play-again loops, early exits, state machines).

2. Structure with Subroutines

Break programs into logical sections:

10-90:     Main program logic
100-999:   Main program helpers
1000-1999: Subroutine 1 (e.g., input validation)
2000-2999: Subroutine 2 (e.g., calculations)
3000-3999: Subroutine 3 (e.g., display)
9000-9999: Utility subroutines used everywhere

This organization makes programs scannable at a glance.

3. Always END Before Subroutines

This prevents accidental fall-through:

40 END
100 REM SUBROUTINE 1
110 ...
120 RETURN

Without line 40, the program runs into subroutine 100, executes it, hits RETURN without GOSUB—error!

4. Use STOP for Debugging

Temporarily insert STOP to examine state:

50 STOP: REM DEBUG - CHECK VARIABLES HERE

Run, examine variables, CONT, repeat. Remove STOPs once bugs are fixed.

5. Comment Complex Flow

Use REM to explain non-obvious logic:

100 REM MAIN MENU DISPATCH
110 ON C GOSUB 1000, 2000, 3000, 4000
120 REM 1=NEW 2=LOAD 3=SAVE 4=QUIT

Future-you (or other programmers) will appreciate the clarity.

6. Validate Before Branching

Check user input before ON...GOTO:

10 INPUT "CHOICE"; C
20 IF C < 1 OR C > 5 THEN PRINT "INVALID": GOTO 10
30 ON C GOSUB 100, 200, 300, 400, 500

This prevents weird behavior from out-of-range values.

7. Watch FOR Loop Variables

Don't modify loop variables inside the loop—it creates confusing, hard-to-debug code:

10 FOR I = 1 TO 10
20   PRINT I
30   I = I + 1: REM DON'T DO THIS!
40 NEXT I

Let FOR...NEXT manage the counter automatically.

Common Pitfalls

NEXT Without FOR

10 FOR I = 1 TO 5
20 FOR J = 1 TO 3
30 NEXT I    ← ERROR: Wrong order!
40 NEXT J

Fix: NEXT the innermost loop first: 30 NEXT J then 40 NEXT I.

RETURN Without GOSUB

10 GOTO 100
100 PRINT "HELLO"
110 RETURN    ← ERROR: No GOSUB called us!

Fix: Use GOSUB instead of GOTO, or remove RETURN.

Infinite Loop Without Exit

10 X = 1
20 PRINT X
30 GOTO 20

This runs forever. If intentional (game loop), ensure there's a way out (IF condition, user input, etc.).

FOR Loop Boundary Errors

10 DIM A(10)
20 FOR I = 1 TO 11
30   A(I) = I    ← ERROR: A(11) doesn't exist!
40 NEXT I

Arrays dimensioned with DIM A(10) have indices 0-10 (11 elements). Loop from 0 TO 10, not 1 TO 11.

Falling Through Into Subroutines

10 PRINT "MAIN"
20 PRINT "DONE"
100 PRINT "SUB"
110 RETURN    ← ERROR when main falls through!

Fix: Add END before line 100 to stop main program execution.

Advanced Pattern: State Machine

Complex programs often need to track "states"—different modes of operation. A state machine uses a variable to remember the current state and ON...GOSUB to dispatch to state-specific code.

10 REM SIMPLE STATE MACHINE
20 REM STATE: 1=MENU, 2=PLAYING, 3=GAMEOVER
30 S = 1: REM START IN MENU STATE
40 REM MAIN LOOP
50 ON S GOSUB 100, 200, 300
60 GOTO 50
70 REM MENU STATE
100 PRINT "1. START GAME"
110 PRINT "2. QUIT"
120 INPUT C
130 IF C = 1 THEN S = 2: RETURN
140 IF C = 2 THEN END
150 PRINT "INVALID": RETURN
200 REM PLAYING STATE
210 PRINT "PLAYING... (PRESS 1 TO WIN, 2 TO LOSE)"
220 INPUT C
230 IF C = 1 THEN PRINT "YOU WIN!": S = 3
240 IF C = 2 THEN PRINT "YOU LOSE!": S = 3
250 RETURN
300 REM GAMEOVER STATE
310 PRINT "GAME OVER"
320 INPUT "PLAY AGAIN (Y/N)"; A$
330 IF A$ = "Y" THEN S = 2: RETURN
340 S = 1: RETURN
RUN

The state variable S controls program flow:

• S=1 → Menu (subroutine 100)
• S=2 → Playing (subroutine 200)
• S=3 → Game Over (subroutine 300)

Each subroutine can change S to transition to a new state. The main loop (lines 50-60) continuously dispatches based on S. This pattern scales to complex programs with many states and transitions.

Chapter Summary

You've mastered the commands that control program execution flow:

Unconditional Jumps:

• GOTO line_number - Jump to a specific line

Conditional Execution:

• IF condition THEN action - Execute if condition is true
• IF condition THEN action ELSE action - Binary choice

Loops:

• FOR var = start TO end ... NEXT var - Counted loops
• FOR var = start TO end STEP increment - Custom increment loops
• Nested FOR...NEXT - Loops within loops

Subroutines:

• GOSUB line_number - Call a subroutine
• RETURN - Return from subroutine
• ON variable GOSUB list - Computed subroutine dispatch

Computed Branching:

• ON variable GOTO list - Jump based on numeric value

Program Control:

• END - Terminate program cleanly
• STOP - Suspend execution (allows CONT)
• CONT - Continue after STOP

These commands form the foundation of structured BASIC programming. Combined with variables (Chapter 5) and operators (Chapter 6), you can now write sophisticated programs that make decisions, repeat actions, and organise code logically.

The next chapter covers Input and Output—how to interact with users, format displays, and create professional-looking programs. With flow control mastered, you're ready to build interactive applications that respond intelligently to user input.

Input and Output

Professional programs don't just compute—they communicate. They present information clearly, organise data logically, and interact gracefully with users. In this chapter, you'll master BASIC's input and output tools: the commands that transform raw calculations into polished, readable programs.

You already know the basics of PRINT and INPUT from earlier chapters. Now we'll go deeper, exploring formatting techniques that make your output look professional. By the end of this chapter, you'll be able to create aligned tables, formatted reports, interactive menus, and visually appealing displays.

The PRINT Statement

You've been using PRINT since Chapter 4, but let's formalize what you know and extend it.

PRINT Basics

The PRINT statement displays text, numbers, and variables:

10 PRINT "HELLO WORLD"
20 PRINT 42
30 A = 100
40 PRINT A

Each PRINT statement outputs its content, then moves to a new line. This is the default behavior—unless you change it with formatting characters.

The ? Shorthand

Typing PRINT repeatedly gets tedious. BASIC provides a shortcut: the question mark (?) means exactly the same thing as PRINT.

10 ? "HELLO"
20 ? 42

This is identical to:

10 PRINT "HELLO"
20 PRINT 42

PRINT with Nothing

A PRINT statement with no content prints a blank line:

10 PRINT "FIRST LINE"
20 PRINT
30 PRINT "THIRD LINE"

This is essential for visual spacing. Use blank lines liberally to organise output and make it easier to read.

Multiple Items

You can print several things in one statement using commas or semicolons (we'll explore these in detail soon):

10 PRINT "VALUE:", 42
20 PRINT "NAME:"; "ALICE"

The comma and semicolon control spacing differently—this is where BASIC's formatting power begins.

10 PRINT "HELLO WORLD"
20 PRINT 42
30 PRINT
40 ? "SHORTHAND WORKS TOO!"
50 END

Try both PRINT and ? to see they're identical. Add a blank line with PRINT alone.

Formatting with Commas

The comma (,) is BASIC's primary tool for creating columns. When you separate items with commas, BASIC divides the screen into zones and places each item in the next zone.

Understanding Zones

BASIC divides each line into zones of 14 characters. On a Commodore 64's 40-column screen, this gives you:

• Zone 1: Columns 0-13
• Zone 2: Columns 14-27
• Zone 3: Columns 28-41 (wraps to next line at column 40)

The 14-Character Rule

Each zone is exactly 14 characters wide. If your text is shorter than 14 characters, BASIC pads with spaces. If longer, it still occupies only one zone (but may look odd).

Creating Simple Tables

Commas are perfect for tabular data:

The columns align automatically because commas tab to the next 14-character boundary.

Multiple Zones Per Line

You can use up to 5 zones on a 40-column screen (though zone 3 starts to wrap):

10 PRINT "A", "B", "C", "D", "E"

Numbers and Commas

Numbers work the same way:

10 PRINT "NAME", "AGE", "SCORE"
20 PRINT "ALICE", 25, 95
30 PRINT "BOB", 30, 87

BASIC right-aligns numbers within their zones (though this isn't always obvious with the 14-character spacing).

Practical Example: Multiplication Table

10 PRINT "PRODUCT", "PRICE", "STOCK"
20 PRINT "-------", "-----", "-----"
30 PRINT "WIDGET", "$5.00", 150
40 PRINT "GADGET", "$8.50", 75
50 PRINT "DOOHICKEY", "$12.00", 42
60 END

Run this inventory report. Try adding more products or changing the column headers.

Formatting with Semicolons

While commas create spacious columns, semicolons do the opposite: they eliminate spacing entirely, placing items directly adjacent to each other.

Semicolon: Tight Spacing

The semicolon (;) tells BASIC: "print the next item right here, with no extra space."

10 PRINT "HELLO"; "WORLD"

Adding Your Own Spaces

Since semicolons add no space, you control spacing explicitly:

10 PRINT "HELLO"; " "; "WORLD"

Building Output Piece by Piece

Semicolons let you construct output from multiple pieces:

10 NAME$ = "ALICE"
20 AGE = 25
30 PRINT "NAME: "; NAME$; " AGE: "; AGE

This is incredibly useful for mixing text and variables in natural-looking sentences.

Suppressing the Newline

Here's a powerful trick: a semicolon at the end of a PRINT statement suppresses the automatic newline:

10 PRINT "PART 1";
20 PRINT " PART 2";
30 PRINT " PART 3"

Progress Indicators

Semicolons at line endings enable progress bars and animations:

10 PRINT "LOADING";
20 FOR I = 1 TO 10
30 PRINT ".";
40 NEXT I
50 PRINT " DONE!"

Combining Commas and Semicolons

You can mix both in a single statement:

10 PRINT "NAME:"; "ALICE", "AGE:"; 25

This gives you fine control over spacing.

Practical Example: Formatted Receipt

10 PRINT "BUILDING";
20 PRINT " A";
30 PRINT " SENTENCE";
40 PRINT " PIECE";
50 PRINT " BY";
60 PRINT " PIECE"
70 END

See how semicolons connect multiple PRINT statements into one line. Try removing semicolons to see the difference.

TAB() for Absolute Positioning

Commas and semicolons control relative spacing—but what if you want to place text at an exact column position? That's where TAB() comes in.

TAB(n) Syntax

TAB(n) moves the cursor to column n:

10 PRINT TAB(10); "HELLO"

Absolute Column Control

Unlike commas (which tab to 14, 28, etc.), TAB() lets you specify any column from 0 to 39 (on a 40-column screen):

10 PRINT TAB(5); "FIVE"
20 PRINT TAB(15); "FIFTEEN"
30 PRINT TAB(25); "TWENTY-FIVE"

Creating Precise Tables

TAB() excels at creating professionally aligned tables:

10 PRINT TAB(0); "ITEM"; TAB(20); "PRICE"; TAB(30); "QTY"
20 PRINT TAB(0); "----"; TAB(20); "-----"; TAB(30); "---"
30 PRINT TAB(0); "APPLE"; TAB(20); "$1.50"; TAB(30); "12"
40 PRINT TAB(0); "ORANGE"; TAB(20); "$2.00"; TAB(30); "8"
50 PRINT TAB(0); "BANANA"; TAB(20); "$0.75"; TAB(30); "20"

TAB() vs. Commas

Compare these approaches:

With commas (14-char zones):

10 PRINT "NAME", "SCORE"
20 PRINT "ALICE", 95

Output:

NAME          SCORE
ALICE         95

With TAB() (exact columns):

10 PRINT "NAME"; TAB(20); "SCORE"
20 PRINT "ALICE"; TAB(20); 95

Output:

NAME               SCORE
ALICE              95

TAB() gives you pixel-perfect control.

TAB() with Variables

You can calculate TAB positions dynamically:

10 FOR I = 0 TO 30 STEP 10
20 PRINT TAB(I); "*"
30 NEXT I

Practical Example: Formatted Report

10 PRINT TAB(5); "MENU"
20 PRINT TAB(5); "===="
30 PRINT
40 PRINT TAB(0); "1."; TAB(5); "NEW GAME"
50 PRINT TAB(0); "2."; TAB(5); "LOAD GAME"
60 PRINT TAB(0); "3."; TAB(5); "OPTIONS"
70 PRINT TAB(0); "4."; TAB(5); "QUIT"
80 END

A professionally formatted menu using TAB(). Try changing the column numbers to see how alignment changes.

SPC() for Relative Spacing

While TAB() positions absolutely, SPC() adds spacing relative to the current cursor position. It prints a specified number of spaces.

SPC(n) Syntax

SPC(n) prints n spaces:

10 PRINT "HELLO"; SPC(5); "WORLD"

Adding Spacing

SPC() is useful when you want gaps without calculating exact positions:

10 PRINT "NAME:"; SPC(3); "ALICE"
20 PRINT "AGE:"; SPC(4); "25"
30 PRINT "CITY:"; SPC(3); "NYC"

Notice how the spacing is consistent, even though the labels are different lengths. (Though in this example, they'd align better with TAB().)

SPC() in Loops

SPC() shines in loops where you need increasing or decreasing spacing:

10 FOR I = 0 TO 5
20 PRINT SPC(I); "*"
30 NEXT I

SPC() vs. TAB()

When should you use each?

Use TAB() when:

• You need exact column positions
• You're creating aligned tables
• Multiple lines need to align precisely

Use SPC() when:

• You need a fixed number of spaces
• You're adding gaps in a line
• You're creating patterns or animations

Creating Patterns

SPC() is excellent for ASCII art and patterns:

10 FOR I = 1 TO 5
20 PRINT SPC(5-I); "*"; SPC(2*I-2); "*"
30 NEXT I

Practical Example: Progress Bar

10 FOR I = 0 TO 10
20 PRINT SPC(I); "*"; SPC(20-2*I); "*"
30 NEXT I
40 END

Watch stars move in opposite directions using SPC(). Try changing the spacing formula.

POS() for Cursor Position

Sometimes you need to know where you are on the screen. POS(0) returns the current cursor column position.

POS(0) Syntax

POS(0) is a function that returns the column number (0-39 on a 40-column screen):

10 PRINT "HELLO";
20 P = POS(0)
30 PRINT " CURSOR AT:"; P

Checking Position Before Formatting

POS(0) helps you decide whether to add spacing:

10 PRINT "NAME:";
20 IF POS(0) < 10 THEN PRINT SPC(10 - POS(0));
30 PRINT "ALICE"

This ensures "ALICE" always starts at column 10, regardless of how wide "NAME:" is.

Dynamic TAB Calculation

Use POS(0) to tab to the next available zone:

10 PRINT "SHORT";
20 NEXTTAB = (INT(POS(0)/14) + 1) * 14
30 PRINT TAB(NEXTTAB); "NEXT COLUMN"

This calculates the next 14-character zone boundary.

Detecting Line Wrapping

Check if you're approaching the edge of the screen:

10 PRINT "THIS IS A LONG LINE OF TEXT";
20 IF POS(0) > 30 THEN PRINT "(NEAR EDGE)"

If the cursor is past column 30, you're getting close to the 40-column limit.

Practical Example: Right-Aligned Text

Centering Text

10 WIDTH = 40
20 TEXT$ = "CENTERED TEXT"
30 CENTERPOS = (WIDTH - LEN(TEXT$)) / 2
40 PRINT TAB(CENTERPOS); TEXT$

POS() Limitations

POS(0) only tracks the column—not the row. BASIC V2 has no equivalent for checking the vertical cursor position.

10 PRINT "HELLO";
20 P = POS(0)
30 PRINT
40 PRINT "CURSOR WAS AT COLUMN:"; P
50 PRINT
60 PRINT "NOW TRY THIS:"
70 PRINT "12345678901234567890";
80 PRINT " POSITION:"; POS(0)
90 END

See POS(0) in action. Try changing the text lengths to see how position changes.

Getting Input with INPUT

You've used INPUT to read user data, but there's more to learn about its behavior and formatting options.

Basic INPUT

The simplest form waits for the user to type something:

10 INPUT A$

When this line executes:

1. BASIC prints ? (the input prompt)
2. Waits for user to type
3. User presses ENTER
4. BASIC stores the input in A$

INPUT with Prompts

Add a message before the ?:

10 INPUT "WHAT IS YOUR NAME"; A$

Multiple Variables

You can input several values at once:

10 INPUT "ENTER THREE NUMBERS"; A, B, C

Mixing String and Numeric Variables

10 INPUT "NAME, AGE, CITY"; N$, A, C$

INPUT Behavior

Important details:

• Numeric variables: If user enters non-numeric text, BASIC shows ?REDO FROM START
• String variables: Accept any text
• Leading spaces: Trimmed from input
• Quotes: Required if input contains commas (e.g., "SMITH, JOHN")

Complete Example

10 PRINT "CALCULATOR"
20 INPUT "FIRST NUMBER"; A
30 INPUT "SECOND NUMBER"; B
40 PRINT
50 PRINT "SUM:"; A + B
60 PRINT "PRODUCT:"; A * B
70 END

Run this calculator and enter two numbers when prompted. Try entering invalid input to see ?REDO FROM START.

Input Prompts

The way you format prompts significantly affects user experience. Let's master prompt customization.

Default Prompt (with ?)

By default, INPUT adds a ?:

10 INPUT "NAME"; N$

Output: NAME? _

Custom Prompt (semicolon suppresses ?)

Use a semicolon instead of a comma to suppress the automatic ?:

10 INPUT "NAME: "; N$

Output: NAME: _

No question mark! This looks more professional.

When to Use Each Style

Use comma (with ?):

• Questions: INPUT "CONTINUE"; A$
• Simple prompts: INPUT "NAME", N$
• Authentic retro feel

Use semicolon (no ?):

• Labels: INPUT "USERNAME: "; U$
• Professional forms: INPUT "ENTER PASSWORD: "; P$
• Modern appearance

Formatting Multi-Line Prompts

For complex input, split the prompt:

10 PRINT "PLEASE ENTER YOUR FULL NAME"
20 PRINT "(FIRST AND LAST)"
30 INPUT "NAME: "; N$

Empty Prompts

For minimal interface, use an empty prompt:

10 PRINT "NAME:"
20 INPUT ""; N$

Arrow Prompts

Create custom prompt characters:

10 INPUT "> "; CMD$

Practical Example: Form

10 PRINT "LOGIN SYSTEM"
20 PRINT "============"
30 PRINT
40 INPUT "USERNAME: "; U$
50 INPUT "PASSWORD: "; P$
60 PRINT
70 IF U$ = "ADMIN" AND P$ = "1234" THEN PRINT "ACCESS GRANTED" ELSE PRINT "ACCESS DENIED"
80 END

A simple login system using semicolon-style prompts. Try entering the username "ADMIN" and password "1234".

Single Keystroke with GET

INPUT waits for the user to type and press ENTER. But what if you want immediate response to a single keystroke? That's where GET comes in.

GET Syntax

GET reads a single character without waiting for ENTER:

10 GET A$

This sets A$ to:

• The character if a key is pressed
• Empty string ("") if no key is pressed

GET vs INPUT

Compare:

INPUT:

10 INPUT "PRESS ENTER"; A$

User types HELLO and presses ENTER → A$ = "HELLO"

GET:

10 GET A$

User presses H → A$ = "H" (immediately, no ENTER needed)

WASM Context Limitation

Checking for Empty String

Because GET might return empty, always check:

10 GET A$
20 IF A$ = "" THEN GOTO 10
30 PRINT "YOU PRESSED: "; A$

This loops until a key is pressed.

Menu Systems

GET is perfect for menu choices:

10 PRINT "MENU: [A] ADD [B] DELETE [Q] QUIT"
20 GET K$
30 IF K$ = "" THEN GOTO 20
40 IF K$ = "A" THEN PRINT "ADDING..."
50 IF K$ = "B" THEN PRINT "DELETING..."
60 IF K$ = "Q" THEN END
70 GOTO 20

Detecting Specific Keys

10 PRINT "PRESS SPACE TO CONTINUE"
20 GET K$
30 IF K$ <> " " THEN GOTO 20
40 PRINT "CONTINUING..."

Waits specifically for the spacebar.

Yes/No Prompts

10 PRINT "DELETE ALL FILES? (Y/N)"
20 GET A$
30 IF A$ = "" THEN GOTO 20
40 IF A$ = "Y" THEN PRINT "DELETED!": GOTO 60
50 IF A$ = "N" THEN PRINT "CANCELLED": GOTO 60
60 END

Case Sensitivity

GET is case-sensitive. "A" and "a" are different. Handle both:

10 GET K$
20 IF K$ = "Y" OR K$ = "y" THEN PRINT "YES"

Or convert to uppercase:

10 GET K$
20 IF K$ >= "a" AND K$ <= "z" THEN K$ = CHR$(ASC(K$) - 32)
30 IF K$ = "Y" THEN PRINT "YES"

Practical Example: Press Any Key

10 PRINT "SIMPLE MENU"
20 PRINT "==========="
30 PRINT
40 PRINT "[N] NEW GAME"
50 PRINT "[L] LOAD GAME"
60 PRINT "[Q] QUIT"
70 PRINT
80 PRINT "CHOICE: ";
90 GET C$
100 IF C$ = "" THEN GOTO 90
110 PRINT C$
120 IF C$ = "N" THEN PRINT "STARTING NEW GAME..."
130 IF C$ = "L" THEN PRINT "LOADING GAME..."
140 IF C$ = "Q" THEN PRINT "GOODBYE!": END
150 END

Try pressing N, L, or Q. Notice how GET responds immediately to a single keystroke.

Formatted Output Examples

Let's put everything together with complete, practical examples that demonstrate professional formatting techniques.

Example 1: Multiplication Table

Example 2: Invoice

Example 3: Restaurant Menu

Example 4: Progress Bar

Example 5: Data Entry Form

Example 6: ASCII Art Border

10 PRINT "GRADE REPORT"
20 PRINT "============"
30 PRINT
40 INPUT "STUDENT NAME: "; N$
50 INPUT "MATH SCORE: "; M
60 INPUT "ENGLISH SCORE: "; E
70 INPUT "SCIENCE SCORE: "; S
80 AVG = (M + E + S) / 3
90 PRINT
100 PRINT "STUDENT: "; N$
110 PRINT STRING$(30, "-")
120 PRINT "MATH"; TAB(20); M
130 PRINT "ENGLISH"; TAB(20); E
140 PRINT "SCIENCE"; TAB(20); S
150 PRINT STRING$(30, "-")
160 PRINT "AVERAGE"; TAB(20); AVG
170 END

A complete grade calculator with formatted output. Enter three scores and see a professional report.

Common Formatting Mistakes

Even experienced programmers make formatting errors. Here are the most common pitfalls and how to avoid them.

Mistake 1: Mixing Comma and Semicolon Accidentally

Fix: Be consistent. Use all commas OR all semicolons:

10 PRINT "NAME:", "AGE:", "CITY:"
or
10 PRINT "NAME: "; "AGE: "; "CITY: "

Mistake 2: Forgetting Semicolon for Continuation

You wanted them on the same line! Fix:

10 PRINT "LOADING";
20 PRINT "..."

Mistake 3: TAB() Past Current Position

Fix: Use TAB() at the start of a line, or ensure you're tabbing forward:

10 PRINT "LONG LINE"
20 PRINT TAB(5); "HERE"

Mistake 4: Not Accounting for Variable Length

Fix: Always start fresh lines for alignment, or use fixed-width fields:

10 PRINT "NAME: "; LEFT$(N$, 10); TAB(20); "AGE:"; A

Mistake 5: Forgetting Spaces in Semicolon Output

Fix: Add explicit spaces:

30 PRINT A$; " "; B$

Output: HELLO WORLD

Mistake 6: Wrong Variable Type in INPUT

Fix: Use numeric variable:

10 INPUT "AGE"; A
20 PRINT "IN 10 YEARS:"; A + 10

Mistake 7: Not Checking for Empty GET

Fix: Loop until you get input:

10 GET K$
20 IF K$ = "" THEN GOTO 10
30 IF K$ = "Q" THEN END

Chapter Summary: Professional Output

You've mastered BASIC's complete I/O toolkit. Let's review what you can now do:

Output Control

PRINT Statement:

• Display text, numbers, and variables
• ? shorthand for fast typing
• Blank lines with PRINT alone

Comma Formatting:

• Tabs to 14-character zones (14, 28, 42...)
• Perfect for simple tables and columns
• Automatic spacing

Semicolon Formatting:

• Tight spacing, no gaps
• Continue lines (semicolon at end)
• Build output piece by piece

TAB(n):

• Absolute positioning to column n
• Precise alignment for professional tables
• Calculate positions dynamically

SPC(n):

• Relative spacing (n spaces)
• Pattern creation
• Variable spacing in loops

POS(0):

• Query current cursor column
• Dynamic positioning calculations
• Right-align and center text

Input Control

INPUT Statement:

• Basic user input
• Custom prompts with comma or semicolon
• Multiple variables at once
• Type validation (numeric vs string)

Prompt Styles:

• Comma: Adds automatic ?
• Semicolon: Suppresses ? for custom prompts
• Multi-line prompts for clarity

GET Statement:

• Single keystroke input
• Menu systems
• "Press any key" prompts
• Non-blocking in WASM (requires loop)

Practical Skills

You can now create:

• ✓ Aligned tables and reports
• ✓ Professional invoices and forms
• ✓ Restaurant menus and price lists
• ✓ Progress indicators
• ✓ Interactive menus
• ✓ ASCII art borders
• ✓ Data entry systems
• ✓ Formatted calculations

Key Principles

Formatting is communication:

• Good formatting makes programs easier to use
• Alignment helps users scan data quickly
• Spacing creates visual hierarchy
• Professional output builds user confidence

Choose the right tool:

• Commas for quick, simple columns
• TAB() for precise alignment
• Semicolons for tight control
• SPC() for patterns and spacing

Test with real data:

• Variable-length inputs affect alignment
• Always verify formatting with actual values
• Plan for the longest expected data

What's Next

You now have all the tools for user interaction and output formatting. The next chapters will teach you:

• Chapter 9 — Arrays for handling collections of data
• Chapter 10 — Built-in functions for text and math
• Chapter 11 — Program management commands
• Chapter 12 — Saving and loading programs

But with what you know now, you can create sophisticated, professional-looking programs. Don't wait—start building!

One Final Challenge

Create a grade book program from scratch:

Requirements:

• Ask for student name
• Input 3 test scores
• Calculate average
• Display formatted report with:
  • Student name
  • Each test score (aligned)
  • Average (highlighted)
  • Letter grade (A/B/C/D/F based on average)

Use everything from this chapter: INPUT prompts, TAB positioning, formatted output, and calculations.

Congratulations! You've completed Chapter 8. You're no longer just printing basic output—you're creating professional user interfaces.

Master formatting, and your programs will look polished and professional, even if they're simple underneath. First impressions matter, and well-formatted output makes all the difference.

Arrays and Data

What Are Arrays?

Variables store single values—one number, one text string. But what if you need to store fifty test scores? Or a hundred temperatures? Or a tic-tac-toe board with nine positions? Creating SCORE1, SCORE2, SCORE3... SCORE50 is tedious, error-prone, and impossible to process in loops.

Arrays solve this problem. An array is a collection of storage locations—numbered boxes—all sharing a single name. Instead of fifty separate variables, you have one array with fifty numbered elements:

SCORE(0) = 85
SCORE(1) = 92
SCORE(2) = 78
...
SCORE(49) = 95

Each element (numbered box) holds a value, accessed by its index (position number). The array name (SCORE) identifies the collection; the index in parentheses (0, 1, 2...) identifies the specific element.

Think of an array as a numbered list:

• Array: A vertical filing cabinet with numbered drawers
• Index: The drawer number (0, 1, 2, 3...)
• Element: The contents of one drawer
• Array name: The label on the cabinet

Arrays organise related data logically. All test scores go in the SCORE array. All daily temperatures go in the TEMP array. All game board positions go in the BOARD array. This organization makes programs clearer and enables powerful patterns like processing every element with a FOR loop.

BASIC supports:

• One-dimensional arrays: Lists indexed by a single number (like a column of data)
• Two-dimensional arrays: Tables indexed by two numbers (like a spreadsheet with rows and columns)

Both types use the same fundamental concept: numbered storage boxes accessed by index.

Declaring Arrays with DIM

Unlike simple variables (which spring into existence on first use), arrays must be declared before use with the DIM statement. DIM stands for "dimension"—you're defining the size and shape of the array.

Basic DIM Syntax

DIM arrayname(size)

Examples:

DIM SCORE(10)        ' Numeric array, 11 elements (0-10)
DIM NAME$(20)        ' String array, 21 elements (0-20)
DIM COUNT%(50)       ' Integer array, 51 elements (0-50)

The number in parentheses is the maximum index, not the number of elements. DIM A(10) creates an array with 11 elements: A(0), A(1), A(2)... A(10). This is the zero-based indexing at work—index runs from 0 to the declared size, inclusive.

Size Calculation

To calculate the number of elements:

Number of elements = declared size + 1

Examples:

• DIM A(10): 11 elements (0-10)
• DIM A(99): 100 elements (0-99)
• DIM A(0): 1 element (just element 0)

This off-by-one calculation confuses beginners. Remember: the DIM parameter is the highest index you can use, not a count of elements.

If you need exactly 50 elements:

DIM SCORE(49)        ' Elements 0-49 = 50 elements

If you need 100 elements:

DIM TEMPS(99)        ' Elements 0-99 = 100 elements

Default Array Size

If you use an array without DIM, BASIC automatically creates it with 11 elements (0-10). This is convenient for small arrays but dangerous for larger ones:

A(5) = 100           ' OK: auto-created with default size
A(15) = 200          ' Error: SUBSCRIPT OUT OF RANGE

Best practice: always use DIM explicitly. It documents your array size and prevents subscript range errors from exceeding the default limit.

Array Types

Arrays have types just like variables:

• Numeric arrays (no suffix): DIM A(10)
• Integer arrays (% suffix): DIM A%(10)
• String arrays ($ suffix): DIM A$(10)

The type suffix applies to every element:

DIM NAME$(10)        ' 11 string elements
NAME$(0) = "ALICE"
NAME$(1) = "BOB"
NAME$(2) = "CHARLIE"

You can't mix types within an array. Each element holds the same type of data.

DIM Restrictions

Important restrictions on DIM:

1. DIM before use: Must declare array before accessing elements
2. DIM once only: Can't re-DIM an array after it's created
3. DIM in program or immediate: Works in both modes, but program-mode DIM is more common

Attempting to DIM an array twice causes an error:

DIM A(10)
DIM A(20)            ' Error: REDIM'D ARRAY

Once dimensioned, an array's size is fixed for that program run. To change size, use NEW (erases program) or CLR (erases variables including arrays), then DIM again with the new size.

Memory Considerations

Arrays consume memory proportional to their size:

• Numeric array: 5 bytes per element (1-byte overhead + 4-byte float)
• Integer array: 3 bytes per element (1-byte overhead + 2-byte int)
• String array: ~20 bytes per element (varies with string length)

Large arrays can exhaust memory:

DIM BIG(10000)       ' ~50KB for numeric array

The C64 has 38911 bytes free; VIC-20 has only 3583 bytes. Plan array sizes carefully. Use integer arrays for whole numbers to save memory (3 bytes vs 5 bytes per element).

DIM Examples

<BasicCode>
10 PRINT "ARRAY DECLARATION DEMO"
20 DIM SCORES(4)
30 SCORES(0) = 85
40 SCORES(1) = 92
50 SCORES(2) = 78
60 SCORES(3) = 88
70 SCORES(4) = 95
80 PRINT "TEST SCORES:"
90 FOR I = 0 TO 4
100 PRINT "SCORE"; I; "= "; SCORES(I)
110 NEXT I
</BasicCode>

Zero-Based Indexing

BASIC arrays start counting at 0, not 1. This zero-based indexing is fundamental to understanding arrays and avoiding off-by-one errors.

Index Range

An array declared with DIM A(N) has indices from 0 to N:

DIM A(10)

Valid indices: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 (that's 11 elements)

Invalid indices: -1, 11, 12, 100 (out of range)

The first element is A(0), not A(1). The last element is A(10), equal to the DIM parameter.

Why Zero-Based?

Zero-based indexing has historical and mathematical reasons:

1. Memory offset: Index represents offset from array start (0 bytes = first element)
2. Mathematical elegance: Modulo arithmetic and array wrap-around work naturally
3. Common practice: Most programming languages (C, Java, Python) use zero-based arrays
4. Commodore heritage: Original BASIC implementations chose this convention

It feels unnatural initially ("first element should be #1!"), but you'll adapt quickly. The key insight: index is a distance from the start, not a position number.

Loop Patterns

Zero-based indexing affects loop patterns. To process every element:

DIM A(10)
FOR I = 0 TO 10      ' Include 0 and 10
    PRINT A(I)
NEXT I

Not:

FOR I = 1 TO 10      ' Wrong: skips A(0)

And not:

FOR I = 0 TO 9       ' Wrong: skips A(10)

The loop must run from 0 to the DIM size, inclusive: FOR I = 0 TO N.

Common Pitfall: One-Based Thinking

Beginners often think in one-based terms:

DIM SCORES(10)       ' "I want 10 scores"
FOR I = 1 TO 10      ' "Process scores 1 through 10"
    SCORES(I) = I * 10
NEXT I

This works but wastes SCORES(0)—you've allocated 11 elements but only use 10. Either:

1. Use all elements (embrace zero-based):

DIM SCORES(10)       ' 11 elements
FOR I = 0 TO 10      ' Use all 11
    SCORES(I) = I * 10
NEXT I

2. Dimension correctly (if you insist on one-based):

DIM SCORES(10)       ' 11 elements (waste SCORES(0))
FOR I = 1 TO 10      ' Use elements 1-10
    SCORES(I) = I * 10
NEXT I

Option 1 is preferred—don't waste memory on unused elements.

Subscript Out of Range Error

Accessing an index outside the declared range causes ?SUBSCRIPT OUT OF RANGE ERROR:

DIM A(10)
A(11) = 100          ' Error: 11 > 10 (max index)
A(-1) = 50           ' Error: negative index
PRINT A(20)          ' Error: 20 > 10

This error is your friend—it catches array bugs before they corrupt memory. Always ensure loop bounds match array dimensions.

Zero-Based Example

<BasicCode>
10 PRINT "ZERO-BASED INDEXING DEMO"
20 DIM DAYS$(6)
30 DAYS$(0) = "SUNDAY"
40 DAYS$(1) = "MONDAY"
50 DAYS$(2) = "TUESDAY"
60 DAYS$(3) = "WEDNESDAY"
70 DAYS$(4) = "THURSDAY"
80 DAYS$(5) = "FRIDAY"
90 DAYS$(6) = "SATURDAY"
100 PRINT "DAYS OF THE WEEK:"
110 FOR I = 0 TO 6
120 PRINT I; ": "; DAYS$(I)
130 NEXT I
</BasicCode>

Notice: 7 days fit in DAYS$(6) because arrays include index 0 through 6 (that's 0,1,2,3,4,5,6 = 7 elements).

One-Dimensional Arrays

One-dimensional arrays are lists: sequences of values indexed by a single number. They're the most common array type and perfect for storing any linear collection of data.

Concept: Lists

A one-dimensional array models:

• List of test scores
• Temperatures for each day of the week
• High scores in a game
• Student names in a class
• Inventory counts for different items

Any data that forms a natural sequence fits a one-dimensional array.

Declaration

DIM arrayname(size)

Examples:

DIM SCORES(9)        ' 10 test scores (0-9)
DIM TEMPS(6)         ' 7 daily temperatures (0-6)
DIM NAMES$(19)       ' 20 student names (0-19)
DIM INVENTORY%(99)   ' 100 inventory items (0-99)

Accessing Elements

Access individual elements with subscript notation:

DIM A(10)
A(0) = 100           ' Assign to first element
A(5) = 200           ' Assign to sixth element
X = A(5)             ' Read from sixth element
PRINT A(0)           ' Print first element

The subscript can be:

• Literal: A(5)
• Variable: A(I)
• Expression: A(I * 2 + 1)

Variable indices enable powerful loop patterns:

FOR I = 0 TO 10
    A(I) = I * I     ' Store squares
NEXT I

Processing All Elements

The standard pattern for processing every element:

DIM A(N)
FOR I = 0 TO N
    ' Process A(I)
NEXT I

Example: Sum all elements

DIM SCORES(9)
' ... fill array ...
TOTAL = 0
FOR I = 0 TO 9
    TOTAL = TOTAL + SCORES(I)
NEXT I
AVERAGE = TOTAL / 10
PRINT "AVERAGE: "; AVERAGE

Student Grades Example

Complete program: Track student grades, calculate average

<BasicCode>
10 PRINT "STUDENT GRADE TRACKER"
20 DIM GRADES(4)
30 PRINT "ENTER 5 GRADES:"
40 FOR I = 0 TO 4
50     PRINT "GRADE "; I + 1; ": ";
60     INPUT GRADES(I)
70 NEXT I
80 TOTAL = 0
90 FOR I = 0 TO 4
100    TOTAL = TOTAL + GRADES(I)
110 NEXT I
120 AVERAGE = TOTAL / 5
130 PRINT ""
140 PRINT "GRADES: ";
150 FOR I = 0 TO 4
160    PRINT GRADES(I); " ";
170 NEXT I
180 PRINT ""
190 PRINT "AVERAGE: "; AVERAGE
</BasicCode>

Temperature Tracker Example

Track daily temperatures, find maximum:

<BasicCode>
10 PRINT "WEEKLY TEMPERATURE TRACKER"
20 DIM TEMPS(6)
30 DATA 68, 72, 75, 71, 69, 73, 70
40 FOR I = 0 TO 6
50     READ TEMPS(I)
60 NEXT I
70 MAXTEMP = TEMPS(0)
80 MAXDAY = 0
90 FOR I = 1 TO 6
100    IF TEMPS(I) > MAXTEMP THEN MAXTEMP = TEMPS(I): MAXDAY = I
110 NEXT I
120 PRINT "TEMPERATURES: ";
130 FOR I = 0 TO 6
140    PRINT TEMPS(I); " ";
150 NEXT I
160 PRINT ""
170 PRINT "HIGHEST: "; MAXTEMP; " ON DAY "; MAXDAY
</BasicCode>

Common One-Dimensional Patterns

Filling an array with calculated values:

DIM SQUARES(10)
FOR I = 0 TO 10
    SQUARES(I) = I * I
NEXT I

Searching an array:

FOUND = 0
FOR I = 0 TO N
    IF A(I) = TARGET THEN FOUND = I: I = N
NEXT I
IF FOUND > 0 THEN PRINT "FOUND AT INDEX "; FOUND

Reversing an array:

FOR I = 0 TO N / 2
    TEMP = A(I)
    A(I) = A(N - I)
    A(N - I) = TEMP
NEXT I

Finding minimum/maximum:

MIN = A(0)
MAX = A(0)
FOR I = 1 TO N
    IF A(I) < MIN THEN MIN = A(I)
    IF A(I) > MAX THEN MAX = A(I)
NEXT I

Two-Dimensional Arrays

Two-dimensional arrays are tables: grids of values indexed by two numbers (row and column). They model spreadsheets, game boards, matrices, or any data naturally organised in rows and columns.

Concept: Tables

A two-dimensional array models:

• Tic-tac-toe board (3×3 grid)
• Chess board (8×8 grid)
• Multiplication table (rows × columns)
• Spreadsheet (rows × columns)
• Pixel display (x × y coordinates)

Any data arranged in a rectangular grid fits a two-dimensional array.

Declaration

DIM arrayname(rows, columns)

Examples:

DIM BOARD(2, 2)      ' 3×3 tic-tac-toe board (0-2, 0-2)
DIM MATRIX(9, 9)     ' 10×10 matrix (0-9, 0-9)
DIM MAP(19, 19)      ' 20×20 game map (0-19, 0-19)

Both dimensions follow zero-based indexing. DIM A(2, 3) creates a 3×4 array:

• Rows: 0, 1, 2 (3 rows)
• Columns: 0, 1, 2, 3 (4 columns)
• Total elements: 3 × 4 = 12

Accessing Elements

Access elements with two indices: arrayname(row, column)

DIM BOARD(2, 2)
BOARD(0, 0) = 1      ' Top-left corner
BOARD(1, 1) = 2      ' Center
BOARD(2, 2) = 3      ' Bottom-right corner

Visualize it as a grid:

       Col 0   Col 1   Col 2
Row 0:   1       ?       ?
Row 1:   ?       2       ?
Row 2:   ?       ?       3

Processing All Elements

Nested loops process every element—outer loop for rows, inner loop for columns:

DIM A(ROWS, COLS)
FOR R = 0 TO ROWS
    FOR C = 0 TO COLS
        ' Process A(R, C)
    NEXT C
NEXT R

This traverses row-by-row (all columns in row 0, then all columns in row 1, etc.).

Multiplication Table Example

Classic 2D array application:

<BasicCode>
10 PRINT "MULTIPLICATION TABLE"
20 DIM TABLE(10, 10)
30 FOR R = 0 TO 10
40     FOR C = 0 TO 10
50         TABLE(R, C) = R * C
60     NEXT C
70 NEXT R
80 PRINT "   ";
90 FOR C = 0 TO 10
100    PRINT C; TAB(4 * (C + 1));
110 NEXT C
120 PRINT ""
130 FOR R = 0 TO 10
140    PRINT R; TAB(3);
150    FOR C = 0 TO 10
160        PRINT TABLE(R, C); TAB(4 * (C + 1));
170    NEXT C
180    PRINT ""
190 NEXT R
</BasicCode>

Tic-Tac-Toe Board Example

Model a game board with 2D array:

<BasicCode>
10 PRINT "TIC-TAC-TOE BOARD"
20 DIM BOARD(2, 2)
30 REM INITIALIZE EMPTY BOARD
40 FOR R = 0 TO 2
50     FOR C = 0 TO 2
60         BOARD(R, C) = 0
70     NEXT C
80 NEXT R
90 REM MAKE SOME MOVES
100 BOARD(0, 0) = 1: REM X
110 BOARD(1, 1) = 1: REM X
120 BOARD(2, 2) = 1: REM X
130 BOARD(0, 2) = 2: REM O
140 BOARD(2, 0) = 2: REM O
150 REM DISPLAY BOARD
160 FOR R = 0 TO 2
170    FOR C = 0 TO 2
180        IF BOARD(R, C) = 0 THEN PRINT "-";
190        IF BOARD(R, C) = 1 THEN PRINT "X";
200        IF BOARD(R, C) = 2 THEN PRINT "O";
210        IF C < 2 THEN PRINT " ";
220    NEXT C
230    PRINT ""
240 NEXT R
</BasicCode>

Matrix Operations Example

Simple matrix addition:

DIM A(2, 2)
DIM B(2, 2)
DIM C(2, 2)

REM Fill A and B with values
FOR R = 0 TO 2
    FOR C = 0 TO 2
        READ A(R, C)
    NEXT C
NEXT R

FOR R = 0 TO 2
    FOR C = 0 TO 2
        READ B(R, C)
    NEXT C
NEXT R

REM Add matrices: C = A + B
FOR R = 0 TO 2
    FOR C = 0 TO 2
        C(R, C) = A(R, C) + B(R, C)
    NEXT C
NEXT R

DATA 1,2,3,4,5,6,7,8,9
DATA 9,8,7,6,5,4,3,2,1

Memory Considerations

Two-dimensional arrays consume rows × columns elements:

DIM A(99, 99)        ' 100 × 100 = 10,000 elements

At 5 bytes per element (numeric), that's 50KB—exceeds C64 memory! Be cautious with large 2D arrays.

Use integer arrays for smaller size:

DIM A%(99, 99)       ' 30KB (3 bytes/element)

Or reduce dimensions:

DIM A(49, 49)        ' 50 × 50 = 2,500 elements (12.5KB)

The DATA Statement

The DATA statement embeds constant values directly in your program. It's a convenient way to initialize arrays, create lookup tables, or store configuration data without prompting the user for input.

Basic Syntax

DATA value1, value2, value3, ...

Examples:

DATA 10, 20, 30, 40, 50
DATA "ALICE", "BOB", "CHARLIE"
DATA 3.14159, 2.71828, 1.41421

DATA statements store values in a program-wide list. You access these values sequentially with the READ statement (covered next).

Multiple DATA Statements

You can have multiple DATA statements anywhere in your program:

10 DATA 1, 2, 3
20 DATA 4, 5, 6
100 DATA 7, 8, 9

BASIC treats all DATA statements as a single continuous list: 1, 2, 3, 4, 5, 6, 7, 8, 9. The line numbers don't matter—DATA is read in program order (lowest line number to highest).

Data Types in DATA

DATA can contain:

• Numeric values: 10, -5, 3.14, 1.5E-3
• String values: "HELLO", "ALICE", "123"
• Mixed types: DATA 10, "HELLO", 3.14

When using mixed types, ensure your READ statements match the data type order.

DATA Placement

DATA statements can appear anywhere in your program:

10 PRINT "SETUP"
20 DATA 1, 2, 3
30 PRINT "PROCESSING"
40 DATA 4, 5, 6

Common conventions:

• Beginning: DATA statements before main program logic
• End: DATA statements after program end (after line 9999 or at high line numbers)
• Grouped: Related DATA statements together

Most programmers put DATA at the end for clarity—it separates data from logic.

String Data Gotcha

String data in DATA statements doesn't require quotes unless the string contains commas or leading/trailing spaces:

DATA HELLO, WORLD        ' Two strings: "HELLO" and "WORLD"
DATA "HELLO, WORLD"      ' One string: "HELLO, WORLD"
DATA HELLO WORLD         ' One string: "HELLO WORLD" (no comma)

If your string contains:

• Commas: Use quotes
• Leading/trailing spaces: Use quotes
• Just letters/numbers: Quotes optional

Best practice: always quote strings in DATA for consistency.

Example: Embedding Configuration

<BasicCode>
10 PRINT "GAME CONFIGURATION"
20 READ MAXLIVES, STARTLEVEL, DIFFICULTY$
30 PRINT "MAX LIVES: "; MAXLIVES
40 PRINT "START LEVEL: "; STARTLEVEL
50 PRINT "DIFFICULTY: "; DIFFICULTY$
60 DATA 3, 1, "HARD"
</BasicCode>

Example: Color Names

10 DIM COLORS$(7)
20 FOR I = 0 TO 7
30     READ COLORS$(I)
40 NEXT I
50 PRINT "COLORS: ";
60 FOR I = 0 TO 7
70     PRINT COLORS$(I); " ";
80 NEXT I
90 DATA "RED", "ORANGE", "YELLOW", "GREEN"
100 DATA "BLUE", "INDIGO", "VIOLET", "WHITE"

Notice: DATA split across two lines (lines 90-100) but accessed as one continuous list.

Reading Data with READ

The READ statement extracts values from DATA statements and stores them in variables. READ works sequentially—each READ gets the next value from the DATA list.

Basic Syntax

READ variable

Examples:

READ A               ' Read next value into A
READ NAME$           ' Read next value into NAME$
READ X, Y, Z         ' Read three values

READ advances an internal data pointer that tracks the current position in the DATA list. First READ gets the first DATA value, second READ gets the second value, and so on.

Sequential Access

READ processes DATA values in order:

10 READ A
20 READ B
30 READ C
40 PRINT A, B, C
50 DATA 10, 20, 30

Output: 10 20 30

Each READ consumes one value from the DATA list. The pointer advances automatically.

Multiple Variables in READ

Read multiple values in one statement:

10 READ A, B, C
20 PRINT A, B, C
30 DATA 10, 20, 30

This is equivalent to three separate READ statements but more concise. Useful for related values.

Type Matching

READ variables must match DATA types:

10 READ A, B$
20 PRINT A, B$
30 DATA 10, "HELLO"      ' OK: number then string

Mismatched types cause errors:

10 READ A$
20 DATA 10               ' Error: reading string, got number

BASIC attempts type conversion but not always successfully. Best practice: match READ variable types to DATA values.

Loop Pattern for Arrays

The standard pattern for filling an array from DATA:

DIM A(N)
FOR I = 0 TO N
    READ A(I)
NEXT I
DATA ...

Example:

<BasicCode>
10 PRINT "ARRAY FROM DATA"
20 DIM SCORES(4)
30 FOR I = 0 TO 4
40     READ SCORES(I)
50 NEXT I
60 PRINT "SCORES: ";
70 FOR I = 0 TO 4
80     PRINT SCORES(I); " ";
90 NEXT I
100 DATA 85, 92, 78, 88, 95
</BasicCode>

OUT OF DATA Error

Reading beyond available DATA causes ?OUT OF DATA ERROR:

10 READ A, B, C
20 DATA 10, 20           ' Only 2 values, need 3
RUN
?OUT OF DATA ERROR

Ensure DATA contains enough values for all READ statements. Count carefully!

Example: Menu Options

<BasicCode>
10 PRINT "MAIN MENU"
20 FOR I = 1 TO 4
30     READ OPTION$
40     PRINT I; ") "; OPTION$
50 NEXT I
60 DATA "PLAY GAME", "HIGH SCORES"
70 DATA "SETTINGS", "QUIT"
</BasicCode>

Resetting with RESTORE

The RESTORE statement resets the DATA pointer to the beginning of the DATA list, allowing you to re-read DATA values. This is useful for multiple passes through the same data or restarting a data sequence.

Basic RESTORE

RESTORE

RESTORE (without parameters) resets the pointer to the first DATA statement in your program:

10 READ A
20 PRINT "FIRST READ: "; A
30 RESTORE
40 READ B
50 PRINT "AFTER RESTORE: "; B
60 DATA 10, 20, 30

Output:

FIRST READ: 10
AFTER RESTORE: 10

Both READ statements get the value 10 because RESTORE reset the pointer to the start.

RESTORE with Line Number

You can RESTORE to a specific DATA statement:

RESTORE linenumber

The pointer jumps to the DATA statement at the specified line:

10 RESTORE 100
20 READ A
30 PRINT A
40 DATA 10, 20, 30
100 DATA 40, 50, 60

Output: 40 (first value from line 100's DATA)

This enables multiple data sets in one program—RESTORE to different line numbers to switch between data sets.

Multiple Data Sets Example

<BasicCode>
10 PRINT "RESTORE DEMO: MULTIPLE DATA SETS"
20 PRINT "SET 1:"
30 RESTORE 100
40 FOR I = 1 TO 3
50     READ A
60     PRINT A; " ";
70 NEXT I
80 PRINT ""
90 PRINT "SET 2:"
95 RESTORE 200
100 FOR I = 1 TO 3
110    READ A
120    PRINT A; " ";
130 NEXT I
140 PRINT ""
150 DATA 10, 20, 30
200 DATA 40, 50, 60
</BasicCode>

Note: Line 150 is ignored because we explicitly RESTORE to lines 100 and 200.

Re-Reading Data

RESTORE enables multiple passes through the same data:

10 DIM A(4)
20 PRINT "FIRST PASS:"
30 FOR I = 0 TO 4
40     READ A(I)
50     PRINT A(I); " ";
60 NEXT I
70 PRINT ""
80 RESTORE
90 PRINT "SECOND PASS:"
100 FOR I = 0 TO 4
110    READ A(I)
120    A(I) = A(I) * 2
130    PRINT A(I); " ";
140 NEXT I
150 DATA 1, 2, 3, 4, 5

Output:

FIRST PASS: 1 2 3 4 5
SECOND PASS: 2 4 6 8 10

When to Use RESTORE

Use RESTORE when:

• Multiple passes: Process same data repeatedly
• Data sets: Switch between different data groups
• Reset after partial read: Start over mid-program
• User-driven re-read: Let user repeat operations

Common pattern: Menu system with multiple DATA sets for different menu levels, RESTORE to jump between them.

Practical Array Applications

Arrays enable powerful programming patterns. This section demonstrates practical applications: sorting, searching, and statistics.

Bubble Sort

Sort an array from smallest to largest using the bubble sort algorithm:

<BasicCode>
10 PRINT "BUBBLE SORT DEMO"
20 DIM A(9)
30 PRINT "UNSORTED:"
40 FOR I = 0 TO 9
50     A(I) = INT(RND(1) * 100)
60     PRINT A(I); " ";
70 NEXT I
80 PRINT ""
90 REM BUBBLE SORT
100 FOR I = 0 TO 8
110    FOR J = 0 TO 8 - I
120        IF A(J) > A(J + 1) THEN TEMP = A(J): A(J) = A(J + 1): A(J + 1) = TEMP
130    NEXT J
140 NEXT I
150 PRINT "SORTED:"
160 FOR I = 0 TO 9
170    PRINT A(I); " ";
180 NEXT I
</BasicCode>

The algorithm: Compare adjacent elements, swap if out of order, repeat until sorted.

Linear Search

Find an element in an array:

<BasicCode>
10 PRINT "LINEAR SEARCH DEMO"
20 DIM A(9)
30 FOR I = 0 TO 9
40     A(I) = I * 10
50 NEXT I
60 PRINT "ARRAY: ";
70 FOR I = 0 TO 9
80     PRINT A(I); " ";
90 NEXT I
100 PRINT ""
110 INPUT "SEARCH FOR"; TARGET
120 FOUND = -1
130 FOR I = 0 TO 9
140    IF A(I) = TARGET THEN FOUND = I: I = 9
150 NEXT I
160 IF FOUND >= 0 THEN PRINT "FOUND AT INDEX "; FOUND ELSE PRINT "NOT FOUND"
</BasicCode>

Statistics: Mean, Max, Min

Calculate statistics from array data:

<BasicCode>
10 PRINT "STATISTICS CALCULATOR"
20 DIM DATA(9)
30 PRINT "DATA:"
40 TOTAL = 0
50 FOR I = 0 TO 9
60     READ DATA(I)
70     PRINT DATA(I); " ";
80     TOTAL = TOTAL + DATA(I)
90 NEXT I
100 MEAN = TOTAL / 10
110 PRINT ""
120 MINVAL = DATA(0)
130 MAXVAL = DATA(0)
140 FOR I = 1 TO 9
150    IF DATA(I) < MINVAL THEN MINVAL = DATA(I)
160    IF DATA(I) > MAXVAL THEN MAXVAL = DATA(I)
170 NEXT I
180 PRINT "MEAN: "; MEAN
190 PRINT "MIN: "; MINVAL
200 PRINT "MAX: "; MAXVAL
210 DATA 23, 45, 12, 67, 89, 34, 56, 78, 90, 11
</BasicCode>

Histogram

Count occurrences of values:

10 DIM COUNTS(9)
20 REM Initialize counts to 0
30 FOR I = 0 TO 9
40     COUNTS(I) = 0
50 NEXT I
60 REM Count random digits
70 FOR I = 1 TO 100
80     DIGIT = INT(RND(1) * 10)
90     COUNTS(DIGIT) = COUNTS(DIGIT) + 1
100 NEXT I
110 REM Display histogram
120 PRINT "DIGIT COUNT"
130 FOR I = 0 TO 9
140    PRINT I; TAB(6); COUNTS(I)
150 NEXT I

Lookup Table

Use arrays for fast lookups (e.g., month names):

10 DIM MONTHS$(11)
20 FOR I = 0 TO 11
30     READ MONTHS$(I)
40 NEXT I
50 INPUT "ENTER MONTH (0-11)"; M
60 IF M < 0 OR M > 11 THEN PRINT "INVALID": END
70 PRINT "MONTH: "; MONTHS$(M)
80 DATA "JAN", "FEB", "MAR", "APR", "MAY", "JUN"
90 DATA "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"

Common Array Mistakes

Arrays introduce new error patterns. Avoid these common pitfalls:

Mistake 1: Forgetting Zero-Based Index

DIM A(10)
FOR I = 1 TO 10          ' Skips A(0)
    A(I) = I
NEXT I

Solution: Loop from 0 to N: FOR I = 0 TO 10

Mistake 2: Off-By-One in Loop

DIM A(10)
FOR I = 0 TO 11          ' Error: 11 > 10
    A(I) = I
NEXT I

Solution: Loop to DIM size exactly: FOR I = 0 TO 10

Mistake 3: Forgetting DIM

A(50) = 100              ' Error if A not DIMmed (default is 0-10)

Solution: Always DIM before use, even if size ≤ 11

Mistake 4: Re-DIMming

DIM A(10)
DIM A(20)                ' Error: REDIM'D ARRAY

Solution: DIM once only; use CLR to clear and re-DIM

Mistake 5: Type Mismatch in Arrays

DIM A$(10)
A$(0) = 100              ' Error: number to string array

Solution: Match types (use A$(0) = "100" or DIM A(10))

Mistake 6: Subscript Out of Range

DIM A(10)
A(15) = 100              ' Error: 15 > 10

Solution: Check loop bounds; ensure indices ≤ DIM size

Mistake 7: Mixing 1D and 2D Syntax

DIM A(10, 10)
PRINT A(5)               ' Error: need two indices

Solution: Use A(5, 5) for 2D arrays

Mistake 8: OUT OF DATA Error

FOR I = 0 TO 10
    READ A(I)            ' Reads 11 values
NEXT I
DATA 1, 2, 3             ' Only 3 values!

Solution: Count DATA values; ensure enough for all READs

Summary

Arrays organise related data into numbered collections, enabling powerful programming patterns. This chapter covered:

• What arrays are: Numbered storage boxes, indexed by position
• DIM statement: Declares array size (DIM A(N) = N+1 elements)
• Zero-based indexing: Arrays start at index 0, run to DIM size
• One-dimensional arrays: Lists indexed by single number
• Two-dimensional arrays: Tables indexed by row and column
• DATA statement: Embeds constant values in program
• READ statement: Extracts values from DATA sequentially
• RESTORE statement: Resets DATA pointer (with optional line number)
• Practical applications: Sorting, searching, statistics, lookup tables

Key takeaways:

1. Always DIM arrays explicitly: Prevents subscript errors, documents size
2. Remember zero-based indexing: Loop from 0 to N, not 1 to N
3. Match types: Array type (%, $) must match element type
4. Count DATA carefully: Ensure enough values for all READs
5. Use arrays for collections: Whenever you have related data, use an array instead of separate variables
6. Loop patterns are standard: FOR I = 0 TO N processes every element
7. 2D arrays for grids: Natural model for tables, boards, matrices

Arrays transform BASIC from a calculator into a data processing powerhouse. Combined with loops (Chapter 7) and functions (Chapter 10), arrays enable sophisticated programs: games with state, data analysis, simulations, and more.

Master arrays to unlock BASIC's full potential. Practice with the examples, modify them, create your own. Arrays are fundamental—every significant BASIC program uses them.

End of Chapter 9

Proceed to Chapter 10: Built-in Functions to learn mathematical, string, and system functions that operate on variables and array elements.

Built-in Functions

Introduction to Functions

Functions are pre-written pieces of code that perform specific calculations and return a result. Unlike statements that perform actions (PRINT, GOTO), functions compute values that you use in expressions.

Functions always appear on the right side of assignments or inside other expressions:

X = SQR(16)          ← Function call
PRINT ABS(-5)        ← Function inside PRINT
IF LEN(N$) > 10 THEN ← Function in condition

Functions take parameters (inputs) in parentheses and return a single value. Some functions work with numbers (INT, SQR), others with strings (LEFT$, LEN), and some query system state (FRE, POS).

Function naming convention: String functions end with $ (LEFT$, CHR$), numeric functions don't (ABS, SIN). This matches the type of value they return.

All functions are read-only—they calculate results without changing your program's state (except RND, which advances the random number generator).

Mathematical Functions

ABS(x) - Absolute Value

Returns the absolute value of a number (distance from zero, always positive).

Syntax: ABS(expression)

Parameters:

• expression - Any numeric value (integer or floating-point)

Returns: Non-negative number of same type as input

Examples:

PRINT ABS(5)
5
PRINT ABS(-5)
5
PRINT ABS(-3.14159)
3.14159
PRINT ABS(0)
0
X = -100
PRINT ABS(X)
100
PRINT ABS(10-20)
10
READY.

Common uses:

• Distance calculations
• Error magnitude (ignoring sign)
• Checking if values are close: IF ABS(A-B) < 0.001 THEN

INT(x) - Integer Part

Returns the largest integer less than or equal to x (floor function). This rounds down toward negative infinity.

Syntax: INT(expression)

Parameters:

• expression - Any numeric value

Returns: Integer value (technically still floating-point type, but whole number)

Examples:

PRINT INT(3.7)
3
PRINT INT(3.2)
3
PRINT INT(-2.3)
-3
PRINT INT(-2.9)
-3
PRINT INT(5)
5
X = 7.9999
PRINT INT(X)
7
READY.

Important: INT rounds toward negative infinity, not toward zero:

• INT(2.9) = 2 (correct)
• INT(-2.9) = -3 (not -2!)

Rounding to nearest integer:

REM ROUND TO NEAREST INTEGER
X = 3.7
PRINT INT(X + 0.5)
4
X = 3.2
PRINT INT(X + 0.5)
3
X = -2.7
PRINT INT(X + 0.5)
-2
READY.

Common uses:

• Extracting whole numbers from calculations
• Rounding (with offset)
• Generating random integers: INT(RND(1)*10)

SGN(x) - Sign

Returns the sign of a number: -1 for negative, 0 for zero, +1 for positive.

Syntax: SGN(expression)

Parameters:

• expression - Any numeric value

Returns: -1, 0, or 1

Examples:

PRINT SGN(100)
1
PRINT SGN(-50)
-1
PRINT SGN(0)
0
PRINT SGN(0.001)
1
PRINT SGN(-0.001)
-1
X = 10-20
PRINT SGN(X)
-1
READY.

Common uses:

• Direction indicators
• Normalizing values to unit sign
• Checking positive/negative in conditional logic

Practical example:

10 REM TEMPERATURE CHANGE INDICATOR
20 INPUT "YESTERDAY TEMP"; Y
30 INPUT "TODAY TEMP"; T
40 D = SGN(T-Y)
50 IF D=1 THEN PRINT "WARMER"
60 IF D=-1 THEN PRINT "COOLER"
70 IF D=0 THEN PRINT "SAME"
LIST
RUN
YESTERDAY TEMP? 72
TODAY TEMP? 68
COOLER
READY.

SQR(x) - Square Root

Returns the square root of a non-negative number.

Syntax: SQR(expression)

Parameters:

• expression - Non-negative numeric value

Returns: Square root (floating-point)

Error: ?ILLEGAL QUANTITY ERROR if x < 0

Examples:

PRINT SQR(16)
4
PRINT SQR(2)
1.41421356
PRINT SQR(100)
10
PRINT SQR(0)
0
PRINT SQR(0.25)
0.5
X = 49
PRINT SQR(X)
7
READY.

Distance formula (Pythagorean theorem):

10 REM DISTANCE BETWEEN TWO POINTS
20 INPUT "X1,Y1"; X1,Y1
30 INPUT "X2,Y2"; X2,Y2
40 DX = X2-X1
50 DY = Y2-Y1
60 D = SQR(DX*DX + DY*DY)
70 PRINT "DISTANCE ="; D
LIST
RUN
X1,Y1? 0,0
X2,Y2? 3,4
DISTANCE = 5
READY.

Common uses:

• Geometry calculations
• Physics equations
• Standard deviation and statistics
• Normalizing vectors

LOG(x) - Natural Logarithm

Returns the natural logarithm (base e) of a positive number.

Syntax: LOG(expression)

Parameters:

• expression - Positive numeric value (x > 0)

Returns: Natural log (floating-point)

Error: ?ILLEGAL QUANTITY ERROR if x ≤ 0

Examples:

PRINT LOG(1)
0
PRINT LOG(2.71828)
1
PRINT LOG(10)
2.30258509
PRINT LOG(100)
4.60517019
X = 7.389
PRINT LOG(X)
2.00001629
READY.

Converting to other bases:

10 REM LOG BASE 10 CONVERTER
20 X = 1000
30 LOG10 = LOG(X)/LOG(10)
40 PRINT "LOG10("; X; ") ="; LOG10
RUN
LOG10( 1000 ) = 3
READY.

Common uses:

• Scientific calculations
• Exponential decay/growth
• Converting between logarithm bases: LOGB(X) = LOG(X)/LOG(B)
• Sound intensity (decibels)

EXP(x) - Exponential

Returns e raised to the power of x (e^x where e ≈ 2.71828).

Syntax: EXP(expression)

Parameters:

• expression - Any numeric value

Returns: e^x (floating-point)

Note: Result can overflow for large values (x > 88)

Examples:

PRINT EXP(0)
1
PRINT EXP(1)
2.71828183
PRINT EXP(2)
7.3890561
PRINT EXP(-1)
0.367879441
X = 3
PRINT EXP(X)
20.0855369
READY.

Relationship with LOG:

X = 5
PRINT EXP(LOG(X))
5
Y = EXP(2)
PRINT LOG(Y)
2
READY.

Exponential growth model:

10 REM COMPOUND INTEREST
20 P = 1000: REM PRINCIPAL
30 R = 0.05: REM 5% RATE
40 T = 10: REM YEARS
50 A = P * EXP(R*T)
60 PRINT "AMOUNT: $"; INT(A*100+0.5)/100
RUN
AMOUNT: $ 1648.72
READY.

Common uses:

• Exponential growth/decay
• Continuous compounding
• Normal distribution calculations
• Physics (radioactive decay)

RND(x) - Random Number

Returns a pseudo-random number between 0 (inclusive) and 1 (exclusive).

Syntax: RND(expression)

Parameters:

• x > 0 - Generate next random number (most common: use RND(1))
• x = 0 - Repeat last random number generated
• x < 0 - Seed generator with x (same seed = same sequence)

Returns: Random value in range [0, 1)

Examples:

PRINT RND(1)
0.737927713
PRINT RND(1)
0.293746442
PRINT RND(1)
0.629374802
PRINT RND(0)
0.629374802
PRINT RND(0)
0.629374802
READY.

Seeding the generator:

REM SEED WITH -1
X = RND(-1)
PRINT RND(1)
0.185032621
PRINT RND(1)
0.842648298
REM SEED AGAIN WITH -1
X = RND(-1)
PRINT RND(1)
0.185032621
PRINT RND(1)
0.842648298
READY.

Generating random integers (dice, cards, etc.):

10 REM ROLL A 6-SIDED DIE
20 FOR I=1 TO 10
30 ROLL = INT(RND(1)*6)+1
40 PRINT ROLL;
50 NEXT I
RUN
3 1 6 2 5 4 6 1 2 3
READY.

Random number in range [MIN, MAX]:

10 REM RANDOM NUMBER BETWEEN 10 AND 20
20 MIN=10: MAX=20
30 FOR I=1 TO 5
40 R = INT(RND(1)*(MAX-MIN+1))+MIN
50 PRINT R;
60 NEXT I
RUN
17 12 19 14 16
READY.

Practical dice roller:

10 REM DICE ROLLER
20 INPUT "HOW MANY DICE"; N
30 T=0
40 FOR I=1 TO N
50 D=INT(RND(1)*6)+1
60 PRINT "DIE"; I; ":"; D
70 T=T+D
80 NEXT I
90 PRINT "TOTAL:"; T
LIST
RUN
HOW MANY DICE? 3
DIE 1 : 4
DIE 2 : 2
DIE 3 : 6
TOTAL: 12
READY.

Common uses:

• Games (dice, card shuffling)
• Simulations
• Random sampling
• Procedural generation

Trigonometric Functions

All trigonometric functions work in radians, not degrees.

Degree/Radian conversion:

• Radians to degrees: DEGREES = RADIANS * 180 / PI
• Degrees to radians: RADIANS = DEGREES * PI / 180
• Pi constant: PI = 3.14159265

SIN(x) - Sine

Returns the sine of an angle (in radians).

Syntax: SIN(expression)

Parameters:

• expression - Angle in radians

Returns: Sine value in range [-1, 1]

Examples:

PRINT SIN(0)
0
PI = 3.14159265
PRINT SIN(PI/2)
1
PRINT SIN(PI)
-8.74227766E-08
PRINT SIN(PI*2)
-1.74845553E-07
PRINT SIN(-PI/2)
-1
READY.

Working with degrees:

10 REM SINE IN DEGREES
20 PI = 3.14159265
30 DEF FN RAD(D) = D*PI/180
40 INPUT "ANGLE IN DEGREES"; A
50 PRINT "SIN("; A; ") ="; SIN(FN RAD(A))
LIST
RUN
ANGLE IN DEGREES? 30
SIN( 30 ) = 0.5
RUN
ANGLE IN DEGREES? 90
SIN( 90 ) = 1
READY.

COS(x) - Cosine

Returns the cosine of an angle (in radians).

Syntax: COS(expression)

Parameters:

• expression - Angle in radians

Returns: Cosine value in range [-1, 1]

Examples:

PRINT COS(0)
1
PI = 3.14159265
PRINT COS(PI/2)
-4.37113883E-08
PRINT COS(PI)
-1
PRINT COS(PI*2)
1
READY.

TAN(x) - Tangent

Returns the tangent of an angle (in radians).

Syntax: TAN(expression)

Parameters:

• expression - Angle in radians

Returns: Tangent value (can be very large near π/2)

Examples:

PRINT TAN(0)
0
PI = 3.14159265
PRINT TAN(PI/4)
1
PRINT TAN(PI/6)
0.577350269
PRINT TAN(-PI/4)
-1
READY.

ATN(x) - Arctangent

Returns the arctangent (inverse tangent) of a number, in radians.

Syntax: ATN(expression)

Parameters:

• expression - Any numeric value

Returns: Angle in radians, range (-π/2, π/2)

Examples:

PRINT ATN(0)
0
PRINT ATN(1)
0.785398163
PI = 3.14159265
PRINT ATN(1)*4
3.14159265
PRINT ATN(1000000)
1.5707953
READY.

Calculating Pi:

10 REM CALCULATE PI USING ATN
20 PI = ATN(1)*4
30 PRINT "PI ="; PI
RUN
PI = 3.14159265
READY.

Complete trigonometry example (right triangle solver):

10 REM RIGHT TRIANGLE SOLVER
20 PI = 3.14159265
30 INPUT "ADJACENT SIDE"; A
40 INPUT "OPPOSITE SIDE"; O
50 H = SQR(A*A + O*O)
60 ANG = ATN(O/A) * 180/PI
70 PRINT "HYPOTENUSE ="; H
80 PRINT "ANGLE ="; INT(ANG*100+0.5)/100; "DEG"
LIST
RUN
ADJACENT SIDE? 3
OPPOSITE SIDE? 4
HYPOTENUSE = 5
ANGLE = 53.13 DEG
READY.

Polar to Cartesian conversion:

10 REM POLAR TO CARTESIAN
20 PI = 3.14159265
30 INPUT "RADIUS"; R
40 INPUT "ANGLE (DEGREES)"; D
50 A = D * PI/180
60 X = R * COS(A)
70 Y = R * SIN(A)
80 PRINT "X ="; X
90 PRINT "Y ="; Y
LIST
RUN
RADIUS? 10
ANGLE (DEGREES)? 45
X = 7.07106781
Y = 7.07106781
READY.

String Functions

String functions manipulate text. String variables end with $ suffix (N$, A$), and string functions return strings (LEFT$, CHR$) or numbers (LEN, ASC).

LEN(s$) - String Length

Returns the number of characters in a string.

Syntax: LEN(string$)

Parameters:

• string$ - Any string expression

Returns: Integer count of characters (0 to 255)

Examples:

PRINT LEN("HELLO")
5
PRINT LEN("")
0
A$ = "COMMODORE 64"
PRINT LEN(A$)
12
PRINT LEN("  SPACES  ")
10
X$ = "ABC" + "DEF"
PRINT LEN(X$)
6
READY.

Validation example:

10 REM PASSWORD LENGTH CHECK
20 INPUT "ENTER PASSWORD"; P$
30 IF LEN(P$)<6 THEN PRINT "TOO SHORT": GOTO 20
40 IF LEN(P$)>20 THEN PRINT "TOO LONG": GOTO 20
50 PRINT "PASSWORD ACCEPTED"
LIST
RUN
ENTER PASSWORD? ABC
TOO SHORT
ENTER PASSWORD? MYPASSWORD
PASSWORD ACCEPTED
READY.

LEFT$(s$,n) - Left Substring

Returns the leftmost n characters of a string.

Syntax: LEFT$(string$, count)

Parameters:

• string$ - Source string
• count - Number of characters (0 to length)

Returns: Substring of leftmost characters

Examples:

PRINT LEFT$("HELLO",3)
HEL
PRINT LEFT$("BASIC",1)
B
A$ = "COMMODORE"
PRINT LEFT$(A$,4)
COMM
PRINT LEFT$("TEST",10)
TEST
PRINT LEFT$("WORD",0)

READY.

Truncation example:

10 REM TRUNCATE TO 10 CHARS
20 INPUT "NAME"; N$
30 IF LEN(N$)>10 THEN N$=LEFT$(N$,10)
40 PRINT "HELLO "; N$
LIST
RUN
NAME? CHRISTOPHER
HELLO CHRISTOPH
READY.

RIGHT$(s$,n) - Right Substring

Returns the rightmost n characters of a string.

Syntax: RIGHT$(string$, count)

Parameters:

• string$ - Source string
• count - Number of characters (0 to length)

Returns: Substring of rightmost characters

Examples:

PRINT RIGHT$("HELLO",3)
LLO
PRINT RIGHT$("BASIC",2)
IC
A$ = "FILENAME.BAS"
PRINT RIGHT$(A$,3)
BAS
PRINT RIGHT$("TEST",10)
TEST
READY.

File extension parser:

10 REM EXTRACT FILE EXTENSION
20 INPUT "FILENAME"; F$
30 E$ = RIGHT$(F$,3)
40 IF E$="BAS" THEN PRINT "BASIC PROGRAM"
50 IF E$="TXT" THEN PRINT "TEXT FILE"
60 IF E$="DAT" THEN PRINT "DATA FILE"
LIST
RUN
FILENAME? GAME.BAS
BASIC PROGRAM
READY.

MID$(s$,start[,length]) - Middle Substring

Returns a substring starting at a specified position.

Syntax:

• MID$(string$, start) - From start to end
• MID$(string$, start, length) - Specific length

Parameters:

• string$ - Source string
• start - Starting position (1-based, first char is 1)
• length - Optional, number of characters to extract

Returns: Substring from specified position

Examples:

PRINT MID$("HELLO",2,3)
ELL
PRINT MID$("COMMODORE",4,3)
MOD
PRINT MID$("BASIC",2)
ASIC
A$ = "123-456-7890"
PRINT MID$(A$,5,3)
456
PRINT MID$("TEST",1,1)
T
READY.

String parsing example:

10 REM PARSE DATE MM/DD/YYYY
20 INPUT "DATE (MM/DD/YYYY)"; D$
30 M$ = MID$(D$,1,2)
40 D$ = MID$(D$,4,2)
50 Y$ = MID$(D$,7,4)
60 PRINT "MONTH:"; M$
70 PRINT "DAY:"; D$
80 PRINT "YEAR:"; Y$
LIST
RUN
DATE (MM/DD/YYYY)? 03/15/1982
MONTH: 03
DAY: 15
YEAR: 1982
READY.

CHR$(n) - ASCII to Character

Converts an ASCII code number to its character.

Syntax: CHR$(code)

Parameters:

• code - ASCII value (0 to 255)

Returns: Single-character string

Examples:

PRINT CHR$(65)
A
PRINT CHR$(97)
a
PRINT CHR$(48)
0
PRINT CHR$(32)
 
PRINT CHR$(72);CHR$(73);
HI
A = 65
PRINT CHR$(A); CHR$(A+1); CHR$(A+2)
ABC
READY.

Building strings from codes:

10 REM GENERATE ALPHABET
20 FOR I=65 TO 90
30 PRINT CHR$(I);
40 NEXT I
RUN
ABCDEFGHIJKLMNOPQRSTUVWXYZ
READY.

ASCII table reference (common characters):

32: Space    48-57: 0-9     65-90: A-Z     97-122: a-z
13: Return   10: Linefeed   8: Backspace   27: Escape

ASC(s$) - Character to ASCII

Returns the ASCII code of the first character in a string.

Syntax: ASC(string$)

Parameters:

• string$ - Non-empty string

Returns: ASCII value (0-255) of first character

Error: ?ILLEGAL QUANTITY ERROR if string is empty

Examples:

PRINT ASC("A")
65
PRINT ASC("HELLO")
72
PRINT ASC("a")
97
PRINT ASC("0")
48
PRINT ASC(" ")
32
READY.

Character classification:

10 REM CHARACTER TYPE CHECKER
20 INPUT "ENTER CHARACTER"; C$
30 IF C$="" THEN PRINT "EMPTY": GOTO 20
40 A = ASC(C$)
50 IF A>=48 AND A<=57 THEN PRINT "DIGIT"
60 IF A>=65 AND A<=90 THEN PRINT "UPPERCASE"
70 IF A>=97 AND A<=122 THEN PRINT "LOWERCASE"
LIST
RUN
ENTER CHARACTER? 5
DIGIT
RUN
ENTER CHARACTER? Z
UPPERCASE
READY.

Case conversion:

10 REM UPPERCASE CONVERTER
20 INPUT "TEXT"; T$
30 U$ = ""
40 FOR I=1 TO LEN(T$)
50 C$ = MID$(T$,I,1)
60 A = ASC(C$)
70 IF A>=97 AND A<=122 THEN A=A-32
80 U$ = U$ + CHR$(A)
90 NEXT I
100 PRINT U$
LIST
RUN
TEXT? Hello World
HELLO WORLD
READY.

STR$(n) - Number to String

Converts a number to its string representation.

Syntax: STR$(number)

Parameters:

• number - Any numeric value

Returns: String representation (includes leading space for positive)

Examples:

PRINT STR$(123)
 123
PRINT STR$(-456)
-456
X = 3.14159
PRINT STR$(X)
 3.14159
PRINT "VALUE:" + STR$(100)
VALUE: 100
READY.

Note: Positive numbers have a leading space where the minus sign would go.

Removing leading space:

X = 42
S$ = STR$(X)
IF LEFT$(S$,1)=" " THEN S$=MID$(S$,2)
PRINT ">" + S$ + "<"
>42<
READY.

Concatenating numbers and strings:

10 REM SCORE DISPLAY
20 S=1000
30 L=3
40 M$ = "SCORE:" + STR$(S) + " LIVES:" + STR$(L)
50 PRINT M$
RUN
SCORE: 1000 LIVES: 3
READY.

VAL(s$) - String to Number

Converts a string to a numeric value. Parsing stops at first non-numeric character.

Syntax: VAL(string$)

Parameters:

• string$ - String containing numeric representation

Returns: Numeric value (0 if no valid number found)

Examples:

PRINT VAL("123")
123
PRINT VAL("-456")
-456
PRINT VAL("3.14159")
3.14159
PRINT VAL("  42")
42
PRINT VAL("10ABC")
10
PRINT VAL("ABC")
0
READY.

Parsing user input:

10 REM CALCULATOR
20 INPUT "ENTER EXPRESSION (A+B)"; E$
30 FOR I=1 TO LEN(E$)
40 C$=MID$(E$,I,1)
50 IF C$="+" OR C$="-" OR C$="*" THEN 70
60 NEXT I
70 A=VAL(LEFT$(E$,I-1))
80 OP$=C$
90 B=VAL(MID$(E$,I+1))
100 IF OP$="+" THEN PRINT A+B
110 IF OP$="-" THEN PRINT A-B
120 IF OP$="*" THEN PRINT A*B
LIST
RUN
ENTER EXPRESSION (A+B)? 15+27
42
RUN
ENTER EXPRESSION (A+B)? 100-25
75
READY.

System Functions

System functions query the interpreter's state and environment.

FRE(0) - Free Memory

Returns the number of bytes of free memory available for program and variables.

Syntax: FRE(0) or FRE(dummy)

Parameters:

• Dummy parameter (by convention 0, value ignored)

Returns: Free memory in bytes

Examples:

PRINT FRE(0)
38911
10 DIM A(1000)
PRINT FRE(0)
34815
READY.

Memory monitoring:

10 REM MEMORY MONITOR
20 PRINT "FREE:"; FRE(0); "BYTES"
30 INPUT "ARRAY SIZE"; N
40 DIM A(N)
50 PRINT "USED:"; FRE(0); "BYTES"
LIST
RUN
FREE: 38911 BYTES
ARRAY SIZE? 500
USED: 36863 BYTES
READY.

Note: Values differ between C64 mode (38911 bytes) and VIC-20 mode (3583 bytes).

POS(0) - Cursor Position

Returns the current cursor column position (0-39 on C64, 0-21 on VIC-20).

Syntax: POS(0) or POS(dummy)

Parameters:

• Dummy parameter (by convention 0, value ignored)

Returns: Column position (0-based)

Examples:

PRINT POS(0)
0
PRINT "HELLO";
PRINT POS(0)
5
PRINT TAB(20); "X";
PRINT POS(0)
21
READY.

Formatted table with alignment:

10 REM ALIGNED TABLE
20 FOR I=1 TO 5
30 PRINT "ITEM"; I;
40 PRINT TAB(15); "VALUE"; I*10
50 NEXT I
LIST
RUN
ITEM 1        VALUE 10
ITEM 2        VALUE 20
ITEM 3        VALUE 30
ITEM 4        VALUE 40
ITEM 5        VALUE 50
READY.

PEEK(addr) - Read Memory

Reads a byte from a memory address in the 64KB simulated memory space.

Syntax: PEEK(address)

Parameters:

• address - Memory address (0-65535)

Returns: Byte value at address (0-255)

Examples:

POKE 1024,65
PRINT PEEK(1024)
65
POKE 2000,123
X = PEEK(2000)
PRINT X
123
READY.

Memory inspection:

10 REM MEMORY HEX DUMP
20 INPUT "START ADDRESS"; A
30 FOR I=0 TO 15
40 V=PEEK(A+I)
50 PRINT V;
60 NEXT I
LIST
RUN
START ADDRESS? 1024
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
READY.

Note: SLP-BASIC uses simulated memory, not real hardware. PEEK/POKE are useful for data storage but don't access actual hardware registers.

User-Defined Functions with DEF FN

DEF FN allows you to create your own custom functions.

Syntax: DEF FN name(parameter) = expression

Naming rules:

• Function name must start with FN
• Followed by letter (FNA, FNX, FNCALC)
• Parameter name is a variable

Limitations:

• Single-line only - Expression must fit on one line
• Single parameter only
• Cannot call other DEF FN functions
• Cannot use IF, FOR, GOTO, etc. (expression only)

Examples:

DEF FN DOUBLE(X) = X*2
PRINT FN DOUBLE(5)
10
PRINT FN DOUBLE(3.5)
7
READY.

DEF FN SQU(X) = X*X
FOR I=1 TO 5
PRINT I; "SQUARED ="; FN SQU(I)
NEXT I
1 SQUARED = 1
2 SQUARED = 4
3 SQUARED = 9
4 SQUARED = 16
5 SQUARED = 25
READY.

Mathematical formulas:

10 REM TEMPERATURE CONVERTER
20 DEF FN C2F(C) = C*9/5+32
30 DEF FN F2C(F) = (F-32)*5/9
40 INPUT "CELSIUS"; C
50 PRINT C; "C ="; FN C2F(C); "F"
60 INPUT "FAHRENHEIT"; F
70 PRINT F; "F ="; FN F2C(F); "C"
LIST
RUN
CELSIUS? 0
0 C = 32 F
FAHRENHEIT? 212
212 F = 100 C
READY.

Complex expressions:

10 REM CIRCLE CALCULATIONS
20 PI = 3.14159265
30 DEF FN AREA(R) = PI*R*R
40 DEF FN CIRC(R) = 2*PI*R
50 INPUT "RADIUS"; R
60 PRINT "AREA:"; FN AREA(R)
70 PRINT "CIRCUMFERENCE:"; FN CIRC(R)
LIST
RUN
RADIUS? 5
AREA: 78.5398163
CIRCUMFERENCE: 31.4159265
READY.

Using with trigonometry:

10 REM DEGREE/RADIAN CONVERTERS
20 PI = 3.14159265
30 DEF FN RAD(D) = D*PI/180
40 DEF FN DEG(R) = R*180/PI
50 INPUT "DEGREES"; D
60 PRINT "SIN("; D; ") ="; SIN(FN RAD(D))
70 PRINT "COS("; D; ") ="; COS(FN RAD(D))
LIST
RUN
DEGREES? 45
SIN( 45 ) = 0.707106781
COS( 45 ) = 0.707106781
READY.

Common uses:

• Unit conversions (temperature, distance, weight)
• Mathematical formulas (area, volume)
• Physics equations
• Financial calculations

What you CANNOT do with DEF FN:

DEF FN BAD(X) = IF X>0 THEN X ELSE -X  ← NO! Can't use IF
DEF FN BAD(X) = FN OTHER(X)            ← NO! Can't call other FN
DEF FN BAD(X,Y) = X+Y                  ← NO! Single parameter only

For complex functions requiring multiple statements, use GOSUB subroutines instead.

Function Examples

Example 1: Scientific Calculator

10 REM SCIENTIFIC CALCULATOR
20 PI = 3.14159265
30 DEF FN RAD(D) = D*PI/180
40 PRINT "SCIENTIFIC CALCULATOR"
50 PRINT "1) SQUARE ROOT"
60 PRINT "2) SINE (DEGREES)"
70 PRINT "3) LOGARITHM"
80 PRINT "4) POWER"
90 INPUT "CHOICE"; C
100 IF C=1 THEN GOSUB 200
110 IF C=2 THEN GOSUB 300
120 IF C=3 THEN GOSUB 400
130 IF C=4 THEN GOSUB 500
140 GOTO 50
200 INPUT "NUMBER"; X
210 PRINT "SQRT("; X; ") ="; SQR(X)
220 RETURN
300 INPUT "ANGLE"; A
310 PRINT "SIN("; A; ") ="; SIN(FN RAD(A))
320 RETURN
400 INPUT "NUMBER"; X
410 IF X<=0 THEN PRINT "MUST BE >0": RETURN
420 PRINT "LOG("; X; ") ="; LOG(X)
430 RETURN
500 INPUT "BASE,EXPONENT"; B,E
510 PRINT B; "^"; E; "="; B^E
520 RETURN
LIST
RUN
SCIENTIFIC CALCULATOR
1) SQUARE ROOT
2) SINE (DEGREES)
3) LOGARITHM
4) POWER
CHOICE? 1
NUMBER? 144
SQRT( 144 ) = 12
1) SQUARE ROOT
2) SINE (DEGREES)
3) LOGARITHM
4) POWER
CHOICE? 2
ANGLE? 30
SIN( 30 ) = 0.5
READY.

Example 2: String Analyzer

10 REM STRING ANALYZER
20 INPUT "ENTER TEXT"; T$
30 PRINT "LENGTH:"; LEN(T$)
40 U=0: L=0: D=0: S=0
50 FOR I=1 TO LEN(T$)
60 C$=MID$(T$,I,1)
70 A=ASC(C$)
80 IF A>=65 AND A<=90 THEN U=U+1
90 IF A>=97 AND A<=122 THEN L=L+1
100 IF A>=48 AND A<=57 THEN D=D+1
110 IF A=32 THEN S=S+1
120 NEXT I
130 PRINT "UPPERCASE:"; U
140 PRINT "LOWERCASE:"; L
150 PRINT "DIGITS:"; D
160 PRINT "SPACES:"; S
LIST
RUN
ENTER TEXT? Hello World 123
LENGTH: 15
UPPERCASE: 1
LOWERCASE: 9
DIGITS: 3
SPACES: 2
READY.

Example 3: Random Statistics

10 REM RANDOM STATISTICS
20 INPUT "HOW MANY SAMPLES"; N
30 DIM R(N)
40 T=0
50 FOR I=1 TO N
60 R(I)=RND(1)
70 T=T+R(I)
80 NEXT I
90 M=T/N
100 PRINT "MEAN:"; M
110 V=0
120 FOR I=1 TO N
130 V=V+(R(I)-M)^2
140 NEXT I
150 V=V/N
160 SD=SQR(V)
170 PRINT "STD DEV:"; SD
180 PRINT
190 PRINT "FIRST 10 VALUES:"
200 FOR I=1 TO 10
210 PRINT R(I)
220 NEXT I
LIST
RUN
HOW MANY SAMPLES? 100
MEAN: 0.493846279
STD DEV: 0.289471236

FIRST 10 VALUES:
0.737927713
0.293746442
0.629374802
0.851930174
0.142756847
0.287461925
0.763847294
0.539281764
0.914738562
0.391847562
READY.

Example 4: Distance Calculator (Haversine Formula)

10 REM DISTANCE BETWEEN CITIES
20 REM HAVERSINE FORMULA
30 PI=3.14159265
40 DEF FN RAD(D)=D*PI/180
50 INPUT "LAT1,LON1"; LAT1,LON1
60 INPUT "LAT2,LON2"; LAT2,LON2
70 A1=FN RAD(LAT1)
80 A2=FN RAD(LAT2)
90 DA=FN RAD(LAT2-LAT1)
100 DO=FN RAD(LON2-LON1)
110 A=SIN(DA/2)^2
120 A=A+COS(A1)*COS(A2)*SIN(DO/2)^2
130 C=2*ATN(SQR(A)/SQR(1-A))
140 D=6371*C
150 PRINT "DISTANCE:"; INT(D); "KM"
LIST
RUN
LAT1,LON1? 40.7128,-74.0060
LAT2,LON2? 51.5074,-0.1278
DISTANCE: 5570 KM
READY.

Example 5: Number Guessing with Hints

10 REM NUMBER GUESSING GAME
20 N=INT(RND(1)*100)+1
30 T=0
40 PRINT "GUESS NUMBER 1-100"
50 INPUT G
60 T=T+1
70 D=ABS(N-G)
80 IF D=0 THEN 150
90 IF D<5 THEN PRINT "VERY HOT!": GOTO 50
100 IF D<10 THEN PRINT "HOT": GOTO 50
110 IF D<20 THEN PRINT "WARM": GOTO 50
120 IF D<30 THEN PRINT "COOL": GOTO 50
130 PRINT "COLD"
140 GOTO 50
150 PRINT "CORRECT IN"; T; "TRIES!"
LIST
RUN
GUESS NUMBER 1-100
? 50
WARM
? 60
COOL
? 55
HOT
? 57
VERY HOT!
? 58
CORRECT IN 5 TRIES!
READY.

Summary

Built-in functions are essential tools for computation:

Mathematical: ABS, INT, SGN, SQR, LOG, EXP, RND Trigonometric: SIN, COS, TAN, ATN (remember: radians!) String manipulation: LEN, LEFT$, RIGHT$, MID$ String conversion: CHR$, ASC, STR$, VAL System queries: FRE, POS, PEEK User-defined: DEF FN for custom formulas

Key concepts:

1. Functions return values, statements perform actions
2. Trigonometry uses radians (use DEF FN for degree conversion)
3. INT rounds down, not toward zero
4. RND(1) generates random, RND(-x) seeds generator
5. String functions simplify text processing
6. DEF FN limited to single-line expressions

Next chapter: Program Management - organizing and debugging your code.

End of Chapter 10

Program Management

You've written programs, entered lines, and seen your code execute. Now it's time to master the tools that every BASIC programmer uses dozens of times each session: commands for managing, viewing, running, and controlling programs.

This chapter covers the essential program management commands that transform BASIC from a simple calculator into a complete development environment. You'll learn how to clear memory safely, list program sections efficiently, run code from specific points, and control program flow. These tools are your constant companions throughout your programming journey.

By the end of this chapter, you'll work efficiently—navigating programs quickly, testing sections independently, and debugging with confidence. These aren't flashy features, but they're absolutely fundamental to productive programming.

Clearing Programs with NEW

The NEW command is both the simplest and the most dangerous command in BASIC. Type three letters, press ENTER, and everything disappears—your entire program and all variables vanish instantly.

What NEW Does

NEW completely resets BASIC to a clean slate:

NEW

In one atomic operation:

1. Deletes all program lines — Every line, from first to last
2. Clears all variables — Numeric, integer, and string variables all gone
3. Resets program state — No execution history remains
4. Returns to ready state — The READY. prompt appears

When to Use NEW

Use NEW at the start of each new programming project:

• Beginning a new session — Clear out old experiments
• Starting a different program — When you're completely done with current code
• After loading a program — Actually, LOAD does NEW automatically (see Chapter 12)
• When everything is broken — Nuclear option: start completely fresh

Safe NEW Workflow

Experienced programmers follow this pattern:

LIST             (Review what you have)
(Is this program important?)

(If yes: SAVE "MYPROGRAM" — See Chapter 12)
(If no: continue)

NEW              (Clear memory)
LIST             (Verify clean slate)

(Start entering new program)

NEW vs. Other Commands

Compare NEW to similar operations:

NEW is the most destructive. Use it only when you truly want to discard everything.

10 PRINT "THIS PROGRAM WILL BE DELETED"
20 A = 42
30 PRINT "A ="; A
40 END

Try this sequence:

• RUN to see the program execute
• PRINT A to see the variable (42)
• NEW to clear everything
• LIST (nothing appears)
• PRINT A (gives 0—variable is gone)

Listing Programs with LIST

The LIST command is your window into program memory. It displays your code, formatted and organised, so you can see what BASIC has stored. Mastering LIST variations makes navigating programs effortless.

LIST (Display Everything)

The simplest form shows your entire program:

LIST

BASIC displays every line from lowest to highest line number, each on its own line.

This is the most common form—use it constantly while developing programs.

LIST n (Display One Line)

To examine a single line, specify its number:

LIST 30

Perfect for checking the exact contents of a specific line without scrolling through your entire program.

LIST n-m (Display a Range)

To see consecutive lines, specify a range:

LIST 20-40

The format is start-end. BASIC displays all lines from start through end, inclusive. Both boundaries must exist as line numbers or be close to existing lines.

LIST -n (From Beginning to Line n)

To see everything up to a specific line:

LIST -30

Note the hyphen before the number. This shows line 30 and everything preceding it.

LIST n- (From Line n to End)

To see everything from a specific line onward:

LIST 30-

Note the hyphen after the number. This shows line 30 and everything following it.

When to Use Each Form

10 REM PROGRAM START
20 PRINT "INITIALIZING..."
30 A = 0: B = 0
40 REM MAIN LOOP
50 FOR I = 1 TO 10
60 A = A + I
70 B = B + I * 2
80 NEXT I
90 REM DISPLAY RESULTS
100 PRINT "SUM:"; A
110 PRINT "DOUBLE SUM:"; B
120 END

Practice all LIST variations:

• LIST shows everything
• LIST 50 shows just the FOR line
• LIST 40-80 shows the main loop section
• LIST -40 shows initialization
• LIST 90- shows results section

Running Programs with RUN

The RUN command executes your program. You've used it before, but RUN has capabilities beyond simple execution—you can start from any line number.

RUN (Execute from Beginning)

The basic form starts at the lowest line number:

RUN

BASIC immediately:

1. Clears all variables (fresh start)
2. Jumps to the lowest line number
3. Executes lines sequentially
4. Continues until END or program runs out of lines
5. Returns to READY. prompt

RUN Clears Variables

Important: RUN always clears all variables before execution, even if you've set them in immediate mode:

The A = 99 from immediate mode is gone—RUN cleared it. This ensures programs start with a clean variable state every time.

RUN n (Execute from Line n)

You can start execution at any line number:

RUN 50

BASIC:

1. Clears all variables (same as RUN)
2. Jumps directly to line 50
3. Executes from there to the end

When to Use RUN n

RUN n is invaluable for testing:

Testing specific sections:

(Skip initialization, test main logic)
RUN 100

Testing subroutines in isolation:

(Jump directly to subroutine)
RUN 900
GOSUB 1000
END

Debugging:

(Problem seems to be after line 200)
RUN 200
(Now you can focus on that section)

RUN vs. GOTO

Don't confuse these:

• RUN — Clears variables, starts fresh (use from immediate mode)
• GOTO — Jumps to a line, keeps variables (use within programs)

RUN 100       (From immediate mode: clear vars, start at 100)
10 GOTO 100   (Within program: jump to 100, keep vars)

10 PRINT "SECTION 1: INITIALIZATION"
20 A = 50
30 B$ = "HELLO"
40 PRINT "A ="; A; " B$ ="; B$
50 PRINT
60 PRINT "SECTION 2: MAIN PROGRAM"
70 PRINT "A * 2 ="; A * 2
80 PRINT "MESSAGE:"; B$
90 END

Try these commands:

• RUN (executes from line 10, A = 50)
• RUN 60 (executes from line 60, A = 0 because we skipped initialization!)
• Notice how RUN 60 shows A * 2 = 0 and MESSAGE: is empty

Program Termination: END and STOP

Two commands terminate program execution: END and STOP. They look similar but behave differently—understanding when to use each prevents confusion.

The END Statement

END terminates your program gracefully:

50 END

When BASIC executes END:

1. Stops execution immediately — No more lines execute
2. Returns to immediate mode — Shows READY. prompt
3. Keeps variables — All variables retain their values
4. Cannot continue — You can't resume with CONT

Where to Place END

Traditionally, END appears at the end of your program:

10 PRINT "HELLO"
20 PRINT "WORLD"
999 END

Some programmers use a high line number (900, 999, 9999) for END so there's room to add lines before it.

The STOP Statement

STOP suspends your program temporarily:

50 STOP

When BASIC executes STOP:

1. Pauses execution — Stops at the STOP line
2. Shows BREAK message — Displays BREAK IN 50
3. Returns to immediate mode — Shows READY. prompt
4. Allows continuation — You can resume with CONT

When to Use Each

Use END when:

• Your program completes normally
• You want final, definite termination
• You're structuring program flow (multiple exit points)

Use STOP when:

• Debugging—inspect variables mid-execution
• Testing—pause before a problem section
• Development—check intermediate results

Multiple END Statements

Programs can have multiple END statements:

10 INPUT "CONTINUE"; A$
20 IF A$ = "NO" THEN END
30 PRINT "CONTINUING..."
40 PRINT "MORE PROCESSING..."
50 END

If user types "NO", the program ends at line 20. Otherwise, it continues and ends at line 50.

10 PRINT "CALCULATING..."
20 FOR I = 1 TO 5
30 PRINT "I ="; I
40 NEXT I
50 PRINT "HALF WAY DONE"
60 STOP
70 PRINT "RESUMING..."
80 FOR J = 6 TO 10
90 PRINT "J ="; J
100 NEXT J
110 END

Run this program and observe:

• RUN executes through line 60, then shows BREAK IN 60
• Type PRINT I to see I = 5 (loop completed)
• Type CONT to continue from line 70
• Program completes the second loop

Continuing Execution with CONT

The CONT command resumes a program that was suspended by STOP (or by pressing ESC to interrupt execution). Think of it as "unpause."

How CONT Works

When you type:

CONT

BASIC resumes execution at the line after the one that caused the break.

CONT After ESC Interrupt

If you press ESC during program execution, the program pauses:

10 FOR I = 1 TO 10000
20 PRINT I
30 NEXT I

RUN
1
2
3
(Press ESC)
BREAK IN 20

READY.
CONT
(Continues counting...)

This is useful when a program runs too long or enters an infinite loop.

When CONT Works

CONT works after:

• STOP statement — Program executed STOP
• ESC interrupt — You pressed ESC during execution

When CONT Fails

CONT does not work after:

• END statement — Program terminated completely
• Error — Runtime error occurred
• Program edit — You changed any program line
• RUN command — Starting fresh clears continuation state

Inspecting Variables During STOP

The power of STOP + CONT is examining program state:

10 A = 5
20 B = 10
30 C = A + B
40 STOP
50 PRINT "RESULT:"; C
60 END

RUN
BREAK IN 40

READY.
PRINT A
5
READY.
PRINT B
10
READY.
PRINT C
15
READY.
CONT
RESULT: 15

READY.

You inspected variables A, B, and C in immediate mode, then continued execution.

10 PRINT "MULTIPLICATION TABLE FOR 7"
20 FOR I = 1 TO 3
30 PRINT "7 x"; I; "="; 7 * I
40 NEXT I
50 STOP
60 FOR I = 4 TO 6
70 PRINT "7 x"; I; "="; 7 * I
80 NEXT I
90 END

Try this sequence:

• RUN (stops after 7x1, 7x2, 7x3)
• PRINT I (shows 3, the loop completed)
• CONT (continues with 7x4, 7x5, 7x6)

Clearing Variables with CLR

The CLR command clears all variables but preserves your program. It's like NEW but less destructive—your code stays intact.

What CLR Does

Type:

CLR

BASIC:

1. Sets all numeric variables to 0 — A, X, COUNT%, etc.
2. Sets all string variables to empty — A$, NAME$, etc.
3. Clears arrays — All array contents reset
4. Keeps your program — Every line remains unchanged
5. Stays in immediate mode — Shows READY. prompt

CLR vs. RUN vs. NEW

Compare these commands:

When to Use CLR

Testing programs repeatedly:

(After first run, variables have values from execution)
CLR
RUN
(Now you know variables start at 0)

Cleaning up after experiments:

A = 99
B$ = "TEST"
(Experiments done, don't want garbage values)
CLR

Before running manually:

(You're about to run a program with GOTO 10)
CLR
GOTO 10
(Variables start clean)

CLR Is Automatic in RUN

You rarely need CLR because RUN does it automatically:

RUN
(RUN clears variables, then executes)

But CLR is useful when:

• Testing setup before running
• Using GOTO to enter program without RUN
• Experimenting in immediate mode and want a clean slate

10 PRINT "ENTER A NUMBER:"
20 INPUT A
30 PRINT "YOU ENTERED:"; A
40 PRINT "DOUBLE:"; A * 2
50 END

Try this experiment:

• RUN and enter 50
• After program ends, PRINT A (shows 50)
• CLR to clear variables
• PRINT A (now shows 0)
• LIST to verify program still exists

Commenting with REM

The REM statement adds comments to your programs—notes for yourself (and other programmers) that explain what the code does. BASIC ignores REM lines during execution.

REM Syntax

10 REM THIS IS A COMMENT

Everything after REM on that line is ignored:

10 REM INITIALIZE VARIABLES
20 A = 0
30 B = 0
40 REM START MAIN LOOP
50 FOR I = 1 TO 10

What Makes a Good Comment

Bad comment (obvious):

10 REM SET A TO 5
20 A = 5

The code already says A = 5—the comment adds nothing.

Good comment (explains why):

10 REM A = 5 BECAUSE WE START AT LEVEL 5
20 A = 5

Now we understand the reason behind the value.

Bad comment (too vague):

100 REM DO CALCULATIONS
110 C = (F - 32) * 5 / 9

Good comment (specific):

100 REM CONVERT FAHRENHEIT TO CELSIUS
110 C = (F - 32) * 5 / 9

When to Use Comments

Document sections:

10 REM ============================
20 REM INITIALIZATION SECTION
30 REM ============================
40 A = 0: B = 0: C$ = ""

100 REM ============================
110 REM MAIN PROGRAM LOOP
120 REM ============================
130 FOR I = 1 TO 100

Explain complex logic:

200 REM CHECK IF NUMBER IS PRIME
210 REM TRY DIVIDING BY 2 THROUGH SQRT(N)
220 FOR I = 2 TO SQR(N)
230 IF N/I = INT(N/I) THEN RETURN
240 NEXT I

Document subroutines:

1000 REM ==========================
1010 REM SUBROUTINE: DISPLAY TITLE
1020 REM SHOWS CENTERED TITLE TEXT
1030 REM ==========================
1040 PRINT "        PROGRAM TITLE"
1050 RETURN

Mark TODO items:

500 REM TODO: ADD ERROR CHECKING HERE
510 INPUT A

REM Must Be Entire Line

You cannot put REM at the end of a code line:

10 A = 5 REM SET A TO 5    (WRONG!)

This causes a syntax error. Comments must be on their own line:

10 REM SET A TO 5          (CORRECT)
20 A = 5

REM and Multi-Statement Lines

However, after a colon separator, REM works:

10 A = 5: REM THIS WORKS

Everything after REM is ignored, even on multi-statement lines.

Performance Note

REM lines slow down execution very slightly—BASIC must skip them. In practice, this is negligible. Always prioritize clarity over micro-optimization. Well-commented programs are worth the tiny performance cost.

10 REM ========================
20 REM MULTIPLICATION QUIZ
30 REM ========================
40 REM GENERATE RANDOM PROBLEM
50 A = INT(RND(1) * 10) + 1
60 B = INT(RND(1) * 10) + 1
70 REM ASK USER FOR ANSWER
80 PRINT A; "x"; B; "= ";
90 INPUT ANS
100 REM CHECK IF CORRECT
110 IF ANS = A * B THEN PRINT "CORRECT!"
120 IF ANS <> A * B THEN PRINT "WRONG. ANSWER:"; A * B
999 END

Notice how comments make this program's structure clear. Try LIST to see the organization, then RUN to see how BASIC skips the comments.

Development Workflows

Now that you know all the program management commands, let's see how experienced BASIC programmers use them together in typical workflows.

The Edit-List-Run-Debug Cycle

This is the heartbeat of BASIC programming:

1. EDIT — Enter or modify program lines

10 PRINT "HELLO"
20 END

2. LIST — Review your changes

LIST
10 PRINT "HELLO"
20 END
READY.

3. RUN — Execute the program

RUN
HELLO

READY.

4. DEBUG — Fix any problems, return to step 1

Repeat this cycle continuously. Most programming sessions involve hundreds of iterations through this loop.

Starting a New Program

Clean slate workflow:

NEW                    (Clear memory)
LIST                   (Verify empty)

10 REM MY NEW PROGRAM
20 PRINT "STARTING..."
...
(Enter program lines)
...
LIST                   (Review what you entered)
RUN                    (Test initial version)

Debugging a Problem

Isolate-and-inspect workflow:

(Program has a bug around line 200)

LIST 180-220          (Review problem area)
(Identify suspect line)

(Add debugging output)
195 PRINT "A ="; A; "B ="; B

RUN
(Check output)

(Or use STOP to inspect)
195 STOP

RUN
BREAK IN 195

READY.
PRINT A
(Inspect variable)
PRINT B
(Inspect another)

CONT
(Continue execution)

(Bug found! Remove debugging code)
195

LIST 180-220          (Verify fix)
RUN                   (Test again)

Testing a Subroutine

Isolated subroutine test:

(Program has subroutine at line 1000)

LIST 1000-1100        (Review subroutine)

(Add temporary test code before program)
5 GOSUB 1000
6 END

RUN                   (Test subroutine)
(Subroutine executes)

(Works! Remove test code)
5
6

RUN                   (Normal execution)

Making Major Changes

Incremental-change workflow:

SAVE "MYPROGRAM"      (Backup current version - Ch 12)
LIST                  (Review before changes)

(Make first change)
50 PRINT "NEW VERSION"

LIST 40-60           (Verify change)
RUN                  (Test)
(Works!)

(Make second change)
100 A = A * 2

LIST 90-110          (Verify)
RUN                  (Test)
(Works!)

SAVE "MYPROGRAM"     (Save working version)

When Things Go Wrong

Recovery workflow:

(Made a mistake, program broken)

LIST                  (See what's wrong)

(Try to fix)
50 (Delete bad line)

RUN                   (Test)
(Still broken)

NEW                   (Nuclear option)
LOAD "MYPROGRAM"      (Restore from save - Ch 12)
(Back to last working version)

Building Programs Incrementally

Progressive-development workflow:

(Start with simplest version)
10 PRINT "HELLO"
20 END

RUN
(Works!)

(Add feature #1)
15 INPUT "NAME"; N$
30 PRINT "HI, "; N$

RUN
(Works!)

(Add feature #2)
35 INPUT "AGE"; A
40 PRINT "YOU ARE"; A; "YEARS OLD"

RUN
(Works!)

LIST                  (Review complete program)
SAVE "GREETER"        (Save final version)

The Line Number Strategy

Organised numbering:

10-90      REM Initialization
100-890    REM Main program
900-990    REM Cleanup/end
1000-1990  REM Subroutines
9000-9999  REM Data statements

Example:

10 REM INITIALIZATION
20 A = 0: B = 0
30 DIM SCORES(10)

100 REM MAIN PROGRAM
110 FOR I = 1 TO 10
120 GOSUB 1000
130 NEXT I

900 REM END
910 PRINT "COMPLETE"
999 END

1000 REM SUBROUTINE: INPUT SCORE
1010 INPUT "SCORE"; SCORES(I)
1020 RETURN

10 REM VERSION 1: BASIC GREETING
20 PRINT "HELLO, WORLD!"
30 END

Practice incremental development:

1. RUN this basic version
2. Add line 15 INPUT "NAME"; N$
3. Change line 20 PRINT "HELLO, "; N$
4. RUN to test
5. Add line 25 INPUT "AGE"; A
6. Add line 35 PRINT "IN 10 YEARS YOU'LL BE"; A + 10
7. LIST to see your evolved program
8. RUN for final test

Chapter Summary

You've mastered the essential program management tools that every BASIC programmer uses constantly.

Commands Covered

Memory Management:

• NEW — Clear program and variables (permanent!)
• CLR — Clear variables, keep program

Viewing Programs:

• LIST — Show entire program
• LIST n — Show single line
• LIST n-m — Show range
• LIST -n — Show start through line n
• LIST n- — Show line n through end

Execution Control:

• RUN — Execute from beginning (clears variables)
• RUN n — Execute from line n (clears variables)
• END — Terminate program (cannot continue)
• STOP — Suspend program (can continue)
• CONT — Resume after STOP or ESC

Documentation:

• REM — Add comments (entire line only)

Key Insights

NEW is permanent — Always save important programs before using NEW.

LIST has many forms — Master all variations for efficient navigation.

RUN clears variables — Every RUN starts fresh, even RUN n.

END vs STOP — END terminates, STOP suspends. Use STOP for debugging.

CONT requires STOP — Can't continue after END, errors, or edits.

CLR rarely needed — RUN does it automatically.

REM makes code maintainable — Future you will thank present you.

Typical Session

NEW                       Start fresh
(Enter program lines)
LIST                      Review code
RUN                       Test execution
(Error occurs)
LIST 50                   Inspect problem line
50 (corrected line)       Fix the error
RUN                       Test again
(Works!)
SAVE "MYPROGRAM"          Save it (Chapter 12)

What's Next

You now have complete control over program development. In Chapter 12, you'll learn to save programs permanently with SAVE and LOAD, ensuring your work survives browser restarts.

But first, you have all the tools needed to write, test, and debug BASIC programs effectively. The commands in this chapter are your constant companions—you'll use them thousands of times in your programming journey.

File Operations

You've written programs, debugged them, perfected them—and then closed your browser. When you return, they're gone. Hours of work, vanished.

This chapter solves that problem permanently.

BASIC's SAVE and LOAD commands preserve your programs in browser storage, making them persistent across sessions. Write a program today, load it next week, share it next month. Your work survives browser restarts, computer reboots, everything.

File operations transform BASIC from a sandbox into a proper development environment. You'll learn to save programs safely, load them reliably, manage multiple projects, handle errors gracefully, and develop backup strategies. Never lose work again.

By the end of this chapter, you'll save programs as naturally as you RUN them. File operations become second nature—automatic protection for everything you create.

Introduction to File Storage

Every program you've written so far exists only in temporary memory. Close the browser tab, and it's gone forever. NEW deletes it. A browser crash erases it. There's no recovery, no undo, no second chance.

The Solution: Persistent Storage

SLP-BASIC uses your browser's localStorage to save programs permanently. Think of localStorage as a virtual filing cabinet—a place where BASIC stores your code safely, independent of the interpreter's memory.

Programs saved to localStorage:

• Survive browser restarts — Close and reopen, programs are still there
• Survive BASIC restarts — Disconnect and reconnect, programs remain
• Survive NEW commands — Clear memory all you want, saved programs are safe
• Persist indefinitely — Browsers preserve localStorage forever (unless you clear browser data)

How Storage Works

When you save a program named "MYGAME", BASIC:

1. Converts your program to plain text (one line per program line)
2. Writes it to browser localStorage
3. Uses a unique key: emulator.ca/disk/basic/MYGAME
4. Returns success confirmation

When you load "MYGAME", BASIC:

1. Looks up the key in localStorage
2. Reads the plain text
3. Clears current program (like NEW)
4. Parses each line back into memory
5. Returns ready to RUN

The BackendDisk Abstraction

Technically, BASIC uses a component called BackendDisk that provides a file-system-like interface over browser localStorage. This abstraction:

• Handles all storage operations
• Manages the emulator.ca/disk/basic/ namespace
• Converts between BASIC program format and storage format
• Reports errors when storage fails

You don't interact with BackendDisk directly—you use SAVE and LOAD, and BackendDisk handles the details.

Storage Limitations

Browser localStorage has limits:

Capacity:

• Most browsers: 5-10 MB total for the entire domain
• Shared with all site data, not just BASIC programs
• Typical BASIC program: 1-50 KB (you can store hundreds of programs)

What happens when full:

• SAVE fails with ?SAVE ERROR
• Delete old programs to free space
• Or clear browser storage (loses everything!)

Per-browser isolation:

• Programs saved in Chrome aren't visible in Firefox
• Programs saved on Computer A aren't on Computer B
• Each browser/device has its own independent storage

Where Are Programs Stored?

The storage namespace is:

emulator.ca/disk/basic/<filename>

So saving "TEST" creates:

emulator.ca/disk/basic/TEST

And saving "GAME.BAS" creates:

emulator.ca/disk/basic/GAME.BAS

Plain Text Format

Unlike some classic BASIC implementations that tokenize programs into binary format, SLP-BASIC saves programs as human-readable plain text:

10 PRINT "HELLO"
20 FOR I = 1 TO 10
30 PRINT I
40 NEXT I
50 END

This format:

• Readable — You can see exactly what's stored
• Debuggable — Easy to inspect in DevTools
• Portable — Copy/paste between systems
• Reliable — No binary corruption issues

The tradeoff: plain text is larger than tokenized binary (real Commodores used binary). But with modern storage sizes, this doesn't matter.

10 PRINT "TEST PROGRAM"
20 PRINT "THIS WILL BE SAVED"
30 END

Before continuing, save this program:

• Type SAVE "TEST"
• You should see SAVING TEST
• Type NEW to clear memory
• Type LOAD "TEST" to restore it
• Type LIST to see it's back

Saving Programs with SAVE

The SAVE command writes your current program to persistent storage. Once saved, your program survives anything—browser restarts, memory clears, even computer crashes (assuming browser data is preserved).

SAVE Syntax

SAVE "filename"

The filename must be in quotes. These are all valid:

SAVE "MYPROGRAM"
SAVE "GAME.BAS"
SAVE "MULTIPLICATION-QUIZ"
SAVE "VERSION-2"

What SAVE Does

When you execute SAVE "filename":

1. Validates filename — Checks that it's a non-empty string
2. Converts program to text — Each line becomes text (e.g., 10 PRINT "HELLO")
3. Writes to storage — Stores in emulator.ca/disk/basic/filename
4. Shows confirmation — Prints SAVING filename
5. Reports errors — Shows ?SAVE ERROR if storage fails

The program in memory remains unchanged—you can continue editing, running, whatever. SAVE is non-destructive to the active program.

SAVE Overwrites Existing Files

If you save a program with a name that already exists, SAVE overwrites the old version without warning:

There's no confirmation prompt, no "Are you sure?" message. SAVE immediately overwrites. If you want to preserve the old version, use a different filename (see versioning strategies later).

SAVE Does Not Clear Memory

After saving, your program remains in memory:

SAVE "MYPROGRAM"
SAVING MYPROGRAM
READY.

LIST
(Program still appears)

RUN
(Program still executes)

SAVE is like taking a snapshot—the original stays where it is.

Filename Restrictions

Filenames should:

• Be descriptive — PRIME-FINDER not P
• Avoid special characters — Stick to letters, numbers, hyphens, underscores
• Use extensions optionally — .BAS is traditional but not required

When SAVE Fails

SAVE can fail if:

• Storage is full — Browser localStorage limit reached
• Storage is disabled — User disabled storage in browser settings
• Permission denied — Browser security blocks storage access
• Invalid filename — Empty string or invalid characters

When SAVE fails:

SAVE "MYPROGRAM"
?SAVE ERROR
READY.

The error message is generic—BASIC can't tell you why it failed. Check browser storage capacity in DevTools.

10 REM PRIME NUMBER FINDER
20 PRINT "PRIME NUMBERS UP TO 50:"
30 FOR N = 2 TO 50
40 P = 1
50 FOR I = 2 TO SQR(N)
60 IF N/I = INT(N/I) THEN P = 0
70 NEXT I
80 IF P THEN PRINT N;
90 NEXT N
100 PRINT
110 END

Practice saving:

• LIST to review the program
• SAVE "PRIMES" to save it
• NEW to clear memory
• LOAD "PRIMES" to restore (we'll learn LOAD next)
• RUN to verify it still works

Loading Programs with LOAD

The LOAD command restores a saved program from storage back into memory. Think of it as the opposite of SAVE—you take a snapshot off the shelf and put it back in the camera.

LOAD Syntax

LOAD "filename"

The filename must match exactly what you used with SAVE:

SAVE "MYPROGRAM"
(Later...)
LOAD "MYPROGRAM"

LOAD Clears Current Program First

Important: LOAD does NEW automatically before loading. Your current program is deleted:

If you need to save the current program before loading another:

SAVE "CURRENT"        (Save what you have)
LOAD "DIFFERENT"      (Now load the other one)

What LOAD Does

When you execute LOAD "filename":

1. Looks up filename — Searches emulator.ca/disk/basic/filename
2. Checks if exists — Returns ?FILE NOT FOUND if missing
3. Clears memory — Executes NEW (deletes current program and variables)
4. Reads file contents — Retrieves plain text from storage
5. Parses lines — Converts text back to program lines
6. Loads into memory — Each line is entered (like typing manually)
7. Shows confirmation — Prints LOADING filename
8. Returns ready — Program is loaded, ready to LIST or RUN

LOAD Does Not RUN

After LOAD, your program is in memory but not executing:

LOAD "MYPROGRAM"
LOADING MYPROGRAM
READY.

(Program is loaded but not running)
(You must RUN manually)

RUN
(Now it executes)

To load and run in one sequence:

LOAD "MYPROGRAM"
RUN

Or combine with colon separator:

LOAD "MYPROGRAM": RUN
(Loads, then immediately runs)

When LOAD Fails

The most common error is file not found:

LOAD "TYPO"
?FILE NOT FOUND
READY.

This happens when:

• Filename misspelled — "MYGAME" vs "MYGAMME"
• Case mismatch — "MYGAME" vs "mygame"
• File never saved — You thought you saved but didn't
• Wrong browser — Saved in Chrome, trying to load in Firefox

Other errors:

LOAD ""
?MISSING FILE NAME
READY.

LOAD "CORRUPTED"
?LOAD ERROR
INVALID LINE: (details)
READY.

?LOAD ERROR means the file exists but is corrupted or invalid.

LOAD and Variables

LOAD clears all variables (because it does NEW):

A = 100
PRINT A
100
READY.

LOAD "MYPROGRAM"
LOADING MYPROGRAM
READY.

PRINT A
0
READY.

The variable A is reset to 0. This is usually what you want—loading a program should start fresh.

10 PRINT "TEMPORARY PROGRAM"
20 PRINT "ABOUT TO BE REPLACED"
30 END

If you saved "PRIMES" earlier:

• LIST to see current program
• LOAD "PRIMES" to replace it
• LIST to see the loaded program
• RUN to execute

If LOAD fails with ?FILE NOT FOUND, you'll need to SAVE "PRIMES" first (see previous section).

Using String Variables for Filenames

Both SAVE and LOAD accept string variables in place of literal filenames. This enables dynamic filename generation—programs that save/load based on user input, numbered versions, or computed names.

Basic String Variable Usage

Instead of:

SAVE "MYPROGRAM"

You can use:

F$ = "MYPROGRAM"
SAVE F$

Dynamic Filename Generation

This becomes powerful when combined with user input:

Version Numbering

You can automatically generate version numbers:

Numbered Backups

Create multiple backups with sequential numbers:

Cleaning Up STR$() Spaces

STR$() adds a leading space for positive numbers. Remove it with MID$():

10 N$ = "PROG"
20 V = 5
30 F$ = N$ + MID$(STR$(V), 2)
40 PRINT F$

RUN
PROG5
READY.

MID$(STR$(V), 2) extracts from character 2 onward, skipping the space.

Loading with String Variables

Same principle applies to LOAD:

10 INPUT "FILENAME TO LOAD"; F$
20 LOAD F$
30 RUN

(Note: Lines after LOAD don't execute—LOAD clears program!)

Wait—that won't work! LOAD clears the program, so line 30 disappears. Instead:

INPUT "FILENAME TO LOAD"; F$
LOAD F$

Do this in immediate mode, not in a program.

Program-Managed Saves

A self-saving program:

Wait—same problem! SAVE happens inside the program, but the program is what you're saving. This works fine! SAVE doesn't clear memory—it just writes the current program to storage.

10 PRINT "VERSION SAVER"
20 INPUT "BASE NAME"; N$
30 INPUT "VERSION NUMBER"; V
40 F$ = N$ + "-V" + MID$(STR$(V), 2)
50 PRINT "WILL SAVE AS: "; F$
60 SAVE F$
70 PRINT "SAVED!"
80 END

Try this program:

• RUN and enter TEST as base name
• Enter 1 as version number
• It saves as TEST-V1
• NEW to clear memory
• Type LOAD "TEST-V1" to restore
• LIST to verify

Storage Details

Understanding how storage works helps you avoid problems and use it efficiently. This section covers the technical details of SLP-BASIC's storage system.

The localStorage Namespace

All BASIC programs are stored under the namespace:

emulator.ca/disk/basic/

A file saved as "MYGAME" is stored with key:

emulator.ca/disk/basic/MYGAME

A file saved as "PROJECT.BAS" is stored with key:

emulator.ca/disk/basic/PROJECT.BAS

The namespace ensures BASIC programs don't collide with other site data.

Storage Capacity Limits

Browser localStorage is typically limited to 5-10 MB per origin (domain). This storage is shared by:

• BASIC programs (our files)
• Other site data (telemetry, settings, etc.)
• Anything else the site stores

How much space do programs use?

A typical BASIC program:

• Small program (10-20 lines): ~200-500 bytes
• Medium program (50-100 lines): ~1-3 KB
• Large program (200+ lines): ~5-20 KB
• Very large program (1000+ lines): ~50-200 KB

With 5-10 MB available, you can store:

• Hundreds of small programs
• Dozens of large programs
• Several very large programs

Checking Storage Usage

No built-in command shows storage usage. You must use browser DevTools:

1. Open DevTools (F12)
2. Go to Application → Local Storage
3. Click the site domain
4. Look for keys starting with emulator.ca/disk/basic/
5. Each key shows its size in the value column

What Happens When Storage Is Full

When localStorage reaches capacity, SAVE fails:

SAVE "BIGPROGRAM"
?SAVE ERROR
READY.

Solutions:

1. Delete old programs (use DevTools to remove keys)
2. Clear browser data (loses everything!)
3. Use private/incognito mode (fresh storage, but lost on close)
4. Export programs (copy text manually, import later)

Data Persistence

localStorage data persists:

• Browser restarts — Yes, survives
• Computer restarts — Yes, survives
• Browser updates — Usually survives
• Clear browsing data — NO, deleted
• Private/incognito mode — NO, cleared on close

Per-Browser Isolation

Each browser maintains separate storage:

• Programs saved in Chrome are invisible to Firefox
• Programs saved on Computer A are invisible on Computer B
• Programs in normal mode are invisible to private mode

To share programs between browsers/computers:

1. LIST the program
2. Copy the output text
3. Manually enter lines on the other system
4. Or use browser sync features (if available)

Storage Format

Programs are stored as plain text with one line per program line:

10 PRINT "HELLO"
20 FOR I = 1 TO 10
30 PRINT I
40 NEXT I
50 END

Exactly as LIST displays. No compression, no tokenization, no binary encoding.

Advantages:

• Human-readable
• Easy to debug
• Copy/paste friendly
• No corruption from binary issues

Disadvantages:

• Larger file size than tokenized binary
• Slower to parse (negligible for programs <1000 lines)

Comparison to Real Commodore Storage

SLP-BASIC storage is more reliable and faster, but less authentic (no disk drive sounds!).

10 PRINT "STORAGE TEST"
20 PRINT "THIS PROGRAM IS SAVED IN PLAIN TEXT FORMAT"
30 PRINT "EXACTLY AS LIST DISPLAYS IT"
40 END

Save this program, then inspect storage:

• SAVE "FORMAT-TEST"
• Open browser DevTools (F12)
• Go to Application → Local Storage
• Find key emulator.ca/disk/basic/FORMAT-TEST
• Look at the value—it's the plain text of your program!

Error Messages

File operations can fail for various reasons. Understanding error messages helps you diagnose and fix problems quickly.

?FILE NOT FOUND

Appears during: LOAD

Means: BASIC searched storage but couldn't find a program with that filename.

Common causes:

1. Filename misspelled — "MYGAME" vs "MYGAMME"
2. Case mismatch — "MYGAME" vs "mygame"
3. Program never saved — You intended to save but didn't
4. Wrong browser — Saved in Chrome, loading in Firefox
5. Browser data cleared — Storage was reset

Solutions:

• Double-check spelling: LOAD "MYGAME" not LOAD "MYGAMME"
• Try alternate case: LOAD "mygame" if LOAD "MYGAME" fails
• Verify program was saved: Check DevTools → Local Storage
• Re-save the program if you have it in memory

?MISSING FILE NAME

Appears during: SAVE or LOAD

Means: You didn't provide a filename, or the filename is an empty string.

Common causes:

1. Empty string: SAVE ""
2. Empty variable: F$ = "" then SAVE F$
3. Missing quotes: SAVE FILENAME (treats as variable, might be empty)

Solutions:

• Always provide a filename: SAVE "MYPROGRAM"
• Check variable before using: IF F$ = "" THEN INPUT "FILENAME"; F$

?SAVE ERROR

Appears during: SAVE

Means: BASIC attempted to save but storage operation failed.

Common causes:

1. Storage is full — Browser localStorage capacity reached
2. Storage disabled — User disabled storage in browser settings
3. Permission denied — Browser security blocks storage access
4. Private mode — Some browsers restrict storage in incognito mode

Solutions:

• Delete old programs to free space (DevTools → Local Storage)
• Check browser storage settings (enable storage if disabled)
• Try normal mode instead of private/incognito
• Use a different browser

?LOAD ERROR

Appears during: LOAD

Means: BASIC found the file but couldn't parse it as a valid program.

Common causes:

1. File corrupted — Storage data damaged
2. Manually edited — You edited storage in DevTools incorrectly
3. Invalid format — File wasn't created by BASIC
4. Line number format — Lines don't start with valid numbers

Solutions:

• If you have the program elsewhere, re-save it
• If manually edited in DevTools, fix the format
• If corruption is severe, delete the file and re-create the program

INVALID LINE: (details)

Appears with: ?LOAD ERROR

Means: A specific line couldn't be parsed.

The error shows the problematic line text. Common issues:

• Typo in command: PRINNT instead of PRINT
• Missing line number: Line starts with text instead of number
• Malformed syntax: Invalid BASIC syntax

Solutions:

• Note the error details
• Load fails, but you can manually enter corrected line
• Or delete the corrupted file and re-create

Error Handling Workflow

When you encounter an error:

1. Read the error message carefully — It usually tells you exactly what's wrong
2. Check obvious causes — Spelling, case, quotes
3. Inspect storage — Use DevTools to verify file exists and looks correct
4. Try alternatives — Different case, different filename
5. Re-save if needed — If you have the program in memory, save again
6. Delete corrupted files — If file is damaged beyond repair

10 PRINT "ERROR TEST PROGRAM"
20 END

Test error handling:

• SAVE "" (shows ?MISSING FILE NAME)
• SAVE "TEST-ERROR" (saves successfully)
• LOAD "WRONG-NAME" (shows ?FILE NOT FOUND)
• LOAD "TEST-ERROR" (loads successfully)

File Naming Best Practices

Good filenames make programs easy to find, organise, and manage. Poor filenames lead to confusion, overwrites, and lost work. Here's how to name files effectively.

Use Descriptive Names

Bad:

SAVE "P"
SAVE "PROG"
SAVE "TEST"
SAVE "X"

Good:

SAVE "PRIME-FINDER"
SAVE "MULTIPLICATION-QUIZ"
SAVE "TEMPERATURE-CONVERTER"
SAVE "FIBONACCI-SEQUENCE"

Months later, which will you recognise? Descriptive names tell you what the program does at a glance.

Follow Naming Conventions

Recommended style:

• UPPERCASE — Traditional BASIC style, consistent with commands
• Hyphens or underscores — Separate words (PRIME-FINDER or PRIME_FINDER)
• Descriptive but concise — 2-4 words maximum

Examples:

SAVE "GUESS-THE-NUMBER"
SAVE "AREA-CALCULATOR"
SAVE "STUDENT-GRADES"
SAVE "MENU-SYSTEM"

Include Version Numbers

For evolving programs, include version indicators:

Pattern 1: Suffix version

SAVE "MYGAME-V1"
SAVE "MYGAME-V2"
SAVE "MYGAME-V3"

Pattern 2: Date-based

SAVE "MYGAME-JAN23"
SAVE "MYGAME-JAN24"

Pattern 3: Status suffix

SAVE "MYGAME-ALPHA"
SAVE "MYGAME-BETA"
SAVE "MYGAME-FINAL"

Use Extensions Optionally

.BAS is traditional but not required:

SAVE "PROGRAM.BAS"      (Traditional style)
SAVE "PROGRAM"          (Also fine)

Extensions add clarity but take up space in filenames. Your choice.

Organise by Project

For large projects with multiple programs, use prefixes:

SAVE "GAME-MAIN"
SAVE "GAME-INTRO"
SAVE "GAME-LEVELS"
SAVE "GAME-HISCORE"

Or categories:

SAVE "MATH-PRIMES"
SAVE "MATH-FACTORS"
SAVE "MATH-FIBONACCI"
SAVE "GAMES-GUESS"
SAVE "GAMES-QUIZ"

Avoid Problematic Characters

Safe characters:

• Letters: A-Z, a-z
• Numbers: 0-9
• Hyphen: -
• Underscore: _
• Period: .

Avoid:

• Spaces (use hyphens instead)
• Special characters: !, @, #, $, %, ^, &, *, (, ), etc.
• Quotes within filename (syntax error)

Why: Some characters cause parsing issues or are reserved by browsers.

Keep Names Reasonable Length

Too short:

SAVE "P"        (What does P mean?)

Too long:

SAVE "MY-REALLY-AWESOME-PROGRAM-THAT-DOES-CALCULATIONS"

Just right:

SAVE "CALCULATOR"

Aim for 1-3 words, 10-30 characters total.

Backup Naming Strategy

For backups, add identifiers:

SAVE "MYPROGRAM-BACKUP"
SAVE "MYPROGRAM-BACKUP-2"
SAVE "MYPROGRAM-BEFORE-CHANGES"
SAVE "MYPROGRAM-WORKING"

Real-World Examples

Here's how you might organise a collection of programs:

UTILITIES:
  SAVE "UTIL-UNIT-CONVERT"
  SAVE "UTIL-DATE-CALC"
  SAVE "UTIL-BASE-CONVERT"

GAMES:
  SAVE "GAME-GUESS-NUMBER"
  SAVE "GAME-MATH-QUIZ"
  SAVE "GAME-WORD-SCRAMBLE"

LEARNING:
  SAVE "LEARN-LOOPS"
  SAVE "LEARN-ARRAYS"
  SAVE "LEARN-STRINGS"

PROJECTS:
  SAVE "PROJECT-GRADEBOOK-V1"
  SAVE "PROJECT-GRADEBOOK-V2"
  SAVE "PROJECT-GRADEBOOK-BACKUP"

Anti-Patterns to Avoid

Generic names:

SAVE "PROGRAM"
SAVE "TEST"
SAVE "NEW"
SAVE "TEMP"

You'll have dozens of these and won't remember which is which.

Numbered names:

SAVE "PROG1"
SAVE "PROG2"
SAVE "PROG3"

Numbers don't convey meaning. What's the difference between PROG1 and PROG2?

Random names:

SAVE "ASDF"
SAVE "QWERTY"
SAVE "XYZ"

These are impossible to search or remember.

10 REM TEMPERATURE CONVERTER
20 REM CONVERTS FAHRENHEIT TO CELSIUS
30 PRINT "TEMPERATURE CONVERTER"
40 INPUT "FAHRENHEIT"; F
50 C = (F - 32) * 5 / 9
60 PRINT "CELSIUS: "; C
70 END

Practice good naming:

• Bad: SAVE "TEMP"
• Better: SAVE "TEMPERATURE"
• Best: SAVE "TEMP-CONVERTER" or SAVE "UTIL-TEMP-CONVERT"

Choose a descriptive name and save this program.

Backup Strategies

Hard drives fail. Browsers crash. Accidents happen. The only defense is backups—multiple copies of your important programs. Here's how to protect your work.

The 3-2-1 Backup Rule

In professional computing:

• 3 copies — Original + 2 backups
• 2 different media — Hard drive + cloud, or browser storage + text file
• 1 off-site — Cloud storage or different computer

For BASIC programs:

• Original — Current version in memory / localStorage
• Backup 1 — Saved with -BACKUP suffix
• Backup 2 — Exported as text file (copy from LIST)

Strategy 1: Version Suffixes

Save multiple versions as you work:

(Initial version)
SAVE "MYGAME-V1"

(After adding features)
SAVE "MYGAME-V2"

(After major changes)
SAVE "MYGAME-V3"

Benefits:

• Easy to revert to previous version
• Can compare versions (load each, examine changes)
• Protection against destructive edits

Downside:

• Uses more storage
• Older versions become clutter

Strategy 2: Backup Copies

Before risky changes, save a backup:

(Current working version)
SAVE "MYGAME"

(Before major refactoring)
SAVE "MYGAME-BACKUP"

(Make changes to original)
SAVE "MYGAME"

(If changes work: delete backup)
(If changes fail: LOAD "MYGAME-BACKUP")

Strategy 3: Milestone Backups

Save at significant milestones:

SAVE "MYGAME"              (Daily working version)
SAVE "MYGAME-ALPHA"        (First playable version)
SAVE "MYGAME-BETA"         (Feature-complete)
SAVE "MYGAME-FINAL"        (Release version)

Strategy 4: Time-Based Backups

Save with timestamps (manual, no DATE$ function yet):

SAVE "MYGAME-JAN23"
SAVE "MYGAME-JAN24"
SAVE "MYGAME-JAN25"

Or session numbers:

SAVE "MYGAME-SESSION1"
SAVE "MYGAME-SESSION2"

Strategy 5: Export to Text

The ultimate backup: copy program as plain text.

Process:

1. LIST your program
2. Select all output text
3. Copy to clipboard
4. Paste into a text editor (Notepad, TextEdit, etc.)
5. Save as MYGAME.TXT or MYGAME.BAS

Benefits:

• Survives browser data clearing
• Portable to any system
• Can edit outside BASIC
• Can commit to version control (Git)
• True off-site backup

Restoration:

1. Open text file
2. Copy program lines
3. In BASIC, type NEW
4. Manually enter each line (or paste if terminal supports it)

Automated Backup Pattern

Build backups into your workflow:

Backup Checklist for Important Programs

Before making major changes:

1. Save current version — SAVE "PROGRAM"
2. Create backup — SAVE "PROGRAM-BACKUP"
3. Export to text — LIST, copy, save to file
4. Verify backup — LOAD "PROGRAM-BACKUP" to confirm it works
5. Proceed with changes — Now it's safe to experiment

When to Delete Backups

Don't let backups accumulate forever:

Keep:

• Current working version
• Last 2-3 versions
• Milestone versions (ALPHA, BETA, FINAL)

Delete:

• Old experimental versions
• Temporary backups after changes succeed
• Duplicate versions
• Versions older than 1 month (unless milestones)

Use DevTools → Local Storage to review and delete old backups.

Recovery Scenarios

Scenario 1: Accidentally overwrote program

LOAD "PROGRAM-BACKUP"
(Restore previous version)

Scenario 2: Browser data cleared

(Load text file)
(Manually re-enter program lines)

Scenario 3: Corrupted file

(Try backup)
LOAD "PROGRAM-BACKUP"

(If backup also corrupted, use text export)

10 REM IMPORTANT PROGRAM
20 REM DO NOT LOSE THIS
30 PRINT "CRITICAL CALCULATION"
40 A = 1000000
50 PRINT "VALUE: "; A
60 END

Practice backup workflow:

1. SAVE "IMPORTANT" (main version)
2. SAVE "IMPORTANT-BACKUP" (backup)
3. Edit line 40: 40 A = 2000000
4. RUN (test change)
5. SAVE "IMPORTANT" (save if good, or...)
6. LOAD "IMPORTANT-BACKUP" (restore if bad)

Complete Save/Load Workflow

Let's put everything together with a complete development workflow—from starting a new project to saving multiple versions and managing backups.

Workflow: Creating a New Program

Step 1: Start Fresh

NEW

Step 2: Enter Your Program

10 REM MULTIPLICATION QUIZ
20 REM ASKS 5 RANDOM PROBLEMS
30 PRINT "MULTIPLICATION QUIZ"
40 PRINT
50 SCORE = 0
60 FOR Q = 1 TO 5
70 A = INT(RND(1) * 10) + 1
80 B = INT(RND(1) * 10) + 1
90 PRINT Q; ". "; A; " X "; B; " = ";
100 INPUT ANS
110 IF ANS = A * B THEN SCORE = SCORE + 1: PRINT "CORRECT!"
120 IF ANS <> A * B THEN PRINT "WRONG. ANSWER: "; A * B
130 NEXT Q
140 PRINT
150 PRINT "SCORE: "; SCORE; " OUT OF 5"
999 END

Step 3: Test

RUN
(Test the program)

Step 4: Save

SAVE "MULT-QUIZ-V1"

Now your program is safe!

Workflow: Iterative Development

Session 1: Initial Version

(Create basic version)
SAVE "MYGAME-V1"

Session 2: Add Features

LOAD "MYGAME-V1"
(Make changes)
SAVE "MYGAME-V2"

Session 3: Major Refactoring

LOAD "MYGAME-V2"
SAVE "MYGAME-V2-BACKUP"    (Backup before risky changes)
(Refactor code)
RUN                         (Test)
(Works!)
SAVE "MYGAME-V3"

Session 4: Polish and Release

LOAD "MYGAME-V3"
(Final tweaks)
SAVE "MYGAME-FINAL"

Workflow: Bug Fixing

Discover Bug

LOAD "MYPROGRAM"
RUN
(See bug)

Create Debug Version

SAVE "MYPROGRAM-DEBUG"
(Add debug PRINT statements)
150 PRINT "DEBUG: A = "; A
RUN
(Find problem)

Fix Bug

(Remove debug lines)
150
(Fix actual bug)
100 IF A > 0 THEN ...

Test and Save

RUN
(Works!)
SAVE "MYPROGRAM"

Workflow: Backup Before Experiment

Safe Experimentation

LOAD "STABLE-VERSION"
LIST                           (Review it)
SAVE "STABLE-VERSION-BACKUP"   (Backup)

(Try experimental idea)
50 (Delete old approach)
55 (Add new approach)

RUN
(Doesn't work...)

LOAD "STABLE-VERSION-BACKUP"  (Restore)
(Back to working version)

Workflow: Multi-Version Management

Maintaining Multiple Versions

Active development:
SAVE "PROJECT-DEV"              (Daily working version)

Stable versions:
SAVE "PROJECT-V1"               (Released version 1)
SAVE "PROJECT-V2"               (Released version 2)

Experimental branches:
SAVE "PROJECT-EXPERIMENT-AI"
SAVE "PROJECT-EXPERIMENT-SOUND"

Backups:
SAVE "PROJECT-BACKUP-JAN23"

Workflow: Collaborative Development

(Well, as collaborative as localStorage allows!)

Developer A:

(Create program)
SAVE "SHARED-PROGRAM"
LIST
(Copy output)
(Send text to Developer B via email/chat)

Developer B:

NEW
(Paste lines from Developer A)
10 PRINT "HELLO"
20 END
...
(Make changes)
SAVE "SHARED-PROGRAM-B"
LIST
(Send changes back)

Workflow: End-of-Session Checklist

Before closing the browser:

1. LIST                    (Review current work)
2. SAVE "CURRENTPROJECT"   (Save main version)
3. SAVE "CURRENTPROJECT-BACKUP"   (Save backup)
4. (Optional: Export to text file)

Tomorrow you'll return to a clean slate:

1. LOAD "CURRENTPROJECT"
2. LIST                    (Review where you left off)
3. RUN                     (Test that it still works)
4. (Continue development)