How to Write Software - Features of Ubercode
Solid Developer Environment helps you develop programs.
- Ubercode runs under all versions of Windows from 1995 onwards.
- All Ubercode Packages have everything you need to write industry standard EXE files.
- The Developer Environment runs well on a mid-range Pentium with an 800 by 600 pixel screen. It
has a clean interface and doesn't clutter your desktop with multiple toolbars and floating
- Ubercode makes it easy to add windows and menus to your programs.
- Ubercode applications avoid "DLL hell" and "Framework hell" because they have their own version
system. They avoid troublesome Windows DLLs such as the MFC DLLs.
- 'Single button' support to copy EXE files for running on other computers. You can copy the EXE
files and supporting files to floppy disks, local folders, network folders, and to zip files!
- Programs written in Ubercode are easy to distribute. You don't need special installation
programs that delete system DLLs, trash the registry, reboot three times and work inconsistently on
different computers. Ubercode applications can be installed just by copying the files over.
- The Developer Environment is extensible with full source code available.
Easy Reference Manual gives you information at your fingertips.
- Slim-line Learning to Program manual tells you everything you need to get started.
- Fast on-line help gives you information within seconds. You don't have to wait while your
browser dredges up information from disk.
- Context-sensitive help and Example programs are available for all language commands.
- Detailed on-line reference information is available if you need it.
- Printed Language Reference Manual (LRM) is available.
- Get to the source if you need to. All Ubercode customers have access to Technical Support which
has answers to all the questions and sample programs too.
High Level Language makes it easy to write code.
- Ubercode is a High Level Language. This means you spend your time writing your program,
not dealing with language trivia.
- The run time library has hundreds of useful commands. This is more code you don't have to write
- High level commands such as Loadfile and Savefile read and write text files,
binary files, dBase files, XML files and bitmaps.
- Msgbox, Inputbox and Listbox functions display dialogs with a single
- Windows common dialogs can be displayed with a single function call.
- Functions can return values of any type.
- Run-time structured expressions allow initialization of entire records and arrays with a single
- High level iterate statement loops through most structured types.
Seamless integration with other software tools.
- All Ubercode tools in the build chain (compiler, make utility) have a well-documented command
line interface. They can be invoked from external build scripts and 3rd party developer
- Ubercode programs use RC and DLG files for dialog definitions (form layouts). This makes it
possible for Ubercode to use dialogs from other programming environments.
- Ubercode programs can read and write from text files, CSV files, dbase files and XML files.
Data stored in these files can be read and written from most data types. This makes Ubercode highly
compatible with existing applications.
- Ubercode applications are portable to all versions of Windows (from 1995 onwards). Ubercode
development and deployment works identically under all versions of Windows.
- Ubercode programs and development tools are low impact, and work independently of the .NET
framework and MFC DLLs. The presence (or absence) of any optional Windows component has no effect
on Ubercode applications.
Strong Type System makes your code more reliable.
- Ubercode uses strong typing which means the compiler catches most logic errors when creating
the EXE file. It doesn't leave the errors in the EXE file for your customers.
- There are powerful data types such as resizable Arrays of any type, Lists of any
type and Tables which help you model real-world applications.
- Ubercode data types automatically allocate and free memory as required. There is no danger of
memory leaks, invalid pointers or corrupted structures. Also there are no pauses for garbage
collection which would slow down your program.
Object Oriented Programming makes it easy to reuse code.
- Ubercode programs have a simple modular structure which implements object oriented programs
(OOP) in a natural manner.
- Objects are allowed preconditions and postconditions that can be checked automatically.
- There is typesafe linkage across class boundaries which avoids all linker errors.
- The compiler keeps track of class dependencies and recompilation requirements without "make"
- Powerful objects are ready for use "out of the box", such as Property editors, Resource
editors, and more than 10 common dialogs.
Event Driven Windows make it easy to add code to windows.
- Ubercode code is based around an application's windows and written in an event driven
- Ubercode supports industry standard Windows RC (resource script) files. This allows reuse of
resource scripts from existing programs.
- Window definitions and code are stored in a closely related group of files, so you can't "lose"
code as is possible in other event driven models.
- Events are always fired when Windows is stable. For example you can call a Msgbox when
handling most events.
Error Proof Technology prevents most run time errors.
- Ubercode has GPF-resistant code. Array reference errors, invalid pointers, memory allocation
failures, illegal parameter values, overflow of variables, and similar errors, are handled by the
library and do not cause a GPF.
- Ubercode has two levels of error handling for safety. Your code gets first look at errors, then
all unhandled errors are dealt with by the Ubercode library.
- Ubercode has no dangerous language elements such as goto statements, implicit declarations and
- Preconditions and Postconditions provide extra levels of error checking.