type system hole

#1 05-14-2008, 06:26 PM

Did I understand correctly that Eiffel is not type safe because of the
argument covariance? This seems like a strange feature to have for a
language that markets itself as a correctness-oriented language. C#,
Java and MLs are type-safe and memory-safe and run at a speed
comparable to C , and one is supposed to pick Eiffel for mission-
critical code? Am I misunderstanding something here? Type- and memory-
safety is an important property for language to have, and either it
has it, or it doesn't (Fortran, C, C++ and, I think, Ada95 don't)

#2 05-15-2008, 02:10 AM

jhc0033@gmail.com wrote:
> C#,
> Java and MLs are type-safe and memory-safe and run at a speed
> comparable to C , and one is supposed to pick Eiffel for mission-
> critical code? Am I misunderstanding something here?

It so happens that you have to leave a language's type-safe subset
in order to have the program interact with hardware and call external
software, or to run within time bounds. It seem then that programs
that do something observable may well require type-unsafe parts.

When some type-unsafety is needed to meet the requirements,
a question then is, how does a language handle objects
of unsafe type?
Arguments about variance-related things should
take considerable space in the archives.

#3 05-15-2008, 05:03 AM

The ECMA specification requires covariant redefinition to redefine to
detached types so in order to call operations on them it'll need to
pass an object test and therefore will be type safe. This is new and
not yet implemented in all compilers.

Covariant redefinition is still under discussion but is safe with
ECMA.

On May 14, 5:26 pm, "jhc0...@gmail.com" <jhc0...@gmail.com> wrote:
> Did I understand correctly that Eiffel is not type safe because of the
> argument covariance? This seems like a strange feature to have for a
> language that markets itself as a correctness-oriented language. C#,
> Java and MLs are type-safe and memory-safe and run at a speed
> comparable to C , and one is supposed to pick Eiffel for mission-
> critical code? Am I misunderstanding something here? Type- and memory-
> safety is an important property for language to have, and either it
> has it, or it doesn't (Fortran, C, C++ and, I think, Ada95 don't)

#4 05-15-2008, 06:26 AM

<jhc0033@gmail.com> wrote in message
news:6014e129-f8fb-47f3-a75f-64be201c754a@a9g2000prl.googlegroups.com...
> Did I understand correctly that Eiffel is not type safe because of the
> argument covariance? This seems like a strange feature to have for a
> language that markets itself as a correctness-oriented language. C#,
> Java

Type safe containers, for example, in Java is not simply "yes".

and MLs are type-safe and memory-safe and run at a speed
> comparable to C , and one is supposed to pick Eiffel for mission-
> critical code?

Yes, if you take DbC into account.

Am I misunderstanding something here?

Yes, type safety vs. usability is today still a tradeof.

Type- and memory-
> safety is an important property for language to have, and either it
> has it, or it doesn't

Yes, if you do not need to take usefulness into account.

(Fortran, C, C++ and, I think, Ada95 don't)

#5 05-15-2008, 05:53 PM

>>>>> "jhc0033@gmail" == jhc0033@gmail com <jhc0033@gmail.com> writes:

jhc0033@gmail> Did I understand correctly that Eiffel is not type
jhc0033@gmail> safe because of the argument covariance? This seems
jhc0033@gmail> like a strange feature to have for a language that
jhc0033@gmail> markets itself as a correctness-oriented
jhc0033@gmail> language. C#, Java are type-safe and
jhc0033@gmail> memory-safe and run at a speed comparable to C ,

They most certainly are not.
--
Colin Adams
Preston Lancashire

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode