The Jonah Group

• Overview
• Clients
• Case Studies
• By Industry
• By Service

Performance Tuning - Medical Application

The Problem

Our large health insurance client had designed and implemented a thick-client Physician's Practice Management application that allowed health care providers to manage all aspects of a medical practice within their own office. The system was implemented as a large Java (Swing) application that communicated with a back-end application server and database. Upon completion, the application was sluggish and plagued by memory leaks.

Our client requested that Jonah conduct a performance review, provide suggestions and best practices for improvement of the performance, and to render opinions on what minimally had to be fixed/upgraded before the application could sensibly be deployed.

Our Responsibilities

• Performance review
• Source code analysis
• Architecture analysis
• Prototype upgrades to poorly performing functions
• Report and recommendations

Back To Top

The Solution

Jonah allocated two senior developers and an architect to perform the review and prototype the new functions. The architechture of the application, as well as the known bottlenecks were discussed on the first day, after which the Jonah team dove into three days of intense code reviews. Once the candidates for detailed performance analysis were identified, we installed the application in a development environment in the Jonah labs, where detailed performance testing began in ernest.

Four days were spent collecting raw performance data for the three main transaction bottlenecks in the system. During the analysis, the team used the the following tools and technologies:

Tools and Technologies

• MSDE Database Server
• Optimize-It Java Performance Analysis tool
• Java / Swing Libraries
• Visual Basic (for prototyping)
• Web Browser

Back To Top

Unique Challenges, Solved.

• For specific transactions, Database calls were optimized, decreasing the load time of the case history screen by an order of magnitude. This was achieved by:
  • Loading large static tables using JDBC rather than the proprietary persistence framework.
  • Replacing an eager loading strategy with a lazy strategy for related objects,
  • Caching the results of query-intensive tables
  • Using DB sort capabilities


• We related the following key points to the client:
  • Application of simple UI design patterns can make a big difference in UI responsiveness.
  • The portability of Java and Swing were not required for the application, and could be replaced by high-performance native widgets.
  • The scalability of a three-tiered architecture was overkill for the application, which would be better served by a traditional client/server architecture.
  • A deep understanding of the persistence framework is often required to achieve good performance.


• A proposed 2-tier solution was prototyped and analyzed for performance in 7 days using Visual Basic to demonstrate possible increases in performance. Significant memory savings were realized and the responsiveness of the prototype was very impressive. Our three engineers delivered a detailed report, a high-level presentation, and a prototype of our proposed solution on time, and within the space of three weeks.

Back To Top