Languages of Computers

Assembly Language

Basic Language

Basic as discussed for Linux by Rick Beauchamp All Tech Development 2009

Gone are the days of traditional Basic where an interpreter was used to run tokenized code with limited potentials in software design. While Basic stands for (Beginer All-purpose Symbolic Instruction Code), today it has a much higher meaning in RAD (rapid Application development). Over the years, There has been a marked and definitive progression to making the language more versatile.
1980 Feb BASIC or PC Basic was the first Basic for DOS PC's.
1980 Jun BASIC PLUS came out as the first Compiled BASIC for DOS PC's
1981 may GWBasic came onto the market as a Free Basic Interpreter for DOS PC's
198? ? Quick Basic offered a more robust platform for coding
1985 ? Microsoft releases Visual Basic for DOS it's the first GUI
style of basic to reach the general public.

Visual Basic by Microsoft
Over the years, Visual Basic has gone through many transitions that allowed it to create CLI programs (DOS), GUI programs for Windows desktops, Plug-ins for web apps, and more.
   Visual Basic is an integrated development environment designed form RAD. This IDE is available for only the Microsoft platform. Just as in Visual Basic for DOS, the windows versions consist of forms designer with drag and drop funtionality, a coding editor, and a runtime environment for testing. All Visual Basic programs in corporate event driven programming models and compile through a built-in compiler. However, where earlier Visual Basic programs compiled directly into machine code, newer Visual Basic apps compile into a type of tokenized runtime code which call library routines to perform their functions.
   Each project consists of one or more forms files, one or more module files, and may also require Plug-in files. Projects are stored in their own independant folders.

Multi-Platform RAD
   In the grand scheme of things, application development needs to be able too function in multiple Platforms. That is the code created for running under Microsoft Windows must be able to be compiled with little or perferably no changes on both the MAC OS-X and Linux enviroments. With MAC OS-X taking on a UNIX framework the overall task has just become simplified. We now only need to work with two platforms.

Entering a New Era

xBasic 6.2.3 by Matt Reason / Eddie P.
   xBasic is an integrated development environment designed for RAD (Rapid Application Development). This IDE is available for both the Linux and Windows platforms. There are 2 differing program sources. One is for use under Windows, the other is for use in Linux.
   Applications written in one environment are directly portable for use under the other with almost no need for recoding. xbasic applications are directly compiled into an efficient runable program which only requires the runtime library.
   *Windows - programs designed under this environment will compile       and run on any Microsoft based product except       Windows 7. The IDE itself works on Windows 98/2000/XP/Vista32. The IDE will not run properly under Vista64. The forms
       designer portion of the program works under Windows 98/2000/XP but will fail under Vista32 or Vista64.
   *Linux - programs designed under this environment will compile and run on any Linux distro. The IDE itself does not run
    perfectly when using KDE 4.1 and in fact, the forms designer crashes if using this version of KDE. Everything works fine with
   KDE 3.5 and below or KDE 4.3 .

      The xbasic program should be installed to /usr/xb6.2.3 and a link must be in /usr/bin/xb ->/usr/xb6.2.3/xb
Projects : Projects should be created under /home/*user*/xbprojects. Each project consists of a single file [programname].x and contains the following sections:

    Prolog ... defines included libraries, function declarations, and global constants.
    Entry() ... where the program starts where event loop code is.
    CreateWindows() ... autogenerated code for creating forms of the project
    initGUI() ... system generated initialization code
    initprogram() ... user created code needed to be done before windows are created.
    initwindows() ... user created code needed to be done after windows are created
    [windowname]() ... code used to create a form in the project
    [windownameCode]() ... event code to use for the form

It is Important to note that xBasic as compiled becomes and assembly langauge program that can be linked with other programs. It can also be compiled as a library to further enhance xBasic or other xBasic developed software.
   Below, we will follow along the process of porting an xBasic program created in Windows-xBasic over to Linux. As a first step of the process, you need an xBasic program to port. Therefore we chose Smart Maps (An application created for the Home food delivery industry) Our Application allows addresses throughout a city to be instantly checked to see if they are valid addresses. In addition, the app allows dispatchers to guide newer drivers with precise turn by turn directions with an on-screen map. Ok, so here we go...
We have moved our app to our openSUSE Linux system and started xBasic. 1) We load the smap.x file with the load command.
   2)Next we open the fastmap() code view (which is the name of one of the forms in the project). 3) With this formcode open we select the form design button which opens the toolkit. 4) We choose get form from the menu on the toolbox.

We don't need to make any changes here but if we did, we could delete existing objects or widgets if you like the term. We can also reposition, or change the appearance of any object simply by double clicking on it to bring up the properties window. Ok, we exit the form designer, which allows us to save or update the event handler for our form at the same time as it updates the form code function.

Now that we have exited the form designer we are in the event handler for the form.
Each object we defined on our form is known as a kid of the form.
xBasic, creates a kid based 'Select Case' code to include the kids. It is your task to define the events to occur when an operator reacts with the objects. This step may and regularly does involve calling other functions from with-in the event handler. You can call '.c' '.asm' or library external functions or any internal functions you have created.
As we work on the event handler, it is common to switch to coding view to add new code modules as you discover the need for them. Typically, you trap values in the event handler and pass them as variables to code functions but you can also assign them to local shared or global variables.
Again we don't need to change our project so we will just move on to test run it.
We are in the home stretch! Our program starts and tests out perfectly. Maps display, addresses confirm and we are ready to compile a Linux version right from our IDE. One more Linux app hits the openSUSE environment. Problem is how to make it distributable.
I do have a caveat. I asked for Pensylvania Ave S and took the snapshot with ksnapshot and yep it took the snapshot faster than the system could switch map views. As a result, the system still 100 blk of Abalone Pl NE still circled with green circle.

gambas2 is an integrated development environment designed for RAD (Rapid Application Development). This IDE is available only for the Linux platform. gambas applications are not directly compiled into an efficient runable program but instead produce a type of tokenized execution file which must have the gambas runtime interpreter.
gambas has an extensive system of plugins which enhance the base program with an unparalleled set of features.
Projects : Projects should be created under /home/*user*/[gambasprojects] Each project must be in it's own folder and will consist of 1 to x files. Each form will consist of [formname.form],[formname.class] and each module will consist of [module].class and each class file will consist of [code].class. Other files used in the program will also be contained here.
Unlike xbasic, gambas handles multiple modules to define a project. Where xbasic can directly access objects contained on other forms, gambas must pass references to a module routine which then passes the information to the intended form.

The Gambas system is similar to xBasic in some senses but quite different in others. First off you will notice that the GUI designer has a project list on the left, the properties dialog on right, and a toolbar for designing the form above the forms window. The shown portion of this project is for a multi-document examination program I was building. The purpose of the project is to facilitate examining a series of set-up files to locate errors so you know which files need to be corrected. You might ask why this program is needed. In short, when I tried to establish wifi networking Yast would just enter a continuous loop because of a setting error in one of the files. So I created the program to load up to 7 files at a time so I could examine them without having to open multiple editors and search for relevant file. Though I had not finished the program, it located multiple files with bad IPv6 entries which corrected the problem.
Ok so here we have the Gambas form that was created.In the top listbox are the different definable settings. The Add and Remove buttons allow the user to adjust the preset ones to include or exclude different settings. The next listbox contains all pertinent files associated with the set-up. Again there is an Add and remove button for changing the list. The Last listbox has a list of pertinent commands associated with the set-up such as lsusb. Clicking on a file loads that file into the next available tab object. So you simply need to load up the tabs and switch between them.
In Gambas, all event code is in it's own event function just like Visual Basic from Microsoft. A project can have multiple form files and multiple form.class files containing the forms code and multiple module.code files for the underlying support routines. From our previous xBasic example, it had multiple forms, multiple forms code (events for each form) and the underlying support routines all in a single .x file for the project.
In xBasic, you can directly pass values from one formcode to another directly, but in Gambas, you must use routines in a module.code file to do this job as each formcode module is independant.

C/C++ Language

xForms C/C++ GUI Language
XForms Version 1.0.92
This is the Free Software distribution of the XForms Library, a graphical user interface toolkit for X Window Systems. It should work under X11 R4, R5 & R6. XForms is free software. It is licensed under the GNU LGPL (Lesser General Public License) version 2.1. See the file COPYING.LIB for the gory details.
Getting XForms --------------
The XForms homepage is accessible at The sources can be downloaded from the project page at Compiling XForms ----------------
You should be able to compile XForms on any 'reasonable' flavour of Unix or Linux. XForms relies on several other libraries, namely * libXpm, version 4.7 or newer. * libjpeg, 6.0b or newer. * libGL (optional) You will find generic installation instructions common to all autoconf-based packages in the file INSTALL. In general, all it takes to compile and install XForms is ./configure make make install

I had no problem installing xForms on my openSUSE 11.1 system however, when I try to run it, it errors with not found. trying to install this library responds with missing XFree86-libs installation failed. I did find the source for XFree86-libs, downloaded them but can't seem to compile and install.
I know from previous experience with Mandrake 9.1 and xForms, it is a robust development system close to xBasic except it produces c++ code instead of assembler code. As for features, they are unparalleled in that you can create transparent windows, irregular shaped windows and objects and create both single file and multi-file projects so it matches a combination of Gambas 2 and xBasic all in one. Until I can get fdesign (the GUI designer) running I can't showcase this powerful development system.

Visual Language

.NET Language