products - Perfect Developer
Step-by-step
guide to software development using Perfect Developer
Here is our recommended approach for developing
a system or a component. You may wish to adapt it to suit
your particular development needs and preferences (for example,
your Quality Plan may require additional deliverables);
or you may wish to use an agile method such as Extreme Specification
instead..
| Step
summary |
Detail |
Deliverables |
| 1 |
Establish
and record the requirements |
However you wish
(Perfect Developer does not address this step). |
Informal description
of requirements. |
| 2 |
Design
an architecture for the system, including the simplest possible
abstract model of the data |
Either construct
a UML model (you will need a UML modelling tool) and import the
class diagrams into Perfect Developer, or express them
directly in Perfect as class skeletons. |
Perfect class
skeletons with method prototypes. |
| 3 |
Express
the requirements in Perfect |
Express the requirements
precisely in Perfect, adding them to the class skeletons. |
Perfect class
skeletons with precise requirements. |
| 4 |
Specify
the class methods |
For each method
prototype, specify what the method achieves (but not
how). |
Perfect class
skeletons with precise requirements and method specifications. |
| 5 |
Prove
that the specifications are consistent and meet the requirements |
Run the Verify
function of Perfect Developer. Correct the specifications
where Perfect Developer indicates that the requirements
may not be met. |
Proof that the specifications
are consistent and meet the requirements. |
Having reached this stage, if you
are only using Perfect Developer to produce verified specifications,
you can stop here and continue developing the system using your
preferred means. However, most users will want to produce verified
designs as well, continuing as follows. [Note: steps 6 and 7 may
not be appropriate and may be omitted, e.g. when developing real-time
applications].
| Step
summary |
Detail |
Deliverables |
| 6 |
Build
a prototype |
Run the Build
function of Perfect Developer and compile the generated
code. In some cases you may need to do a limited amount
of method refinement first (see step
9). |
Fully-functional
prototype, possibly good enough for production use. |
| 7 |
Evaluate
the prototype |
Deliver the prototype
to target users to try out. Solicit feedback to verify that
the user requirements were correctly captured and to establish
what performance improvements are needed. |
Confirmation that
user requirements were correctly captured. Report on which aspects
of the prototype (if any) provide inadequate performance. |
| 8 |
Refine
the abstract data model to an implementation model, if and where
needed |
Where the prototype
provides inadequate performance, determine whether a change
in the representation of data is needed in order to achieve
the required performance. For example, a set
of records might be replaced by a hash table, or supplemented
by adding an index. Add the new data as internal data
in the Perfect classes. Specify how the internal data
is related to the original abstract data model. |
Internal data added
to Perfect classes where needed. |
| 9 |
Add
efficient implementations of methods, where needed |
Where internal data
has been added or performance is insufficient, attach implementation
code to the method specifications. You do not always need to
provide full implementation code; sometimes it is sufficient
merely to specify the major steps required. |
Implementation code
added to Perfect method specifications where needed. |
| 10 |
Prove
that the implementations are correct |
Run the Verify
function of Perfect Developer. Correct the implementations
where Perfect Developer indicates that the specifications
may not be satisfied. |
Proof that the implementations
and internal data correctly implement the specifications. |
If you wish to complete the project
using hand-written code, you can now do so, using the verified design
as a model. However, for most applications, Perfect Developer
can perform this chore for you:
| Step
summary |
Detail |
Deliverables |
| 11 |
Build
the system |
Run the Build
function of Perfect Developer and compile the generated
code. |
System ready for
testing |
| 12 |
Test
the system |
Test the system
to ensure that your compiler, linker etc. have not introduced
errors and to make sure the required performance has been achieved.
If improved performance is still needed in some areas, repeat
from step 8. |
System ready for
delivery |
The result: a more reliable
system produced with less effort
than by traditional means!
|
TOP
