Test your code on a real Apple II

Oct 13, 2025 by wbrum.org 81 views

The LET HEN GOTO Conundrum: Understanding AppleSoft BASIC's Parsing Quirks

AppleSoft BASIC, a popular programming language for the Apple II, has a reputation for being quirky and finicky. One of the lesser-known quirks of AppleSoft BASIC is its parsing behavior, which can lead to unexpected results if not handled correctly. In this article, we will delve into the intricacies of AppleSoft BASIC's parsing and explore a specific issue that has been reported by developers using emulators to write code for the Apple II.

The issue at hand is related to the way AppleSoft BASIC parses certain lines of code. Specifically, when the emulator parses the line 7010 IF LS > LE THEN GOTO 7060, it does not behave as expected on a real Apple II. Instead, the line is parsed as 7010 IF LS > LET HEN GOTO 7060, which is not the intended behavior.

To understand why this is happening, let's take a closer look at the correct parsing of the line. The correct line would be 7010 IF LS > (LE) THEN GOTO 7060. As you can see, the parentheses are crucial in this case, as they tell AppleSoft BASIC to treat LE as a single expression, rather than parsing it as LET HEN.

Unfortunately, the emulator being used to develop the code does not pick up on this parsing issue, and any code written using this emulator will run as expected on the emulator. However, this does not mean that the code will work correctly on a real Apple II. In fact, the code may break or behave unexpectedly on the real machine.

The point of this article is to highlight the importance of testing code on a real Apple II, rather than relying solely on an emulator. While emulators can be incredibly useful for development and testing, they are not a substitute for actual hardware. By using an emulator to develop code, you may inadvertently introduce parsing issues like the one described above, which can lead to unexpected behavior on the real machine.

So, what can you do to avoid this issue? Here are some best practices for developing AppleSoft BASIC code:

Test your code on a real Apple II: While emulators can be useful, they are not a substitute for actual hardware. Make sure to test your code on a real Apple II to ensure that it behaves as expected.
Use parentheses correctly: As we saw in the example above, parentheses are crucial in AppleSoft BASIC. Make sure to use them correctly to avoid parsing issues.
Be aware of AppleSoft BASIC's quirks: AppleSoft BASIC has a reputation for being quirky and finicky. Make sure to be aware of its quirks and limitations to avoid introducing issues into your code.

AppleSoft BASIC, a popular programming language for the Apple II, has a reputation for being quirky and finicky. In our previous article, we explored the LET HEN GOTO conundrum, a parsing issue that can lead to unexpected results if not handled correctly. In this article, we will answer some frequently asked questions about AppleSoft BASIC, its quirks, and how to avoid common pitfalls.

Q: What is the LET HEN GOTO conundrum?

A: The LET HEN GOTO conundrum is a parsing issue in AppleSoft BASIC where the line 7010 IF LS > LE THEN GOTO 7060 is parsed as 7010 IF LS > LET HEN GOTO 7060 instead of the intended 7010 IF LS > (LE) THEN GOTO 7060. This can lead to unexpected behavior on a real Apple II.

Q: Why does the emulator not pick up on this parsing issue?

A: The emulator being used to develop the code does not pick up on this parsing issue because it does not accurately simulate the behavior of AppleSoft BASIC on a real Apple II. While emulators can be incredibly useful for development and testing, they are not a substitute for actual hardware.

Q: How can I avoid introducing parsing issues like the LET HEN GOTO conundrum?

A: To avoid introducing parsing issues like the LET HEN GOTO conundrum, make sure to:

Test your code on a real Apple II
Use parentheses correctly
Be aware of AppleSoft BASIC's quirks and limitations

Q: What are some other quirks of AppleSoft BASIC that I should be aware of?

A: Some other quirks of AppleSoft BASIC that you should be aware of include:

The use of REM statements to comment out code
The use of END statements to end a program
The use of GOTO statements to jump to a specific line of code
The use of FOR loops to iterate over a range of values
The use of NEXT statements to increment a loop counter

Q: How can I troubleshoot issues with my AppleSoft BASIC code?

A: To troubleshoot issues with your AppleSoft BASIC code, try the following:

Use a debugger to step through your code and identify the source of the issue
Use print statements to output the values of variables and expressions
Use the LIST command to list your code and identify any syntax errors
Use the RUN command to run your code and see if it produces the expected output

Q: Are there any resources available for learning AppleSoft BASIC?

A: Yes, there are several resources available for learning AppleSoft BASIC, including:

The AppleSoft BASIC manual, which provides a comprehensive guide to the language
Online tutorials and guides, which provide step-by-step instructions for learning AppleSoft BASIC
Communities of AppleSoft BASIC enthusiasts, which provide a forum for discussing the language and sharing knowledge

In conclusion, AppleSoft BASIC is a powerful and flexible programming language that can be used to create a wide range of applications. However, it also has a reputation for being quirky and finicky, and can be prone to parsing issues like the LET HEN GOTO conundrum. By being aware of AppleSoft BASIC's quirks and limitations, and by following best practices for development and testing, you can avoid introducing issues into your code and create successful applications.