All modern software development lifecycles (SDLCs) include the following standard phases:

  • analysis (what are we doing?)
  • design (how are we doing it?)
  • construction (do it)
  • testing (verify it was done right)
  • deployment (use it)

Fdata Framework can be easily incorporated into existing SDLCs.

Fdata Framework allows development to be performed iteratively and rapidly. If a Rapid Application Development (RAD) approach is taken, several iterations of analysis, design, construction, and test are followed in a spiral approach. The first iteration is typically a day with subsequent iterations getting progressively longer depending on the size of the project. Alternatively, if the requirements are very well defined, a waterfall approach can be followed. It is important to realize that with a Framework application, the team is always working with a real, n-tier system…not a prototype.  What you see is what you get.


Fdata Framework allows systems to be developed in-cooperation with business users; specifically, the user can view the system as it is, request changes, and the developer can often make the changes and show the user the results in literally minutes. This includes the ability to add new business classes (entities), new business attributes, new business relationships, custom form and list panels, etc.

AnalysisThis phase includes capturing the requirements and verifying them with the business community. The functional requirements are captured in UML using use-cases, activity diagrams, and class diagrams (for the persistent object model). The non-functional requirement (primarily technical) is captured in a table of requirements. The persistent object model is used to define the business classes, attributes, and relationship. This allows the first cut of the system to be viewed by the user immediately to provide feedback.
DesignThis phase can be divided into high-level design (architecture) and detailed design. The detailed design consists of a static object model and a dynamic object model. The detailed design is capture in UML using class diagrams, collaboration diagrams, object interaction diagrams and state transition diagrams. This allows a second cut of the system to be viewed by the user and feedback is incorporated. Significant savings are realized during design as the architecture is already set by Framework (Java smart-client presentation tier, Java service-oriented service/business tier, and Oracle data tier).
ConstructionThis phase includes implementing model components (business classes, attributes, and associations), custom presentation components (dialogs, panels, desktop, menu, etc.), business logic, and custom shared services. Significant savings are realized during construction as the default, customizable, extendable, behavior of Framework/FBS components are leveraged.
TestingThis phase is used to verify that the system behaves as it is specified. Depending on the size to the system, this may include leveraging an automated testing facility (ATF) to facilitate regression testing and load testing. JUnit testing is performed on service components. Significant savings are realized during testing as the standard Framework/FBS components have already been tested; therefore, only new functionality needs to be verified.
ReportsReports are developed using Microsoft Office (Word and Excel) using the Document Builder Module. Report templates are created in Word/Excel with place holders for the data, loaded into the application and registered to the corresponding screen.

Deployment will depend upon the number of stations and the complexity of integration with other systems. At a minimum, this will include:

  • installing the server application
  • training the trainer
  • installing at least one client application
  • executing the client acceptance test