New Programming Language

So, /prog/

You are in charge of developing a new programming language. You are not the one who has to implement it, you just have to tell the codemonkies what you want.

Some things to think about:

- syntax style
- paradigm
- garbage collection or not
- vm or compiled
- type system
- special features of the compiler or language

- syntax style
C-like, or Python-like, or Lisp-like, or Assembly-like; whatever you prefer. Before a block of code you declare what style your code is written in; the implementation is distributed with tools that will automatically reformat code from any style to any style without, so you, your old school COBOL granddad and that perl hacker in Poland can all understand each other's modifications to a shared piece of code.
- paradigm
Bare bones: The base language should only have simple operations common to the vast majority of processors, like addition, multiplication (the implementation will handle the few cases where such an operation isn't available on the architecture), moving data between variables, binary operators and so on.
There will be standard libraries that extend functionality; however, there must be code that implements these special functions in terms of the base language (for code compatibility between architectures) that can be run to perform the same functions in addition to any specialized versions of the code that takes advantage of the host architecture's non-standard extra machine operations.
- garbage collection or not
I'm debating with myself how to go about it; I'm thinking that there should be three types of variables, "garbage collect when out of scope", "garbage collect when there are no more references to this variable" and "do not automatically garbage collect at all".
- vm or compiled
Implementations of compilers to all systems and all virtual machines would be nice; I'm
- type system
The fundamental character of a variable is byte-size; "foo, n bytes", for instance, declares that I want an n-byte variable. The implementation handles whether this is at the machine code level actually an array of bytes or a native system type. You can further put type checks in the variables, like "foo, n bytes, array of m byte elements, two's complement". (Preferably with better syntax.) This is used for both error checking (all type casts are explicit, by the way; none of C's auto-casting) and for choosing between functions with the same name but different arguments.
- special features of the compiler or language
Ultimately, I want something that is highly portable,