The InteractBASIC Project


Picture if you will a language so interactive that you create a function, class, library and bang it is part of your environment right then and there. Can you imagine that? I can, that part has existed for a while in other languages, such as Forth, Lisp, and Logo. Combine that with the ease of language that BASIC offers and you have InteractBASIC Let's face it, one of the founding blocks of BASIC is to be Interactive. So I decide to push that to the extreme.

I created InteractBASIC for that reason alone. Push the interactivity to the limits. Now the language will have the ability to be interactive of course. But that's not where the interactivity stops. The whole environment will be pushing that interactivity at every level as well. THis combined with the language together will bring a whole new level of interactivity. Along with the ability to create syntaxes on the fly, imagine you make a library of function, and they become part of the language. you add a translator to make calling your function easier and more interactive. I just know that there will be demand for it. I'm not even worried.

Fields Of Applications:

InteractBASIC has so many fields of applications that I couldn't possibly define them all. Every domain I can imagine can use this type of language interactivity. Here are a few examples of the thousands of examples, if not more, that can make use of InteractBASIC. Not just make use of, but are so meant to be built with InteractBASIC. Take these examples, and multiply the advantages of InteractBASIC in each of these fields, and ask yourself, in your respective fields, could your next programming project benefit from a language like InteractBASIC?

  • In the medical field:
    how would you like to have a self modifying program that could adjust it's way of thinking or any other part of itself based on sensor analysis, delays and reactions to medication, and so much more variables, parameters that can come into play. control these parameters live, as they come into play.

  • In the robotics/AI:
    Can you imagine what the point above could mean? What it would mean for a programming language to be self reliable, self modifiable? Self adjusting code that can create and adapt to the new or current reality.

  • In the field of astronomy:
    If a comet is caught early or if anything else, it could decide to play it's subroutines in accordance with the occurrence, and hence we would heighten the early warning system. Just because it decided to follow it's gut feeling. And that is just on scenario out of a million.

  • In the programming field:
    We could definitely benefit from a language that can adapt and become the industry it's used as. The possibilities are endless and so is InteractBASIC. it could be changed to a database environment, to internet gofer, to whatever else is needed or required to get the information we want.

  • In the field of music:
    Ever wanted to have an environment that can be as interactive as you? If you so choose it. InteractBASIC will allow you to say create a track object, a MIDI Interpreter, and have them both there live, so you can see if he MIDI Interpreter is right, if your track has all information needed, then you can mix that with an audio track, and see if all that makes sense too. you can't get this kind of interactivity in a normal compiler language.

This is just a small sample of the possibilities. Imagine for a minute a language that grows with the industry it is used for every function can be in the language, every library too, evething can just be as part of the environment, part of the language. How specialized can that be as far as an industry is concerned? How many uses could that represent. What industry can that not be applied in? The answer is none. It can be applied to anything, and you shall soon see, it will be.

How It Will Works

Basically there's two way it can work. At this point in time, I could go both ways. I do something of an interpreter and interpret the code to run it. which would mean that the code would be executed by the language it's interpreted by. Languages like Lisp and Logo and good examples of this techniqu ae. They're live, very interactive as a language, and they seem to offer quite a sophisticated set of instruction to allow to make them the languages that they are.

Another way is to have a live compiler always available. Forth is a great example of this technique. from what I see, the dictionaries would be a great add on. it can also make the whole system need to be distributed as part of an application project. And that too can have it's advantages. I'm a bit on the fence between the two techniques. They both offer some advantage over the other but it's the user who will have the last word I think.

In Conclusion:

I created this project because I can see the fields of applications a plenty. This isn't just another interactive language it is also a language aimed at being a BASIC dialect that is also very interactive. WHich means it will be easy to learn and quick to start building something because of all the basic founding principles. Those founding principle are:

  • Be easy for beginners to use.
  • Be a general-purpose programming language.
  • Allow advanced features to be added for experts (while keeping the language simple for beginners).
  • Be interactive.
  • Provide clear and friendly error messages.
  • Respond fast for small programs.
  • Not require an understanding of computer hardware.
  • Shield the user from the operating system.

You can always contact me with any comment, suggestion, or anything else. I can see how InteractBASIC can be right now, in my mind. I just need to bring it out into an intelligent language designed to offer the most interactive development project available.