Qomp was originally written using FPC compiler as a base. All FPC code could be compiled and used in Qomp code. This made reusing existing modules from FPC simple and easy, rather than starting a language without any code and libraries to work with.

However, a Qomp based on Oberon compiler is also considered, because Oberon compilers are much much simpler and easier to maintain than the complex monster that is FPC. In fact FPC is just becoming the next C++ or Pascal++ with it's million compiler modes and complex features (featureitis?).

GoLang succeeded by starting a new language without too many libraries. QompOberon would be able to use all existing Oberon libraries, or most of them, and oberon code, while having a nicer (in our opinion) language to work with. For example many people are upset about bulky, ugly CAPS LOCK reserved words in Oberon, despite 1 or 2 people who defend them such as Samuel A Falvo.

How procedure looks in oberon:

  PROCEDURE LifeMeaning (s: STRING): INTEGER;
  VAR i, l: INTEGER;
  BEGIN i := 0; l := s.len;
    WHILE (i <= 42) DO INC(i); END;
    Console.WriteString("The answer is: ");
    Console.WriteInt(i);
    RETURN i
  END LengthN

How a procedure would look in QompOberon

  proc lifeMeaning(s: string): int;
  v i, l: int;
  b
    i =. 0;
	l =. s.len;
    while (i <= 42) do inc(i); e;
    out('The answer is: ' + itos(i));
    return i
  e

Qomp programmers find Oberon syntax ugly, but Oberon is a great language despite its ugly syntax and horrid CAPS LOCKS reserved words.

Disadvantage of using B and E as reserved words

In Qomp b and e are used to begin and end a code block. The only disadvantage of this is when writing math code or calculations where you multiple "a" by "b" you can not use the variable name "b", as b and e are already reserved. or a*b*c*d*e cannot be done because "e" is already a reserved word. However, since QompOberon is case sensitive, one can still use A*B*C in math equations or just avoid "a" and "b" as variable names, and use "x", "y", and "z" or similar.

All languages have compromises, and this seems like a minor issue. In fact in C or C++ the { curly braces } are taken from you so you cannot use them in math, as they are reserved. I.e. sets in math may use curly braces, or other math may use curly braces, and C limits you from using this, the same way QompOberon would take away your ability to use "b" and "e" as variable names.

People have literally been hospitalized for typing injuries and overuse of the fingers. Emacs users are an example of this (and it is not a joke). Oberon syntax is very cumbersome and tedious, heavy, and straining on the hands to type. The constant bickering about how code should be more verbose and readable, often forgets the fact that the programmer has to be able to write the code and enjoy doing it.

Those Ada type programmers who argue one should never complain about how verbose the code is because it makes it more readable, fall into the same trap as COBOL programmers, and we all know how the verbose COBOL experiment ended up. Virtually everyone hates and or does not use COBOL, and the programmers who do use it, are hiding somewhere scared of their own verbose obscurities, because you don't see many of them on the internet. Mathematics, is not a verbose COBOL like language or system at all, and neither should programming be, since programming is basically an advanced branch of mathematics.

Back to home page

The home page for Qomp will have more details soon.