Delivery Expertise

Objectives:

 Help you reach your business goals

 Deliver products that meet or exceed requirements

We achieve your objectives!

Global Delivery Methodology

Our global delivery methodology has evolved over time based on our experience with various kinds of projects. It can be summarized by the following four facets:

Iterative Software Lifecycle Process

 Vertical development provides business value early & often

 Continuous feedback & improvement

 Frequent risk assessment & mitigation

Object Oriented Analysis and Design using UML

 Use case driven methodology

 Refinement from behavioral to logical to implementation models

 Focus on modular architecture and design

Emphasis on Quality Assurance

 Tracing of requirements through design & test

 QA involvement in all lifecycle phases

 Peer reviews of project deliverables

 Client acceptance plan

Integrated, Global Delivery Teams

 Joint development of process model with client

 “Follow the sun” development

 Comprehensive communication plan

 Mix of U.S. & China based skills & talents

Iterative Software Lifecycle

OO Analysis & Design

Emphasis on QA

Global Delivery Teams

Project Management

Tools

Iterative Software Life-cycle Process

Managing complex software development projects is about efficient utilization of resources, risk management, accurate estimation of budgets and timelines, experienced selection of appropriate technologies, and scheduling feature development to meet time-to-market requirements. Risk is a reality in every project; Objectiva’s iterative process for software development is designed specifically to mitigate risk. Let us explain how.The most important question to answer before starting product development is: Why is this product needed in the marketplace? The answer to this question constitute the business objectives of the product that should drive its entire lifecycle.A software product’s development lifecycle is comprised of four facets:

  • Requirements: What features will the product have?
  • Design: How will the product offer these features?
  • Coding: How will the features be coded and unit tested?
  • Testing and packaging: How will the products be tested and delivered to customers?

These four facets are managed by a project plan that determines when the software product will offer the required features.

In a traditional Waterfall lifecycle model, (shown to the right) the project plan organizes the four phases in a strict serial order. A lot of time is spent up front to define and analyze requirements and to complete the design of the target system before a line of code is written. This model does not handle changes in requirements or design well. In addition, it creates an artificial separation between business analysts, architects, designers, and programmers, leading to the risk of miscommunication and divergence between the business objectives and vision of a software product and its implementation.

Using an Iterative lifecycle model, the four facets of a software product are integrated so that business objectives drive the entire process, and the requirements and design are continuously refined while the code evolves. The project plan arranges the development into small releases, and mandates continuing integration of all coded components, incremental builds, and periodic validation of refined requirements and design. By doing so, it encourages a shared ownership of the product among business analysts, software architects, designer, programmers, and testers; this shared ownership reduces the risk of miscommunication and divergence. It also enables continuing refinement and integration to avoid any unpleasant surprises just before the delivery date.

The Benefits of Objectiva’s Iterative Process are the following:
  • Quick feedback loop from business stakeholders to engineering back to business stakeholders
  • Rapid software product conceptualization and materialization through prototyping
  • Ability to refine requirements and design, and handle changes in both in the early phases of a product lifecycle
  • Focus on getting the highest priority features and the highest risk features implemented as fast as possible
  • Ability to validate pieces of design incrementally, providing continuous analysis and mitigating the risks

OO Analysis & Design

Our name, Objectiva, is inspired by our focus on object modeling, object-oriented design, analysis and programming. We pursue a breadth-first approach that emphasizes developing a solid architecture and object-oriented design that allows implementing a working software system based on the design in the early stages of a project, and then refining the objects that make up the system gradually to obtain all required functionality. We consider the software architecture and design the core of a software product; the architecture can be viewed from four complementary models:

  1. Behavioral model: translates the functional requirements into behaviors that can be visualized in terms of use cases and activity diagrams.
  2. Logical model: defines the classes that implement the desired behavior and the state diagrams of these classes.
  3. Component model: shows the collection of classes into software components and the dependencies/interactions among these components.
  4. Deployment model: maps the software components onto the hardware on which the software product will run.

We use the Universal Modeling Language (UML) and UML modeling tools to model these four views of the architecture. The development of these models becomes the means through which we gather and analyze requirements, refine the design, and link the design pieces to the code. Having a UML model of the architecture also allows us to approve requirements and design pieces, and yet be able to refine and evolve them during coding without losing trace of how the refinement affects the code.
The UML models become a primary means of documenting the object-oriented design and communicating with developers, testers, technical writers, and business stakeholders about how the software product will deliver the needed functionality.
Within the UML models, our design methodology focuses on defining interfaces among objects and components first then designing the internals of each object. We also apply the 80/20 rule to get 80% of the functionality working in 20% of the time rather than obsessing about a single object and risk not delivering the software. We achieve this by making sure not to re-invent the wheel. For example, we use design patterns that fit the requirements of a project to establish a basis for the software design rather than developing every design from scratch.
For enterprise software systems, we use industry standards and platforms like J2EE, Microsoft .NET, and application servers as a basis for the enterprise software and then build custom objects on top of that.

Emphasis on Quality Assurance

We take every care to ensure that the software we build satisfies our client’s requirements. The only way to ensure that is to perform quality assurance throughout the software lifecycle. We typically involve a lead quality engineer in the early phases of a project to participate in requirements elicitation and analysis, to ensure that our quality assurance team understands the business objectives and the detailed requirements. This understanding enables the team to develop a comprehensive quality assurance plan for the project that includes the following elements:

  1. Test Plan and Test Cases:
    We develop a complete testing plan based on the requirements. The test plan includes unit, integration and system testing. The test plan includes all the test cases that typically cover functionality, error handling, performance, scalability, and fail over, among other required tests. The test plan and test cases are validated with the client during the early stages of a project, and are refined and enhanced during the downstream activities (detailed design and coding).
  2. Traceability Matrix:
    During the software lifecycle we trace the requirements to the design components, to the code modules, and to the test cases. This enables us to track changes to the requirements and to validate the test plan covers all requirements and all design elements.
  3. Peer reviews of designs and code:
    Depending on the size and duration of a project, we conduct design and code reviews with architects and engineers from outside the project. These reviews provide an opportunity for valuable feedback and independent perspective.
  4. Acceptance Plan:
    At the beginning of each iteration of a project, we develop a detailed acceptance plan that describes all the expected deliverables during or at the end of the iteration. The client signs off on the acceptance plan to indicate agreement on the expected results.

The quality engineers staffed on a project are responsible for implementing, tracking and adjusting the quality assurance plan to make sure that it is completed successfully by the delivery date. They often use test automation tools to help them in conducting the required testing and establishing a complete regression test suite for the product that is as automated as possible.

Global Delivery Teams

We staff each project with an integrated, global team that includes the right mix of skills depending on the project needs. Typically, a global team will include project leadership (e.g., Project manager, Architect) both in the US and in China. Our iterative software lifecycle model is architecture-centric and requirements-driven. Therefore, we pay utmost attention to getting both the requirements and the architecture right. To ensure this, we bring the technical leadership of the team to the client location during requirements elicitation and architecture activities to ensure deep understanding of the requirements and the architecture. The technical leadership then transforms this knowledge to the rest of the team offshore. In addition, our US-based project managers travel to China to be with the team during critical junctions in the project. This ensures that the team behaves as a single unit.

Because of our global structure, we can form a team that works seamlessly on a 24-hour basis. The time difference between our locations in the US and China works to our advantage; the end of the working day in the US coincides with the beginning of the following working day in China. Any issues or problems left unsolved by the US-based team at the end of the working day are worked on by the China-based team and resolved before the following morning.

Our global delivery methodology ensures that team members in the US and in China form a cohesive team. We structure a communication plan to ensure open upward and downward communication lines between the client and us; between the design team and the development team; and between the business stakeholders and the development team. The communication plan is developed in the early phases of a project and is signed off by our clients.

Our method includes extensive on-boarding sessions to ensure that each team member understands the business objectives of the software product, the project plan, the requirements, their roles and responsibilities, and the communication plan. We follow that up with regular check-ins, email, instant messaging, conferencing and model-based communications (using a UML-based tool to communicate via models).

Project Management

In any outsourced project, establishing the most effective project management is crucial. That is the reason why we take utmost care in assigning a project manager to a project. In most cases, the project manager is local to the client and works closely with the client liaison(s) throughout the project life-cycle.

The very first task of the project manager is to develop a comprehensive Project Management Plan (PMP) that establishes the following:

  • Process Customization:
    Any deviation from Objectiva’s standard Global Delivery Process and the reasons for such a deviation (budget, time pressure, etc.)
  • Communication Plan:
    How will the team communicate across geographic locations, daily and weekly status reporting mechanisms, use of instant messaging, email, video conferencing, web conferencing, telephone and other communications tools.
  • Configuration Management Plan:
    What tools to use for version control, build packaging and releases.
  • Roles and Responsibilities:
    Who does what on the project team; reporting and escalation mechanisms.
  • Project Scope, Timelines and Objectives:
    Limitations of the scope, the major milestones and timelines that must be achieved, and the overall business objectives of the project.
  • Change Control Process:
    The objectives process of requesting a change to the scope or requirements of a project and how to reach sign off by both the client and our team on each change request.
  • Project Audit Plan:
    How will the project checkpoints be audited to ensure that they have been followed consistently.

Tools

A world-class software organization must use tools that enable it to go through a project lifecycle in the most efficient manner possible.

At Objectiva, we have built an infrastructure of tools in the following areas:

  • Process Customization:
    Any deviation from Objectiva’s standard Global Delivery Process and the reasons for such a deviation (budget, time pressure, etc.)
  • Configuration Management:
    Our teams use a variety of CM and version control tools, including Microsoft VSS, Source OffSite for remote access, CVS, and others, depending on project needs.
  • Project Planning:
    We use Microsoft Project to develop and track project plans for all our projects. In some cases, and based on client request, we use other project planning tools. In addition, we use our templates for project management plans to cover all the checklists involved in a typical project.
  • Estimation:
    We have developed a method called Requirements Decomposition Matrix that enables us to view all the required features of a project grouped in categories. The cells of the matrix are used to estimate the complexity, business priority and estimated effort to design and code the functionality.
  • Bug Tracking:
    We use the same ticketing and bug tracking tools used by our client. We have used Clarify, Bugzilla, and others.
  • Software Development and Testing:
    The selection of the development tools to use in a project depends on the technology used and client preferences. We have used a variety of IDEs, including IBM Visual Age for Java, Websphere Studio, Microsoft Visual Studio (.NET), Together Software, JBuilder, JProfile, ANT and other testing tools.
  • Design Tools:
    We use the UML tools that our clients use, including Rational Rose, MS Visio, Together Software, and others.