Working with incompetent adaists / unsafe typing war story

[Anonymous Coward <anonymous@coward.org>]

I'd like to start with a war story:

<war story>

  Despite the lack of coding standard, Mr. Safety wrote a well
  constructed package that uses private types, then wrote some packages
  that use those types.  After these packages all reach a mature and
  refined (and tested) state, another developer (Mr. Sloppy) finds that
  they need to use Mr. Safety's package, which requires private types in
  the interface.  Mr. Sloppy refuses to work with private types.  It's
  the typical anti-strong typing mentality, where the developer refuses
  to accept anything that might limit their power.

  Mr. Safety was forced to introduce support for duplicate public
  versions of these types to accommodate Mr. Sloppy's skill limitations;
  which obviously produced a sloppy free-for-all in the work product.

  The understanding that most s/w developers seem to have is that they
  design their own interfaces for packages they create, and users of
  that ada spec only have a say in whether it meets standards and
  requirements.  I always bend to accommodate types that other
  developers require in their spec, because it's theirs.  Maybe I'm
  wrong about what I think is typical.  It was explained to me that
  interfaces are "shared" and are no more controlled by the author than
  the users of it.

</war story>

That story is just a sample of what I encounter too frequently in the
Ada workforce.  It seems a /majority/ of ada developers have no formal
Ada training, and are primarily C developers who picked up the Ada
syntax on the job.  Consequently, ada principles are lost, and much of
the ada code out there is only slightly safer than C code (but still
safer primarily because even a poor Ada developer cannot write
ambiguous code like they can in C).

I've only worked on four or so workplace ada projects.  The projects
with elaborate coding standards produced substantially better code,
but I think it was just chance that those projects also had Ada
enthusiasts who used private types, as the coding standard did nothing
to promote private typing.

Do you folks encounter this frequently?  And what's the solution?
Management can never appreciate the benefits of concepts like type
safety.  Strong typing is incorrectly viewed as "academic" and counter
to progress.