Function - a small block of code which takes a single set of input
and provides a single set of output.
Tool - a group of related system functions used by a
large number of other parts of a software system to provide system type
functionalities. For example: external access, resource management or
Unit - A group of related business functions that work
together to provide a business functionality. For example: order entry,
generation of a specific report or calculation of stock requirements.
Software goes through many phases during its development and maintenance.
These phases are usually referred to as the software life cycle. Most
software will go through these phases more than once. Knowing which phase
the software is currently in is very important to good software development.
I like to breakdown the software life cycle this way.
- Problem identification - At this step you want to identify what need
you are trying to fill and to determine what it would take to make
an improvement. Who are the people who will be affected by the solution.
- Learn the job - How can you create good software to replace a task
if you do not know how to do the task? It is imperative to watch people
do their jobs.
- Make a design plan - This plan lays out how you will go about developing
the design (and prototypes).
- Create initial design (and prototypes) - This design gives scope
to the design and provides the people who will be using the software
a chance to examine your understanding of their jobs.
- Review the design (and prototype) - With the people that will be
using the software explain what you will be doing for them. (Repeat
steps 4 and 5 until consensus is achieved)
- Implementation plan - This is a detailed (level of detail depends
on complexity of solution) plan that allows many developers to work
together. They each can tell what their part is supposed to do and
how it connects to all of the others. At a minimum it lays out all
the units and estimates of how much work is required for that unit.
- Testing plan - This is a detailed (level of detail depends on complexity
of solution) plan that explains how the software will be tested as
a unit to decide when it is ready for release. Additionally, it outlines
how each function within the system should be tested as it is implemented.
- Tool Implementation - Each tool that will be required during unit
implementation is built and tested during this phase. For each tool
a test suite is created to make sure that when the business logic
tries to use the tools they will function as expected.
- Unit Implementation - Each function within the design is implemented,
in addition for each function a test suite is created that tests that
the function provides the correct results for any given set of input.
- System Implementation - This is when all of the units are combined
into the application.
- System Test - This phase is in some ways the most difficult. (This
is where most of those 260 folks at NASA earn their $750,000,000.)
When all of the parts are assembled, units that worked flawlessly
by themselves suddenly start having problem because of interaction
with each other. Good software is tested that it does what it is supposed
to and that it handles error conditions well.
- Beta Test - Controlled environments are nice, but they hide blind
spots. This is also the chance for the people who will be using the
software to really make sure that the software will meet their needs
in ways that were not fully possible in steps 4 and 5.
- Repeat steps 4 through 12 as necessary for the life of the software.
If the implementation and testing plans are well done, there will be
many small milestones along the way to gauge overall progress. Ideally,
milestones are no longer than 2 weeks, so that delays can be quickly
caught and addressed.