1. 33
  1.  

  2. 3

    This was totally me in high school. I learned assembly and C through my TI-83 and I can say with confidence that this contributed to me becoming a software developer.

    1. 1

      Same, with me it was my sister’s hand-me-down TI-81. Later it was a TI-89 which I would largely program to do my math and physics homework for me. Even if it was less work to just do it by hand, which it often was, and since you had to show your work anyway it was more or less used to check my homework.

      Still have the TI-89 in my desk drawer, and I graduated in ’03. Will probably never get rid of it.

      1. 1

        Haha I did the same thing with my TI-83, programming it to do whatever we were doing at the time including showing the working. I got a TI-89 when I went to university, which I still have. I recently got it out and put it on my desk and started using it for quick calculations.

    2. 3

      In the mid-to-late 2000s, you either knew, or were, that kid in grade school.

      Grade school, really? In the late 90s this was true of high school.

      1. 2

        For whatever reason, it was the Casio calculators that were popular in the UK. The only language for programming was the normal calculator language - no BASIC or assembly. There was only 422 bytes of memory on Casio’s original model but you could do more with that than would be possible in assembly. There were weird tricks to optimising programmes for size. I had Connect 4 working in barely more than 100 bytes.

        1. 3

          The TI calculators were on the approved list for GCSR and A-level maths in the ’90s. The vast majority of the of the functionality of the calculator was completely irrelevant to (or actively unhelpful to) the course. It could solve quadratic equations via a repeated approximation method, which was useful for checking your answers, but pretty much everything else was useless.

          I had a TI-86 (which was like the TI-85 but with more RAM and, for some reason, much slower screen updates). I never really got into the whole coding-on-the-calculator thing. I had had a Psion Series 3 for several years by the time I got the TI-86 and the Psion ran a full multitasking OS and came with a decent keyboard for writing code on the device. I wrote a load of programs on that machine and the TI calculator seemed quite clunky in comparison.

          The XKCD in the article really resonated with me. I can run GNU Octave on a bargain basement Android phone and have something vastly more powerful than the TI calculator for less money. They seem to make their money from the fact that exams place an upper limit on what a calculator can do in your exam. This, in turn, annoys me because it’s pretty clear that the exams aren’t actually measuring useful skills. I spent a year in maths lessons going from being able to solve differential equations in a thousand times as long as it would take a computer to being able to solve them in a hundred times as long. If I ever need so solve a differential equation now, I’ll reach for Matlab / Mathematica / Octave because then I’ll definitely get the right answer and even installing the tool from scratch to solve a single equation will probably take less time than solving it on paper. Being able to construct the right equation to represent a problem is a useful skill. Being able to understand the underlying theory that leads to things like the chain rule is useful in some contexts (though that isn’t actually taught until university in the UK: at school they’re just magic recipes). Being able to run an algorithm slowly with a piece of paper and a pencil is as useful as being able to write with a quill pen: it may make you some friends at a historical re-enactment event but that’s about it.

          1. 1

            I remember getting programs written in C on my Casio calculator (maybe a 9750? Its in my storage somewhere still). I was an active member on casiocalc.org forum, and vaguely recall one of the French members teaching me how to do the C programs on the calculator. All I can recall is that it was done on the computer, with a link cable (which was hand made )

            That must have been in 1999 or so, based on which school I was in. Now I feel old.

          2. 1

            z80 TI calcs are cool.

            m68k TI calcs (TI-89, TI-92, Voyager 200) are cooler, and can be found in good condition at less than $50.

            Newer TI-83/84 have (deliberately) much less functionality, and are far more expensive. It’s a shame.

            1. 1

              Ooh, memories :-D

              Back when I was in high school, I was the guru on writing high-performance TI-basic. There were a lot of arcane and/or vaguely documented tricks that I painstakingly discovered in the process of trying to write a 3D renderer; by the end, I could get a poly every ~20ms or so. (Obviously, this could be done much faster in assembly, but I was limited in my time in front of a PC, but not my time in front of a calculator).

              The big ones I remember are:

              • Close parens are slow. Evaluating 2*(3+4) became something like 20% faster if you left off the close paren
              • Accessing Ans was almost an order of magnitude faster than any other variable. Presumably Ans was in a fixed memory location, while other variables needed to walk the object directory.
              • If you needed to do the same set of operations to more than about 3 values, it became cheaper to put them in a list or matrix and then perform the operations on that. This will sound familiar to anybody who has done significant work in Python; it gets the loop done in native code rather than the slow interpreter

              I had a hand-written document that I photocopied and handed out to the other calculator nerds with these and another ~15 tricks, but it doesn’t seem that it ever made it online. I think it got left behind when I was escaping from a hostile living situation a couple years ago, but I really don’t know.

              At one point I made a solitaire game (complete with fisher-yates shuffle and graphics) as part of a graphical shell, again entirely in Basic. Those programs got so big that I needed to introduce subroutines, which TI Basic lacked; IIRC, you couldn’t even call another program without stopping the program you were running. I ended up implementing that by starting each of the programs with something that checked whether Ans had a magic value in it; if so, it would jump to an appropriate label depending on the “call number” in some variable. I forget how I handled returns, but I suspect that I just used that variable as a link register and let each program have its own set of subroutine libraries.

              Sadly, all this happened almost 20 years ago and the only thing that remains is a very cringy thing[1] that “encrypts” strings by encoding them as numbers in a matrix and multiplying that by a key. “Very secure” indeed :-/

              [1] https://www.ticalc.org/archives/files/fileinfo/252/25214.html