In light of today's compressed development cycles, multi-tiered application architectures and complex technologies, many organizations are challenged to get reliable yet scalable enterprise Java applications out the door in a timely manner. Devoting a small amount of energy throughout the development process to identify, address, and correct performance obstacles can lower the risks and costs associated with poorly performing applications over the life of the code.

Java performance tuning simply means optimizing your code for speed, reliability, scalability and maintainability. Producing truly scalable, lightning-fast Java SE and Java EE applications demands clarity of purpose and well-understood programming priorities. A major benefit of adopting regular performance tuning cycles is instantly seeing exactly which parts of your applications represent critical bottlenecks and which are behaving efficiently.

Performance Tuning: A Development Best Practice
A major strength of Java is its platform-independent byte-code approach and automatic handling of garbage collection. Unlike with C/C++, developers are able to focus on an application's business requirements, and are largely free from platform considerations.

Experienced developers, however, do not focus exclusively on application functionality. The reality is that below this level of abstraction, hard limitations of memory and processing power exist, as do the patterns and constraints of garbage collection, thread scheduling, and a host of other considerations managed by the Java Virtual Machine (JVM) and the underlying operating system.

Successful developers - and productive development processes - incorporate regular use of performance analysis from the earliest stage of code creation throughout the development process, into QA testing, and beyond. Frequent, frontline checking and testing of small modules of code by the principal author is often the best way to assure that the Java applications produced will be fast, reliable, and scalable.

Seeing the Big Picture Means Digging Deep
The latest generation of Java application servers brings increased memory capacity and processing power to the party. However, even with this and the common practice of throwing more hardware at the problem can you ever really overcome truly flawed code? A single buggy line ripples forward and can cause application-wide bottlenecks or can mysteriously trigger disastrous crashes once an application is in production.

The developer's tall challenge is to determine which part of a Java SE or Java EE application is causing a performance bottleneck or memory issue. The strength of Java and its various platforms is the high level of abstraction, re-use of objects, and insulation from layers of processing and system dependencies. But while encapsulation is great for shielding you from vast lower-level complexities, it also leaves few clues about where to focus your performance attention.

Tools are needed that extend your intuition and let you effortlessly see and understand how your Java application behaves when running. With the advent of highly abstracted, object-oriented languages such as Java, Stanford Computer Science Emeritus Professor Donald Knuth raised the concern that programmers are in danger of losing touch with the factors determining whether their code will run and scale well saying, "At first you try to ignore the details of what's happening at the lower levels. But when you're debugging, you can't afford to be too compartmentalized. You can't afford to only see things at the highest level of abstraction."

Performance Tools Allow You to Be Smart and Efficient About Optimizing
Knuth advises that developers need insight about what's going on below the surface if their code is to be scalable, reliable, and fast.

A fundamental question is: "What are the priority performance issues for this module or application?" Tools specifically designed for Java performance tuning offer an ideal way to answer this question - and be assured that your code improvements are informed and efficient. Without tools to help prioritize key Java trouble areas, you are likely to spend a lot of time micro-optimizing unimportant sections at the expense of the crucial optimization issues that actually drive your application's overall performance.

The goal ought to be for each member of the development team to be equipped with the tools to be smart about performance tuning each step of the way. Smart performance tuning will take place in the context of an application's overall business requirements. Some tiny performance issues simply may not warrant improvement efforts. Other important optimizing trade-offs will arise only when components are brought together, at which point an understanding of the overall architecture will guide modifications.

Tuning your code for speed and performance iteratively, as you develop and bring modules of code together, is the best way to minimize frantic troubleshooting sessions at the end of a project - or worse, in production, where even small problems are transformed into costly, complex challenges. The tuned applications delivered to QA and to customers will instead be lightweight, stable, scalable, and screamingly fast.

Conclusion: Performance Tuning Is Crucial for Java
Conceiving, designing, and testing your approach against performance goals as you build means more than just avoiding underperforming applications or even crashes. By being appropriately alert to how your code performs throughout the development process, you avoid expensive, disruptive late-stage fixes. Fast, scalable, high-performance code is a design imperative from the beginning. It is also a serious, regularly exercised element of the development process for each front-line developer (not a specialized skill for an isolated performance team).