Path: utzoo!mnetor!uunet!lll-winken!lll-lcc!ames!eos!aurora!labrea!Shasta!neff
From: neff@Shasta.STANFORD.EDU (Randy Neff)
Newsgroups: comp.software-eng
Subject: A Cynic's Guide, part 1
Message-ID: <2541@Shasta.STANFORD.EDU>
Date: 3 Mar 88 23:44:31 GMT
Reply-To: neff@Shasta.UUCP (Randall Neff)
Distribution: na
Organization: Stanford University
Lines: 64

------		The Cynic's Guide to Software Engineering		------
------ an invitation to dialog, starting with the personal view of	------
------		    Randall Neff @ sierra.stanford.edu			------
------	        	March 3, 1988   	part 1			------
------------------------------------------------------------------------------
			Hardware vs Software

State-of-the-practice in Hardware:
At companies that are serious about producing hardware, either
pc board or integrated circuits;  the first parts produced USUALLY work 
correctly.   At Application Specific Integrated Circuit (ASIC) companies,
it is an embarrassment if the first parts don't work correctly.

State-of-the-practice in Software:
"THE PROGRAM IS PROVIDED "AS IS' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF 
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO
THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM
PROVE DEFECTIVE, YOU (AND NOT IBM OR AN AUTHORIZED PERSONAL COMPUTER DEALER)
ASSUME THE ENTIRE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION"
one paragraph from IBM program Licence Agreement (shrink wrap).

All software is known by version number, both for bug fixes and enhancements:
Turbo C 1.0, 1.1, 1.2, 1.5, etc.   An Ada compiler 5.0, 5.1, 5.41, 5.5, etc.
X windows 10.4, 11.1 (about one hundred bugs reported), 11.2, etc.   A new 
version of an operating system takes about two weeks to install correctly and
now cannot network to some other computers.   A new version of a compiler 
compiles, but generates bad code (illegal instructions, segmentation faults), 
for previously working programs;  man months wasted trying to find work 
arounds.  A portable language won't port between different brands of compilers 
or even different versions.  No brand names here, similar problems occur with 
almost any software.  In order to survive, a programming group MUST have full 
source code for all of the software they use.

Why the big difference?   Both hardware and software are working instantiations
of behavior as described by requirements and specifications.  There is the
obvious difference in the scale of the projects:  designing and implementing
a RISC chip is a lot simpler than designing and implementing a compiler for
it or (gasp) a new operating system for it.  Why can hardware engineers do 
their job so well and software engineers talk about the (huge) percentage 
lifecycle cost in the maintenance phase?   

Looking at the last ten years in hardware design tools, the following trends
can be observed:

-- Willingness to learn new paradigms of design, new methods, new tools.
   Hierarchical design in functional languages, logic, switches, transistors.
   Willingness to change methods and design in order to use tools.
-- Capital investment in both hardware (originally $75,000 to $100,000 per 
   station) and in software (like $100,000 programs).   Buy or lease Cray time.
   Use days of mini and super-mini computer time to check design.
-- Venture Capital/Entrepreneur boom in new companies, products.  (then 
   bust or buyout for most, now mostly stagnant).  This was started/fed by
   university research into hardware CAD tools.
-- Return on Investment (ROI) and productivity gain was obvious (sometimes
   order of magnitude) over previous methods.  
-- Manufacturing cost was increased to drastically shorten design time with 
   standard cells, gate arrays, and silicon compilers.
-- Enormous amounts of reuse of specification, design, and testing through
   standardized part libraries:  off shelf parts, standard cells, gate array 
   cells, etc.
-- Constructing the test procedures along with the design; and designing for
   easier testing.

Why haven't software engineers followed similar trends?