Initial commit -- cal-3040 from Osmosian.com

This version includes all of the core functionality
of the Win32 compiler / editor / finder
written by the Osmosian Order of Plain English Programmers,
as of March 5, 2014.  It also includes the lexicon
and the source code of the instructions.
It does not include the sample project (Cal Monet).

Version 3040 has the following features and limitations:
- It requires Win32 (such as Win XP, Win Vista, Win 7, or WINE).
- It is designed to be customized using Plain English programming.

The programming paradigm is "speak to a young child in plain English":
- Most statements are complete sentences.
- Mathematical notation is used as little as possible.
- Parentheses are rare; their main use is to distinguish
  procedures that share names and argument types.

Common impressions of the language include:
- It feels like COBOL.
- It is designed to be Lisp-like, but without the parentheses.
  Typical data structures are int32, strings, and doubly linked lists.
- The system is designed as a top-to-bottom immersive environment,
  and designed to encourage customization and hacking,
  similar to early 1980s Lisp Machines and Smalltalk machines.
- Object oriented programming is theoretically possible.
  Language features include mix-ins, flexible procedure naming,
  records, pointers, and vtables.  There are no namespaces,
  no object hierarchies, and no polymorphism.

The user interface is very rough:
- The user interface has two choices:  minimized or full screen.
  It uses Windows' restore mode, but at the full screen size.
  There are not features for changing the main windows size or location.
- It defaults to a custom font (included in the software).
  The font is fun, but harder to read than most text editors' fonts.
- The user interface includes alphabetical menus, not categorized menus.
- The menus' unused letters of the alphabet are not grayed out.
- It has a tabbed interface, but it does not hide unused tabs.
- Windows and buttons are either simple rectangles,
  or "roundy rectangles", without any up-versus-down shading.
- It does not distinguish between the Ctrl- and Alt- keys.
- It supports Ctrl-<letter> shortcut keys.
- It does not systematically support Alt- based accelerator keys.

The system is not modular:
- It requires a custom compiler (included in the software).
- The compiler is part of the executable.
- It has 23,000 lines of code (including white space), in just 6 files.
- Source code files are defined to be any text files
  (that do not have file extensions) in the compiler's folder.
- Within each file, most code blocks are sorted alphabetically
  (ignoring initial keywords).
- There are no namespaces.
- The system avoids using file extensions.
- The system does not use file type indicators inside files.
- There are no config files, nor any registry entries.
- The system's use of [] for in-line comments
  is not consistent with the JSON file format.

The system does not use the Windows common dialog box, so:
- The system uses a custom file finder.
- The system only uses the default printer.
- The user interface does not provide a way to change the font.

The system has very limited debugging tools:
- It is a compiled language.
- There is neither an interpreter nor a debugger.
- There is only one automated test:
- It checks for memory leaks at run-time.
- It does not have any tools for gathering automated tests.
- The standard types each have a DEBUG feature,
  allowing popping up their values at runtime.
- It has functions for buzzing and beeping, especially during debugging.
- It includes an extensive demo:
  the instructions for writing the sample project (Cal Monet).

Technical themes:
- Variable names are determined by their class names.
- Variables are declared implicitly, using indefinite articles.
- Subsequent uses of variables are done with definite articles.
- The most commonly used classes are strings and linked lists.
- It uses 32-bit signed integers as the basis for all calculations
  and numeric types.  The numeric types include booleans,
  32-bit integers, ratios, and mixed (improper) fractions.
- The classes are statically-typed structs called "records".
- It dynamically chooses mixed-in procedures based on the best fit
  between the caller's syntax and the procedures' declarations.

Memory management is a compromise between manual and automatic:
- Local variable strings and numbers are automatically cleaned up
  at the end of each procedure.
- Dynamically created structures (such as linked lists)
  need to be explicitly destroyed.
- At the end of each program run, the program reports
  the amount of leaked heap space.  This is meant to encourage
  debugging memory leaks promptly.

Code written by:  Gerry Rzeppa and Dan Rzeppa <help@osmosian.com>
This summary prepared by:  Jasper Paulsen <jasper@folds.net>