Ultimate Language feature list

["MSG" <michael@pickles.org>]

I do all my development in C++.  Not necessarily because I want to, but
because I keep looking (and looking) for alternate languages/environments
and they ALWAYS come up short.  I've decided that the language/environment
for me hasn't been created, so I'm starting a list of features that I
like/require.  It's drawn from good languages (I don't consider C++ a "good"
language", neither is Java).  If anyone would care to contribute, please
feel free.  Who knows, maybe with enough interest we can create a
language/environment we REALLY like and that works easily on any platform,
allowing you to use a sophisticated  language and still access platform
specific features for truly fantastic and stable applications.

I hope a posting like this doesn't cause a flame war.  I'm just sharing my
feelings and hoping that some interest will spark -- to what end, I'm not
sure.

Michael Scott Garnett
michael@pickles.org

#1 Verbosity.  C++ and Java's cryptic syntax is cute and fun, but not
useful.  Our Language (OL -- come up with a good name) should be verbose
like Ada and Eiffel.  Semicolons optional like Eiffel (except where
ambiguous).
#2 Completely OO.  No free floating subroutines.  The only construct higher
than a CLASS is an Organizational Unit (like an Eiffel cluster).
#3 Object-Dot-Feature syntax.  No Ada95esque subprograms which take class
arguments (like C++ friend functions).  I am torn between Object-Dot-Feature
and Object SPACE feature syntax (like Smalltalk).
#4 Reference Objects as a default with the ability to expand an object or
class to full form (like Eiffel EXPANDED types)
#5 Garbage Collection.
#6 Construction and Finalization
#7 Predictable Finalization for stack-based objects (either reference or
expanded).  When the immediately enclosing scope terminates, the
finalization is called THEN. This is VERY important for reliable external
resource management (OK, C++ did this right).
#8 Polymorphism as the rule.  Let the compiler figure out which routines are
not overridden and use static calls where appropriate (a la Eiffel).
#9 Named arguments.  Either like Ada or like Smalltalk (object moveTo: here
usingPath: aPath).
#10 Array and record aggregates (like Ada).
#11 Multiple inheritance like Eiffel, NOT C++.
#12 STRONG typing and constraint/program checking in the compile and runtime
like Ada.  Options to remove such features in a "finalized" version is very
much necessary.
#13 Ada-style tasks.  Using Object-as-task, like the proposed Eiffel
extension "separate".  Ada's SELECT mechanism.  Protected types (like
Ada95), Java almost got this right.
#14 EASY access to other languages/calling conventions.  Any CLASS's
features my be effected by external other-language routines. The includes an
easy way to link to C++ libraries.  Such special classes can specify that
for "THIS" an other-language-notion be used. Such classes would lack
"variables", being limited to routines only.
#15 Generics.  Not templates.
#16 Intrinsic types (like Integer) as objects, but completely replaced in
generated code by native types (like Eiffel).
#17 Ada's float types (delta, digits).
#18 Range specifications (like Ada).  Checked at compile time and run time.
#19 Discriminated record/class types (like Ada).  Checked at compile time
and run time. (maybe not necessary with inheritance)
#20 An easy with to extend and re-expose/hide features of parents.  Like
Eiffel.
#21 Distributed computing.
#22 Pre- and post-conditions (from Eiffel).  Including support for the "old"
keyword.  The closest thing to Z (pronounced Zed - a formal method) that
I've seen.