Copyright © 2005 by Philip L. Bewig of Saint Louis, Missouri, USA.  All rights reserved.  This work is available under the Creative Commons Attribution-
NonCommercial-NoDerivs  License.   For information  regarding  this  license, visit http://creativecommons.org/licenses/by-nc-nd/2.0/  or  write to Creative 
Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.  Excel is a registered trademark of Microsoft Corporation. 
How do you know your spreadsheet is right? 
Principles, Techniques and Practice of Spreadsheet Style 
Philip L. Bewig — July 28, 2005 
You  know  it’s  true:    Spreadsheets  have  errors 
like  dogs  have  fleas.
1
 It  is  generally  accepted
2
that  nine  out  of  every  ten  spreadsheets  suffer 
some error, and consequences can be severe:
3
•  A  cut-and-paste  error  cost  TransAlta  $24  million 
when it underbid an electricity-supply contract.
4
•  A  missing  minus  sign  caused  Fidelity’s  Magellan 
Fund to overstate projected earnings by $2.6 billion 
(yes, billion) and miss a promised dividend.
5
•  Falsely-linked  spreadsheets  permitted  fraud  totaling 
$700 million at the Allied Irish Bank.
6
•  Voting officials reported spreadsheet irregularities in 
New Mexico
7
and South Africa.
8
•  A new drug introduction was delayed several months 
by  an  untested  macro,  costing  the  pharmaceutical 
company profits and its patients misery.
9
You can’t eliminate errors from the spreadsheets 
you  develop,  but  you  can  reduce  their  number.  
The principles  and  techniques  described  below, 
applied consistently, will improve the quality of 
your spreadsheets.  The discussion assumes Ex-
cel, but the principles and techniques apply eve-
rywhere.  The spreadsheet shown below will be 
used as a practical example:  
Think  before  you  write.    Resist  the  urge  to 
jump right in to actual development.  Start with 
 clear  understanding  of  the  requirements  of 
your task.  Sketch your design on a whiteboard, 
and look for flaws.  Consider alternate software 
tools  such  as  databases,
10
statistics  packages,
11
financial modeling systems,
12,13
business intelli-
gence  systems,
14,15
mathematical  programming 
languages,
16,17,18
and  traditional  computer  pro-
gramming  languages.    This  is  the  most  funda-
mental level of your work, and the most creative 
moment  in  the  entire  existence  of  your  spread-
sheet.   An error here  can be  hard to fix, requir-
ing  massive  rearrangements  of  the  spreadsheet 
structure or new inputs from new sources. 
Know the players.  The reader sees the printed 
output, and uses it to  make a decision; he relies 
on  you  to  organize  and  present  the  data  he 
needs, as he needs it.  The user inputs data, op-
erates  macros,  and  prints  output,  but  doesn’t 
modify  anything;  he  relies  on  you  to  provide 
adequate  instructions.    You,  the  developer,  de-
sign  and  implement  the  structure  and  all  the 
formulas in the spreadsheet.  The auditor checks 
the  work  of  the  developer;  he  relies  on  you  to 
produce  a  clean  design  and  good  documenta-
tion.  The sponsor assigns the task, provides re-
sources,  and  has  overall  responsibility  for  the 
spreadsheet; he  relies  on you to meet  his  speci-
fications.    In  many  cases  some  of  these  roles 
overlap;  keep  them  all  in  mind  as  you  develop 
your spreadsheet. 
Make your spreadsheet as simple as possible, 
but no simpler.
19
Most spreadsheets work well 
enough  with  a  few 
SUM
 and 
IF
s,  and  using 
functions like 
SUMPRODUCT
or features like array 
formulas, or writing your own macros and func-
tions, can make a spreadsheet harder to read and 
understand than it should be.  On the other hand, 
don’t  “dumb  down”  your  spreadsheet,  feel  free 
to hide complex logic in user-defined functions, 
Pdf first page thumbnail - application SDK tool:C# PDF Thumbnail Create SDK: Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
Pdf first page thumbnail - application SDK tool:VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 2 
and if some advanced feature will simplify your 
task, use it.  Be wary of features just added to or 
changed  in  the  newest  version  of  Excel,  where 
bugs are likeliest to lurk;  for instance, the 
RAND
function  has  changed  with  each  version  of  Ex-
cel, and statisticians claim
20,21
it’s still not right. 
Plan  to  throw  one  away;  you  will,  anyway.
22
Prototypes are useful for spreadsheet developers 
for the same reason that scale models are useful 
for architects; they  help you visualize  what you 
are building.  They can help you add meaning to 
ill-defined  specifications,  demonstrate  a  partial 
solution,  or  work  out  tricky  formulas.    Fre-
quently, prototypes grow  into a  solution; some-
times,  the  prototype  is  the  solution,  and  the 
whole problem need never be solved. 
Design for change.  Few spreadsheets are still-
born;  most  evolve  and  grow  through  countless 
versions,  then  may be  copied with a  new name 
next  month  when  the  process  starts  anew.  
Brooks  says:  “All  successful  software  gets 
changed.”
23
The best place to plan for change is 
during the initial design of the spreadsheet.  Re-
flection,  described  below,  is  a  useful  tool  for 
implementing  that  plan.    Building  a  change-
tolerant  spreadsheet  isn’t  much  harder  than 
building  the  other  kind,  but  so  much  better  for 
the  poor  fellow  who  has  to  modify  your  work; 
you’ll  especially  appreciate  the  initial  effort  if 
you are, yourself, that poor fellow. 
Keep  input,  logic,  and  reports  in  separate 
sections  of  a  spreadsheet,  preferably  on  dif-
ferent tabs.
24
That way you can always see the 
assumptions  neatly  in  a  single  place,  formulas 
are  less  likely  to  be  overwritten,  you  know 
where to go to make changes, and output can be 
formatted for the reader  while  logic can be laid 
out for the developer.  If you can’t put the three 
sections on separate tabs, arrange them on a sin-
gle  tab  in  a  stepped  diagonal  so  that  rows  and 
columns  can be inserted or  deleted in each area 
without  affecting  the  other  areas.    But  beware 
the  false  modularity  of  separate  worksheets; 
since all  cells in a worksheet are globally read-
able, and globally writeable with a macro, using 
separate  worksheets  hides  no  information.
25
Worksheets  can’t  be  “dropped  in”  and  reused, 
nor  can  they  be  checked  individually  without 
reference to other worksheets. 
Keep your entire spreadsheet on a single tab, 
intermixing  input,  logic  and  reports.
26
 You 
can’t see your whole spreadsheet at a glance if it 
occupies  multiple  worksheets.    Multiple  sheets 
make  formulas  longer  and  harder  to  read  be-
cause  the  sheet  name  must  be  included.    They 
breed  spurious  cells  (cells  that  simply  copy 
other cells without calculation, like 
=R12C4
) be-
cause the spreadsheet developer wants to see the 
precedent  cell.  The  auditing  toolbar  fails  with 
multiple  sheets  because  arrows  don’t go  to  off-
sheet cells,  and searches  are confined  to the se-
lected  worksheet.    With  input  and  logic  inter-
mixed, arcs of precedence are shortened. 
Lay  out  your  spreadsheet  as  determined  by 
the  needs  of  your  problem.    Obviously,  the 
two previous suggestions conflict, and in fact no 
single  design  is  always  right;  the  size  of  the 
spreadsheet,  frequency  of  off-sheet  references, 
complexity  of  formatting,  and  many  other  fac-
tors must all be considered.  The sample spread-
sheet has four sections:    growth  rates (input) at 
the top of the first column, tax rate (input) in an 
unlabelled cell at the bottom of the first column, 
base  values (input) and growth amounts  (calcu-
lated)  in  the  top  rows,  and  income  statement 
(calculated)  in  the  bottom  rows.    An  alternate 
layout would have base values in a section next 
to  growth  rates,  with  formulas  that  copy  base 
values  into  the  calculation  area  of  the  spread-
sheet;  this  design  works well  if there  are many 
input  values  or  the  calculation  section  is  large.  
Some people will object to the inclusion of fixed 
costs  twice  on  the  spreadsheet,  saying  that  one 
or the other is spurious and should be removed, 
but  that’s  a  consequence  of  separating  logic 
from  output;  in  some  cases it  will  be  sufficient 
to have only a single appearance of the number, 
but  if  logic  and  output  are  both  large,  it  may 
make sense to have the number appear twice. 
Make  your  spreadsheet  read  top-to-bottom 
and left-to-right.  All dependent arrows should 
point  down,  right,  or  somewhere  in  between.  
application SDK tool:VB.NET Image: Program for Creating Thumbnail from Documents and
are supposed to read VB.NET Imaging: Get Started first! document and image formats, such as PDF, TIFF, GIF server space, which results in slower web page loading
www.rasteredge.com
application SDK tool:How to C#: Preview Document Content Using XDoc.PowerPoint
Project. RasterEdge XDoc.PowerPoint provide you with APIs to get a thumbnail bitmap of the first page in the PowerPoint document file.
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 3 
One exception is when the beginning balance at 
the  top  of  one  column  depends  on  the  ending 
balance at the bottom of the previous column. 
Build  a  complicated  spreadsheet  in  stages.  
Let  it  grow,  but  always  with  a  working  partial 
solution at hand.  Test as you go,
27
so you have 
confidence  in  the  pieces  as  well  as  the  whole.  
Fix problems immediately; don’t leave them for 
the next version. 
Draw  the  dependency  graph.    “A  picture  is 
worth  a  thousand  words.”
28
 The  dependency 
graph of the sample spreadsheet looks like this: 
Beware the cascade effect.  The likelihood that 
 spreadsheet  produces  erroneous  output  is  a 
function  of  the  error  rate  e  for  individual  cells 
and the number n of cells that must each be cor-
rect in succession (a “cascade” of cells) in order 
for  the  whole  spreadsheet  to  be  correct.  
Mathematically,
29
this  function  is  1–(1–e)
n
which grows asymptotically to 100%, as shown 
in the graph below; with a 5% error rate, even a 
cascade of only six cells gives more than a 25% 
chance of overall error.  You can reduce the cell 
error rate by careful checking, but it’s generally 
easier  to  restructure  the  computation  to  reduce 
the  length  of  the  cascade.    The  sample  spread-
sheet  has  seventeen  cascades,  six  of  six  cells, 
eight of  five  cells, two of four  cells, and one of 
three  cells,  as  shown  in  the  diagram  above 
(every  cascade  through 
Pretax  Earnings
counts 
twice, since it has two out-arrows); it also has a 
one-cell cascade for the year captions that is not 
included in the diagram. 
0
20
40
60
80
100
0
1.0%
2.0%
3.0%
4.0%
5.0%
0.0%
25.0%
50.0%
75.0%
100.0%
Cascade
error
rate
Cascade length
Error
rate
Document  the  design  of  your  spreadsheet  on 
 separate 
HOWTO
tab.    State  the  purpose  of 
your spreadsheet in a single sentence.  Include a 
drawing  of the  dependency  graph.    Make  a list 
of  all  the  individual  tabs  in  your  spreadsheet, 
and write a single sentence describing each one.  
State the source of all inputs  (be specific:  “Pat 
at  extension  3220  in  the  Sales  Department”), 
and specify by name and job title all the people 
that will see your output.  Briefly describe  your 
overall  design  (if  that  takes  more  than  a  sen-
tence  or  two,  your  design  is  too  complicated) 
and  point  out  any  unusual  or  tricky  spots.    De-
scribe  macros  and  user-defined  functions.    In-
clude  instructions  so  someone  else  can  change 
input and obtain output without your help.  Up-
date  your  documentation  when  the  spreadsheet 
changes. 
Base 
Value 
Growth 
Rate 
Base 
Value 
Growth 
Rate 
Base 
Value 
Growth 
Rate 
Base 
Value 
Growth 
Rate 
Price 
Per Unit 
Unit 
Sales 
Cost 
Fixed 
Cost 
Sales 
Cost Of 
Sales 
Pretax 
Earnings 
Tax 
Net 
Income 
Income 
Tax 
application SDK tool:How to C#: Preview Document Content Using XDoc.Word
Programming Project. RasterEdge XDoc.Word provide you with APIs to get a thumbnail bitmap of the first page in the word document file.
www.rasteredge.com
application SDK tool:C# Word - Render Word to Other Images
String inputFilePath = Program.RootPath + "\\" 1.docx"; DOCXDocument doc = new DOCXDocument(inputFilePath); // Get the first page of Word file.
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 4 
Provide  basic  documentation  with 
Workbook 
Properties
.   And make it  easily  accessible  by 
setting 
Prompt for workbook properties
. It’s a con-
venient  place  to  put  summary  documentation, 
and  is  searchable.    The 
Category
and 
Keyword
fields  are  useful  (think  about  a  category 
July2005
for  all  your  workpapers  this  month), 
and  the 
Custom
tab  provides  many  additional 
fields, including 
Purpose
and 
Checked by
Use 
R1C1
-style  cell  references.   Though 
$A$1
-
style  cell  references  are  more  common, 
R1C1
-
style cell references are preferable because they 
are  self-contained;  you  don’t  need to  know  the 
current address to know what relative references 
in a formula mean.  For instance, 
=C7+C8
means 
something different in  cell 
C9
than in  cell 
C10
but 
=R[-2]C+R[-1]C
means  the  same  thing  no 
matter  the  current  cell,  and  copies  are  visually 
identical to the original. 
Use  descriptive  range  names.    But  don’t  use 
Excel’s  natural-language  labels,  which  some-
times  fail  in  unexpected  ways.    It’s  easier  to 
read 
=Sales-Cost_Of_Sales-Fixed_Cost
than 
=R[-3]C-R[-2]C-R[-4]C
and understand that it 
says  what  you  expect.
30
 Cell  addresses  are  a 
physical concept; names are a higher-level logi-
cal concept directly relating spreadsheet to task.  
Names should be meaningful, brief, and distinc-
tive;
31
well-chosen  names  are the  first  and  best 
form  of  documentation.    Names  are  better  de-
clared with 
Create
rather than 
Define
, as there 
is  less  possibility  of  the  name  referring  to  the 
wrong  range.    Prefer  VBA  functions  to  named 
formulas.  Here is a list of names defined in the 
sample spreadsheet, produced by 
Paste List
Cost_Of_Sales 
=Forecast!R7C3:R7C7 
Cost_Per_Unit 
=Forecast!R4C3:R4C7 
Fixed_Costs 
=Forecast!R5C3:R5C7 
Growth_Rate 
=Forecast!R2C1:R5C1 
Income_Tax 
=Forecast!R10C3:R10C7 
Pretax_Earnings  =Forecast!R9C3:R9C7 
Price_Per_Unit 
=Forecast!R3C3:R3C7 
Prior_Year 
=Forecast!RC[-1] 
Sales 
=Forecast!R6C3:R6C7 
Tax_Rate 
=Forecast!R10C1 
Unit_Sales 
=Forecast!R2C3:R2C7 
Year 
=Forecast!R1C3:R1C7 
Thoroughly  understand  the  difference  be-
tween  absolute and  relative  references.    Like 
pointers in  a traditional programming language, 
errors  in  absolute  and  relative  references  can 
cause insidious errors that are almost impossible 
to  find.    Be  sure  you  understand  the  different 
effects of  insertion,  deletion,  copy,  sorting,  and 
other  ways of  moving  a  cell  from  one  place  to 
another. 
Know  the  difference  between  early-binding 
and  late-binding  cell  references.   Normal  cell 
references, both absolute and  relative,  using  ei-
ther  $A$1-style  or  R1C1-style  cell  references, 
are  early-binding;  if  you  insert  a  row  in  a  col-
umn  of  formulas,  each  referring  to  the  one 
above,  the  cell  below  the  insertion  point  will 
continue  to  refer  to  the  cell  that  was  originally 
above  it  even  after the  insertion.   Range names 
and cells referenced by 
OFFSET
or 
INDIRECT
are 
late-binding;  if  that  same  insertion  was  done 
using a range name that referred relatively to the 
cell  above,  the  cell  below  the  insertion  point 
would refer to the new cell. 
Allow  only  one  unique  formula  per  row  or 
column.    Consider  your  spreadsheet  as  a  data-
base table, with attributes (fields) and tuples (re-
cords);  for instance, the sample  spreadsheet  has 
income  and expenditure captions running down 
application SDK tool:C# powerpoint - Render PowerPoint to Other Images
String inputFilePath = Program.RootPath + "\\" 1.pptx"; PPTXDocument doc = new PPTXDocument(inputFilePath); // Get the first page of PowerPoint file.
www.rasteredge.com
application SDK tool:C# Word - Insert Blank Word Page in C#.NET
page inserting library control toolkit allows developers to specify where they want to insert (blank) Word document page (before the first page or after the
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 5 
the  leftmost  column  and  time  marching  along 
the top row, giving it row attributes and column 
tuples.  One useful design technique is to organ-
ize your spreadsheet so  each attribute  uses  only 
a single formula.  Thus, you should prefer 
This year Last year 
Sales 
$14,729 $14,021 
Gross profit 
$4,601
$4,292 
Net income 
$1,245
$880 
Percent to sales 
Gross profit 
31.2%
30.6% 
Net income 
8.5%
6.3% 
rather than 
This year 
Last year 
Sales 
$14,729
$14,021 
Gross profit  $4,601  31.2%
%
$4,292  30.6%
%
Net income  $1,245  8.5%
5%
$880  6.3%
%
Your reader will prefer it, too, since the various 
elements  of  the  analysis  are  more  clearly  sepa-
rated.  If a single attribute must use  two formu-
las, write them in the two legs of an 
IF
, using a 
reflective  condition  to  distinguish  them;  for  in-
stance,  the  formula   
=(1+IF(Year<=3,Growth
-
_Rate,MIN(10%,Growth_Rate))*Prior_Year
caps the growth rate at 10% after the third year. 
Consider entering identical formulas in adja-
cent  cells as  array formulas  rather than  cop-
ies.  Since all cells in the array are identical, by 
definition,  it  is  impossible  to  sustain  the  very 
common spreadsheet error of changing some but 
not  all of a series of copied formulas.    But ar-
ray  formulas
32
can’t  be  recommended  in  most 
cases,  since  they  freeze  the  structure  of  a 
spreadsheet,  rendering  subsequent  changes  in-
convenient.  The sample spreadsheet uses copies 
rather than array formulas. 
Make  assumptions  visible,  but  hide  magic 
numbers.    Use  numbers  explicitly  in  formulas 
only  when  they  represent  mathematical  identi-
ties, as in 
(1+GrowthRate)*PriorYear
 Magic 
numbers  (constants  that  are  an  artifact  of  the 
implementation rather than the problem, such as 
the offset  in  a table  lookup) are  best defined  as 
named  constants,  where  they  are  visible  to  the 
spreadsheet  developer  (and  easy  to  maintain) 
but hidden from the reader.  Assumptions (num-
bers intrinsic  to  the  problem,  such  as  tax  rates) 
should be made visible in their own cells. 
Validate  input  cells,  and  make  them  visible 
with  a  “glowing  pencil.”
33
 Use  the 
BETWEEN
operator, make ranges tight enough to be  effec-
tive, and never use open-ended  ranges; enumer-
ated  lists  are  also  effective.    Use  the  input 
prompt  to  instruct  the user  (even if  that  user is 
yourself)  of  the  source  of  the  input.    Turn  off 
auto-completion;  it’s  easy  to  automatically  in-
sert  incorrect  data.    Ensure  both  you  and  your 
reader  know  which  cells  are  input  cells  by  for-
matting them differently  than the rest;  blue ital-
ics work well, distinguishing cells on-screen and 
when printed.  Here is the cell validation list for 
the sample spreadsheet:  
R2C1 
Decimal 
Between 
0% 
100% 
R3C1 
Decimal 
Between 
0% 
100% 
R4C1 
Decimal 
Between 
0% 
100% 
R5C1 
Decimal 
Between 
0% 
100% 
R10C1 
Decimal 
Between 
0% 
100% 
R2C3 
Whole Number 
Between 
100,000 
R3C3 
Decimal 
Between 
1,000 
R4C3 
Decimal 
Between 
1,000 
R5C3 
Whole Number 
Between 
100,000 
That list was created by the following macro: 
Sub PasteValidationTable() 
Dim C As Range, T As Range 
Set T = ActiveCell 
For Each C In ActiveSheet.Cells.Special- 
Cells(xlCellTypeAllValidation) 
T.Offset(0, 0) = _ 
C.AddressLocal(True, True, _ 
Application.ReferenceStyle) 
T.Offset(0, 1) = _ 
Choose(C.Validation.Type + 1, _ 
"Input Only", "Whole Number", _ 
"Decimal", "List", "Date", _ 
"Time", "Text Length", "Custom") 
T.Offset(0, 2) = _ 
Choose(C.Validation.Operator, _ 
"Between", "Not Between", "Equal", _ 
"Not Equal", "Greater", "Less", _ 
"Greater Or Equal", "Less Or Equal") 
T.Offset(0, 3) = C.Validation.Formula1 
T.Offset(0, 4) = C.Validation.Formula2 
Set T = T.Offset(1, 0) 
Next C 
End Sub
Be wary of links to other spreadsheets or  ex-
ternal data sources.  A changed link that audi-
tors  failed  to  catch  was  the  trick  behind  the 
Allied  Irish  Bank  fraud;  the  criminal  spread-
sheeter  substituted  a  spreadsheet  containing  his 
made-up  cross-currency  rates  for  one  main-
tained  by  the  bank.    It’s  hard  to  know  where 
application SDK tool:C# Raster - Image Save Options in C#.NET
Tiff Edit. Image Thumbnail. Image Save. Advanced Save Options. Save Image. VB.NET How-to, VB.NET PDF, VB.NET Word to icon file, false: just save the first page to
www.rasteredge.com
application SDK tool:C# PowerPoint - Insert Blank PowerPoint Page in C#.NET
page inserting library control toolkit allows developers to specify where they want to insert (blank) PowerPoint document page (before the first page or after
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 6 
links point; they tie the spreadsheet to a particu-
lar  directory  structure,  and  may  mask  circular 
references.    Links  expand  audits; link-ees  must 
be  audited  as  well  as  link-ers.    And  links  lose 
synchronization  if not updated.   Format  linking 
cells distinctively; violet italics work well. 
Trap  formula  errors.    But  allow  unexpected 
errors  to  propagate  rather  than  masking  them.  
Convert errors into appropriate values; 
ISERROR
and 
ISNA
may be helpful.  Any reader who sees 
#DIV/0!
is  entitled  to  assume  your  incompe-
tence without further evidence. 
Maintain a common interval for calculations.  
If  your  spreadsheet  switches  from  quarterly 
forecasts  for  the  first  year  to  annual  forecasts 
thereafter,  keep  calculations  in  quarters,  then 
sum  the  out-year  quarters  for  reporting.    Alter-
nately, write two separate spreadsheets. 
Describe  your  formulas.    If  they  are  compli-
cated  or  there  is  some  possibility  of  confusion, 
describe  your  formulas,  in  English  prose,  di-
rectly on the printed output.  That way, both you 
and your reader know what you are doing. 
Use 
Goal  Seek
34
to  calculate  iterative  solu-
tions.    Reserve  circular  references  to  indicate 
errors.    Use  the  circular  reference  toolbar  to 
track down circular references that do occur. 
Lock  all  cells  except  input  cells,  but  publish 
the  key.    Your  goal  is  to  prevent  inadvertent 
change, not to forestall needed change.  Excel’s 
password protection is easy to defeat,
35
so don’t 
rely on it for security.  Be sure to know all your 
options,  including  file-level  security  from  the 
operating system, and the various levels of pro-
tection  that  Excel  offers  to  workbooks,  work-
sheets, and cells. 
Program defensively using assertions.  Given 
Function Assert(X, Y, Msg As String) 
If Abs(X / Y - 1) < 1E-13 Then 
Assert = X 
Else 
Assert = 1 + Msg 
End If 
End Function
then 
=ASSERT(SUM(RowSums), SUM(ColSums), 
"Row  sums  must  equal  column  sums")
in 
the lower right-hand corner of a table will check 
that the table foots  and cross-foots;  the strange-
looking condition traps rounding differences.  If 
the  assertion  ever  fails,  the  expression 
1+Msg
will  throw  an  error  that  propagates  to  the  final 
result;  backtracking  to  the  source  of  the  error 
will  bring  you  to  the  message  planted  earlier.  
Assertions can be based on mathematical identi-
ties  (footings  and  cross-footings  must  equal), 
external  identities  (assets  equal  liabilities  plus 
equities),  or  redundancies  (two  different  inputs 
both  lead  to  the same output).   Assertions
36
are 
valuable  because  they  test  the  spreadsheet  dy-
namically,  every  time it  is  recalculated,  instead 
of  statically  when a  test  is  called.   If you  wish, 
you could replace the growth formulas in the top 
half of the sample spreadsheet with the assertion 
suggested in the comment box below. 
Document  your  work  liberally  using  in-cell 
comments.  Describe precisely the source of all 
inputs.    Explain  complicated  formulas.    Docu-
ment  user-defined  functions  and  macros.    Ex-
plain  the  condition  and  both  arms  of  any 
IFs.
Document your work  as you are doing it, when 
the reason for all your design decisions is fresh 
in  your  mind; you  will  surely forget something 
important  if  you  save  the  documentation  work 
for later.   Update  comments when the cell  con-
tents  change.  This comment is in  cell R2C4  of 
the sample spreadsheet: 
Use  Excel’s  reflective  features  to  automate 
your work.  Reflection
37
makes a programming 
language  self-referent.    The 
CELL
INFO
and 
TYPE
functions  return much  useful information.  
Dynamic named ranges
38
grow and  shrink  with 
the data.  Use 
COUNTA
instead of hard-wiring the 
size of a range.  Define names as entire rows or 
columns  instead  of  just  occupied  cells.    Write 
macros that adapt to  the size of  the data instead 
of  fixing  the  number  of  cells  in  advance.    Get 
application SDK tool:C# Image: Quick to Navigate Document in .NET Web Viewer
Navigation Throw Thumbnial Image. The first method recommended can be called from any document page object for formed documents, like Word and PDF, will contain
www.rasteredge.com
application SDK tool:C# Word - Table Cell Processing in C#.NET
Create a Table for document ITable table = doc.CreateTable(3, 3); //Get all rows in table List<ITableRow> rows = table.GetRows(); //Get first row ITableRow row
www.rasteredge.com
How do you know your spreadsheet is right? 
Page 7 
familiar with the tasteful use of the 
OFFSET
and 
INDIRECT
functions.    When  you  use  reflection, 
the computer does more of the work and you do 
less  of  it;  guess  which  of  you is  more likely to 
get the right answer? 
Build  reflective  features  into  your  spread-
sheets.    The  sample  spreadsheet  uses  the  for-
mula 
=1+Prior_Year
to  put  the  numbers 
1
through 
5
in the  year-caption cells,  displays the 
cells with the custom format 
"Year "#
, and as-
signs the  range name 
Year
.  That makes  it easy 
to  refer  to  the  year  number,  as  in  the  previous 
example capping the growth rate. 
Exploit  the 
Go To  Special
dialog.    It  selects 
special  cells  on  the  active  worksheet;  for  in-
stance, click 
Constants
and 
Numbers
to select all 
cells containing a number, or click 
Formulas
and 
Errors
to  select  all  cells containing  error  values 
like 
#N/A!
or 
#DIV/0!
 The 
Row differences
and 
Column  differences
options  are  especially  useful 
in  discovering  formulas  that  differ  from  their 
neighbors. 
Use  conditional  formatting  to  highlight  un-
likely results.  Or collect all your sanity checks 
at the end of the spreadsheet.  If the new product 
forecast  on  the  sample  spreadsheet  suggests  a 
57% net income, it’s either a great new product 
or there’s some error in model or data. 
Format  using styles  rather than toolbar  but-
tons.    In  fact,  you  should  close  the  formatting 
toolbar  entirely.    Styles  can  be  applied  quickly 
once  they  are  set  up  and  provide  a  consistent 
interface to the reader; you may want to add the 
style  control  to  the  standard  toolbar.    Save 
common  styles  in  a  template  in  your  XLStart 
folder.  Even better, program common styles on 
a  toolbar  loaded  by  an  add-in,  and  have  every-
body  in  your  department  use  the  same  format-
ting styles, giving a consistent look everywhere. 
Use  blanks  around  rows  and  columns  to  de-
fine  “areas.”    Areas  (a  maximal  rectangle  of 
occupied cells surrounded by  unoccupied cells) 
have  meaning  to  Excel’s  object  model,  define 
the extent of an 
END+ARROW
key, and can be un-
ioned to form a range.  It may be useful to make 
each distinct area a separate worksheet.  Instead 
of blank rows and  columns, create output space 
using  row  height  and  column  width,  and  use  a 
single  cell  with  embedded  newlines  to  store  a 
lengthy column header. 
Avoid color.  Although some printers now han-
dle color, most photocopy and fax machines still 
don’t,  so  assume  a  black-and-white  world.  
That’s  limiting  only  if  you  let  it  be;  remember 
Apple’s original  Macintosh was  gray-scale, but 
the crisp, clear screen made many color screens 
look blurry and ugly by comparison.  Also avoid 
shaded backgrounds that lose contrast.  
Don’t let  your charts look like ducks.
39
Line 
charts  present  continuous  data,  bar  charts  pre-
sent discrete data, and pie charts show the com-
ponents  of  a  single  variable.    Area  charts  and 
stacked bar charts show how the components of 
 variable  fluctuate  over  time,  for  continuous 
and  discrete  variables,  respectively.    A  scatter 
chart  shows  the  relationship  between  two  dis-
crete variables.  Charts with a false third dimen-
sion  should  be  avoided,  since  the  extra 
dimension adds clutter without adding meaning. 
Never  do  the  same  thing  twice;  record  a 
macro  instead.    The  macro  will  do  the  job 
much  faster  than  you  can,  and  more  consis-
tently.    It’s  not  hard
40
to  write  simple  macros, 
especially if you use the macro recorder, and the 
effort you put into learning to write macros will 
be  amply  repaid  in  improved  accuracy  and  re-
duced development times. 
How do you know your spreadsheet is right? 
Page 8 
Break up a complicated expression into mul-
tiple  cells  with  intermediate  results.    The  re-
sult  is  generally  more  readable  than  one  big 
formula could ever be.    Often,  the  intermediate 
results are useful, too.  If you wish, 
ASSERT
that 
the final  answer is  the  same  as  the  complicated 
expression.    But  consider  the  earlier  advice 
about  cascade  lengths,  and  consider  the  next 
technique, which provides an alternative. 
Write a  VBA function rather  than  a compli-
cated expression.   VBA provides more built-in 
power  than  Excel  expressions,  so  VBA  func-
tions  can  do  more  things  more  easily.    If  you 
can write Excel expressions you can write func-
tions,  at  least  simple  functions  that  avoid  such 
features as loops and file operations. 
Let  the  VBA  development  environment  help 
you.  The single most important rule is  to auto-
matically  set 
OPTION  EXPLICIT
by  clicking  on 
Require Variable  Declaration
; think of it as a  pro-
phylactic for  your code.  Make friends  with the 
Object Browser, and learn to find objects in the 
help  screens.    Use  the  debugger  to  set  watch 
variables  and  breakpoints  and  single-step  your 
code. 
Build  a  library  of  frequently-used  macros 
and  functions.   Store  the library  in  your PER-
SONAL.XLS  spreadsheet  so  it  is  always  avail-
able.    But  be  aware  that  your  personal  macros 
and  functions  won’t  be  available  if  you  share 
your spreadsheet with someone else.  If you pre-
fer,  common  macros  and  functions  can  be  dis-
tributed in an add-in. 
Build templates for common tasks.  Templates 
store  captions,  formulas,  formatting,  and  mac-
ros,  making  it  easy  to  build  a  set  of  similar 
spreadsheets.    Templates  speed  debugging  as 
well as  development  because  the  common  por-
tions only need to be debugged once. 
Use  a  macro  to  automatically  add  the  user 
name,  file  name,  date  and  time  to  the  footer 
of all your spreadsheets.  Your readers deserve 
to know.  A macro stored in an add-in that traps 
the 
WorkbookBeforePrint
event  is simple  and 
convenient,  and  can  use  VBA  functions  to  ex-
tract 
Workbook  Properties
and  perform  other 
useful  tasks.    You  may  want  to  have  the  same 
macro force a file-save with a new name, so you 
can quickly return to any printed version of your 
spreadsheet. 
Print a listing of all your formulas.  If you fol-
low the earlier advice to name all cells and write 
one formula per row or column, you can print a 
list  of  all  your  formulas  by  transposing  the 
spreadsheet so  attributes  run  down  the  left  col-
umn,  displaying  formulas  rather  than  values, 
and printing.  The resulting listing shows all the 
logic  of  your  spreadsheet,  neatly  formatted.
41
It’s  much  easier  to read  the  printed  listing than 
to  scroll  back and  forth  from cell to cell  on the 
screen;  when  you  look  at  cell  addresses  on 
screen,  you  tend  to  think  physically  (“that  cell 
over  there”)  rather  than  logically (“unit sales”), 
and what do  you do if “over there” has scrolled 
off the screen?  That listing, with all your hand-
written  notes and  marks,  is  an excellent  exhibit 
to show the auditors why you think your spread-
sheet is right; it’s even useful to show your boss 
how hard you worked. A formula listing of col-
umns  C2  and  C4  of  the  sample  spreadsheet  is 
shown below: 
Year 
=1+Prior_Year 
Unit_Sales 
=(1+Growth_Rate)*Prior_Year 
Price_Per_Unit  =(1+Growth_Rate)*Prior_Year 
Cost_Per_Unit 
=(1+Growth_Rate)*Prior_Year 
Fixed_Costs 
=(1+Growth_Rate)*Prior_Year 
Sales 
=Unit_Sales*Price_Per_Unit 
Cost_Of_Sales 
=Unit_Sales*Cost_Per_Unit 
Fixed_Costs 
=Fixed_Costs 
Pretax_Earnings =Sales-Cost_Of_Sales-Fixed_Costs 
Income_Tax 
=Pretax_Earnings*Tax_Rate 
Net Income 
=Pretax_Earnings-Income_Tax 
Use  a  spreadsheet  auditing  tool. 
Excel’s  au-
diting toolbar allows you to trace precedents and 
dependents  and  highlight  invalid  data,  but  is 
otherwise  limited.    Spreadsheet  auditing  tools
42
help you identify errors with a variety of identi-
fication,  searching,  reporting,  and  visualization 
techniques; using them  will help  you  better  un-
derstand your spreadsheet.  My CellMaps
43
tool 
colors cells according to type, as in this display 
of  the  sample  spreadsheet,  showing  input  cells 
with  pink backgrounds,  formulas  with  lavender 
How do you know your spreadsheet is right? 
Page 9 
backgrounds,  and  formulas  copied  right,  down 
and  both  with  blue,  green,  and  gray  back-
grounds, respectively. 
Avoid  common  errors.   The  single most com-
mon  error
44
in  spreadsheet  development  is 
pointing  to  the  wrong  cell  during  formula  con-
struction;  fortunately,  use  of  named  ranges 
eliminates  that  problem,  as  long  as  you  con-
struct  the  range  names  automatically.    Other 
common errors include: 
•  Changing some but not all of a series of copied cells 
(array formulas prevent this problem, but at consider-
able inconvenience); 
•  Incomplete ranges (cells are omitted from one end of 
a range or the other, often when a range is expanded 
but the formula that relies on the range isn’t changed; 
this was the error in the TransAlta case); 
•  Temporary fixes (a calculated cell is replaced by the 
amount it  calculates, perhaps to  make  the  rounding 
come out right, but is not changed back to a formula 
when the input values change later); 
•  Confusion  between  relative  and  absolute  references 
(R1C1-style cell references clarify the difference, and 
named ranges help, but training is the only answer for 
this problem); 
•  Incorrect units (mixing apples and oranges, this prob-
lem is frequently seen when mixing units with thou-
sands of units); and 
•  Function arguments in the wrong order (this error can 
be hard to find, but using the function wizard to help 
write unfamiliar functions can make it less frequent). 
Even  more  common  than these  technical  errors 
is failing to meet the specifications of the task.
45
It  never  hurts  to  write  down  exactly  what  you 
intend  to  do, and  get  approval  from  your spon-
sor before you proceed. 
Check your work before you publish it.   Cal-
culate check totals.  Compare to previous work.  
Test with known values.  Put zeros in all the in-
put cells, and ensure the output is zero.  Perform 
dimensional  analysis,
46
to  make  sure  the  units 
come  out  right.    Perform  sensitivity  analysis; 
does  adding  one  more  unit  sold  increase  pretax 
earnings by the gross profit of one unit?  Stress 
test  your  spreadsheet  at  the  outer  limits  of  all 
data  validation  bounds.    Sit  down  and  read  a 
printed  version  of  your  spreadsheet,  as  if  you 
were  the  intended  reader.    Approach  your 
spreadsheet as if you were an auditor examining 
any  financial  exhibit;  test  the  footings  with  a 
calculator  and  tie  all  inputs  to  source  docu-
ments.  Wait until morning, then check it again.  
Best  is  to  document  your  test  plan  before  you 
begin  work,  then  perform  your  test  plan  before 
you  publish.    Spreadsheets  that  are  large,  com-
plex, of great import or urgency, or that have ill-
defined  specifications  bear  more  risk  and  thus 
require  more  testing  than  spreadsheets  without 
those  properties.    Don’t  fret  about  errors  your 
tests  reveal;  remember the purpose of testing is 
to  find the  errors that certainly  exist, so  finding 
an  error  is  a  vindication  of  your  test work,  not 
an indictment of your development work. 
Have a colleague check your work before you 
publish it.   He  should review  your documenta-
tion,  analyze  your  design,  critique  your  test 
plan,  and  test  for  reasonableness.    Cell-by-cell 
inspection is  tedious,  but  is  the  only  method  of 
spreadsheet testing known to be effective.
47
My 
TrafficLights
48,49
tool,  shown  in  action  below, 
provides  a  simple  framework  for  cell-by-cell 
inspection.    The  auditor  has  already  checked 
green  cells,  finding no  errors.   Yellow  cells are 
ready  to check because, as the arrows show, all 
their precedents are green.  The auditor is about 
to check R7C3; adjacent cells with the same for-
mula  are  a  darker  yellow,  suggesting  to  the 
auditor  that  he  may  want  to  check  them  at  the 
same time.  Red cells are not ready to check be-
cause  they  have  unchecked  precedents.    When 
How do you know your spreadsheet is right? 
Page 10 
the entire spreadsheet is green, the audit is com-
plete. 
Work  in  pairs.    Panko  and  Halvorsen
50
report 
that the effect of combining the efforts of multi-
ple  spreadsheet  developers  working  together  in 
front  of  a  single  computer  is  positive,  reducing 
errors  as  each  checks  the  work  of  the  other.  
One approach  to  pair programming
51
is  to  cou-
ple  a  spreadsheet  expert  with  a  domain  expert; 
their  skills  complement  each  other.    Another 
approach  is  to  couple  a  domain  expert  with 
someone  junior  (or  someone  expert  in  a  differ-
ent domain), to allow skills transfer between the 
two.  Two or more auditors also seem to be bet-
ter  than  one;  related  work  by  the  same  authors 
shows
52
that  two auditors who check independ-
ently  then  compare  notes  will  find  over  four-
fifths of all errors, as compared to the third-to-a-
half of errors found by a single auditor. 
Create  an  organizational  environment  that 
encourages  correctness.    Insist  on printing the 
developer’s  name  on  each  page  of  a  spread-
sheet;  asking people to acknowledge their work 
is a powerful  incentive  for  them  to  get  it  right.  
Establish a  formal system  of peer  review  of  all 
spreadsheets;  be  sure  to  add  the  reviewer’s 
name  to  the  identification  string  in  the  footer.  
Print  and store  documentation and  formula list-
ings in a standard location and periodically pick 
one for review and  group discussion.  For criti-
cal spreadsheets, two developers can work inde-
pendently  writing  two  separate  spreadsheets, 
then compare, cycling until both agree. 
Maintain  a  log  of  spreadsheets  in  use.    Re-
view  the  log  with  your  boss  monthly.    Mark 
critical  spreadsheets  for  audit,  and  allocate  the 
needed time.  Don’t maintain your log by hand; 
instead,  write  a macro that  crawls  your file tree 
and  extracts  the  documentation  from 
Workbook 
Properties
  Called  as 
PasteSpreadsheetLog 
"C:\", ActiveCell
,  the crawler shown  below 
is a useful starting point for a crawler specific to 
your needs: 
Sub PasteSpreadsheetLog( _ 
ByVal DirName As String, _ 
OutCell As Range, _ 
Optional Headers As Boolean = True) 
Dim CurrFile As String, CurrDir As String 
Dim DirNames() As String, DirIndex As Integer 
Dim InBook As Workbook, OutBook As Workbook 
DirIndex = 0 
Set OutBook = ActiveWorkbook 
Application.ScreenUpdating = False 
If Right(DirName, 1) = "\" Then 
DirName = Left(DirName, Len(DirName) - 1) 
End If 
If Headers Then 
OutCell.Offset(0, 0) = "Directory Name" 
OutCell.Offset(0, 1) = "File Name" 
OutCell.Offset(0, 2) = "File Size" 
OutCell.Offset(0, 3) = "Author" 
OutCell.Offset(0, 4) = "Comments" 
OutCell.Offset(0, 5) = "Checked By" 
OutCell.Offset(0, 6) = "Purpose" 
Set OutCell = OutCell.Offset(1, 0) 
End If 
CurrFile = Dir(DirName & "\*.xls", vbNormal) 
Do Until CurrFile = "" 
If CurrFile <> OutBook.Name Then 
Workbooks.Open _ 
FileName := DirName & "\" & CurrFile 
Set InBook = ActiveWorkbook 
On Error Resume Next 
OutCell.Offset(0, 0) = DirName 
OutCell.Offset(0, 1) = CurrFile 
OutCell.Offset(0, 2) = _ 
FileLen(DirName & "\" & CurrFile) 
OutCell.Offset(0, 3) = InBook.- 
BuiltinDocumentProperties("Author") 
OutCell.Offset(0, 4) = InBook.- 
BuiltinDocumentProperties("Comments") 
OutCell.Offset(0, 5) = InBook.- 
CustomDocumentProperties("Checked by") 
OutCell.Offset(0, 6) = InBook.- 
CustomDocumentProperties("Purpose") 
On Error Goto 0 
InBook.Close SaveChanges := False 
Set OutCell = OutCell.Offset(1, 0) 
CurrFile = Dir 
End If 
Loop 
Documents you may be interested
Documents you may be interested