Re: Coding Standards
On Sep 8, 6:15 pm, Jerry Coffin <jcof...@taeus.com> wrote:
In article <1188945755.913459.37...@y42g2000hsy.googlegroups.com>,
james.ka...@gmail.com says...
[ ... ]
While 1 to 5 lines sounds a bit too strict, anytime a function
gets longer than about 10 lines, I start asking myself
questions. As always, however, there are exceptions: a single
switch with 100 cases, each of which is a single line, is not a
problem, and trying to break it into smaller functions is
definitly counter productive.
I wonder if I'm the only one who pays little or no attention to the
length of a function per se.
It's a symptom. If I see a collegue systematically producing
functions of 20 lines or more, it makes me suspicious.`
I get concerned about things like:
1) repetition of code
2) things that could be spun out into separate functions whose names
would clarify the code.
3) a routine with more than one real purpose
Agreed. However, violating those principles frequently leads to
overly long functions. The function length is a symptom, and
it's easier to check mechanically.
OTOH, I semi-frequently run into things that don't seem amenable to
particuarly short routines either. Some are things like filling out a
structure to interface with the OS -- e.g. under Windows, creating a
font or registering a window class requires you to fill out a structure
with 30 or so members -- so most of it is simple assignments, but you
still end up with 30+ lines of them. I see nothing to be gained by
attempting to break this up.
If your point is that there are definite exceptions, I agree.
Another classical case is a simple switch with a lot of cases.
Likewise, a few things are simply sufficiently complex that they end up
somewhat long. Just for one example, consider the code to delete a node
from a red-black tree or an AVL tree. You can (and certainly should,
IMO) delegate things like 'rotate_right' to separate routines -- but
even after you do that, you end up with a routine that's 100 lines long
or so. I suppose you _could_ break it up into routines that are 5-10
lines long, but if there's a way to do so while keeping the code as
readable, I haven't found it yet.
Are you sure? I've never actually written such code, but the
examples I've seen in textbooks have lead me to believe that
it's only about 10 lines. I can't imagine anything consisting
of 100 lines of swapping pointers that would be understandable
by a mortal human being, regardless of whether it was in one
function or many.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34