How to Write Software using Ubercode


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 windows.
  • 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 yourself.
  • 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 call.
  • 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 command.
  • 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 environments.
  • 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" files.
  • 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 style.
  • 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 global variables.
  • Preconditions and Postconditions provide extra levels of error checking.