Deliver specifications and implementations in parallel
The principle "Deliver specifications and implementations in parallel" invites development teams to record specifications of their work in the same development environment as where the actual working software (the implementations) is manufactured.
Many organisations are looking for this combination of specifications and corresponding implementations, because it solves the well-known problem of not knowing exactly what software does, or where in the software a given specification has been implemented.
The USoft Approach delivers this desirable combination more fully than other platforms:
•Specifications and implementations are stored in (different tables of) the same repository. The basic format for both specifications and implementation is database records, not (sections of) documents. This makes it easier to be methodical about specifications and implementations, and it makes it easier to establish point-to-point and queryable two-way references between specifications and implementations.
•The USoft Approach takes a specific view of the preferred format of both specifications and implementations and does this in such a way that the two are more easily linked than on most other platforms.
•Specifications in USoft do not typically express the behaviour or characteristics of software, but rather the desired structure and rules of target business conduct. The USoft approach favours specifications of structure in the form of structured, modelled business vocabulary. It also favours specifications of rules in the form of natural-language statements that express business rules.
•The format that USoft favours for implementations is well-structured data and rule-based system behavior. This maps comfortably to the favoured specification formats.
In reality, there are many details that do not fit this general picture. On the specification side, you will have things like process flow diagrams and service-oriented, message-oriented or event-based design and architecture. On the implementation side, you will have specific routines coded in procedural or object-oriented languages. However, the general repository-based principle as outlined in this section creates and identifies a core system where multiple formats may be registered and traced with ease.
Realistic take-it-or-leave-it strategy
Combining specifications and corresponding implementations is an ambitious ideal. It is often seen as tedious at the time of software development. In the case of team members who focus on program code (for example, Java or .NET), their highly specialised coding skills do not clearly map to the tasks of drawing up specifications and connecting them point-by-point to implementations. Understandably, they are enclined to skip these tasks, or execute them only in small part.
The USoft Approach recognises that drawing up specifications and implementations in a structured way requires discipline. It facilitates this by taking a realistic take-it-or-leave-it strategy. Instead of enforcing the presence of parallel specifications and implementations at all times, it allows teams to have specifications that are not (yet) implemented, and even implementations that are not properly specified. It is characteristic of USoft's repository-based approach that you do not have to supply complete specifications and implementations, but that the actual existence of corresponding specifications and implementations, or the lack of them, is highly traceable.
In the USoft Approach, the principle "Deliver specifications and implementations in parallel" is based on the fact that the USoft toolset allows you:
•to create specifications optionally, and separately from implementations.
•to create implementations optionally, and separately from specifications.
•to link corresponding specifications and implementations, again optionally.
•to trace with ease which specifications are without corresponding implementation, and vice versa.