Re: fyi, very interesting Ada paper OOP vs. Readability

["Randy Brukardt" <randy@rrsoftware.com>]

"Nasser M. Abbasi" <nma@12000.org> wrote in message 
news:jodq5f$j5f$1@speranza.aioe.org...
...
> There are always tradeoffs in language design. Ada's
> expressed design goal, of emphasizing ease of reading and
> understanding over ease of writing, means such tradeoffs
> should be decided in favor of ease of reading against ease
> of writing, This was clearly not done in the case of inheritance.
>
> The goals of inheritance and dispatching, and so of OOP,
> conflict with Ada's expressed design goals"

The problem with this conclusion, of course, is that inheritance in Ada long 
predates OOP in Ada (Ada derived types have always had inheritance, even in 
Ada 80). So clearly the most original of Ada's designers disagree with this 
conclusion.

I suspect the problem is that the contention that inheritance reduces 
readability is contentious. It's in the same category as use clauses and 
generic instantiation, both of which are original Ada 83 features that make 
declarations appear without appearing in the source code. You can make an 
argument that all of these things harm readability, but it is obvious that 
they all were considered important enough for the usability of the language 
to go in anyway.

I can imagine a language that offered none of these things (inheritance, use 
clauses, generic instantiation), but it's unclear that the result would be 
particularly usable, and whether the extra declarations needed really would 
help readability. (There is an argument that brevity also helps readability, 
after all, and a language with more text is not necessarily more readable.)

I tend to lean toward the explicit side of the fence (I try to avoid use 
clauses because of the maintenance headaches that they cause), but I do know 
that code can be too explicit. People hate it when I write:

          if Ada.Strings.Unbounded."="(My_String, 
Ada.Strings.Unbounded.To_Unbounded_String ("open") then ...

because I refuse to use use clauses in almost all instances. I surely can 
see why they might not find the above as readable as:
         if My_String = "open" then ...

                                      Randy.