Re: Naming convention to identify functions with side effects

[Georg Bauhaus <see.reply.to@maps.futureapps.de>]

Dmitry A. Kazakov wrote:
> On Mon, 29 Sep 2008 11:55:49 -0700 (PDT), Adam Beneschan wrote:

>> Several times, I've heard people say (in similar cases) that the name
>> should be something like this:
>>
>>    function Web_Page_Is_Loaded (URL : String) return Boolean;
>>
>> so that it's grammatically correct when you put it in an IF statement:
>>
>>    if Web_Page_Is_Loaded ("http://www.irvine.com") then...
>>
>> This is WRONG, WRONG, WRONG!!!  It may make your IF statement look
>> more grammatically correct, but it OBSCURES what the program is
>> doing.  The above "grammatically correct" statement looks more like a
>> check to see if the page is already loaded; a programmer reading this
>> will not be able to figure out that the function call is the routine
>> that actually does the loading.  This is much better:
>>
>>    if Load_Web_Page ("http://www.irvine.com") then...
> 
> I don't like either.

Me neither.

While a style of "packed programming" might be expected in SETL
or APL, I can't imagine this sort of cleverness to be a preference
when using a deliberately verbose language such as Ada.

A more strict recommendation is perhaps worth noting, named the
Command-query separation (coined by Betrand Meyer). For primitive
functions  of some type T (called queries, like Is_Loaded), it
means the functions should not have abstract side effects.
"Abstract side effects" are side effects that can change the return
value of public functions of type T.  (Functions are the only
means to query the state of an object of type T.)

Some issues become more obvious in a concurrent setting
perhaps,

   Web_Page.Load ("http://www.irvine.com");

   if Web_Page.Is_Loaded then...

There needs to be a lock of some sort joining the two calls.
Otherwise, the Web_Page object might have changed
between the two calls, a logic error.
Again, it might be tempting to pack the two calls in just
one in order to hide the locking mechanism, to give the
illusion of atomicity. But shouldn't normal Ada
concurrency features be employed instead?

If concurrency features of Ada are used instead, the
naming problem is also gone:
the commands (procedures) can be verbs and the queries
(predicate functions) can be named "Is_Something" or
"Has_Something".