16.2. Coding Guidelines
Programmers inevitably develop their own style for writing
code. This is fine so long as the developer works alone. However,
when multiple developers each attempt to impose their own style on a
project, it will inevitably lead to problems. Code that does not
follow one consistent style is much more difficult to read and
maintain than uniform code. Thus, if you have more than one developer
working on the same project, you should agree on a common style for
writing code. Even if you are working alone, it is a good idea to
look at common standards so that your style does not become so
different that you have problems adapting when you do work with
others.
Here are some topics that a style guide should cover, along with
suggestions. These suggestions follow the syntax that was used
throughout this book, largely based upon the style suggested in
the
perlstyle
manpage:
Flags and
pragmas
. This covers the first couple of
lines of your code:
#!/usr/bin/perl -wT
use strict;
You may want to require taint mode on all your scripts or allow
certain exceptions. You may want to enable warnings by default for
all of your scripts too. It is certainly a good idea to require that
all scripts use strict and minimize the use of global variables.
Capitalization
. This includes the
capitalization of variables (both local and global), the
capitalization of subroutines, the capitalization of
modules, and the
capitalization of filenames. The most common convention in
Perl is to use lowercase for local
variables, subroutines, and filenames; words should be separated by
an underscore. Global variables should be
capitalized to make them apparent. Module names typically use mixed
case without underscores. Note that this convention is quite
different from the mixed case conventions of other languages like
JavaScript or Java.
Indentation
. This should specify whether to use tabs
or spaces. Most editors have the option to automatically expand tabs
to a fixed number of spaces. If spaces are used, it should also
indicate how many spaces are used for a typical indentation. Three or
four spaces are common conventions.
Bracket
placement
. When
creating the body of a subroutine, loops, or conditionals, the
opening brace can go at the end of the statement preceding it or on
the following line. For example, you can declare a subroutine this
way:
sub sum {
return $_[0] + $_[1];
}
Or you could declare it this way:
sub sum
{
return $_[0] + $_[1];
}
This very trivial distinction somehow manges to generate
serious discord among some developers. The latter is familiar to
programmers who have written a lot of C, while the former is more
common in Perl.
Documentation
. You don't need to decide
whether to document your code or not; obviously you should. However,
you may want to decide certain standards for it. Remember that there
are different levels of documentation. Documentation can include
comments within your code adding explanation to sections of code.
Documentation can also include an overview of the purpose of a file
and how it fits into the larger project. Finally, a project itself
may have goals and details that don't fit within particular
files but must be captured at a more general level.
You
should decide how you will capture each of these levels in your
documentation. For example, will all of your files use Perl's
pod format to capture an overview of their
purpose? Or will you use standard comments or capture documentation
elsewhere? If so, what about your shared modules? If developers must
interface with these modules in the future, pod
is a convenient way for them to find the information they need to do
so.
You also may wish to create standard templates for
comments that appear at the beginning of a file and at the beginning
of each subroutine. We have omitted large blocks of
comments in this book because
we review each section of code afterwards. However, most production
code should include details such as who wrote the code, when they
wrote it, why they wrote it, what it does, etc. A revision control
system that captures some of these details can help immensely.
Grammar
. This defines the rules for
choosing names of variables, subroutine calls, and modules. You may
wish to decide whether to keep variable and subroutine names long or
allow abbreviation. You may also want to make rules about whether to
use plural terms for naming data structures that contain multiple
elements. For example, if you pull data from a database, do you store
the list in an array named @rec or
@record or @records? Long names
and plural names for compound data are probably more common.
Similarly, the names of subroutines are typically actions while the
names of modules (which are also class names for object-oriented
modules) are typically nouns.
Whitespace
. One thing that can
certainly contribute to making code easier to read and thus maintain
is an effective use of whitespace. Separate items in lists with
spaces, including parameters passed to functions. Include spaces
around operators, including parentheses. Line up similar commands on
adjacent lines if it helps make the code clearer. One the other hand,
one shouldn't go overboard. Code with lots of formatting is
easier to read but you still want it to be easy to change too,
without the maintainer needing to worry too much about reformatting
lines.
Tools. You may wish to standardize on
tools such as modules for
development. It helps if everyone agrees on one particular method of
generating output, such as CGI.pm, an HTML template module, etc.
Additions.
This list is by no means exhaustive, so keep your style guide
dynamic. If issues come up that are not covered by the style guide,
work out a solution and then update the guide.
Don't forget to document other
general development and architectural guidelines too, such as those
we have discussed earlier in this chapter and throughout the book.
However, keep in mind the goal is to be organized, not bureaucratic.
You should not be heavy handed about guidelines. It is not possible,
nor desirable, to make everyone's code look the same. The goal
is simply to allow developers to work with each other's code
without difficulty. Also, style decisions should be determined by
discussion and consensus, not dictated. Keep it fun.
| | | 16. Guidelines for Better CGI Applications | | 17. Efficiency and Optimization |
Copyright © 2001 O'Reilly & Associates. All rights reserved.
|
|