Re: Ada Quality and Style book discussion ("_Type" suffix)

[Maciej Sobczak <no.spam@no.spam.com>]

Brian May wrote:

>     Marc> (http://www.joelonsoftware.com/articles/wrong.html).
> 
> Looks like a good article.

I agree, but there is some bias in it, see below.

> 
> In a strongly typed language, I would prefer to use different types,
> so the compiler does the checking.

I fully agree. Making wrong code *look* wrong is a good idea, but it is 
only half of the solution. Complete solution is making wrong code *fail 
to validate* in the automated way (compilation belongs to this).

> However, if you have to use a language that isn't strongly typed, good
> Hungarian notation looks like a good compromise.

Fully agreed. The problem with this article is that it does not name the 
languages to which it mostly applies and instead makes an impression 
that it applies to every language. Certainly Hungarian notation (in its 
original sense) is a good compromise in C, PHP, Perl and other languages 
where you cannot express separate domains with separate types.
But I consider it to be useless for languages that provide the way to 
separate domains of interest by defining separate types, possibly with 
dedicated functions as the only gateways for conversions between those 
domains. Ada is such a language. C++ is also such a language and the 
problem with this article is that it might suggest the opposite to those 
who don't know it.

> With respect to his complaint on exception handling - I like the Java
> model where every exception that can be raised by a function has to be
> declared [...]

Except that the exception is not necessarily a contract between the 
direct caller and that function. Consider the sorting procedure, which 
accepts, as a parameter, a comparator which might throw some exception:

Caller -- catches/handles exception

    -> Sorting_Function(array, comparator)

          -> comparator.Compare(...) -- throws/raises exception

The type of this exception is actually a contract between the caller of 
sorting function and the comparator. The sorting function itself should 
be completely transparent w.r.t. exception that is thrown/raised by 
comparator and catched/handled by the caller. Java got it wrong.

 > Nor does Ada have a
> "finally" clause.

Ada doesn't need it (nor C++).
Finalizers + object lifetime controlled by scope is a superior tool.


-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/