Artwork by Don

HotBasic™ is a new basic compiler with CONSOLE, CGI, GUI, DLL and OBJ application types. Introducing 21st Century coding standards for Windows and Linux, HotBasic delivers best executables to software writers.
Table 1 compares compilers for Windows GUI applications with a GUI-aware instruction set, listing all compilers in any language that produce "small footprint", stand-alone executables without "bloat-ware" run-time libraries in an external .dll or packed in the .exe file:

Table 1
Premium Brand Compilers
1) HotBasic
2) [Editor's note: There are no other entries.]

Non-GUI-aware programs rely only on API calls, shown in this demo.
Software writers review HotBasic on this page.
Does any C language compiler have premium quality? Please consider this.
If you know of other compilers that qualify or over the last two years have begun to follow the HotBasic lead, please advise. Thank you.
Deliver to software developers the best executables for efficient and secure computing.

Buffer overflows? HotBasic will not allow them. Buffer size will just be increased. And this applies to SOCKET data transfers as well. Internet programs can be more secure with HotBasic.

Simply, you cannot write a statement in HotBasic that could cause a buffer overflow and associated security risks. Why? Data blocks are never copied until the required space is verified and allocated as necessary. [Note: Advanced programmers are on their own with MEMCPY and MEMSET.]

Connecting the dots, reported buffer-overflow bugs most often arise when an application program has asked the OS to do something. Obviously, secure software should avoid asking the OS to do things.

Best executables utilize the minimum of system resources and services. For STRING, ARRAY and LIST objects, HotBasic uses its own library procedures rather than calls to system services. Call it the "If you want it done right, do it yourself" philosophy. Not only is this more secure, it is more efficient, enhancing speed.

This slim-trim-isolated profile may generally have favorable security implications. By the code written, the user knows exactly which system functions are invoked. This degree of isolation of software development from system services may give the user more control and may avoid inadvertant incorporation into user programs of bugs or vulnerabilities in system services.

The Windows OS can provide a wide spectrum of useful services. The HotBasic design principle is to use them when necessary, but to take care of its own business as much as possible. This is the "Give me my time slice and I can do my own work, thank you" guideline, which is believed to enhance both security and efficiency.

HotBasic development software consists of stand-alone components which do not alter the system Registry or require information from it.

The Exclusive HotBasic FPU object technology provides the theoretical maximum for optimization of compiled machine opcode sequences for the FPU hardware. HotBasic users can do calculations as efficiently as if the math routines were written in assembler.
The FPU object clearly puts HotBasic in a class by itself. Thus, HotBasic would be the compiler of choice for software developers in science (physics, statistics, matrix algebra, etc), gaming, simulation and business -- wherever calculation-intensive work is done. When your clients ask if HotBasic technology is used in your applications, be sure the answer is "Yes".
War games, anyone? While the opponent is still calculating, your clients will be done and making their move.

REAL10 data type stores the full 10 bytes of floating numbers, as used by the FPU unit.

ARRAY setup includes a vector of products to speed up item localization. Also, MEMORY statements can be applied to ARRAYs for increased speed in reading/writing sequential ARRAY values. E.g., x=A(i,j,k) or A(i,j,k)=x leave the .Position property of the ARRAY pointing to the next value. Hence, y=A.ReadNum(4) reads and A.Write(y) writes the next value without offset calculation used by A(i,j,k).

HotBasic autodetects zero-based ARRAYs, on a per-dimensioned-array basis, so added speed is obtained with the ARRAYs that are zero-based.

Dimensioned ARRAYs, STRINGs, LISTs and MEMORYs are objects. Some implications: String functions listed above can be used on ARRAYs, LISTs or MEMORYs. A STRING can be used as a LIST. An ARRAY, LIST or STRING can be manipulated with MEMORY properties and methods, including .Position and .Length. "Dim s$ As STRING" and "Dim s$ As MEMORY" result in identical actions.

HotBasic executables exhibit very low stack usage, providing more stack space for other modules or procedures. Some other compilers may be less efficient, storing large data structures on the stack.

Best executables are obtained only when the compiler is written for the library and the library is written for the compiler. Library writers usually target "all people" so library functions are written to serve all needs of all people. This is understandable because the writers legitimately want many people to use their libraries.
Such libraries are next to useless for a compiler. A compiler needs a library which serves only the needs of the compiled application. This coordination of compiler coding procedures and library code produces "best executables" for HotBasic applications.

For source code to become a best executable, known facts cannot be ignored. The compiler already knows where arguments are -- CPU registers, the FPU, RAM locations in the executable, etc. There is seldom any need to pass stack arguments to library functions, because the library was prepared specifically for the compiler.

Thus, HotBasic executables flow seamlessly from compiler-generated code to its library routines.

HotBasic uses a linker utility so that only what you write in your source code is compiled (and linked) and then uses your RAM resources. These details are all handled automatically by the compiler and do not require any specific user actions.

HotBasic design also offers the important efficiency factor of substantially reduced development and debugging time.

Usage is simple: "hot test" compiles test.bas to test.exe and "test" runs it.
Detailed error messages show source file ($INCLUDE may be used), source code line, position in line and explanatory text.

If a compiler fails to produce best executables, software developer effort to write efficient and secure code may be quickly defeated. From conception, HotBasic is well-built and highly desirable.

Copyright © 2003-2013 James J Keene PhD
HotBasic™ is a trademark of James J Keene
Original Publication: May 29, 2003

Back to HotBasic Home Page.

Miss Compiler 2005