🚀 go-pugleaf

The working name for this language is hereby Q.

Here's the start of a list of Q design goals, in no particular order.
If I'm going to put my foot down on anything, I'll start with these.
Follow up in this thread only to comment on design issues. If you want
to criticize on religious grounds, move to alt.religion.computers: we
want to design a language, not justify its existence.

Portability: It is easy to write Q programs that run on many different
platforms with few changes.

Efficiency: Q compiles naturally to efficient code. Q can do most of
what the computer can with a minimum of fuss. Efficiency takes back seat
to portability by default; only in a small and thoroughly considered set
of cases is portability sacrificed to efficiency.

Compilability: Q is easy to compile and optimize. There are various ways
(perhaps, e.g., assertions, antialiasing) for the programmer to both aid
coding and maintenance and to help the compiler.

Interoperability: If the OS supports it, Q can be linked with existing
code from similar languages, without any special effort. (This is very
important under UNIX.)

Readability: Any code can be written without much fuss in a form that
the average programmer can read. It takes at least a bit of effort to
write obfuscated code.

Flexibility: Q works for a wide variety of applications. (Ada's mistake
is achieving flexibility at the expense of simplicity, cleanliness,
efficiency, etc.)

Simplicity: Whenever two constructions are merely syntactic manglings of
each other, only the simpler one is part of the basic Q language, except
in particular well-discussed cases where both constructions are natural.
This implies a (smart) preprocessor. It's also the most important way in
which Ada fails.

Reliability: This includes a lot of different items.

Cleanliness: Q isn't just a compendium of hacks. It's a sensible,
straightforward language. Special cases are rare.

Scale: Q supports the features needed for large programs: some form of 
modules, logical and physical information hiding and data abstraction,
and so on. (One of C's major faults is that physical information hiding
is the only straightforward way to achieve logical information hiding.
``Straightforward'' basically means without defeating type checking.)

Extensibility: Compilers can add any kind of feature (new types, new
operations, new control sequences, whatever) to Q without kludging too
hard. (Kludging is a verb? Oh, well.) In other words, Q recognizes the
existence of extensions and provides standard ways to introduce them.

Implementation Quality: Q compilers must do more than just compiling.
For example, a compiler that provides extensions must have a way to turn
them off. The particular quality-of-implementation requirements or
suggestions aren't as important as the idea that they're part of a
language.

Likability: Q is easy to like.

---Dan