I cannot find any good places to learn ti-basic 68k.

Any suggestions?

You can always use http://tibasicdev.wikidot.com/68k:home or some good YouTube videos.

http://tibasicdev.wikidot.com/68k:home is incomplete.

Can you give me a link to a "good YouTube video"?

Which kinds of programs do you want to make in TI-68k BASIC ?

Why do you ask?

Well, if you give more details about what you're trying to do, it may help people pointing documentation more relevant to your purposes

Well if you guys are just going to make short, back and forth conversation, SAX is here for a reason.

Nothing in particular. Just want learn the basics.

That is simultaneously the best and worst pun I've seen today. (but not the only)

Anyways, post some of your adventures here, I want to see 'em!

The pun actually wasn't intended.

Have you had experience programming in other languages yet?

Back when I started, I didn't have the benefit of Internet access or online tutorials. I just read the calculator manuals (gasp!). I just picked a few bits and pieces, fooled around, and eventually figured things out. Granted, this started on the TI-81, which had a very primitive programming language that couldn't do much, but this made it easier to learn. But I used the same method to subsequently learn 82, 85, and 86 BASIC (which were essentially just extensions of the 81's language), and then 89/92+/V200 (whose language is different in a lot of fundamental ways).

If you have had previous programming experience, then I'd say the programming section of the manuals (89/92+, 89t/V200) really are all you should absolutely need to get started.

If you are completely new to programming, though, that can admittedly be a bit overwhelming. 68K calcs don't get a lot of attention, so programming resources are going to be a bit harder to find. If all else fails, perhaps you could start with a more popular language, like 83+/84+ BASIC or even Python or Ruby, to get familiar with programming, as these have a lot of good, easy-to-find tutorials and books. Once you're familiar with the process of learning one programming language, just using the non-tutorial reference materials for learning others isn't quite so bad. There are differences, but much of the knowledge is transferrable.

I'm not saying tutorials are bad, just that people sometimes seem to overlook the goldmine of information that is provided right there with the product itself. A lot of tutorials you find aren't going to include everything you may want to know. They're good for getting started, but at some point it's probably best just to start looking through the manual/reference guide to discover the rest of what's possible.

I already know ti-84+ basic.

That's a rather.... short reply for a long post. Have you considered reading the official manuals Travis has linked you? They are professionally developed books; unlike us, these people have been paid to write documentation for the product you bought. As such, it has been made easy to understand for people with varying levels of competence in programming; not just hobbyists, but businesspeople as well who don't have all the time in the world and just want to get something done on their calculator so that they can do their job faster.

The section of the manual you are looking for (Appx. A: Functions and Instructions) is 130 pages long and has the near-complete list of commands, with descriptions, parameters, and examples. Given this book was written before it was easy to Google things (2002), it's very likely that an answer you may have to a question will be somewhere in the book.

From what I have read, 68k basic is very different than 84+ basic.

It seems that the latter is much, much less structured and rigid with its rules, and that the former requires you to to take more steps to accomplish the same task, but that also would let you do more, potentially. (This is coming from a guy whose only 68k experience was looking that up)

For example, this code in 68k Basic (grabbed from ti-basic dev):


Code:


is does the same thing as this 84+ code, which is much, much smaller:


Code:


Although knowing 84+ BASIC is good, and teaches important fundamental programming concepts, it probably will not help you much while learning 68k BASIC, other than the aforementioned programming concepts.

I agree with what Travis said, about learning one programming language, and it helping you learn others, as I learned the original BASIC first, and it helped me later unlock (with some degree of ease) useful languages like JS, Java, and C.

I also agree with him on the original manuals, as they were probably written by people who either participated in making or designing the language, or people extremely familiar with it.

Along with Kerm's book, my TI-85 manual (even though the TI-85 BASIC is different than the 84+BASIC) was instrumental in teaching me the basics of TI-BASIC, and both are missing covers, pages, and need replaced...

DAMMIT I WAS NINJA'D WHILE TYPING A POST!

How I learned TI Basic was by picking apart programs and seeing how each line worked. It helped me to slowly memorize the functions of certain commands, so try that. The TIBD is also a good resource, and there should be some examples for you to use (I know because I worked on a lot of the programming section of the command index). You can also try this guidebook, which is also a good reference (start at page 560). If we knew what calculator you are trying to code in 68k Basic for, we could help more (I suggest the TI 89 Titanium )

Best of luck to you as you learn!

68K BASIC is a bit more structured and syntactically picky, though in that example from the tutorial, not all of the code is technically necessary:

Code:

The simplest possible version is actually very similar to _iPhoenix_'s 84+ example:

Code:

The only real difference is the “hellowld()”, “Prgm”, and “EndPrgm” lines, which are just boilerplate that's required for every program (and which are inserted automatically for you when you create a new program). The extra “DispHome” instruction in the first example is just an optional convenience that causes an automatic return to the home screen before the program quits, as the 68K calcs use a separate screen for program I/O and normal calculation entry. Without it, it just stays on the output screen with “Hello, world!” until you manually close it (in which case, you could just use Disp instead of Pause since the extra delay for a keypress is unnecessary).

Quite a few of the syntactic elements of 68K BASIC actually should look familiar for 83+/84+ programmers, though there are a lot of important differences. I never tried to make a list of all of them, but here are a few tips off the top of my head:

• Variables have names up to eight characters (case insensitive) and can contain any data types, rather than being restricted to a limited, predefined set of names/tokens for each type.
  
  
• There is a concept of local variables, folders, and functions that can return values, though you don't have to deal with these when you're starting out (except to keep an eye on the current folder setting if your program relies on variables to stay there between runs—without special code, it will only see variables in the current folder).
  
  
• You can use lowercase letters as much as you want with no special third-party tools and without wasting bytes.
  
  
• 0 and 1 don't work as booleans; the “true” and “false” expressions are required. So if you try to do something like “If 1+1 Then…”, the calculator will complain because the expression must evaluate to either “true” or “false”, not an number, string, or anything else. So you can't use 83+/84+ optimization techniques based on that.
  
  
• There's a difference between integers and real numbers. You have to really watch the exact/approx mode setting or you might get some really weird symbolic results when you were expecting reals. But you can take advantage of this for optimization: If you're writing code that will only ever deal with ints, using exact mode usually makes the program run noticeably faster (IIRC). For just non-symbolic reals, better use approx, as complex symbolic expressions and fractions can slow things down unnecessarily.
  
  
• Indeed, the calc is so eager to do symbolics (it is a CAS, after all) that it sometimes tends to produce them when you don't want. If you accidentally use an undefined or misspelled variable name, instead of giving an error or some kind of default like 0, your programs often will just silently produce partially-evaluated symbolic results, which can cause some really weird, confusing behavior. In time, you get used to it and learn to recognize your mistake a little faster, but this is one thing I know took me a while to get used to, and it sometimes makes debugging a bit more difficult.
  
  
• You aren't allowed to omit closing quotes or parentheses. The parser is different and more picky, so those 83+/84+ optimizations won't work, either. (Though there's not much need to worry about the extra bytes since you do get a generous amount of RAM and archive space from which programs can run directly.)
  
  
• Speaking of the above, watch out for accidentally missing ending quotes in strings. The 68K BASIC parser permits string literals that span multiple lines(!). The first time I made that mistake, I was very confused to have an error and have it take me to a random location right in the middle of another string, far away from where the actual error of the missing quote was. (It turned out it was looking for the end of the string and thought the contents of the next string literal was code!)
  
  
• As I hinted at above a couple of times, because of the parsing and tokenizing differences, many, if not most, of the other clever optimizing tips for 83+/84+ code simply do not work or don't apply. 68K code has a different set of rules. Since space isn't as much a restriction, size optimization isn't nearly as important, though finding ways to optimize for speed can still be. Even 68K BASIC isn't always as stellar as one would like when it comes to execution speed.…
  
  
• Indentation of code is accepted, and I recommend it, as it makes structured programs a lot easier to read and edit (and 68K BASIC encourages structured programming). Although the editor lacks conveniences like auto-indentation, and the menu templates aren't indentation-aware when pasting, the indentation is preserved on tokenization. In fact, TI was actually kind of clever with the tokenizer, as once the program is tokenized, indented lines end up take the same number of bytes as the same lines without indentation! So there's really no reason to avoid it.

68K BASIC is powerful, but it's also much more complex than TI-BASIC, and it can take a while to get the hang of all the quirks. Some of them can be confusing and take a while to figure out. It's probably unavoidable that you'll have to learn a few the hard way or even post here for help. I hope the list of some of them I mentioned above will be helpful, though.

The language is nearly identical on all 68K calcs. The only real differences, IIRC, are a few extra commands/functions added to the later models (and sometimes newer versions of AMS on the same model), the display resolutions between the 89/89t and 92+/V200, and possibly some of the getKey codes.

getConfg() is provided to determine LCD size (among other interesting things), so one could make a program that checks it and automatically adapts itself at runtime so that it will run on all models without changing the code. (This even applies to ASM programs, too; the model compatibility of 68K programs is largely just a matter of whether the developer wanted to go through the effort to design and test the UI for two different LCD sizes and key layouts.)