. A Glossary of Software Development methods processes and techniques
. Warnings
.As_is There are some attempts at humor here.
. See also
.See http://www.csci.csusb.edu/dick/samples/languages.html/
.See http://www.csci.csusb.edu/dick/etc.html
.See http://www.csci.csusb.edu/dick/research.html
.See http://www.csci.csusb.edu/dick/samples/subjects.html
. ABCD
ADO::=Abstract data Object.
ADV::=Abstract Data View.
ADV/ADO::=An architecture for object oriented software that separates physical and logical structures, and connects objects in a more reusable way.

ADT::="Abstract Data Type",
Precursor to $object-oriented thinking where data is encapsulated
in modules and is accessable only by operations/functions/methods,
but without any form of derivation/inheritance or polymorphism.

ASM::="Abstract State Machines", (formerly Evolving Algebras)     
.See http://www.eecs.umich.edu/gasm/ 

ASD::="Adaptive Software Development", -- a nonmethod!  More of a $process
and management concept than any help to doing software well.
.Box
.See [Highsmith99b]

Jim Highsmith developed
this way of developing software for when the risks are high
and the situation likely to change.  He argues that managers should
not prescribe particular methods or processes but only set objectives.
The teams must do whatever is needed to meet managerial goals.  He
argues for an incremental or evolutionary approach so that as the 
developing software keeps pace with the changing requirements.  He
thinks that there is no way to guarantee success in highly risky
and unstable projects but argues that a flexible and iterative
and well motivated team gives the best chance.  He believes in
internal discipline, understanding and skill rather than forms,
documentation, and preprogrammed process.

ASD is an $Agile method.
.Close.Box
Agile::="Allowing developers to do the right thing at the time".
A group of methodologists who don't like rigid methods have
formed an alliance promoting methods that let people adapt
quickly to new circumstances.  These methods are good when
circumstances are changing or undefined. See $ASD above and $XP
below.
.Find AGILE

aspect::="A cross cutting concern that impacts many different parts of a program".
AOP::="Aspect Oriented Programming",
An Aspect is some desirable property of a piece of software
that can only be be implemented by code is many different places
in the software.  Aspect oriented tools allow these cross-cutting
concerns to be written once and automatically propagated to all
the places where they might be needed.
.Find ASPECT

B::=a method developed by Jean-Raymond Abrial.
Comapre the $Z specification language.
Booch::=a method and a methodologist, See $UML

BON::=Business Object Notation.
.See http://www.eiffel.com/products/bon.html
at
.See http://www.eiffel.com/
(Interactive Software Engineering</A>)

bottom_up::=attempting to create something by assembling components so that when connected together they satisfy the clients needs, also known as flying a kite.
.See top_down

catalysis::method=http://www.catalysis.org/.

CLEANROOM::method=a rigorus quality controled and structured method of software development and management distinguished by the idea that code must be shown to work before it is tested and code is then tested against a simulated sample of typical uses.

Coad_method::=An object oriented method developed by Peter Coad of Object Iternational, Now chief strategist at Borland.
.See http://www.oi.com/peter/index.htm

collaboration::=`co_labor_ation: pertaining to working together`.
collaboration::=`A relationship between two classes when an object in one class needs to make use of some member of an object of the other class in some way or other`.
collaborator::=`something that takes part in a colaboration`
CRC::card=Class><Responsibility><collaboration.  A way to record and develop an
object oriented class structure that fits a set of use-cases or scenarios.

contracts::=plural of $contract.
contract::=a clear specification of what a piece of software is
responsible for and what it assumes about the rest of the software.

data_structure::= A small transient data base.
data_base::= A large persistent data structure.

death_march::="Any project that has less than 50% of the time or resources rationally needed to complete."

discrete_mathematics::=`Computers and information systems are handling discrete objects and discrete methematics studies their behavior`.
Discrete mathematics is essentially one step more complex
than symbolic/formal logic.
It is a $weak technique that can be incorporated into
any method or process.  There are three problems: it's almost trivial
mathematics so it is not taught well, it does take training to use, and
the common notations do not fit with common computer technology.
It has the advantage of abbreviating complex sentences into shorter
forms with well-defined operations.
See $Z $MATHS 

design::= $look_and_feel | $internal_structure.  This is ambiguous and causes many useless dscussions where the discussants have adopt different definitions.
.Box
Because the interface with the outside world needs to be tuned to 
fit users and circumstances independently of changes in the 
internal logic of a piece of software it is worth separating these two
concerns.  This is the most obvious form of Parnas's 
$information_hiding.

Internal design is about splitting up software
into structured subprograms($SP), functions($functional) or 
objects($object_oriented), or responsibilities($RDD)
with or without $contracts.

.Close.Box
design_by_contract::=following
.Net
 Design By Contract
 A direct
application of $information_hiding
combined with techniques developed for assuring the correctness
of algorithms.  A $contract specifies a set of rules
for two parts of a program to work together.  It states that
if one part behaves in the correct manner then the other part
will guarantee to also work in a specific (correct) manner.
Implicitly, this means that one part doesn't have to worry
about actions that don't fit the contract, or about how
contractual obligations are met.  The technique has been
embedded in the Eiffel $OOPL and marketed by
Bertrand Meyer.
.Close.Net

. EFGH

ELECTRE::= Reactive language or method, $RFP.

Enterprise Modeling::= $RFP.

ESTEREL::= Reactive language or method, $RFP.

Equational Logic::=Teaching Logic as a Tool 
.See http://www.cs.cornell.edu/Info/People/gries/logicthetool.html
by David Gries 
.See http://www.cs.cornell.edu/Info/People/gries/gries.html

extreme::buzz_phrase="identifies a method, process, or sport as a late 1990's thing".

Extreme_Programming::process=$XP.

Formal_Methods::= "Using math and logic in software development" | $Fragile_process.
.Box
Those who develop and use what they call "Formal methods"
mean something different to those who reject "Formal Methods". 
To the some, "Formal" means "Mathematical" and/or "Logical".
Others think that "Formal" means structured, "tidy", controlled, using
lots of redundant paper, or following someone else's
rules. For this meaning see $Fragile_process below. 

Mathematical and Logical methods use a well defined set of formula
and `creativity` to help express and solve problems.  The 
solution to the problem can then be checked by applying a collection 
of clearly specified rules.  As an elementary 
example: arithmetic and algebra are mathematical methods.  Boolean 
algebra and symbolic logic are well known formal systems.  There 
are now a set of mathematical methods that have been demonstrated 
to help good people do good work in some industries - saving money
as a result.  However mathematics and logic may not fit your project.

Examples: $CLEANROOM, $NORMALIZATION , $SDL, $VDM, $B.

There are languages that support mathematics and logic: $Z, $MATHS, ...

See 
.See http://shemesh.larc.nasa.gov/fm/fm-what.html
.See http://www.cs.man.ac.uk/fmethods/projects/essi-ConForm.html
.See http://eis.jpl.nasa.gov/quality/Formal_Methods/

Tools: $PVS

Teaching:
David Gries and Equational Logic
.See http://www.cs.cornell.edu/Info/People/gries/logicthetool.html

Puzzles
.See ftp://ftp.cs.uidaho.edu/pub/formal-methods/simple-puzzles.text

There are also semi-formal methods like $JSP and $JSD that hide
their mathematics away.
.Close.Box

Fit::acronym="Framework for Integration Tests",
Fit::=http://fit.c2.com.

Fragile_process::= one_of following,
.List
 A high ceremony process.
 A mature, rigid, and documented way of producing software that often
use a mathematically ill-defined set of notations and ideas.
 Anything the restricts the programmer's freedom.
 A process that produces something other than executable code.
.Close.List
Often confused with a $Formal_method.

FTR::=Formal Technical Review.$RFP

functional::=one_of following
.List
 Something that works.
 A thirty-year old method of software design that works if you believe in it.
.See [Strachey66]
 Divided up into a set of $functions.
 Pertaining to a set of $functions.
.Close.List

functions::=plural of function.
function::=one_of following,
.List
  (math) A many-to-one total relation between two sets.
  (business) Why they pay for the software.
  (C/C++) A subprogram.
  (Pascal/Ada) A subprogram that returns a value.
.Close.List


Fusion::=HP's 2nd generation $OO method.$RFP

GRAFCET::=a IEC standard, 
.See ./methods.html#GRAFCET
for details.

HOL::=Higher Order Logic,
tools:
.See http://www.lemma-one.com/ProofPower/index/index.html

HOOD::= Hierarchical Object-Oriented Design.
.See http://www.cs.york.ac.uk/rts/books/hood.html
.See [RobinsonP92]
.See [DelatteHeitzMuller93]

. IJKL
information_hiding::=one_of following,
.List
  (Parnas): The doctrine that modules should be chosen so that
each design choice is placed inside a separate module in a way
that makes it easy for the choice to be changed without effecting
the rest of the code. Easy implementation needs $OOT.
See 
.See http://www.acm.org/classics/may96/
and $ADV/$ADO.
  (Popular) Not being allowed to read code. 
  See $design_by_contract.
.Close.List

IP::= "Intentional Programming",
.Box
Based on the harmfulness of syntax this method attempts to 
revolutionize programming(ho hum).   In place of textual source 
code a program is expressed as a tree which contains definitions of
the intent (why) and implementations (whats) of various ideas.  The
environment provides `enzymes` that manipulate the tree and
so the program.  One problem is to re-engineer existing source code
into $IP trees.  One step that is available is to 
`raise the intentional level` of a program by replacing
a chunk of code by a terser expression.

The method seems to a combination of $VDM/VDL trees with a 
touch of $literate_$programming.

But IP comes from Microsoft, so how can it fail?
.Close.Box

Jackson::people=$JacksonMichael | $JacksonDaniel | JacksonK.
Michael is the father of Daniel.
JacksonK invented $MASCOT.

JacksonDaniel::computer_scientist=http://sdg.lcs.mit.edu/~dnj.

JacksonMichael::methodologist=http://dspace.dial.pipex.com/jacksonma/,
see $JSD, $JSP, ...

JSD::=following,
.Net
JSD is a $strong $semiformal method.

A way of analyzing  a situation
into a set of independent but connected dynamic objects with a
high degree of information hiding.
JSD is unusual in that it was the first method
to make heart of the design a simulation of a real system.
It is largely independent of the current functions of the software.
Additional control and reporting functions are added to the central
simulation.  It is suitable for MIS and Real Time systems.  

For more information see
.See http://www.kcsl.btinternet.co.uk/
Keywood Computer Services Limited, UK user group,
and
.See http://home.att.net/~stephen_ferg/index.html
Stephen Ferg's Home page.

JSD, $JSP, and $SSADM share a common diagrammatic notation for
expressing the structure of events and data.
.Close.Net

JSP::="Jackson Structured programming".
JSP is to Data Processing
what "The Dragon Book" is to Programming Languages.
.Box
A $strong $semiformal method suitable for problems that involve processing
data. JSP involves describing the logical structure of the data in
a diagrammatic set of context free grammars.  These become the basis
for a set of cooperating sequential processes with back-tracking.
These are easy to code in COBOL, Assembler and other
languages that permit goto statements.

The ideas for 'JSP' came from Michael $Jackson's work at a UK software
house in the early 70's but they have a solid mathematical basis
in grammar theory.  They adopted the name 'JSP' because
all methods in the 70's had to have the word 'structured' in them 
(private communication, Simpson's on the Strand, London, Circa 
1980).

Try
.See http://www.kcsl.btinternet.co.uk/
Keywood Computer Services Limited, UK user group,
and
.See http://home.att.net/~stephen_ferg/index.html
Stephen Ferg's Home page.

JSD, $JSP, and $SSADM share a common diagrammatic notation for
expressing the structure of events and data.
.Close.Box

LARCH::= (Formal, $ADT Specs) - from Jim Horning
.See http://larch-www.lcs.mit.edu:8001/larch/
.See http://reality.sgi.com/employees/horning_mti/larch-interest.archive.html
.See ftp://larch.lcs.mit.edu/
.See http://reality.sgi.com/employees/horning_mti/handbook.ps

literate_programming::method="A $weak method developed by Donald Knuth the solution is developed as a mathematical paper and translated into code and documentation."

LOTOS::="ISO Standard language that combines CSP/CCS with algebraic $ADT to describe telecommunication systems",
.See http://www.run.montefiore.ulg.ac.be/Research/Topics/index.php?topic=Lotos
.Find LOTOS

LUSTRE::= Reactive language or method, $RFP.

. MNOP
Maria::tool=http://www.tcs.hut.fi/Software/maria/

MartinR::$methodologist="Robert C. Martin",
.See http://objectmentor.com/

MATHS::=`My personal web page and discrete mathematics language`,
.See http://www/dick/maths

MERISE::=a french method for businees applications, $RFP.

methodologist::="A fully mature programmer",
.Box
A programmer who is old enough to
realize that life would be easier if they always did things the
same way.
There are several stages:  
.List
 they organize their own programming, 
 they try to influence their friends, 
 they try to change their organization,
 they try to change the world,
 they become consultants. 
.Close.List
.Close.Box

methodology::=following,
.Net
 The last stage in the life cycle of a software development idea
before it (if successful) vanishes and becomes what everybody does
anyway.

	idea::= hack; trick; technique; pattern; method; (technology | methodology); practice.
 First comes a `hack`.  If this is `neat` then it may be
reused in a different piece of software and so becomes a `trick`.
When used a third time, it becomes a a `technique`.
If there are several similar techniques then a `pattern`(1990s) or
`cliche`(1980s) may be abstracted.  The application of the pattern or
cliche in many (more than three, that is) projects leads to a `method`.
 Sometimes the method is embedded into technology ( a language or tool )
which effectively stops its growth and hastens its death by universal
acceptance.  If the method survives then at some point or other it
becomes highly elaborated or moves across the Atlantic and so 
becomes a `methodology`.

.Close.Net

modular::= Divided up into separated parts.
 Modular programming is a class of informal methods rigidly applied
in the late 60's having been developed in the early 60's to correct the 
problems with complex unmaintainable programs of the 50's.  During
this time the word "modular" was an essential part of any method 
however its meaning depended on the methodologist.  See $SP and $OOP.  
It was said that before modular programming a good programmer wrote 
good modular programs and a bad programmer wrote bad monolithic 
programs.  Afterward the good programmer wrote good modular 
programs and the bad programmer wrote bad modular programs.  This 
was an improvement.

MOSES::=  Method at the University of Technology, Sidney 
.See http://linus.socs.uts.edu.au/~cotar/moses.html

NIAM::=conceptual data modeling
.Find NIAM

normalization::=a mathematical procedure for reducing certain anomalies that occur in badly design data structures and data bases.
It removes all pointers, arrays, repeating groups,
etc. and generates a list of simple tables of records each with
a field that identifies one row in the table.  Normalized data
tends to be easy to understand, search, and update.  Used in
$Shlaer_mellor_method, $SSADM,
and other methods.  Normalized data has to be made abnormal to improve
the performance on all but toy systems.  However normalized
data clearly and simply expresses the logical structure of
the world that the data encodes.

Object::English=a desirable goal.
Object::=A part of a running program that has an independent identity+data+operations. If encapsulated then the data can not be accessed or changed except by the operations.
.See http://www.csci.csusb.edu/dick/samples/objects.html

OMT::=Object Modelling Technique.
.See UML
OO::=$object_oriented,
.Box
A class of informal methods rigidly applied in the 90's having been 
developed 1990-92 to correct the problems with
programming in the middle 80's.  During 1990-2000 the 
phrase "object-oriented" was an essential part of any 
method however its meaning depended on the methodologist.  

By the end of the millenium it became clear that OO means:
.Net
 Classifying objects by their behavior as well as the associations.
 Being able to describe the typical behaviors of a class of objects without describing how they are implemented.
 Being able to supply many implementations for one type of behaviors.  Compare $ADT above.
 Defining new classes of objects in terms of previously defined classes.
 Allowing an object to be refered to be a name or variable associated with a more general class then object itself.
 Expecting objects to be smart enough to select their behavior even when refered to indirectly.
.Close.Net
See $BON $HOOD $UML $Unified $Coad $MartinRobert,
The Object Agency (Ed Berard)
.See http://www.toa.com
which has a number of documents and reports for free downloading 
including "A Comparison of OO Development Methodologies" - a 70 
page report comparing 10 different methodologies.

  Bibliographies
.See [Graham94]
.See [RobinsonBerrisford94]
.Find OBJECT
.Close.Box

OOA::=Object-oriented Analysis.
OOD::=Object oriented Design
OOP::=Object oriented programming.
OOP is a $weak informal method that uses $modules that are
orthogonal to $SP.  SP and OOP were both
invented close to 1970 but SP dominated until the
late 1980's. See

OOPL::=Object oriented programming language.
OOT::=Object oriented technology.
The technology that makes it easy to modularize software into 
objects rather than sequences and selections of procedures and 
functions.  The technology lagged behind the theory for 15 years.

object_oriented::=`using objects+classes+inheritance+polymorphism+etc`, see $OO.
.Box
Newbie asked "Master Li, what is the true nature of 
objects?" The master answered "What is the sound of one programmer
coding" and Newbie said "Hack! Hack! Hack!".  The
master knocked him into a nearby pool of coffee.
As Newbie climbed out he experienced `satori`
and went off to market his own $methodology.
.Close.Box

Object-Oriented::=  Methods(Formal or informal, somewhat unstable), see $OO above.

OSA::= Object-Oriented Systems Analysis at Brigham-Young University , Utah
.See http://osm7.cs.byu.edu/OSA.html

process::="Something looser than a schedule and less technical than a methodology."

Petri nets::technique=An originally overgeneral theory of how a complex 
concurrent system of parts can work together this evolved into a special 
form of diagram which has been used to design operating systems, protocols,
etc.  Also known as marked directed graphs. 
More information in
.See http://www/dick/maths/math_76_Concurency.html
.See http://www.daimi.au.dk/PetriNets/about.html

Process Algebra Semantics::= The report "Process algebra semantics of $\varphi$SDL"  
.See http://www.phil.ruu.nl/home/keesm/SDL.html

PVS::tool="Proof Verification System",
.See http://www.csl.sri.com/pvs.html

. QRST
RAISE::=A formal method intended for industrial use.
.See http://dream.dai.ed.ac.uk/raise/

Refactoring::=a process of code improvement that works by a series of simple steps that leave a program operational.
refactoring::=`technical method of improving code style without changing it;s behavior'.
For example: Copying a piece of code into a function definition and
then replacing the orginal code by a call to the function.
.Box
Refactoring was born in a thesis: 
.See [Opdyke92]
and has become an essential part of $XP and many other methods:
.Find refactor
.Close.Box

RDD::="Responsibillity Driven Design",
Rebecca Wirfs-Brock's way of of packaging the necesary operations in a 
piece of software into coherent modules.
"Objects are citizen's with responsibilities and collaborators".
This way of thinking works so 
well that it has been encorportaed into several other methods.  $CRC cards
are used to document classes, responsibilities, and collaborations. Designs
a tested by a group of people acting out the the behavior of the objects.

responsibility::=something that an object or class either maintains or knows how to do.

RPL::= rapid prototyping for requirements analysis with CASE & OO
.See http://osiris.sunderland.ac.uk/research/canopus/mitchell/rpl.html

SAD::=$Structured Analysis and Design. $RFP.

Scrum::="$Agile $weak $process",
.Box
 The Scrum method seems to be inspired by the game of Rugby.
 This can be described as American football without the armour
 and ceremony.

 Two things seem to be special about Scrum:  the 15 minute daily
 meeting -- where everybody must stand up and reports status, while
 managers listen and look for obstacles that need to be removed.
 The other special thing is that the software is produced in 30 day
 sprints. 
.Close.Box

semiformal::=a method that has a hidden mathematical/logical theory.
Examples: $JSD, $JSP, $SSADM.

SIGNAL::= Reactive language or method, $RFP.

SSADM::=`$Structured Systems Analysis and Design Method`. (semi-formal) 
Note.  This is not SADT or SA/SD because it encorporated ideas such as 
dynamic entities(concurrent objects) and physical design control.
An 'open' method and a registered trademark of CCTA, the UK Government 
Centre for Information Systems.  Google is a good place to find out about
SSADM.  It is still a popular heavywaight method in Europe.

SA/SD::= $Structured Analysis and $Structured Design.  
.Box
A class of weak informal methods rigidly applied in the 80's having been
developed in the 70's to correct the problems with modular 
programming and systems analysis in the 60's.  During this time the
word "structured" was an essential part of any method 
however its meaning depended on the methodologist.  
The two most rigorous methods were $SSADM and $SADT.  Compare with OOA/OOD.
.Close.Box

SADT::=$Structured Analysis and Design Technique.  An interesting method of analysis and design that includes an unusual kind of chart for showing how parts of a
system are related. 
.Box
.As_is 		 ---
.As_is 		| B |----.
.As_is 		 ---     |
.As_is 		  ^     ---     ---
.As_is 		  |    | C |-->| D |
.As_is 		  |     ---     ---
.As_is 		  A
.Close.Box
shows that that A is used to implement B, B controls
C, and C supplies output that is input into D.   Each box
becomes a diagram at a lower level if it is at all complex.
No more than 6 boxes per diagram!  But any number of arrows.
The diagrams are the SA part of SA+DT.  The above diagram does not show
that they are prepared like engineering drawings - names, indexed, signed,...
and subjected to detailed technical reviews.  

DT::part_of($SADT)=Design Technique.
The DT rules like: "Think about the arrows first" plus the discipline of of
reveiws make SADT the method work in just about everything except detailed
design of code.
(The above is my gloss on the method.... if you know
of an Internet source that extends or contradicts 
it, tell me and I will make links here).


SDL::=Formal specification languages used in telecommunications.  Essentially
the basis for UML message sequence charts.
.See http://www.sdl-forum.org/


Shlaer_mellor_method::=recursive design - an object oriented method that includes normalization and dynamics and aims to automate much of the coding.
See Project Technology:
.See http://www.projtech.com

source_code::=The coded version of a software that is translated into an executable form.
.Box
As StarHacker flew over the Evil Empires's DOStar he wondered how he
could destroy it.  He heard a voice: "Use the source, Luke".
[Core Wares, Episode 17.5]

I don't know why, but programmers have always believed that time spent
doing anything but working on code is a waste of time.  This is rather
like a civil engineer deciding that laying bricks is the only thing
worth doing, or an electrical engineer focussing on soldering!

Even famous methodologists are now elevating Source Code to the
methodological pinacle:
.As_is The Code, The Whole Code, and Nothing but the Code!
All diagrams are rejected and the only thinking is done at the
machine.

Code oriented methods tend to be $weak methods.
They need some kind of Quality Assurance to avoid
maintenance nightmares. See testing, pair_programming, refactoring,
smells, inspections, walkthroughs, peer_review, beta, debugging, etc.
.Close.Box



SP::=`$Structured Programming.  Dividing code up using only sequence+selections+iterations`.
.Box
SP is a $weak method.

Structured programming is a class of methods rigidly applied in the
70's having been developed in the late 60's to correct the problems
with complex unmaintainable programs of the early 60's.  During 
this time the word "structured" was an essential part of
any method however its meaning depended on the methodologist.  SP 
can have any degree of formality: For example "No gotos" has none,
but the Dijkstra/Gries Discipline is based on logic.  See 
SA/SD and OOP
.Close.Box

state::=A way of structuring behavior patterns by giving names to certain situations that can occur.
.Box
Also known as "mode".

A way of organizing or modeling a complex behavior.  If something
behaves in one way for a time and then behaves differently we
say it has "changed state".  When the number of different
behaviors are small then a State Transition Diagram (STD) or
table is often used to document the changes.  David Harel has
invented StateCharts to handle more complex systems.  StateCharts
have been adopted as part of OMT and so became part of UML. In
essence StateCharts are a return to the Flowcharts of the 1950's!

Many methods use states as a design technique.
SDL, Shlaer-Mellor, ... But
JSD explicitly avoids states by describing the patterns of behavior
using regular expressions and grammars.  The states are then
derived from these patterns.

States and modes in user interfaces are often a source of problems
for the user but a solution for a harassed designer.

Beware of states but seek them.
.Close.Box

SQA::=Software Quality Assurance.  Any technique that reviews any document
or product to see how good it is.   These vary from formal inspections
to pair programming.  They are commonly applied to code, but pay off
better if applied to user requirements and designs.

STL::="The C++ Standard Template Library",
.See http://www/dick/samples/stl.html

strong::@methods=`Methods that apply to such a small number of problems that they provided precise and powerful help in solving them.`, See $weak,
.See [VesseyGlass98]
and
.See [Jackson95c]

Structured::= divided into pieces according to some set of rules based on a favored set of coding structures.  Different methods favor different sets of coding structures.
structured::= a popular buzz word in the 1960's and 1970's. See
$SP, $SSADM, $SADT, etc etc.
.Box
The incredible Mullah Nazourdon often gave advice
on methods to people in his village.  This varied from year to year
but the methods were always described as "structured".  The
villagers noticed this an asked him why.  He replied that
they wouldn't work unless they were called "structured".
So the villagers asked him if he meant that his clients
wouldn't work or that the methods would not work. And he
said: "Yes".
.Close.Box

testing::=finding out if a program works on a particular set of data.
.Box
There is some experimental evidence that more tests means fewer bugs.

But testing gives a feeling of false confidence -- a defect
will hide where the tests don't go, and in any relaistic
piece of software there are too many paths possible to
cover even 1% of them.   You have to back up testing with
with other disciplines such as code inspection, careful
design, and both unit and accptance testing.

unit tests, acceptance tests, ...
.Close.Box
test_driven_development::=`A process where the tests are coded and
run before the "real" code is written`.

TLA::=The Temporal Logic of actions
.See http://www/dick/methods.html#TLA

top_down::=Attempting to design something by breaking a large probleme into to smaller problems and solving each of these in turn.  Also know as building castles in the air.
.See bottom_up

. UVW
UML::=Unified Modeling Language
.See http://www/dick/samples/uml.html#UML
.Box
Once three methodologist tried to define an elephant:              
One said it looked like a cloud, the next said it looked           
like an upside down tree, and the third said it was a suitcase.

And they all lived happily ever after in the cave of
the jolly blue giant. 
.Close.Box

VDM::=Venna Development Method is based on a mathematical language (VDL) developed in the 1960's for defining the semantics of languages in terms of trees.
.Box
The IBM Laboratory in Vienna once invented a language to define the precise
mathematical semantics of programming languages.  It was called VDL (Vienna Definition Language) In time Cliff Jones worked out some denotational semantics of VDL and it re-emerged as VDM:
Vienna Definition Method.

There is an ASCII based Specification Language: VDM-SL

Also see Z_vs_VDM below.

.Close.Box

weak::@methods=`methods that apply to many problems but do not provide powerful and detailed help solving them`, See $strong.

. XYZ
XP::=$Extreme_Programming.
XP::@method=a rigid informal code_centered Agile process.
.Box
Just when I thought we'd seen the last of the `XY`P methods along
comes XP.  You might think that extreme programming offers
the safety and stability of jumping
off a cliff on a skate board while holding hands with a colleague.
However, because the XP team shows what it can do, as quickly as possible,
it can itterate to a solution that keeps the customer satisfied.

In fact extreme programming offers more disciplined control of
risk than many older methods.  An eXtremely eXciting time
is offered by Highsmith's Adaptive Software Development($ASD).
The $Scrum method claims to be a less disciplined
process which fits the same situations as XP: small colocated team with
a customer representative on site.

XP has many techniques that evolved in practice
and not got any academic respect -- possibly because people
in academe tried them 30 years ago.  Some have
a strong retro feel:  `the design is the code` is pure
a 1960s slogan($source_code).

XP is also highly prescriptive.  Kent Beck lists the critical components:
{ write test first, the planning game, short release cycle, pair programming,
onsite customer, open workspace, yesterday's weather predicts tomorrow's,
refactor code to say every thing once and only once, continuous integration,
collective ownership of all code, sane hours, programmer's resist business pressure },
(Redacted from  Kent Beck's article in the Cutter IT Journal
.See [Beck00a]
).

There is an excellent road map for XP at
.See http://c2.com/cgi/wiki?ExtremeProgrammingRoadmap
and lots of discussion on the rest of the WikiWikiWeb site:
.See http://c2.com/cgi/wiki?WelcomeVisitors

If the above links don't work I made a local ripoff of the
.See http://www.csci.csusb.edu/dick/XPRoadMap.html
Extreme Programming Road Map.

XP is an $weak $Agile $process.
.Close.Box

YSM::="Yourdon's Methods",
These methods span from $SP through to the start of the
object-oriented revolution of the 1990s.  Mike Brough was involved
in this and has prepared an excellent page
.See http://www.keele.ac.uk/depts/cs/Staff/Homes/Mdb3/courses/SD2001/ysmhist.pdf
describing the evolution of the methods.  A fascinating process.

Z::=a mathematical language designed for specifying complex pieces of software.
.Box
.See http://www.afm.sbu.ac.uk/z/
.See http://www.csci.csusb.edu/dick/samples/z.syntax.html

.See http://www.comlab.ox.ac.uk/archive/
.See http://www.lemma-one.com/ProofPower/index/index.html

Z Extensions
.List
 Z/Eves -- for mathematical specifications?
 OOZE - object oriented?
.Close.List
.Close.Box

Z_vs_VDM::= http://www.comlab.ox.ac.uk/archive/z.html#vdm
and
.See http://www.cs.man.ac.uk/csonly/cstechrep/Abstracts/UMCS-93-8-1.html

. Send me EMail
RFP::=Request For Pointer.  If you know of any URLs that I have missed for any
methods/languages please send me EMail (rbotting) at CalState(CSUSB.edu).