• inspired by Algol family languages, Modula, FPC
• build small simple modular programs
• build large modular programs
• objects when you need them - but not as a religion
• some resemblence to Ruby (poetic and precise) but
  • Qomp is not super complex
  • Qomp does not encourage a developer to do the same thing a thousand ways
  • Qomp implementation is not slow, it is as fast as FPC
  • Qomp is not influenced by Perl or Larry Wall. The "use" keyword is pure coincidence.
• algorithms and data structures minus spaghetti = programs
• nail down a prototype in a few seconds or minutes
• reuse millions of lines of existing code not written in Qomp
• performance without having to write extensions in Cee
• Qomp compiler compiles itself
• sound type checking
• stack or heap, no religious following of one
• code reads precisely and from left to right
• automated types (reference counted strings, dynamic arrays)
• no need to use pointers to chars, but can when you need to (interfacing to C libs)
• utf8, wide strings for unicode
• low level when we really need it (memory allocation, embed assembly, write an OS)
• no "everything is a" attitude
• discourages overly complex solutions
• vote for simple, but no simpler
• run on BSD, Linux, Windows, Mac OS X, and many more
• considering many innovations in the future: such as a truly relational add in or built in language via Codd, and The Third Manifesto specifications

  use 
    module1, module2, etc; 

  pro Intro; b Ln('Welcome to Qomp'); e;

  fun Life: byte; 
  c ALMOST = 41;
  b 
    res =. ALMOST + 1; 
  e;

  pro Notify; 
  b
    if life = 42 do Ln('Life answer: ', life);
  e;

  b
    Intro; 
    Notify;
  e.
  

Platforms?

When?

Who?

Implementations Available

Other implementations are of course possible. Qomp will not limit itself to a specific product implementation, although the first available compiler and literature will heavily define the direction of Qomp and Qomp standards.

Head Start