From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.5-pre1 (2020-06-20) on
	ip-172-31-74-118.ec2.internal
X-Spam-Level: 
X-Spam-Status: No, score=-0.0 required=3.0 tests=BAYES_20 autolearn=ham
	autolearn_force=no version=3.4.5-pre1
Date: 19 May 93 21:18:40 GMT
From: agate!howland.reston.ans.net!darwin.sura.net!haven.umd.edu!news.umbc.edu!
nobody@ucbvax.Berkeley.EDU  (Mike Berman)
Subject: Re: McCabe package for Ada?
Message-ID: <1te87gINNt5f@umbc7.umbc.edu>
List-Id: <comp.lang.ada>

On the topic of McCabe complexity, groleau@e7sa.crd.ge.com (Wes Groleau
X7574) writes:

>McCabe scores are not by themselves a very useful indication of Ada quality.
>However, they can be of some use.

>P.S. One thing McCabe doesn't show is what I call "hidden" complexity.
>Hidden, because it doesn't show on a flow chart or path graph.  This kind of
>complexity is produced by a technique more than one of my former colleagues
>was fond of:  That of declaring lots of "flag" variables, and using them to
>control branching at a point far away from where they were set.

While a high McCabe score usually indicates a problem area, a low score
does not necessarily indicate a lack of one. The tradeoff for high
complexity may be an increase in the number of modules, to no benefit
(and often detriment).

Consider the following degenerate case:

	case X is  -- assume X : Integer range 1..4
	when 1 => Do_Something;
	when 2 => Do_Something_Else;
	when 3 => Do_Something_Even_Different;
	when 4 => Do_Yet_A_Fourth_Thing;
	end case;

This statement would add 3 to the complexity of a module containing it.

It could be replaced with the following roughly equivalent code:

	procedure Check_1 is
	begin
	   if X=1 then -- yes, X globally visible for the sake of
	               -- example
	      Do_Something;
	   else
	      Check_2;
	   end if;
	end Check_1;

	procedure Check_2 is
	begin
	   if X=2 then
	      Do_Something_Else;
	   else
	      Check_3;
	   end if;
	end Check_2;

	procedure Check_3 is
	begin
	   if X=3 then
	      Do_Something_Even_Different;
	   else
	      Do_Yet_A_Fourth_Thing;
	   end if;
	end Check_3;

The above scheme results in no added complexity to the module containing
the original case statement, now replaced by a call to Check_1. Each
called module has complexity 2, cleverly eluding the McCabe complexity <
10 check.

The above example is not meant to be realistic, but I have seen cases in
actual code that sure do come close. 

The point of this post is to say that McCabe complexity analysis is
useful, but should be supplemented by a suite of tools to look at code
from other perspectives. The cyclomatic complexity measure, _by itself_,
tells you nothing (as Wes pointed out), especially if a development
community knows that it is the only metric being applied (then the above
transformation is done solely for the purposes of reducing the complexity
score).

-- 
Mike Berman
University of Maryland, Baltimore County	Fastrak Training, Inc.
berman@umbc.edu					(301)924-0050