Project Plan
Overview
The Excellus Senior Project is designed to investigate various methods to increase
performance within a service-oriented architecture. Specifically, the project will be
prototyping the Claims Processing System at Excellus BlueCross BlueShield. The Senior
Project Team will explore performance-enhancing techniques and will document any
increase or decrease in performance with respect to a baseline prototype and provide
technical explanations of the observed results. This project will focus on architectural
qualities rather than functional ones. The architecture and the documentation will be the
main deliverables rather than functional source code.
The project will be developed on the IBM Websphere platform using Java and J2EE.
The system will be developed on the Windows operating system. A relational database
may be required on the backend of the system to help with testing of the performance
improvements. In this case, MySQL will be used.
The primary customer of the project is the Excellus BlueCross BlueShield Enterprise
Architecture Group. They will use the information provided from this project in order to
make further decisions on the best choices for implementation techniques in future
projects involving the Claims Processing System.
There are four major development responsibilities for this project. The team is
responsible for the development of an initial prototype that will be used as a baseline for
the performance enhancements that will be made to the system. Identifying and
recording accurate measurements is the major focus for this project. Because the primary
deliverables are documentation and advice based on the information obtained, these
measurements are extremely important. The fourth major development responsibility for
this project is for the team to use the measurements and documentation to make a
recommendation to the customer about the best methods to use when designing the
Claims Processing System.
Goals and Scope
Project Goals
The main goal of the project is to provide Excellus with performance technique
recommendations. After experimenting and documenting three performance enhancing
techniques, the team will provide Excellus with recommendations as to which techniques
provide the greatest increase in performance, which were the easiest to implement, and
which combination of techniques would benefit Excellus the most.
The recommendations made to Excellus will take multiple forms. The architecture of the
performance techniques will be provided in the form of architecture diagrams. These
diagrams will broken down in the form of architectural views such as a process view or
model decomposition view. Excellus will also be provided documentation for each of the
performance techniques which will take the form of class diagrams, sequence diagrams,
and design documents. In addition, Excellus will be provided justification as to why the
recommended performance techniques will be beneficial to implement. All metrics and
data collected will also be provided to Excellus.
In addition to documentation and recommendations, the team will also provide Excellus
with a functional prototype. This prototype will begin as a baseline system that
implements the necessary requirements with as little effort as possible. From this
baseline, performance enhancing techniques will be added individually, turning our
baseline prototype into an evolutionary prototype. Each prototype (the baseline and the
enhanced prototypes) will be provided to Excellus at the end of the project.
Project Scope
The scope of this project is very straightforward. First, a baseline prototype will be
created. Once the baseline is in place, it will be documented and performance tested.
After the baseline has been set up and documented, three separate performance enhancing
techniques will be added to the baseline individually. These enhancements will also be
performance tested and the results from these tests will be documented. In addition to
implementing the performance prototypes and baseline, one full service may be
implemented down to the database level. The use of Process Choreographer will also be
attempted and documented.
The scope of this project does not include the implementation of more than one full
service. Also, because the low-level services are not yet in place at Excellus and because
development will occur in a different environment, exact timing measurements will not
be provided to Excellus. All performance measurements that are provided will be with
respect to the baseline measurements.
Deliverables
In the initial release, the team will provide a baseline prototype, including functional code
and initial performance measurements. The next three releases will be similar to the first;
they will include the code to implement one performance-enhancing technique,
performance measurements with respect to the baseline, and the rationale for
implementing the corresponding technique.
The last release will contain an overview of all performance-enhancing techniques
including functional source code, performance measurements, the final recommendation
on the technique or techniques that the team feels should be implemented, and
architectural and design documents.
Risk Management
See Risk Management documentation
Scheduling and Estimates
See Schedule documentation
Measurements and Metrics
The time it takes to process a claim will be measured. This is important because it will
serve as the main determination of performance. In addition, the time it takes to process
each individual service call will also be recorded. Process time will be measured using
JUnitPerf and possibly some aspect-oriented programming. Using process time as a
measurement, each performance enhancing technique will be compared to the baseline in
terms of percent increase.
The man hours required to implement each performance technique will be measured.
This measurement is important because it helps determine the effort involved in
implementing each performance technique. This will be measured by having each
developer keep track of how long they have worked on an individual performance
technique.
The lines of code of each performance enhancing technique will be measured. Much like
the man hours, this measurement will help determine the effort involved in implementing
each performance technique. This will be measured by comparing the baseline code with
the code of each of the performance prototypes.
Using the effort measurement and the performance increase, the best performance
enhancing techniques will be determined. The most ideal performance techniques will be
the ones which provide the greatest performance increase with the least amount of effort.
These techniques will be recommended to Excellus at the end of the project. Techniques
whose effort outweighs the performance increase will not be recommended to Excellus.
Technical Process
The team will use a modified (iterative) waterfall methodology to achieve our project
goals. Most of the requirements and design work will be performed up front.
Implementation and testing of the baseline will occur before the submission of the initial
release. For the next three iterations, requirements and design work will be performed on
an as-needed basis before the implementation of a performance-enhancing technique
begins. Although this appears to be a spiral methodology (which is suitable for one
continually-evolving product), a modified waterfall approach will be used. This will be
done because there is one baseline which will later be branched into three different
enhanced versions developed using a linear approach. See Schedule documentation for
details.
Throughout the project life cycle, multiple documents will be created and maintained.
These include, but are not limited to: Risk Management, Rationale, Process and Product
Measurements, Test Plan, Schedule, SRS and Architecture Diagram.