4

I know in TI-BASIC, the convention is to optimize obsessively and to save as many bits as possible (which is pretty fun, I admit).

For example,

DelVar Z
Prompt X
If X=0
Then
    Disp "X is zero"
End                   //28 bytes

would be cleaned up as

DelVar ZPrompt X
If not(X
    "X is zero        //20 bytes

But does optimizing code this way actually make a difference? Does it noticeably run faster or save memory?

user3932000
  • 671
  • 8
  • 24
  • 2
    Tip: on the "clean up" code section, you can remove the `Disp` from the last line. Anything that is evaluated (set to `Ans`) on the last line of a TI-Basic program is implicitly displayed. (If there is nothing set to `Ans` on the last line, `Done` is displayed instead). – Timtech Oct 12 '16 at 14:27
  • @Timtech I didn't know that, thanks! Edited now. – user3932000 Oct 12 '16 at 14:37
  • 1
    Even if this does save on execution time, you are going to loose all that saved time trying to figure out what the program is doing when you try to modify it at a later date. Even in TI-Basic, it's better to write for humans in most cases. – Vaelus Feb 17 '17 at 17:48
  • @Vaelus I write my own programs and I write for myself, so there's no need for readability. Plus TI-84 is REALLY slow and I need all the time saving I can get. – user3932000 Feb 17 '17 at 20:00

4 Answers4

7

Yes. Optimizing your TI-Basic code makes a difference, and that difference is much larger than you would find for most programming languages.

In my opinion, the most important optimization to TI-Basic programs is size (making them as small as possible). This is important to me since I have dozens of programs on my calculator, which only has 24 kB of user-accessible RAM. In this case, it isn't really necessary to spend lots of time trying to save a few bytes of space; instead, I simply advise learning the shortest and most efficient ways to do things, so that when you write programs, they will naturally tend to be small.

Additionally, TI-Basic programs should be optimized for speed. Examples off of the top of my head include the quirk with the unclosed For( loop, calculating a value once instead of calculating it in every iteration of a loop (if possible), and using quickly-accessed variables such as Ans and the finance variables whenever the variable must be accessed a large number of times (e.g. 1000+).

A third possible optimization is for run-time memory usage. Every loop, function call, etc. has an overhead that must be stored in the memory stack in order to return to the original location, calculate values, etc. during the program's execution. It is important to avoid memory leaks (such as breaking out of a loop with Goto).

It is up to you to decide how you balance these optimizations. I prefer to:

  1. First and foremost, guarantee that there are no memory leaks or incorrectly nested loops in my program.
  2. Take advantage of any size optimizations that have little or no impact on the program's speed.
  3. Consider speed optimizations, and decide if the added speed is worth the increase in program size.
Timtech
  • 1,224
  • 2
  • 19
  • 30
4

TI-BASIC is an interpreted language, which usually means there is a huge overhead on every single operation.

The way an interpreted language works is that instead of actually compiling the program into code that runs on the CPU directly, each operation is a function call to the interpreter that look at what needs to be done and then calls functions to complete those sub tasks. In most cases, the overhead is a factor or two in speed, and often also in stack memory usage. However, the memory for non-stack is usually the same.

In your above example you are doing the exact same number of operations, which should mean that they run exactly as fast. What you should optimize are things like i = i + 1, which is 4 operations into i++ which is 2 operations. (as an example, TI-BASIC doesn't support ++ operator).

This does not mean that all operations take the exact same time, internally a operation may be calling hundreds of other functions or it may be as simple as updating a single variable. The programmers of the interpreter may also have implemented various peephole optimizations that optimizes very specific language constructs, e.g. for(int i = 0; i < count; i++) could both be implemented as a collection of expensive interpreter functions that behave as if i is generic, or it could be optimized to a compiled loop where it just had to update the variable i and reevaluate the count.

Now, not all interpreted languages are doomed to this pale existence. For example, JavaScript used to be one, but these days all major js engines JIT compile the code to run directly on the CPU.

UPDATE: Clarified that not all operations are created equal.

Cine
  • 4,255
  • 26
  • 46
  • 2
    But this isn't true, there are huge differences in the performance of commands, it's not like 1 command = 1 unit of time. Ex: `goto` is slow (and can cause memory leak), the performance characteristics of `if` depends on whether there's a `then` after it, `IS>(` is slower than incrementing normally (but does exist!) but if you can use the built-in skipping it's faster than an equivalent increment+`if`. – harold Oct 12 '16 at 10:47
  • Adding on to what @harold said, there are some strange quirks in TI-BASIC, like the `For(` loop running much slower in specific cases (for example, when the following `If` statement without a `Then` is false) if there's no closing parenthesis. – user3932000 Oct 12 '16 at 14:14
3

Absolutely, it makes a difference. I wrote a full-scale color RPG for the TI-84+CSE, and let me tell you, without optimizing any of my code, the game would flat out not run. At present, on the CSE, Sorcery of Uvutu can only run if every other program is archived and all other memory is out of RAM. The programs and data storage alone takes up 20k bytes in RAM, or just 1kb under all of available user memory. With all the variables in use, the memory approaches dangerously low points. I had points in my development where due to poor optimizations, I couldn't even start the game without getting a "memory all gone" error. I had plans to implement various extra things, but due to space and speed concerns, it was impossible to do so. That's only the consideration to space.

In the speed department, the game became, and still is, slow in the overworld. Walking around in the overworld is painfully slow compared to other games, and that's because of what I have to do in that code; I have to check for collisions, check if the user is moving to a new map, check if they pressed a key that should illicit a response, check if a battle should go on, and more. I was able to make slight optimizations to the walking speed, but even then, I could blatantly tell I had made improvements. It still was pretty awfully slow (at least compared to every other port I've made), but I made it a little more tolerable.

In summary, through my own experiences crafting a large project, I can say that in TI-Basic, optimizing code does make a difference. Other answers mentioned this, but TI-Basic is an interpreted language. This means the code isn't compiled into faster, lower level code, but the stuff that you put in the program is read straight out as it executes, is interpreted by the interpreter, calls the subroutines and other stuff it needs to to execute the commands, and then returns back to read the next line. As a result of that, and the fact that the TI-84+ series CPU, the Zilog Z80, was designed in 1976, you get a rather slow interpreter, especially for this day and age. As such, the fewer the commands you run, and the more you take advantage of system weirdness such as Ans being the fastest variable that can also hold the most types of data (integers/floats, strings, lists, matrices, etc), the better the performance you're gonna get.

Sources: My own experiences, documented here: https://codewalr.us/index.php?topic=778.msg27190#msg27190

TI-84+CSE RAM numbers came from here: https://education.ti.com/en/products/calculators/graphing-calculators/ti-84-plus-c-se?category=specifications

Information about the Z80 came from here: http://segaretro.org/Zilog_Z80

Stephen P
  • 195
  • 11
  • Thanks for the informative post. I know it's 5 years since your post, but I'm wondering where I can find more information about which variables perform faster than others. Have you seen that documented anywhere? – Simon East Aug 18 '22 at 06:30
0

Depends, if it's just a basic math program then no. For big games then YES. The TI-84 has only 3.5MB of space available and has the combo of an ancient Z80 processor and a whopping 128KB of RAM. TI-BASIC is also quite slow as it's interpreted (look it up for further information) so if you to make fast-running games then YES. Optimization is very important.

ForTheLulz777
  • 11
  • 2