Methodology / Software Development Cycle
Finport Technologies trends toward becoming mature organization employing a well-defined process to develop complex systems in a repeatable and predictable way. And it’s not only a sustainable process, but also one that can improve with each new project, thereby increasing the efficiency and productivity of the organization as a whole.
Our software engineering process inherits practical, proven methodology and internationally recognized Rational Unified Process (RUP) and processes maturity model (CMM). It provides a disciplined approach to assigning tasks and responsibilities within a development organization. Its goal is to ensure the production of high-quality software that meets the needs of its end users within a predictable schedule and budget.
Finport Technologies, Inc uses an iterative software generating process. Our innovative project development practices, strong project management, and quality assurance set the baseline for project success and ensure that the project will be developed on schedule and within budget.
The Finport Technologies, Inc software development process is viewed time-wise and goal-wise. Project development time is divided into phases, each one consisting of iterations. Each of iterations is comprised of different workflows that lead to the goal. Most development effort is conducted off-site; some project stages are implemented on site when a given project requires it. A step-by-step process generates the individual parts of the entire software solution. This allows minimizing project risks, increasing project communication quality, etc.
- Serious misunderstandings are made evident early in the lifecycle, when it's possible to react to them.
- This approach enables and encourages user feedback so as to elicit the system's real requirements.
- Continuous, iterative testing enables an objective assessment of the project's status.
- Inconsistencies among requirements, designs, and implementations are detected early.
- Stakeholders in the project can be given concrete evidence of the project's status throughout its lifecycle.
Managing the requirements of your
- Communications are based on defined requirements.
- Requirements can be prioritized, filtered, and traced.
- An objective assessment of functionality and performance is possible.
- Inconsistencies are detected more easily.
Using component-based architectures
- Modularity enables a clear separation of concerns among elements of a system that are subject to change.
- Components provide a natural basis for configuration management.
- Visual modeling tools provide automation for component-based development.
Modeling your software visually
- Use cases and scenarios unambiguously specify behavior.
- Models unambiguously capture software design.
- Unambiguous designs reveal their inconsistencies more readily.
- Application quality starts with good design.
Continuous verifying software quality
- Project status assessment is made objective, and not subjective, because test results, and not paper documents, are evaluated.
- This objective assessment exposes inconsistencies in requirements, designs, and implementations.
- Testing and verification are focused on areas of highest risk, thereby increasing the quality and effectiveness of those areas.
- Defects are identified early, radically reducing the cost of fixing them.
- Automated testing tools provide testing for functionality, reliability, and performance.
Controlling changes to software
- The workflow of requirements changes is defined and repeatable.
- Change requests facilitate clear communications.
- Change propagation is assessable and controlled.
Software Development and Software Management
Finport approach distinguishes two fundamental groups of software engineering process – Software Development Processes and Software Management Processes. We won’t consider support processes here, such as system administrating, administrating, etc.
Roughly the division can be described in the next way:
Management Processes last continuously after start till the very end of the project. All these processes activities take place every day in general and last simultaneously.
As regards Development processes, they repeat serially within regular iteration.
Software Development Cycle
The standard Finport Technologies software development process encompasses several phases: Inception, Elaboration, Construction and Transition:
We start off by establishing the best working relationship with our client and investing a great amount of time in understanding the business requirements, analyzing the requirements along with high-level design preparation. It ensures that everyone involved in a project shares the same goal and understanding of project phases, requirements and methodology. During this phase, preliminary project plan is mapped out, and the time and resource estimates are made. After that, a project development proposal is communicated to the client. It covers the business requirements, functional requirements, software requirements, schedule, and estimate project budget. A high-level product ⁄ project design overview might be developed to help in establishing a mutual understanding of the proposed tasks and solutions.
As the engagement moves into this formalized phase, requirements collection is finalized and analysis is done in depth. As the base team is established, functional requirements are developed. Formalized, the Software Requirements Specification documentation provides a guideline for mutual agreement on requirements between the client and the project team.
Detailed system architecture, Quality Assurance, and project development plans are developed. Programming specifications are defined and represented in the coding guidelines. As a result, the client is provided with architecture diagrams and technical specifications on the product. Support activities, such as change management, deployment planning, and configuration management, start at this phase. They are vital for the project’s process stability and its successful completion.
Fully operational product code is developed and documented and the test scripts are written and executed during this phase. The construction phase consists of several iterations, each of which consists of analysis and design, coding, testing and deploying workflows. This allows minimization of future changes. The baseline architecture is clarified into detailed specifications. The coding process is followed by continuous unit testing and periodical code reviews. Deliveries to customer are deployed only after QA testing is complete and delivery acceptance criteria are satisfied. Technical documentation and the User Guide are developed incrementally.
The delivery of the product is planned and defined in the early stages of the project. A number of milestones is scheduled for every project iteration to provide clients with an opportunity to review and provide feedback on the product look and feel, to participate in the product test and beta test. Deployment instructions are developed and first tested on the local environment and then included with each delivery to guide client’s IT group on the product installation. Our IT specialists are also often involved in the deployment of the product on the client’s site and client environment maintenance.
In scope of described above separate iteration can be described in the next way: