NetBeans Software Day

On Sunday afternoon, June 26, the day before the 2005 JavaOne Conference, the
NetBeans Software Team hosted a FREE companion event at The Argent Hotel
near Moscone Center. James Gosling, the father of Java™, and other Java luminaries discussed
NetBeans and the future of Java developer tools.

TS-2670 Twelve Reasons to Use NetBeans

The NetBeans™ interactive development environment offers a wealth of
features today that a short time ago it lacked. Today many developers have put
down some of their existing tools and taken to using the NetBeans IDE because a
number of new features offer developers compelling reasons to use it. This talk
focuses on some key reasons why developers should consider using the NetBeans
IDE.

This technical case study reviews an architecture that enables existing Java™
technology-powered handsets to consume web services. As a result of a
collaboration between Sprint PCS and Sun Microsystems, this case study is aimed
at reducing the life cycle of developing end-to-end mobile applications and
providing developers the flexibility to modify their application logic on the
web services layer without re-deploying the client application. This project was
implemented using the NetBeans™ 4.1 IDE with Mobility Pack and Sprint’s Business
Mobility Framework and consists of three tiers:

Client device based on Java technology with CLDC 1.0/1.1 and MIDP 1.0/2.0

You gain insight on how to develop and connect mobile applications to web
services by utilizing the latest NetBeans IDE with Mobility Pack. You also hear
from Sprint on possible use cases of this architecture based on Sprint's
Business Mobility Framework, as well as its future plans to support mobile web
services.

TS-7143 Project Jackpot: A New Java™ Technology for Source Transformation

Project Jackpot is the code name for a technology that enables developers to make sweeping source file changes safely by combining the best of refactoring and rules engines. Jackpot works with the javac compiler's front-end to apply rules and transformations that preserve a program's behavior then updates the program's source files with the minimum set of changes. We discuss what Jackpot is detail how it works and describe how this technology may be rolled into future products. This is an advanced talk for those interested in refactoring Java™ technology re-engineering and compiler-related topics.

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:

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.

One of the main themes for Java™ 2 Platform, Enterprise Edition (J2EE™ platform) 5.0 (JSR-244) is ease of development (EOD). New specifications (metadata, annotations, better default values and more) are under consideration. At the same time, Java technology tools are evolving rapidly (Eclipse, NetBeans™, IntelliJ) and introducing features that try to hide the complexity of the plumbing aspects of the J2EE platform. The combination of the two (platform and tools) will dramatically change the way J2EE technology developers work and help them to concentrate on their core competencies: business logic and declarative interaction with the J2EE technology containers.

This session covers:

The current J2EE platform 5.0 ease of development features, with an IDE user perspective

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-9581 Using Tools to Learn J2EE Technologies

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.

Ever wanted to add cool functionality to your favorite IDE? Well why write a plug-in for just one IDE when you can write it for three IDEs? We show you how to write a plug-in that will run in NetBeans™ Eclipse and JBuilder IDEs. We focus on abstracting your plug-in's code and then writing adapters to each IDE's plug-in API. We highlight the differences in the IDEs that developers will need to address and give suggested solutions. Developers who attend this session will be able to make better decisions about building their plug-ins in a cross-IDE way.

Developing software in a distributed team although increasingly common remains a serious challenge. We can collaborate with each other online anytime using email instant messaging the Web newsgroups bulletin boards wikis and blogs but only within frustrating limits because these technologies do not specifically target nor completely meet the needs of software developers. Perhaps ironically the authors of these technologies are in desperate need of collaborative tools that work together easily and address their special advanced collaboration needs. We call this new domain developer collaboration and fortunately the time has come for collaboration tailored to the needs of software developers to finally make collaborative software development significantly easier regardless of the distance between team members. As pioneers on the developer collaboration frontier we present the main use cases for developer collaboration a vision for the future of developer collaboration and the work we've done to collaboration-enable the NetBeans™ IDE. We present a number of technologies developed at Sun that you can use to reach new levels of developer collaboration today: the technology-neutral MOXC ( Moxie ) collaboration messaging protocol running atop XMPP the CollabBeans API and the Collablet API. We also demonstrate using these technologies to build a new collablet for the NetBeans IDE.

TS-2845 NetBeans Mobility Pack: Living up to Developer Expectations

Developers are continuously being offered tools, SDKs, code, and documentation
to make the creation of applications for mobile devices easier than ever before.
One offer is the NetBeans™ IDE Mobility Pack: Is this just another IDE or
does it really live up to the hype?

This session strips away the marketing hype and demonstrates how to create
mobile applications with the NetBeans IDE Mobility Pack, with a focus on
integration between the NetBeans IDE and the Sony Ericsson Java™ 2
Platform, Micro Edition (J2ME™) SDK. We also include an in-depth look into
on-device debugging with a demonstration of the interaction between the NetBeans
IDE and a Sony Ericsson device during a live debugging session.

Any desktop application has to solve a similar set of problems: usability look
and feel settings management and presentation support for drag-and-drop UI
design localization management of menus and toolbars wizards help system
integration and much more. Developing such an application from scratch can waste
many years solving problems that every other desktop application has also had to
solve. It is especially wasteful when a free open standards-based solution is
available. This talk is a continuation of the successful 2004 JavaOneSM
conference session TS-1694: Desktop Application Architecture I: Using the
NetBeans™ Platform Application Framework to Create a Rich Client
Application. It describes the changes and improvements that have been achieved
during the last year and gives a live line-by-line demonstration of how to build
a sample application (an RSS feed browser) on the NetBeans Platform 4.0. By
showing the results together with steps on how to reach them the session
promises to be interesting for newcomers as well as NetBeans platform ISVs
looking to ensure they do the right things in the right way.

BOF-9156 GUI Design in a Natural Way: Layout Manager Using the New NetBeans

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.

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

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-9596 Productive Development of Web Apps With the NetBeans IDE

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

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

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.