ISO Studies of underscores vs MixedCase in Ada or C++

[Andy Glew]

I am in search of any rigourous,
scientific, academic or industrial studies
comparing naming conventions in
C++ or similar languages such as
Ada:

Specifically, are names formed with
underscores more or less readable
than names formed with MixedCase
StudlyCaps camelCase?

....and similarly, any measurements
of programmer productivity, bug rate,
etc.; although IMHO readability matters
most.
* Religion - NOT?!

I understand that this is a religious issue
for many programmers, an issue of programming style.
I am not interested in a religious war.
I obviously have my own opinion, but I am
open to scientific evidence.
* Ada Studies?

I thought that I had seen studies like
this in some of the early design documents
for Ada, but I have not been able to find
such references on the web. Which is not
entirely surprising, since Ada was designed
prior to the web.

The Ada 83 and 95 Quality Guidelines recommend
underscores to improve readability, but provide
no source justifying this statement.
* What such studies might look like

Simple readability and recall:
- present a test subject with
a list of compound words
formed with underscoresand mixed case
- remove the list, and ask test subject
to write it
- score on accuracy

Program debugging
- present programs that are otherwise identical,
differing only in their use of underscores/MixedCase
to test subject programmers (e.g. a CS class)
- program has a known bug
- ask test subjects to find bug
- score on accuracy locating bug

Cruel TA study:
- Two sections of a CS class
- Enforce programming standards,
underscores vs MixedCase
- Pose a programming problem
- Score according to success
completing assignment

Empirical:
- Given version control databases
of large programs, some written in underscore
style, others in MixedCase
- Total bug rates normalized by LOC, name count, etc.
- OR: count only bugs that can be attributed
(after inspection of checkins) to misnamed variables

For that matter, I would be interested in any surveys
folks may have done that count projects and their
coding standards, possibly weighted
- open source (e.g. sourceforge)
- industrial
- textbooks, weighted by sales
- websites of coding standards, weighted by Google score...
Although this is less convincing than a rigorous study.
* Explanation of Newsgroups Chosen

I hope it is obvious why I have chosen these
newsgroups to post this search to:

comp.software-eng, comp.programmin g,
- an issue of software engineering
comp.lang.c++,
- the language I am most interested in
comp.lang.ada
- because I vaguely recall historical work

[Jakob Bieling]

"Peter Bushell" <DE************ ****@software-inCAPStegrity.c om> wrote:

"Jakob Bieling" <ne*****@gmy.ne t> wrote:

"Jacob Sparre Andersen" <sp****@crs4.it > wrote: Also, sometimes I tend to abbreviate quite a lot, so that later I

might

not know what it stands for. In cases like those I just put a comment next to where I declared the variable and I can keep saving those keystrokes.

If you can't remember what it meant, pity the poor engineer who has to
maintain your code when you've gone! Having to look up a declaration every
few seconds is not acceptable.
You do not have to. All declarations (loop counters etc. are an
exception) are at the beginning of the function, along with possible
comments. And for those identifiers where comments are necessary, I do not
think it is impossible to remember them.
There is evidence* to suggest that 80% of programming is (or should be)
thinking time. Saving keystrokes is therefore not an issue.

True, but it is still pretty annoying to type all kinds of variable
names out (we are talking about long names, anything over 10 letters,
right?) all the time you use them. The 'burden' of remembering 5 or 6 names
for which you always see the abbreviations is less, in my opinion.

To avoid misunderstandin gs, I do not approve using abbreviations for all
kinds of variables. But I do find it acceptable to use my way of
abbreviating (including comments) for function local variables.

hth
--
jb

(replace y with x if you want to reply by e-mail)

[Alan Balmer]

On Tue, 14 Oct 2003 18:46:59 +0200, "Jakob Bieling" <ne*****@gmy.ne t>
wrote:

True, but it is still pretty annoying to type all kinds of variable
names out (we are talking about long names, anything over 10 letters,
right?) all the time you use them

A good editor can eliminate that problem.

--
Al Balmer
Balmer Consulting
re************* ***********@att .net

[brougham5]

"Jakob Bieling" <ne*****@gmy.ne t> wrote:

Not sure where I picked that habit up, but I guess it is pure laziness.
I could not imagine having to type those long names everytime you use them.

Neither can I. I rarely abbreviate in a variable name. But I rely on code
completion in my editor to save typing those keystrokes.

The problem is that once you start abbreviating, odds are some abbreviations
are not going to be consistent. I've seen nbr, no, nu, or num instead of
number. Using an editor that will complete nu to number might make your
life easier in a multi-person project.

That said, I'll use cachedUrl over the non-abbreviated form, but that's
because I expect most people to abbreviate URL the same way.

[Jakob Bieling]

"Alan Balmer" <al******@att.n et> wrote in message
news:hs******** *************** *********@4ax.c om...

On Tue, 14 Oct 2003 18:46:59 +0200, "Jakob Bieling" <ne*****@gmy.ne t>
wrote:

True, but it is still pretty annoying to type all kinds of variable
names out (we are talking about long names, anything over 10 letters,
right?) all the time you use them

A good editor can eliminate that problem.

For function local variables, mine does not. For class members or
identifiers in a namespace it does.

regards
--
jb

(replace y with x if you want to reply by e-mail)

[Jakob Bieling]

<br*******@yaho o.com> wrote in message
news:h5******** *************** *********@4ax.c om...

"Jakob Bieling" <ne*****@gmy.ne t> wrote:

Not sure where I picked that habit up, but I guess it is pure laziness.
I could not imagine having to type those long names everytime you use

them.
Neither can I. I rarely abbreviate in a variable name. But I rely on code completion in my editor to save typing those keystrokes.
As a said in the other post: For function local variables, mine does not
have that feature.
The problem is that once you start abbreviating, odds are some abbreviations are not going to be consistent. I've seen nbr, no, nu, or num instead of
number. Using an editor that will complete nu to number might make your
life easier in a multi-person project.

Yes, I do write 'num' instead of number. Or I also write 'msg' instead
of message, or 'ips' for an 'InterProcessSy nchronisation' handle. In case of
ips, I might not know what it is without context. But when seeing that
variable used in a function call, it is clear what it is supposed to be.
Along with the comments in the code, I find it justified and not overly hard
to read.

regards
--
jb

(replace y with x if you want to reply by e-mail)

[Alan Balmer]

On Wed, 15 Oct 2003 07:34:33 +0200, "Jakob Bieling" <ne*****@gmy.ne t>
wrote:

"Alan Balmer" <al******@att.n et> wrote in message
news:hs******* *************** **********@4ax. com...

On Tue, 14 Oct 2003 18:46:59 +0200, "Jakob Bieling" <ne*****@gmy.ne t>
wrote:

> True, but it is still pretty annoying to type all kinds of variable
>names out (we are talking about long names, anything over 10 letters,
>right?) all the time you use them

A good editor can eliminate that problem.

For function local variables, mine does not. For class members or
identifiers in a namespace it does.

Mine will complete any symbol it knows about, or give you a drop-down
list if there's more than one choice. However, almost any editor will
allow you to code with abbreviations, then expand them to full names
with search and replace. This can be useful for some people who have
total recall in the heat of a programming session, but can't remember
what they were thinking a week later :-)

--
Al Balmer
Balmer Consulting
re************* ***********@att .net

[Frank Schmitt]

"Jakob Bieling" <ne*****@gmy.ne t> writes:

"Alan Balmer" <al******@att.n et> wrote in message
news:hs******** *************** *********@4ax.c om...

On Tue, 14 Oct 2003 18:46:59 +0200, "Jakob Bieling" <ne*****@gmy.ne t>
wrote:

True, but it is still pretty annoying to type all kinds of variable
names out (we are talking about long names, anything over 10 letters,
right?) all the time you use them

A good editor can eliminate that problem.

For function local variables, mine does not. For class members or
identifiers in a namespace it does.

But why would you want to make function local variables' names more than
10 letters long?
My local variable names tend to consist of only one word, e.g

OutputStreamWri ter writer;

Or are your functions so long that you need longer variable names?

regards
frank

--
Frank Schmitt
4SC AG phone: [phone]
e-mail: frankNO DOT SPAMschmitt AT 4sc DOT com

[Jacob Sparre Andersen]

James Dow Allen wrote:

CamelMode, camel_mode, etc. are all quite *readable*;
It may be a matter of personal taste (haven't seen any actual studies),
but I prefer underscores between words, when I am no allowed to put
spaces there. In Ada I follow the style guide and use both underscores
and capitalisation.
when using long
names the important thing is to make them *writable*,
Try to count how often you _read_ and _write_ an identifier. I think
you might be surprised by the difference. Easy writing of the
identifers is not anywhere nearly as important as easy reading.
Consistency is therefore the important thing.
It is.
If you abbreviate words,
abbreviate them as the first 4 (or whatever) letters, consistently.
I prefer the suggestion from the Ada style guide (IIRC) that you don't
abbreviate words, and that you only use acronyms from a limited
project-specific list.
(I usually rewind a file with "lseek(fd, 0L, 0)" because I can't
remember if 0 is SEEKSET or SEEK_SET.)

Very annoying with a standard library with an inconsistent naming of
identifiers.

One more point on the topic of consistent naming of identifiers. I find
the style with using different naming conventions for functions,
constants, variables, etc. very annoying. I _don't_ want to have to
worry if something is a function, constant or variable. Specially not
if it actually is an implementation dependent detail. So _please_ use
the same naming convention for all identifiers.

Jacob
--
"Any, sufficiently complicated, experiment is indistinguishab le from
magic."

[Jacob Sparre Andersen]

Jakob Bieling wrote:

True, but it is still pretty annoying to type all kinds of variable
names out
I suppose I should thank my mother for insisting that I learned how to
use a typewriter.
To avoid misunderstandin gs, I do not approve using abbreviations for all
kinds of variables. But I do find it acceptable to use my way of
abbreviating (including comments) for function local variables.

Do non-local variables really exist? :-)

But yes, if you make sure that the declaration of the variables is
always immediately visible, when one is observing their use, then I can
understand your argument (although I still don't approve of it).

Jacob
--
"The current state of knowledge can be summarised thus:
In the beginning, there was nothing, which exploded."

[Jacob Sparre Andersen]

Jakob Bieling wrote:

[ abbreviated identifier prefixes ]

Not sure where I picked that habit up, but I guess it is pure laziness.
I could not imagine having to type those long names everytime you use them.
Well. I tend to read code more often than I write it (even my own), and
most of my time is spent thinking about what to write, so saving a few
keystrokes really doesn't make sense to me.
Especially counter variables in for-loops (posting from comp.lang.c++) ..
you also use simple i's and j's etc. there, right?
No. (unless it is for matrix and tensor manipulation, where the
"documentat ion" actually says "i", "j" and "k")
As you seem to be posting from comp.lang.ada,
Well. There and "comp.softw are-eng".
I am not too sure if Ada provides such constructs in the
same way C++ does, so maybe Ada has different means of looping in a
for-loop-kind-of-way (yes, I know pretty much nothing about Ada).
The Ada for loop is not as flexible/error-prone as I remember the C++
for loop (which I haven't had to use for years :). A quick example:

for Day in Monday .. Friday loop
Put (Day); Put_Line (" is a workday.");
end loop;

(where I assume I have declared an enumerated type based on the days of
the week). The counter variable is created by the for loop statement,
so you don't have to worry about making an explicit declaration of a
variable for use as the counter. I seem to remember that you have to
have an explicit declaration of the counter variable in C++, which of
course makes a slight difference.
Also, sometimes I tend to abbreviate quite a lot, so that later I might
not know what it stands for.
Not good. That costs time and is a potential source for errors if you
misremember the meaning of the abbreviation.
In cases like those I just put a comment next
to where I declared the variable and I can keep saving those keystrokes.

I consider that a misuse of comments. I see comments as a means for
expressing what _can_ not be expressed in actual code. Otherwise you
risk ending up with code and comments that say different things. One
result of this view is of course that it differs from language to
language, what are reasonable comments.

My main worry with long identifier names is that they shouldn't make the
lines so long that they become incomprehensibl e.

Jacob
--
"There are only two types of data:
Data which has been backed up
Data which has not been lost - yet"