TS-7330 Profiling Complex Applications Made Simple: How to Diagnose Performance Problems With Integrated NetBeans™ Profiler (Project JFluid)

Date & Time : 28-JUN-05, 2:45 PM
Location : Esplanade 304/306 Moscone
Speaker : Ian Formanek, Gregg Sporar - Sun Microsystems
Description :

Detailed diagnostics of performance problems in large and complex Java™ technology-based applications that need it most remains a challenging and time-consuming task. Thus, profiling, unlike debugging and testing, is still a mystery to many developers and is treated as something outside the scope of normal development. The result is delayed or poorly performing applications. This unfortunate situation can be explained partly by the inherent complexity of profiling, and partly by the lack of cheap, free, and powerful tools.

In versions 4.0 and 4.1, the NetBeans™ IDE has made big steps toward simplifying development, deployment, and debugging of Web applications and programs based on Java 2 Platform, Enterprise Edition (J2EE™ platform). Now, the freely available integrated NetBeans Profiler, also known as Project JFluid (currently in Beta with the first official release planned for Spring 2005) aims at making profiling a natural part of the development process as well.

To address the problems of inherent complexity and the infamous performance overhead of profiling, the NetBeans Profiler offers a number of novel technical solutions pioneered in its base technology, the Sun Labs JFluid project. They are especially relevant for Web and J2EE technology-based applications that consist of multiple software layers (user code, AS, Java technology libraries) and usually perform same actions repetitively. Equally important, tight integration with the NetBeans IDE allows the Profiler to take advantage of the inherent knowledge of the application that the IDE already has. More specifically, the NetBeans Profiler allows developers to:

• Measure CPU performance of applications with low overhead, yet gather enough useful information through selective call tree profiling
• Profile object allocations and lifecycle with small overhead using semi-statistical object lifecycle tracking approach
• Diagnose memory leaks using the number of "surviving generations" metrics that pinpoints sources of growing leaks avoiding costly heap snapshot dumps and compares
• Avoid or greatly simplify setup for profiling?most of it has already been done as a part of project setup in the IDE; the rest can be easily done based on the Project Type and other IDE settings

In this session we explain the innovative features of the JFluid technology and demonstrate how to use the NetBeans Profiler to easily profile a Web or J2EE technology-based application developed in the NetBeans IDE. We also give some hints on results interpretation and how to avoid the most common pitfalls.

BOF-9288 Interactive Ant-Based Development Using the NetBeans IDE

Date & Time : 29-JUN-05, 8:30 PM
Location : Pacific J Marriott
Speaker : Jesse Glick, Petr Hrebejk - Sun Microsystems
Description :

With the advent of Apache Ant as the most popular build tool for Java™ technology programmers it has become more important for the full power of Ant build scripts to be tightly integrated into the daily workflow of a developer. If you are an experienced Ant user you know you can build and test any kind of project with Ant no matter how specialized your needs and no matter what tools or processes you need to incorporate. But are you using Ant to interactively demo your program? Debug it? Deploy it to a server? Run individual unit tests? Check source code style? Generate and browse reports? Launch Java Web Start software? You can. One of the features in the 4.0 release of the NetBeans™ IDE is the ability to use Ant as the native build tool for any project. Although many people focus only on basic targets such as compiling sources or running JUnit you can also enhance your Ant scripts to compile run test or debug individual classes; display HTML reports; run style checkers of all sorts; and more. With IDE integration it is possible to make even complex packaging and debugging procedures a keystroke away and once configured other team members can enjoy the benefits too. The session demonstrates how to load an existing project with a simple Ant script into the NetBeans IDE. You then see how to add to the script and configure the IDE to enable interactive workflow features such as source debugging; running of single unit tests; and reporting on style errors or code coverage with either hyperlinked text or full HTML output. You should have some experience writing Ant scripts. Experience using an IDE will be helpful.

BOF-9581 - Using Tools to Learn J2EE Technologies

Date & Time : 28-JUN-05, 9:30PM
Location : Golden Gate C1
Speaker : Petr Jiricka, Trung Duc Tran - Sun Microsystems
Description :

The main reason why developers usually start using advanced Java™ 2 Platform Enterprise Edition (J2EE™ platform) tools is because these tools make development more productive. Tools generate large pieces of complex scaffolding code suggest suitable class or method names perform refactorings across the whole codebase and automatically manage configuration and deployment information. But there is another important reason why many developers employ tools to help them do their jobs: With tools they can more easily and painlessly learn new complex technologies which would otherwise represent a significant barrier to entry. This session demonstrates how the latest NetBeans™ Integrated Development Environment helps both novice and seasoned developers with or without experience with tools better understand all the aspects of enterprise technologies in situations where they have traditionally relied on online tutorials printed books or classroom courses. From the syntax elements of JavaServer Pages™ (JSP™) technology to the format of deployment descriptors from the enterprise application build and packaging process to command line interoperability from the usage of J2EE technology APIs to common design patterns in J2EE technology development this session discusses it all.

BOF-9596 Productive Development of Web Apps With the NetBeans IDE

Date & Time : 29-JUN-05, 9:30PM
Location : Golden Gate C1
Speaker : Ludovic Champenois, Pavel Buzek, Petr Pisl - Sun Microsystems
Description :

The main reason why developers usually start using an IDE is because tools make development more productive and easier. This session demonstrates the ease of development of web applications in the NetBeans™ IDE through concrete examples. We show how to use NetBeans software for developing web applications based on popular frameworks, such as JavaServer™ Faces, Struts, Spring, or Hibernate. We show the whole end-to-end development cycle from creating a new web application through editing, debugging, and testing to deployment. We also illustrate a bunch of features in NetBeans software that make development easier.

This session is geared toward users who create web applications and use frameworks. We develop an example application, during which will present the following features:

• How to use the NetBeans IDE for developing web applications based on popular frameworks
• How to set up NetBeans software to develop in a framework, which is not supported directly
• How to use test frameworks for the web application
• Other cool features in NetBeans software, such as:
  • JavaServer Pages™ (JSP™) technology standard syntax, code completion, integrated help
  • HTML syntax, code completion, integrated help
  • Error Annotation in JSP technology editor
  • Hyperlinking in JSP technology editor
  • Deployment descriptor syntax
  • Using tag libraries and tag files
  • Debugging web application
  • Deployment web application

BOF-9195 INSANE: Java Technology-Based Application Heap Postmortem Analysis in Practice

Date & Time : 28-JUN-05, 8:30 PM
Location : Pacific J Marriott
Speaker : Radim Kubacki, Antonin Nebuzelsky - Sun Microsystems
Description :

Understanding specifics of memory management in Java™ technology is an important prerequisite for writing well-performing applications. Developers should especially pay attention to the number size and life cycle of objects instantiated during application runtime. This in-depth talk has two parts. It describes memory requirements of Java technology-based applications and explains a method for Java technology heap analysis. The first part describes memory footprint of a Java technology-based application its relationship to the underlying OS memory management and what implications this has for the application runtime behavior. This includes discussion of impact on minimizing and restoring application GUI and virtual page thrashing. Sharing various parts of a Java technology-based application with other processes running on the same machine are covered and special attention is paid to class data sharing among Java Virtual Machine (JVM™ machine) instances. While memory requirements of a JVM machine are hard to influence the content of the Java technology heap and its size are under developer's control. The second part of the presentation is dedicated to heap analysis and problems the analysis can help identify. Enabling tools for the analysis are introduced with a special focus on INSANE a unique postmortem memory analysis tool. INSANE allows developers to browse the heap content and search for suspicious patterns and memory leaks. You'll be able to use the tool to do the analysis and optimize memory usage in your applications

BOF-9184 How to Write APIs That Will Stand the Test of Time

Date & Time : 29-JUN-05, 10:30 PM
Location : Golden Gate C1 Marriott
Speaker : Jaroslav Tulach - Sun Microsystems
Description : To date designing professional cross-platform GUIs with Java™ Foundation Classes/Swing technology (JFC/Swing) has been tedious and error prone. Developers are forced to write cryptic code for an inherently visual task. This has resulted in numerous less than appealing Java technology GUIs as well as unmaintainable code. The new version of the NetBeans™ software GUI builder focuses directly on this problem making the layout design of visual forms easy for everyone without the need to know JFC/Swing layout principles. The GUI builder exposes simple layout rules that the user is able to understand and use quickly. It lets the user lay out components freely providing assistance for optimal spacing between components and easy aligning and it infers resizing behavior and more. In the background it produces a layout implementation using layout managers and other JFC/Swing constructs. Besides seeing the new tool in action you'll also learn what it means to create a good-looking scalable and well-behaved UI. We also cover details of the layout manager being used and look at the generated code.

(Look for Part One of this program here.)