Al Mannarino

Over the past decade, the mobile landscape has changed rapidly. Smartphones have been dominating the market and mobile phones and tablets have become the go-to devices for consumers and business customers alike.

Manage application speed, scalability and reliability throughout the development process

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 under-performing 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.

Embarcadero® J Optimizer™ 2009 tools make performance tuning easy

The 80:20 rule fits well for performance tuning. Eighty percent of an application’s performance problems are usually caused by no
more than 20 percent of the code. The pitfall that development teams fall into is that they delay the identification of key problem
areas until too late, leading to expensive and risky late-stage application redesign. Taking a proactive approach will preempt just
this type of rushed, endgame rework. Adopting tools such as J Optimizer 2009 allows everyone in a development team to become more conscious of—and more conscientious about—the application’s speed, scalability, and reliability throughout the development process.

As each routine or subsystem’s basic functionality is established, the module’s performance can be evaluated within the context of the applications overall business requirements. Clearly not every section of code will need to be labored over with equal intensity and certain key issues will emerge only as pieces of code are combined.

Whatever the situation, spotting and assessing the severity of issues throughout the development process avoids delays, problem escalations, and the kind of deep-rooted performance flaws that can sideline an entire project or create business disasters once an application is live with customers in a production environment.

The Embarcadero® J Optimizer™ performance tools let you keep a tight rein on code, regularly testing where design and compiled code meet hardware and Java virtual machine constraints. By focusing on priority problems, you will be rewarded with fast, reliable, and truly scalable J2SE and J2EE applications.  Feel free to try J Optimizer 2009 on your applications from this 30 day trial link:  http://embarcadero.com/products/j-optimizer

On Wednesday December 9, I gave a webinar discussing:

How do you ensure secure data protection for our applications using InterBase? We all want to develop secure, robust applications with resilient data protection and robust data management. And one of the best ways to achieve this is through solid software design and database technology that provides strong data encryption and automatic disaster recovery capabilities.

Topics covered were:

Structure applications to enhance data security and protection

Maximize data security with multiple forms of encryption, including “Over the Wire” network encryption, Strong Encryption (AES), Database and Column Level Encryption, Backup Encryption, and Long Password Support

Improve your application robustness with Log-based Journaling, Disaster Recovery and Automatic Crash Recovery capabilities,

Enhance your application performance with high-performance data management technology complete with Interbase’s integrated, graphical performance monitoring to diagnose and improve system performance.

The link for the webinar video is here:

http://video.embarcadero.com/InterBase/InterBase2009SecurityWebinar/InterBase2009SecurityWebinar.html

The link for the power point slides is here:  to be posted today.

Enterprise Java Beans (EJBs) are server-side components for modular construction of enterprise applications. JBuilder 2008’s Visual EJB Workbench allows you to create a visual model as you develop EJB applications. The Visual EJB Workbench provides a simplified RAD development experience for both novice and experienced J2EE developers.

Easily create EJBs and model relationships, security and OCL constraints. Changes to the source code, annotations, properties view and graphical view are always in sync through JBuilder’s patented LiveSource technology. JBuilder allows targeting and re-targeting app servers from all major commercial and OSS vendors including IBM, BEA, Sun, JBoss and Apache.

To see and learn more about JBuilder 2008’s Enterprise Development, you are welcome to attend this Webinar where you will learn:

· How to use the Visual EJB Workbench to build, test and deploy EJB 2.x and EJB 3.0 applications.

· EJB Modeling support.

· How to create EJB application containing session bean and entity beans, configuring servers and deploying.

· How to converting pure EJB 2.x projects to the new XDoclet annotated EJB project.

The iterative use of performance tools throughout the development process is critical for keeping performance and reliability problems under control as well as for producing fast, scalable J2EE and J2SE applications. Java technology is great for accelerating time-to-market; but, performance and reliability risks can become a serious challenge. Because Java technology provides a higher level of abstraction, it affords developers only a limited understanding of—and control over—the way their code is executed.

Three common real-life performance problems that you can encounter in Java applications are:

• Excessive temporary object allocations
• Memory leaks
• Performance bottlenecks

Java developers and Quality Assurance need performance management tools to track and fix these problems before application goes into production.

JBuilder 2008 includes great Performance Management capabilities. To see and learn more about implementing performance management, you are welcome to attend this Webinar where you will learn:

How to use the complete set of performance management applications in JBuilder 2008:

o Profiler

o Code Coverage

o Thread Debugger

o Request Analyzer

How to use the JBuilder 2008 tools for measuring and optimizing the performance of Java programs:

o Progress Tracker

o Quality Analyzer