Every now and then I like to write about something that is at least
potentially controversial. The question of whether software engineering
is really engineering ought to do it. I'd like to be more specific:
should people who call themselves software engineers be bound by the
same professional ethical principles that other engineers claim to
follow?
As types of engineering go, software engineering is a
relative newcomer. Philosopher Michael Davis, who has written
extensively on engineering ethics, traces the first use of the term to a
1967 NATO meeting on software design. Since then, computers and the
software they all have to run on have become a huge part of everyday
life, and an even greater part of engineering. There are seventeen
accredited undergraduate programs at U. S. universities and colleges in
software engineering, and by that and other measures you might think
software engineers have as much right to call themselves engineers as
any other member of the profession. But Davis isn't so sure.
That
may be one reason that Davis, along with twenty-four other experts,
contributed to the creation of a distinct ethical code for software
engineers. It is promulgated by the Association for Computing Machinery
(ACM) in cooperation with the Institute of Electrical and Electronics
Engineers (IEEE). The IEEE Code of Ethics, which has been around for at
least thirty years, is only 256 words long. By contrast, the full
version of the ACM/IEEE Software Engineering Code of Ethics is over 2400
words long (although a shorter version is also available). More
important than such superficialities as the length of the codes of
ethics is the question of why software engineers need a separate set of
ethical principles in the first place.
One reason may be that the
education and training to do software engineering is markedly different
than the typical training that other kinds of engineers receive. If
you look at the undergraduate curriculum of most engineering programs,
you see a solid one- to two-year foundation in the sciences: physics,
mathematics, and (usually) chemistry. But it is generally accepted that
people who can do good programming don't need to know any physics or
chemistry, and even the utility of the kind of mathematics most
engineering programs emphasize (that is, calculus, differential
equations, and so on) is questionable. The type of science called
computer science obviously relies on mathematics, but people without any
significant background in computer science do software engineering all
the time.
Are the ethical issues faced by software engineers
markedly different compared to those faced by other engineers? The
people who came up with the ACM/IEEE software engineering code seemed to
think so, or else they would have simply referred inquirers to another
code of ethics such as the IEEE's. A cursory reading of the ACM/IEEE
code's long form reveals only a few items that could not explicitly
apply to other kinds of engineers as well. For example, item 5.03 of
the ACM/IEEE code states that those managing or leading software
engineers should "[e]nsure that software engineers know the employer's
policies and procedures for protecting passwords, files and information
that is confidential to the employer or confidential to others." This
is good advice to any type of manager, not just managers of software
engineers. My sense is that, rather than leave some ethical stones
unturned, the writers of the ACM/IEEE software engineering code tried to
think of nearly every issue that software engineers might face, whether
or not it pertains peculiarly to software engineering.
As a
member of an older engineering discipline (electronic engineering), I
confess to a twinge of professional jealousy as software engineering
gains prominence. The truth of the matter is that as time goes on, the
old divisions between disciplines become harder and harder to find in a
typical workplace. It has always been true that many engineers also do
management at various times, and often become full-time managers later
in their careers. But nowadays it is hard to find any kind of engineer
who doesn't at least use software, and every engineering student takes
at least a smattering of computer-code writing along the way to
graduation.
Still, there is the old notion that engineering is
fundamentally about physical stuff, not the ephemeral and fundamentally
non-material thing called software. Be that as it may, it is a hard
fact that software is (a) produced by people with special knowledge for
(b) use by non-specialists who (c) can be seriously inconvenienced (or
worse) by software that doesn't perform as expected. Those three items
have been true of all engineered products since we began to talk about
engineers in the nineteenth century, and they are also true of the
non-material product called software. So from a pragmatic standpoint,
those who write software for sale or use by others bear the exact same
type of responsibility as engineers who design bridges or rockets. For
that matter, no bridge or rocket is designed today without at least the
use of software, so by implication, software engineers are involved in
most other kinds of engineering too.
Software engineering is
still a young field, and news items about grand software-project
disasters still come up from time to time. But the same was true of the
earliest iron and steel bridges: they collapsed with alarming
frequency. However, their designers didn't give up on the idea.
Instead, they studied what went wrong, learned from their mistakes, got
more organized as a profession, and went on to improve the next
generation of bridges. I hope that the ACM/IEEE code of software
engineering ethics does the same for its young discipline.
