Re: Software landmines (was: Why C++ is successful)

[Richard D Riehle <laoXhai@ix.netcom.com>]

Brian,

Silly indeed!  I do not appreciate your use of the pejorative "silly"
in response to my postingsince it seems to be a deliberate insult. I do
admit that my hastily composed example could have been coded with more
clarity. It did not occur to me that I would need to submit a perfect code
example to make such a simple point but, since martinets abound, I submit a
new, probably unnecessary, example.  In case you have missed my original
point in your zeal to criticize the code fragment, it is as follows: Ada is
designed to encourage use of the assignment statement if we also want our
code to be clear and readable.  This was in response to Robert's (correct)
assertion that programmers use assignment statements too liberally.     

I am appending your code example and mine in case some masochist wants to
read it.  I hope you understand that my example was not intended to
represent real code.  Perhaps the way I wrote the assignment statement
confused you regarding my intentions.  I concur that, if there is a simple
algorithm, it can be stated as part of the declaration.  In the kind of
function I had in mind, there could be multiple possible values for the
Result.  In this case, the choice is between,

       Example (1)
         function F1 (paramter-list) return Result-type is
             Result : Result-type := initial-value;
         begin
           if condition-1 then
              Result := result-1;
           elsif condition-2 then
              Result := result-2;
           else
              Result := result-3;
           end if;
           return Result;
         end F1;

    versus Example(2)

         function F2 (paramter-list) return Result-type is
         begin
           if condition-1 then
              return result-1;
           elsif condition-2 then
              return result-2;
           else
              return result-3;
           end if;
           return Result;
         end F2;

The two (simplified) functions epitomize the debate about a particular
coding style. Example(2) illustrates how functions avoid using an
extraneous assignment statement.  Some practitioners prefer Example(1).
I use both in my coding. It depends on the complexity of the function,
my audience (everyone on the project is an ex-Fortranner), along with
several helpings of intuition.  Over the years I have found that 
Example(1) has been less error-prone and easier for the average programmer
to maintain.  Your mileage may vary according your experience.

-- ==================== Original Postings ====================
-- What follows is my original message along with Mr. Orpin's 
-- rather impolite reply.  
-- ===========================================================


In article <35eca5d9.4354839@news.geccs.gecm.com>,
	abuse@borpin.demon.co.uk (Brian Orpin) wrote:

in response to the following code fragment submitted by me,

>On Mon, 24 Aug 1998 19:47:31 GMT, Richard D Riehle
><laoXhai@ix.netcom.com> wrote:
>
>> Don't take away my assignment statements, Robert.  The help me write
>> crisp, short code sentences that ordinary mortals can understand. In
>> fact, as an old time Fortranner, I sometimes write a function that
>> looks like,
>
>>       function F ( ... ) return some-data-type is
>>         Result : some-data-type := initial-value;
>>       begin
>>         Result := algorithmic-part;
>>         return Result;
>>       end F;
>
>Which of course is pretty silly <g>.  Result has a default value that is
>never used.  Could easily be written..
>
>function F ( ... ) return some-data-type is
>	Result : some-data-type := algorithmic-part;
>begin
>	return Result;
>end F;
>
>or even 
>
>function F ( ... ) return some-data-type is
>begin
>	return algorithmic-part;
>end F;
>
>YMMV