as natural as possible
as smooth transition as practical from earlier versions
smooth interaction between code that uses types and those that don't
want to be able to evolve programs without breaking existing users' code
single program that works on a variety of environments and which adapts to each environment, e.g. to adapt to whether a particular library is present or not
to retain a lot of dynamism to be able to inspect objects/classes that haven't been seen before
want to support programming in the large - which makes static typing attractive
static versus strong typing - strong typing makes it practical to detect errors, static typing allows this to occur at compile time.
safety - if you declare something as private no one else can access it and nobody can replace your private method with one of theirs
abstraction - private is really private ie invisible outside the class or package
is this the same as C++? Does access equal visibility in C++ ?
Robustness - people generally don't write programs fully formed, and a good language makes it easy to evolve programs
e.g. adding a type annotation doesn't break the program, except in very rare cases (Waldemar) where the compiler should be able to alert you to
to change a member's visibility from private to protected etc.
all components of expressions should be 1st class values, so that you can split expressions into separate parts
Waldemar's example:
a = ((x+y)[z])(p, q, x).z;
which could be factored into
var f=(x+y)[z]; a = f(p, q, f).z
This kind of factoring should be possible. In C++ if f is given too general a type, the compiler will warn you that the second statement is in error.
All types for which knowledge of which might make a difference to the expression can be expressed in the type expressions of the language.
namespace independence
class C
{
field m;
}
// should be able to create another class with a field called M.
new style classes should be accessible by old-style code with out having to restructure the old code. It would be unacceptable to limit old code to accessing only ad hoc properties.
Achieving this compatibility shouldn't force you to give up the benefits of classes etc.