Basic+

[Rebma Boss]

I've seen several languages that have been written to make ASM programming easier. I've seen C to TI-ASM, TI-Basic to TI-ASM...I've also seen NEW languages invented.

I'm not trying to put these programs done, but what happened to Microsoft QuickBasic? For three reasons, it seems that QuickBasic should be the best choice for conversion:

1. QuickBasic, in my opinion, is the easiest programming language to learn--even easier than Visual Basic and regular Basic.
2. There are few, if any, programming languages that are as similar to TI-ASM as QuickBasic--if you know what you are doing.
3. QuickBasic is the easiest language to debug!! QuickBasic debugging is MUCH easier and quicker than C debugging, TI-Basic debugging, and even ASM debugging. A program for TI-ASM could be written in QuickBasic, DEBUGGED in QuickBasic, and then converted to TI-ASM, which, as we all know, can cause some nasty headaches.

So, instead of wondering why nobody else is doing this, I'm working on it. The project is called B+. (It's not a code name.) It will be available for free, including the source code.

Here's what will happen:

1. The user loads some predefined TI-83+ or TI-84+ rules into QuickBasic.
2. The user types a program for their calculator using the QuickBasic language, which is VERY EASY to learn.
3. The user debugs the program in QuickBasic. Because of the predefined rules loaded, the debugging program will look exactly like a TI-ASM program...the only issue is speed, it may run too fast.
4. When the user has fixed all the bugs, he/she runs B+ to convert the QuickBasic program into TI-ASM code. No debugging is necessary!
5. The user compiles the TI-ASM code into a TI Application. The program should run as fast as (or a tiensy-wiensy bit slower than) a pure TI-ASM program.

When I am all finished with B+, I also plan to work on B+ 3D. I've noticed that raycasting can be hard to work with, and the graphics aren't as good. B+ 3D will allow easier programming with more realistic, without a cost of speed. The source code and everything needed to use B+ 3D will be available for free, and a world designer will be available for $10.

I will be posting my progress at least once a week if nothing happens. I would appreciate and will consider any hints, suggestions, questions, or comments on this project. Thanks!

[Harrierfalcon]

I honestly don't mean to shoot your project before it takes off, but here's what's happened to previous languages, and why they failed.

• Improper documentation of syntax, functions and commands
  
• Too odd syntax
  
• Improper documentation of usage.
  

And, nobody is going to pay for a calculator program. Honestly.

But a library for raycasting would be very cool .

Welcome to United-TI!

[Pseudoprogrammer]

I might buy a program that helped me finally do anything more powerful than BASIC without actually learning ASM

[Rebma Boss]

Good points, Harrierfalcon. I'm glad you asked about them.

"And, nobody is going to pay for a calculator program. Honestly."

The only thing that would cost would be the software that makes 3D worlds. The software to convert from QuickBasic to ASM is free, the libraries are free, etc.

"But a library for raycasting would be very cool"

Raycasting? I wonder if my posts are confusing. I mentioned that I would use a technique easier than raycasting and better looking than raycasting.

"I honestly don't mean to shoot your project before it takes off, but here's what's happened to previous languages, and why they failed.
Improper documentation of syntax, functions and commands
Too odd syntax
Improper documentation of usage."

Also good points. But consider this:

1. I'm not creating a new language. I'm simply creating software to convert the language into ASM. The language was created by Microsoft and is fault-free. Ask someone who uses QuickBasic (or QBasic for that matter).
2. The language is the easiest invented, there are no odd syntaxs.
3. As for documentation, people have commented on how through my documentation is.

I'm very sorry if my first post was confusing, but I can assure that when I thought of this project, I took all this into consideration.

[Harrierfalcon]

[CoBB]

[Rebma Boss]

"By the way, what prompted me to check out this topic is that I find the name B+ absolutely hilarious, as it is the Hungarian equivalent of a nice English phrase abbreviated as FU."

Boy, I'm glad you caught that, I did not know that. Any suggestions for a new name?

Until I can think of a new name, I'll refer to the project as Basic+.

"Good for you on the proper documentation, a lot of languages like this (SquirrelBox, TIPower Gold) have not been great successes because nobody knows how to use them, because documentation stinks.

Not to mention the useless ‘compilers’..."

Right. For those still in the dark, Basic+ is NOT a new language, nor is it a compiler. It is a translator. It translates Microsoft QuickBasic into TI-ASM.

Right now, here's what I'm at with documentation:

There are a lot of very good tutorials for Microsoft QuickBasic, which is the language that Basic+ will translate into ASM. So my documentation will provide a small amount of help on easy keywords, such as PRINT (The same as B_CALL PutS) and LINE (The line function). The harder ones, such as PUT (For graphics and sprites), I would describe in greater detail. I would also describe the interface of QuickBasic in great detail. Then of course, I'll provide plenty of information on how to use the translator Basic+ for when the user is ready to translate.

[Rebma Boss]

I decided to display these steps again to emphasize the fact that Basic+ is a translator. All programming is done in Microsoft QuickBasic. Debugging is also done in Microsoft QuickBasic--during debug mode, QuickBasic will act almost like a TI-83+ emulator.

So here are the steps:

1. The user loads some predefined TI-83+ or TI-84+ rules into Microsoft QuickBasic. (The predefined rules are provided with Basic+)

2. The user types a program for their calculator using the Microsoft QuickBasic language, which is VERY EASY to learn.

3. The user debugs the program in Microsoft QuickBasic. Because of the predefined rules loaded, the debugging program will look exactly like a TI-83+ ASM program.

4. When the user has fixed all the bugs, he/she runs Basic+ to convert the QuickBasic program into TI-ASM code. No debugging is necessary!

5. The user compiles the TI-ASM code into a TI Application using TASM, Zilog, or any other compiler. The program should run as fast as (or a tiensy-wiensy bit slower than) a pure TI-ASM program.

By the way, Microsoft QuickBasic is free. Just google it. (It's a DOS program.)

[Pseudoprogrammer]

What language is Basic+ written in?

[Rebma Boss]

Basic+ is being written in Visual Basic 6. I may also create a Visual Basic .NET version for Vista Users because of compatibility issues.

I have to write some libraries to make Microsoft QuickBasic function like a TI-83+ during debugging mode. These libraries, which will be included with Basic+, will be written in--Microsoft QuickBasic!!

[DarkerLine]

So you're basically planning to write your own emulator for this? Forgive me if I'm a bit skeptical.

[Rebma Boss]

I don't think you are being skeptical at all. But I'm not quite writing an emulator. Instead, I'm turning Microsoft QuickBasic into a better emulator.

Microsoft QuickBasic and TI-ASM are very, very similar. So I figure, if I write about five pages of code, I can make QuickBasic ACT like a calculator. It's just QuickBasic code that allows any program written in QuickBasic to act like a calculator program.

A few examples:

1. Programs written in QuickBasic run on full screen. I'm writing code to make sure that the program doesn't extend outside the 63x95 window.
2. I'm forcing QuickBasic to use black-and-white graphics. If a user tries to use colors, an error will be produced.
3. There is no QuickBasic command that creates a byte--integers are the minimum. I'm creating a byte variable.

Why the fuss? As I states previously, QuickBasic is MUCH easier than TI-ASM. If it takes you six months to learn TI-ASM and another year to master it, it takes only about two months to learn and master QuickBasic. If that's the case, it's logical that it's easier to find and correct errors in QuickBasic than it is in ASM, right?

So when a user types QuickBasic code to be translated into ASM code, I figure that first, the user can debug in QuickBasic and have the output come out exactly as it would on a TI calculator. That way, all errors can be fixed in about half the time, and the translation should come out with no errors, ready to compile and send to the calculator.

So anyways, I'm not writting an emulator, but rather adjusting one.

[magicdanw]

I'd like to know, have you actually programmed in z80 assembly code? Because, I've programmed in both QuickBasic and z80 asm, and I find no similarities between them. In fact, QuickBasic is closer to TI-Basic than it is to any form of assembly code.

I don't mean to sound rude, but I'm not sure this is a logical language to be writing. But, if you want to anyway, then I wish you the best of luck, and I hope you come up with something useful and interesting to share with the community.

[Rebma Boss]

I've programmed in Z80 code, yes.

It's very hard to explain what I mean by "similar." Of course I don't mean that the languages are similar when it comes to key words, commands, etc.

The closest way I can explain this similarity is that whatever you can do with TI-ASM, you can do with QuickBasic, with few exceptions. You can draw sprites using AND/OR/XOR in QuickBasic, you can play music in QuickBasic (Hey, calculators can play music!), and you can draw in small text in QuickBasic.

Visual Basic has too many things you are required/recommended to have in a program, such as forms and controls. C++ requires libraries. Java is usually fr web-programming. Let's not get into C#.

Of course, there are other languages where anything you can do with TI-ASM you can do with them. But QuickBasic, in my opinion, is the easiest.

[WikiGuru]

Just because a language can do similar things does not render it similar. i don't know much about qbasic, but if it's 'similar' to visual basic, which is 'similar' to c, it's syntax is structured very differently from z80. This leaves the problem of having extremely inefficient code that might or might not work, and doesn't leave a path for users to easily change over to z80. This is the main problem (among others) of why c->z80 doesn't work, because in theory c is also 'similar' to z80

[Rebma Boss]

That's true. Like I said, I don't know how to describe what I mean by similar--it's a similarity that can be found only from really, really studying the languages. Aside from about 8 other programming languages, I've worked with QuickBasic for six years, and TI-ASM for about five years.

Basic+ is not meant to provide an easy transition to ASM--it's just a translator, and not a language in itself. It's meant for people who have trouble learning ASM and yet want to write ASM-quality programs.

What I can say is, you may have to just trust me--just for right now. I plan on showing my progress, and you can see if I know what I'm doing or not.

PLEASE DO NOT LET THIS KEEP YOU FROM COMMENTING. I appreciate everybody's honesty and arguments. "I would appreciate and will consider any hints, suggestions, questions, or comments on this project."

[WikiGuru]

Personally, for me the most helpful way to learn z80 was to have pseudo-code. I found an example in a language I knew (C, TI-BASIC), and tried to emulate that in z80. I would then go back over my code and optimize. I probably have about 20-30 projects where I did this, and I've kept some of them (some where inevitably lost) so if I ever needed a quick "routine" to do something, I had it. The problem with this is that it doesn't teach z80, and is also semi-inefficient when you get to a certain pint, but does help because unless z80 is your strongest knowledge-wise programming language (doubt it, especially if you know TI-BASIC), it's always easier to visualize syntax in higher-level languages. I'd be interested in how you link this language to z80, and how you do it

[Rebma Boss]

"I'd be interested in how you link this language to z80, and how you do it"

I'm kind of confused--are you interested in knowing how I transition QuickBasic to z80, or are you interested in knowing why I think QuickBasic and z80 go well together?

"Personally, for me the most helpful way to learn z80 was to have pseudo-code. I found an example in a language I knew (C, TI-BASIC), and tried to emulate that in z80. I would then go back over my code and optimize. I probably have about 20-30 projects where I did this, and I've kept some of them (some where inevitably lost) so if I ever needed a quick "routine" to do something, I had it. The problem with this is that it doesn't teach z80, and is also semi-inefficient when you get to a certain pint, but does help because unless z80 is your strongest knowledge-wise programming language (doubt it, especially if you know TI-BASIC), it's always easier to visualize syntax in higher-level languages."

I couldn't agree more! I did not do this with z80, but it helped me understand languages such as C++ and Java.

Progress so far: The way I'm handling translations is just for right now, I'm sorting lines into two groups. (My code is flexible enough to allow more groups if needed, but I'm worrying about one thing at a time.) One group will contain lines with "=" and the other lines will be in another group. For those of you who know QuickBasic, the colons (":") will come later on.

[cjgone]

I think he means like:

[tr1p1ea]

Interesting project, im sure many people will be happy if you can succedd.

I was wonder what data types you will support with this? Also what are your ideas on parsing in general?

You mentioned that you wanted to support some 3D stuff? Like actual 3D->2D projection or something else?

Also you could replace the jump on 'nz' with just a ret nz cj.