It appears that some comment boards are borken... (misspell intended)

(Second comment BTW!)

Good luck! I already wrote a 83 basic RPG battle engine (Stupid uncle worm crash cleared it once!)

(as a side note, I made that post when no other posts had been posted. If it was the first comment, it would have been funnier!)

First comment? Way to go Basmic. Basic has needed a champion for some time now.

Rock on.

Go TI BASIC!!!

There is one thing though: TI-BASIC can't crash your calculator, but it sure can but a ton of junk on your calculator, as well as change all your modes (if the programmer is not very good and doesn't put things back the way he found them at the end of the program). But I think BASIC programs can certainly be good - look at that Zelda 89 program.

Nick Chaves

(I was too slow writing this comment - I almost had first...hehe)

I agree that BASIC is good and that BASIC and ASM each have their specific places, but have you been to these guys webpage? Its full of great looking BASIC (w/small ASM) games. I don't know about you, but it seems to me that they are wasting their potential in programming. True, their programs look great, but how much better could they be in ASM? Much.

The way I think about it, their is a threshold on how good a BASIC game should look. Once it hits a certain point in its graphics, its no longer easier to program in BASIC and would be drastically improved if written in ASM.

In addition, I don't mean to disrespect the programmers of great basic games, but generally, BASIC programmers are not as skilled a ASM programmers. My best evidence of this is how it takes real skill and knowledge to turn out an ASM program, while in BASIC, any kid can put out a guessing game in about 5 minutes, but that doesn't make him a good programmer.

Basically, what I'm trying to say is that while BASIC is a great language, especially for mathematics, it will never be as good as ASM for games.

I disagree. Basic programmers have to be fairly good if the game is to turn out good. It takes skill to make a basic game as fast as possible and still look good. An ASM game can be made rather sloppy and still be fast. ASM is definately harder to learn but that doesn't mean it makes you a better programmer. All I want is some respect for Basic. Bashing basic because of speed is like scolding a dog for not catching mice, it doesn't make sense.

Ok, you both are wrong. TI-BASIC is very BAD. There are many reasons for this. First check out Patrick Davidson's website pad.calc.org. There is an article about asm vs. basic on there. I think that the only good thing about TI-BASIC is that it can make fairly good math programs. Come on when was the last time you downloaded a basic game to play on your calculator. The only time that i did this was when i first got my calculator and didn't know anything about ASM. the obvious choice is ASM. Flames are welcome.

--RavenMoss

so you base your arugument on one article (on a basic biased site) and past expereince. Give basic a chance! There are great basic games out there and people just waiting to see your dumbfounded look when you play one!

>Come on when was the last time you downloaded a basic
>game to play on your calculator.

yesteerday i got Yahtzee (by ben miller) and its a great game! theres no slowdown in the gameplay, its fast, entertaining and yes its basic!

Ok, I will give you an instance in which BASIC is worse than ASM. I have written a program called the Genetic Code for TI-86 BASIC, and I just completed a version in TI-86 ASM. The difference is enormous! My ASM version of the program finds the amino acid instantaneously while the basic version can take up to 3-4 seconds to derive this. The ASM version is smaller (by 100 bytes) and have a GUI and several other distinct features. Size, speed, etc. BASIC is BAD and anyone, like SiCoDe, who tells you otherwise is wrong. Read on and listen to Dave Phillips, he knows what he is talking about! BASIC has its place with math functions and what not, but comparing it to the superiority of Assembly Language is the Stupidest thing that i have ever heard. If you want to test out the difference between the two programs, please email me and i will send you a version of both and then you can test it out for yourself

And another one misses the point.... This is not a race for speed, BASMIC is just making a point that good programmers deserve their rewards (basic or otherwise).

There are high quality basic programs and high quality basic programs.
There are low quality asm programs and low quality asm programs.
It all depends on the programmers ability.

Sure if you want to make your programs in ASM Go ahead! They will most likely be smaller and faster (by a whole lot!), but just try some basic games - you may find some you like! :)

>BASIC has its place with
>math functions and what not, but
>comparing it to the superiority of
>Assembly Language is the
>Stupidest thing that i have
>ever heard.

Superiority is a relative thing. It takes a good basic progammer to make up for its myraid limitations, (namley speed and ability).

Your program may be 'better' in Asm, but is that becasue you wrote it to be better or because you didnt want to make it better in basic?

BASMIC
Basic = Asm

Actually, I did try and code it well in basic. Like I and Others have said we don't program bad programs. We program to the best that we can so that the program will be good for the public.

Let me pose an ultimatum for you and all of the other mis-informed people out there. Would you rather play a well coded assembly game, or a well coded BASIC game. The choice is clear, you would choose a well coded ASM game. I don't remember the last time a decent game (besides some for the 89) in BASIC was released and worth my play or download.

-Will Dempster
BASIC <> ASM (<> means does not equal btw)

>Let me pose an ultimatum for you and all of the other mis-informed people out there.
>Would you rather play a well coded assembly game, or a well coded BASIC game. The
>choice is clear, you would choose a well coded ASM game. I don't remember the last
>time a decent game (besides some for the 89) in BASIC was released and worth my
>play or download.

I'd play both. :P A well coded basic game is usually some rpg or other genre not dependant on speed or flashy graphics. A well coded asm game (or moslty all asm games) are flashy graphics and high speed. Since RPG's are my favorate and asm has virtually none (save for joltima) BASIC is an 86 RPG'ers way to go. Action games are fun too.
If you say that you want to make (and play) quality games, then there is no need for discussion, simply have fun playing (or making) fun games, language doesnt matter.

Basic = Asm - BASmIC

-Arcades

The only basic game i have actually played more than once is tanks for the 89. Of course if it were available in assembly i'd get that version. (of course then you'd need a speed setting so that the missiles don't whiz across the screen in 1/103927053750730 seconds. :)

I agree, but asm is hard. And I think the internet is biased against BASIC articles and programs. I have seen some good BASIC programs, but over all, asm rules!

When: Two days ago
Plat: TI 83/+
Game: Ground Assault!! Yeah Baby!!
Resp: The best game of it's Genre on any Calc for any
format! How many ASM games out there do NOT work
or are not FINISHED. Now take a look at BASIC.
I know that SiCoDe has produced multiple BASIC
programs that blow lots and _LOTS_ of ASM games
out of the water. If you have NO idea of what
Ground Assault is or what Lords is then you
definitely need to stop with the ASM is god Krape
(pronounced K'-rap) and actually sit down and
compare some basic games to your ASM games.


That's my rant on this

Another great example of BASIC at its prime is Michael Tussey's "Magic Quest II: Act 2" which I have played a little (couldn't play long since I had trig. homework to do, hehe) and the graphics and GUI are fantastic. Here's the big reasons I like BASIC over ASM:

*I like being able to run BASIC programs from the PRGM key. I hate having to type Asm(name) to run something and I don't like having to use a shell or write a BASIC program to call an ASM program.
*I like being able to look at the code of a BASIC program to understand how some programmers perform certain functions and to get ideas for some of my own programs.
*I can program in BASIC because it's easier for me to understand and I'm not going to bother wasting time to learn ASM.

I hardly use games on my TI-86 and since I make good use of some science and math BASIC programs, I need quick and easy access to those programs and can't mess around typing in letters to start a program during a test or while in class (I'm not cheating, either). I'm not saying I won't ever use ASM programs as I occassionaly play ZTetris or Super Mario 86 and admit that the graphics are quite good and the games are fast. But, I primarily like to use my calculator for what it's meant to do; perform mathematical functions for me.

Basic on the ti80 _can_ crash your calculator. There's a bug in all ROM images (up to and including v4.0, despite what ti have said) that sometimes makes the calculator display all its functions in a list. Reset required.

There's a similar bug in the ti82, I've only seen it once though. It doesn't seem to list everything...

According to one of my mates (?) there's a way of using Basic on the ti86 to add a 'Self Test' function to the custom menu without using assembly or ASAPs. It's based around something obscure though.

Basic on the early ti92s also contains certain bugs that can freeze the calc.

Keesh
<plug>http://www.asm86.cwc.net/ for the best assembly tutorial for the ti86 on the net (?)</plug>

I agree with some of their ideas, but basic <> asm. It takes lots of space in ASM to multiply 2 numbers, but basic can't even dream of sqrxz. But to say basic programmers are equally skilled to ASM programmers... ha ha ha. That is laughable, but there are some damn good TI basic games! (All the ASM I know displays sprites on the screen reading locations from a matrix)

We need BASIC with ASM features! It worked for Qbasic, what about the TI83's send(9 or the 86's asm( commands? (82 is ruled out...)

As a unrelated note: number guessing games have no place on any archive, unless it's a 'one line of code only' real computer programming archive.

I also strongly agree that the similarities between BASIC and assembly are few and far between. Putting BASIC on the same level as assembly is absurd! Assembly *programs*, overall in my opinion, are better than BASIC *programs*. As everyone knows, assembly programs are faster, smaller, more graphical, more powerful, etc., etc., etc. About the only possible advantage BASIC has over assembly is it's mathematics capabilities, and even there it doesn't gain much ground, since assembly programs have access to the OP registers, allowing addition, subtration, multiplication, division, trigonometry, logarithms, etc.

However, where BASIC does win out is it's ease of production (BASIC *programming*, in my opinion overall, is somewhat better than assembly *programming*). I've often written a quick BASIC in just a couple minutes to help me out on a lengthy math problem. Which is why it's called BASIC, I s'pose...

BASIC with the possibility of assembly functions is certainly possible, and should be used! For example, for Usgard (on the TI-85), Andreas Ess has developed Ultra Starter, which allows the relatively weak invoking of assembly programs from the homescreen or within a program. It uses a TSR that checks the Ans variable to see if a string with a certain format is contained within it (email me if you want to know details).

I myself am looking into an alternative method to invoke assembly programs, at least from the home screen. I've found one method where, when evaluating a key press, it jumps to an address specified in RAM, which could be changed to jump to an anchored assembly program. Another option I haven't looked into yet is intercepting a syntax error. If anyone's interested in helping out, feel free to email me.

JayEll

Assembly coding has more possibilities than BASIC, but BASIC is not a terrible code. And who really cares about this stuff anyway? It's just calculator programming, not the next presidential election. Just make the games, don't start making idiotic campaigns or have people fighting over better programming. That's just pathetic

The real reason that few people are aware of the "fact" that BASIC = Asm is because it simply isn't true. It's unfortunate that some people (like those behing this absurd campaing) choose to try to gain support for such nonsense, and the blatant lies they use as evidence for it is even more disturbing.

Worst of all is the myth that assembly programs are likely to crash. This is a highly unwarranted generalization. It is true that some assembly programs crash. However, using this as evidence against all assembly programs is very unfair. An assembly program that contains no errors will never cause a crash; if a program does crash, it's due to a specific error in a specific program.

However, even worse than this outright lie is the misinformation that underlies their "admission" that BASIC is slower than assembler. While this seems to actually be a fair analysis of the issue, notice that they don't say how much slower it is. People who aren't very well informed might think that the difference in performance is by a factor of 10, or maybe 100. Even though they haven't actually said such a thing, that's the idea one might get from reading their propaganda. However, the real truth is much worse than this: in my own timed tests (on a TI-85) BASIC was between 800 and 2700 times as slow as assembly (depending on what I tested). Of course, I'm referring not to graphics display routines (which I'll address soon) but rather to the most rudimentary functions, such as simple calculations, looking up from arrays, and control structures.

Another problem is that some people think they can make up for the incredible slowness of BASIC by using a few "extensions" in assembly that allow fast sprite drawing. Of course, this doesn't matter, because even if the objects are drawn instantaneously, the BASIC program still has to calculate their coordinates and such; and that alone will make the program too slow. Therefore, nomatter how fast graphics is, it can't make up for the slowness of simple computations. Of course, the TI-BASIC graphics functions are even worse in most cases; even though a few primitive operations like recalling a picture may be fast, they are not flexible enough for anything other than animations. The situation is a little better on the calculators such as the TI-92 that can recall a picture onto a specific screen location, allowing some pretense of "sprites", but this by know means approaches assembly in performance; assembly programs can easily draw thousands of sprites per second.

I'd also like to remind everyone that I don't hate TI-BASIC programming or TI-BASIC programmers. I do recognize there are some reasons to use TI-BASIC, and that TI-BASIC programmers can be intelligent.

To be very clear, this article is written only to object to the false propaganda used by some people in promotion of TI-BASIC.

no one ever said basic was up to the same caliber as asm... you came up with that little fact on your own

yes we all know a specific error will crash any program but with basic the ti-os catches it and your calc doesnt crash the program just terminates

of course when you tested basic against asm did you use high quality basic programs are some dinky little shit you made up yourself? why dont you try testing math asm and basic on a ti-83 you will notice the basic program is smaller and is faster.. i have tested this myself it was faster by 2 to 1 and it was less than half the size and it inputed and outputed the information in exactly the same way...

have you even tried a sicode program.. i doubt it

risking getting my post deleted.. get your head out of your a$$ and stop trying to sound smarted than you are.. you disgust me..

Did you even visit the Basmic site? Here are 3 separate instances where they say BASIC is on caliber with ASM:

"As you can see, both languages have their faults and strengths. This is why we believe they are equal."

"TI-BASIC is an equally good programming language to ASM."

"BASIC = ASM (Basmic)"

Also, don't call me a BASIC hater because that's the only programing language I know.

It is true that, as I don't own a TI-83, I could never have had the misfortune of running any of your programs. However, what I've seen on my own calculator proves the case against BASIC so strongly that you'd needto have 100 times the BASIC quality on your TI-83 as is on the TI-85 for there to be any sense to your claims at all.

However, I have viewed the GIF animations of some programs from your web site, and that is more than enough for me to tell that your BASIC programs have no major advantages. They may be 2 or 3 times as good as what I've played, but that's not sufficient.

I find it quite absurd that you assume the fact that I know assembly is superior to BASIC to somehow "prove" that my BASIC programming skills are less than yours. You have no real evidence of this. Especially on the TI-83 (which I don't own) you probably could write faster BASIC programs than I could if you've likely spent a lot of time on pitiful details like whether it's faster to write "If A==5:X+1->X" or "X+(A==5)->X" and things like that. However, the fact that I don't waste my time on arcane considerations like that doesn't mean I'm an inferior programmer, and those details certainly wouldn't account even for a 100x performance difference, much less the 2700x I've observed.

Of course, my performance tests were based on small fragments of programs, not entire games, so that I wouldn't need to waste my time trying to write and optimize complete BASIC games. If you want to see what tests I have done, you can read them
on this web page:

http://pad.calc.org/basic.html

I'm going to write this web page after making this post, so you may need to wait about an hour or two before you can see it.

As far as your apparent BASIC math superiority, I would be quite interested to see how you came up with your ridiculous results. While I know BASIC may be smaller in some cases, there's no way it can ever be faster unless the assembly program is very poorly written (or not really equivalent). After all, the assembly program can call the same ROM math routines a BASIC program does (especially on TI-83) and since it doesn't rely on the BASIC interpreter to call these routines.

Even though your post should be deleted, I don't have much hope that it will. After all, ticalc.org not only hosts your pathetic site, but actually posted a news article for your abusrd campaign, which shows that the current ticalc.org staff (or at least some of them) have very low standards (to say the least).

The reason I posted this was because most people have a misconception of how decent some basic programs can be. You have to look harder to find decent basic games (it's always been that way) and while I do concede that ASM is a better calc-based programming language, BASIC should still be given some regard.
Zelda 89 proved that, if anything.

--BlueCalx

I agree that the good BASIC programs should be recognized. I just don't think that a campaign based on misinformation and outright lies is the best way to go about it. I think that providing ratings of BASIC programs, or having an archive containing only the high-quality ones would be a much better way.

The Basmic campaign is neither based on misinformation or outright lies. We are merely trying to get a fair deal for BASIC programmers who are, as can be seen in your posts, treated by some as stupid illiterate fools who cant be bothered to learn a "decent" programming language and instead waste their and everyone else's time releasing endless "Race" clone games.
Performance-wise BASIC does not stand up (or perhaps sit up) against ASM. But it is still a valid language and thus can be considered equal.

Equal? In what regard? BASIC is only "equal" in the fact it can be used to make calculator programs.

Awww. You're just annoyed that us upstart BASIC programmers want to be treated as well as "proper" ASM programmers are. I suppose since you took the time to learn ASM you don't see why us lazy BASIC programmers should get any credit for our programs, as we should have learnt ASM and used that instead.
Right?

Annoyed? Yes. It's not about getting credit or whatever. Programming is fun. If you don't enjoy it, you should be doing something else. But basic and asm are not equal. Anyone with a little intelligence could understand that. There is quite a bit of difference between asm and basic, and until you realize that, you will never become a better programmer.

Don't be stupid - ASM and BASIC are both valid programming languages. Therefore they are equal. Of course BASIC isn't as fast or efficient as ASM, and we realise that's why people discriminate against BASIC programmers (like you are doing) - but we still believe it has its uses and shouldn't be regarded as "inferior". Merely "different".
Makes sense?

Ok, think about this for a little bit.

>ASM and BASIC are both valid programming languages. >Therefore they are equal.

Could someone please explain the logic in this, cause I'm just not seeing it. BASIC has its uses and ASM has its uses, but thats not to say that the two languages are completely equal. By your logic then, C++ = ASM = TIBASIC = Qbasic = Pascal = Fortron = etc. The lanuages are different.

Basically we saying that the basic = asm becasue [its] programs can be
*AS GOOD AS OR BETTER THAN* asm programs. Sure by your logic that can be, if the games are good enough or as entertaining then in that respect they are equal, thats all
Just dont be predjudice agaist basic, for the simple fault that it isnt as fast as asm.
Download basic games and see them for yourselves, some are crap, yes, and some arent, that is the same for ALL programming languages.

--
Arcades

WTF! Basic != ASM!
I only consider two languages CLOSE if some commands can be used in one language and another, like C++ is "close" to Java.
GWBasic = Basic, every one will agree.
ASM ?= Basic? I don't think that ONE line of code from a basic program will work in an ASM program.exec( is close, but not quite.
ASM is a very low-level language, and Basic is a very high-level language.
ASM does not require interpertation, and Basic does.
Basic != ASM, in almost every way.
saying that basic=asm is like saying that a nuclear submarine= a tricycle, because they are vehicles.

NO ONE from sicode has ever said the same commands work in both languages..

Exactly, the languages are NOT equal, and not just for that reason.

I would like to see a fast version of SMQ in basic, with 4 levels of grey, and fast scrolling.

The languages are in NO way equal.

Your seeing this WAY too litetally. They are both TI-calculator programming languages, each has its faults and its strengths, both have good games, both have bad games. So they are equal in that respect, and i agree are no way equal in the physical sence. (the commands are not interchangable).

they are similar, not equal. in general, most ASM games are better than Basic games, at least better games have been made for ASM than is possible for Basic (ex. SMQ-no good Basic equivelent POSSIBLE)

BASICA and C++ are both valid programming languages. They are by no stretch of the imagination equal. Same with Java/C/assembler in any form. A filet mignon and haggas are both foods, and they are certainly not equal. I'm sorry - no.

Levine

Hear, hear.

Levine

Despite the fact that TI put so many safeguards on BASIC (that's part of why it's so slow). Try running this program on an 86:

:" "->A
:Lbl A
:A+A->A
:Goto A

Once it gets to 64kb it will "crash" your calculator. Oops. This may be fixed in future ROM versions, I'm not sure. That brings up another major point. When you write in BASIC, you're relying on the assembly-coding skills of the TI staff, and if they made even a slight mistake your BASIC program _can_ crash. (I stand behind the premise that something reasonably complex _does_ have bugs).

that doesn't work on my 86. All it does is give me a memory error. maybe rom 1.6 fixed that?

Here's a few bugs:

On a TI83, create this program:
:"
:expr(ans

And it WILL crash on rom 1.07 or less. It even crashes most TI83+'s. (RAM cleared)

Also, there's also always that matrix thing:
[[2,2][2,2]]\->\[A]
[A]/2
{1,1}\->\dim([A]
After typing this on an 83, hit Y= to make it blow up.

Also, Uncle Worm (TI83) crashes when split screen is turned on.

I just tested this on ROM 1.6 (in VTI, not the calc, though it should be the same). From the homescreen:

" "->A:Lbl l:A+A->A:Goto l

This will cause the calculator to hang with the run indicator running. It works on all TI-86 ROM versions that I have tested it on. Makes you wonder just what they change. I've never found anything different (besides memory locations and such).

You have a good point with that crashing your calculator, but think about it this way: only someone completely out of their mind would actually incorporate that into a BASIC program with the *knowledge* that it would crash their calculator. Infinite loops are a Bad Thing(TM) so it would seem somewhat sensible that you wouldn't use it. Even though you are proving your point - that BASIC's functionality is only limited by the code that it runs under - you have to keep in mind that for tasks of value (*g*), BASIC will work fine (despite the slowness, etc. etc. etc.).

--BlueCalx

PS: I'm writing this from toral's box at parrett.net and doing great in MI. I'll see you folks Sunday night. :-)

that doesn't work with my 86 (rom 1.6) :P

Are you sure? Did you run it from the homescreen? As I said above, I tested that exact code on ROM 1.6 and it does work.

yes, I ran from home screen, and when I ran it after awhile good ol "mem" error came up