These are some of the differences between CORBA and this object
model (this list is not meant to be exhaustive):

No preprocessor in the IDL.

No double-extended floating point type (most architectures don't
support it, and its main purpose is extra precision for temporary
calculations, where RPC is somewhat irrelevant).

No fixed point type, at least not as a basic type.  Perhaps as a
value type...

All characters are Unicode; if you need to pass characters or strings
in ISO Latin-1 and/or other character sets, use the octet type.

A string type exists, which holds characters in a UTF-8 encoding.

No "any" type (use objects that encapsulate basic types instead (or
maybe built-in value types?)).

No unions.

Sequences are not a special case; they are merely arrays whose
minimum and maximum lengths are not equal.

No multi-dimensional arrays.

No value types for now (though they look interesting).  At the
moment, I'm leaning towards implementing this as a binding between a
class and a struct. 

Instead of "oneway", there's "async".  The basic idea is the same,
except that async method invocations have the same execution
guarantees as normal methods (that is, it may never complete because
the remote machine is down, or the remote process is hung; however,
it will never be dropped due to things like packet loss).

There is no return type (only out parameters).  This may change.

No attributes (yet).

Structs can inherit from other structs, and this hierarchy can be
used for exceptions.  All structs inherit from the root Struct type.