🚀 go-pugleaf

In article <387@smds.UUCP>, Brian Boutel writes:

In article <1917@optima.cs.arizona.edu>, gudeman@cs.arizona.edu (David
Gudeman) writes:
|> In article  <1991Apr15.065146.16680@tkou02.enet.dec.com> Norman
|> Diamond writes:
|> ]In article <4243.2805b94a@iccgcc.decnet.ab.com>
|> klimas@iccgcc.decnet.ab.com writes:
|> ]>	Some info that I picked up from a company doing a lot of big
|> ]>	project work with C++ (i.e. strong type checking language) was
|> ]>	that postmortems on their project revealed only 10% of their
|> ]>	errors were captured by strong type checking.
|> ]...
|> ]In any other field of engineering, a 10% increase in safety would
|> always
|> ]be applied.  To reject it would be grounds for lawsuits, at least.
|> 
|> How do you get a 10% increase in safety from the above?  If they
|> hadn't caught those errors by static typing they would have caught
|> them by testing -- the same way the found the other 90% of the
|> errors.

]The claim that testing catches all errors is laughable. Errors show up
]in production code every day. Testing, as we tell first year students,
]does not demonstrate the absence of errors, only their presence.

] So what can be said about all the errors in the quoted C++ project that
] where not caught by testing and are still in the production code?

] I'll tell you. They are not type errors.

  Not neccessarily:  

struct junk  { int  x;  float  f; };
struct other { int  y;  double d; };

main() 
{
  static struct junk  myJunk = {1, 1.1};
  struct junk  *p = &myJunk;

  printf("%d\n", ((struct other*)myJunk)->x);
}

  Looks like a type error that got by the compiler to me.  Note that statically
typed languages (such as C++) usually contain some mechanism (here, the cast)
so that the typing system enforced by the compiler may be circumvented.
Therefore, as shown above, type errors can still get by the compiler.

  In fact, in C++, considerable effort is expended (via manipulating the
inheritance tree, or casting derived classes to base classes, etc) to ensure 
that the compiler will accept a given expression as "type safe".  However,
the given expression may well violate the type system.  Errors such as this
are difficult to track down ...