<html>
<body>
<head>
<title>NetBeans at JavaOne and CommunityOne 2009</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<META NAME="description" CONTENT="Information about NetBeans related sessions at the JavaOne conference - talks, schedules, BOFs, labs and more">
<link rel="stylesheet" type="text/css" href="../../../../netbeans.css">
</head>

<h1>NetBeans at JavaOne and CommunityOne</h1>

<h2>CommunityOne West 2009: See the NetBeans IDE in Action</h2>

<p>
Join us for the third annual <a href="http://developers.sun.com/events/communityone/2009/west/index.jsp">CommunityOne conference in San Francisco</a>. Experience three jam-packed days of education, innovation, and exchange. Whether you're focused on creating robust Web apps, building a scalable infrastructure, or thinking about cloud computing, you'll find sessions on proven free and open-source software (FOSS) technologies and tools. This is stuff you can really get excited about - <a href="http://www.cplan.com/communityone2009/west/externalregistration">register now!</a>
</p>

<p>There are <a href="http://developers.sun.com/events/communityone/2009/west/sessions.jsp">several sessions using the NetBeans IDE</a>, including</p> 

<ul><li>
<b>Metro Web Services, NetBeans IDE, GlassFish Application Server, and 
OpenSSO in Action with Amazon WS, Azure, and Office</b>
<p>
Harold Carr introduces you to interoperable web services and OpenSSO in action with Amazon WS, Windows Azure Cloud, Microsoft Office, and identity providers. 
He uses the NetBeans IDE and the GlassFish application server.
</p>
</li><li>
<b>NetBeans IDE + Wicket = Reusable Components and Modular Web Apps</b>
<p>
Learn how to reuse existing NetBeans IDE components, developed for the desktop, in a Web application based on Wicket.
</p>
</li></ul>

<p>
For the complete list and more details check the <a href="http://developers.sun.com/events/communityone/2009/west/sessions.jsp">CommunityOne Session Catalog</a>
</p>

<h2>JavaOne 2009: See the NetBeans IDE in Action</h2>

<p>
Choose from a variety of tracks, labs, and BOFs that will enhance your skill set, help you problem-solve quicker and more efficiently, show you new tools and products, share code, and give you hands-on opportunities. 
If you have only one event you can attend this year, make it <a href="http://java.sun.com/javaone/">JavaOne 2009 in San Francisco</a>! Don't miss out and <a href="http://java.sun.com/javaone/2009/registration.jsp">register now</a>! 
</p>

<p>
There are about <a href="http://www28.cplan.com/cc230/sessions_catalog.jsp?ilc=230-1&ilg=english&isort=&isort_type=&is=yes&icriteria1=+&icriteria2=+&icriteria9=&icriteria8=netbeans&icriteria3=&icriteria4=+">25 sessions using the NetBeans IDE</a>, including 
</p>

<ul><li>
<b>Ajax Performance Tuning and Best Practice (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=305400&ilocation_id=230-1&ilanguage=english" target="_top">TS-5400</a>)</b>
<p>
Here you learn how to use various tools such as the NetBeans IDE, Eclipse, Firebug, and YSlow for optimizing and performance tuning of your Ajax-enhanced web applications.
</p>
</li><li>
<b>Developing RESTful Web Services with JAX-RS and Jersey (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=304878&ilocation_id=230-1&ilanguage=english" target="_top">BOF-4878</a>)</b>
<p>
The Java API for RESTful Web Services (JAX-RS) is an annotation-driven API that makes it easy to build Java technology-based RESTful Web services.
This BOF is an opportunity for developers to meet the Jersey team, ask questions, request demonstrations, and discuss the direction of the Jersey project.
</p>
</li><li>
<b>Your First Mobile Game (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=305502&ilocation_id=230-1&ilanguage=english" target="_top">LAB-5502</a>)</b>
<p>
This Hands-on Lab takes you through the process of developing a Java mobile game
with the assistance of the NetBeans Game Builder. Participants will learn how to design a compelling SVG UI, create an MIDP application, and connect it to a Web service.
</p>
</li></ul>

<p>
For the complete up-to-date list and more details check the <a href="http://www28.cplan.com/cc230/sessions_catalog.jsp?ilc=230-1&ilg=english&isort=&isort_type=&is=yes&icriteria1=+&icriteria2=+&icriteria9=&icriteria8=netbeans&icriteria3=&icriteria4=+">JavaOne Session Catalog</a>.
</p>

<h2>JavaOne 2009: Meet the NetBeans Dream Team</h2>

<p>
For JavaOne, we have brought together some of the best and the brightest at Sun and from the community to create one forum that gives you time to talk to fellow developers and learn from experts. 
</p>

<img src="http://qa.netbeans.org/processes/cat/67/images/logo.png" style="float:right" />
<p>
For the first time at the JavaOne conference, the 
<a href="http://wiki.netbeans.org/NetBeansDreamTeam">NetBeans
Dream Team</a> is participating in the 
<a href="http://www.java.net/pub/ct/javaonecommunitycorner">java.net Community Corner</a>.
The Dream Teamers speak regularly to Java user groups and
engage with Sun's software development teams via the
NetBeans Community Acceptance Testing Program 
(<a href="http://qa.netbeans.org/processes/cat/67/">NetCAT</a>).
</p>

<ul><li>
<b>Adding Some Oomph to the Java VisualVM Tool (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=305566&ilocation_id=230-1&ilanguage=english" target="_top">LAB-5566</a>)</b>
<p>
The Java VisualVM tool provides a great set of tools for analyzing, diagnosing, and troubleshooting your Java technology-based applications. 
In this Hands On Lab, Anton Epple and Geertjan Wielenga show you how to completely deconstruct and rebuild the Java VisualVM tool to make it perform whatever kind of analysis you would like.
</p>
</li><li>
<b>Energy, CO2 Savings with Java Platform, Enterprise Edition and More: Project GreenFire (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=303890&ilocation_id=230-1&ilanguage=english" target="_top">TS-3890<a/>)</b>
<p>
In this technical session, Adam Bien describes the architecture of the GreenFire.dev.java.net project, an intelligent, environmentally friendly heating control system. This talk covers among other things Java EE 6 (JSR 223 Scripting Integration, EJB 3), JavaFX, reporting, and integrates Sun SPOT and sensor networks, FreeTTS speech, and mobile devices.
</p>
</li><li>
<img src="../../../../images_www/articles/worldtour/javaone-jug-logo.jpg" style="float:right" />
<b>
Java Champions, Java User Group Leaders, and NetBeans Dream Team Discussion with Sun Software Executives (<a href="http://www28.cplan.com/cc230/session_details.jsp?isid=303904&ilocation_id=230-1&ilanguage=english" target="_top">BOF-3904</a>)</b>
<p>
This session gives community leaders a chance to have a direct one-on-one discussion with Sun Software executives about Sun's current and future involvement with various communities in the Java technology ecosystem. The 20-minute panel discussion is followed by a 30-minute open-mic Q&A session, which includes Sun Software executives.
</p>
</li></ul>

<h2>Related Links</h2>

<ul><li>
<a href="http://developers.sun.com/events/communityone/2009/west/index.jsp">CommunityOne conference in San Francisco</a>
</li><li>
<a href="http://java.sun.com/javaone/">JavaOne 2009 in San Francisco</a>
</li><li>
<a href="http://www.adam-bien.com/roller/abien/entry/communityone_west_san_francisco_session">Adam Bien's session at CommunityOne East</a>
</li></ul>

</body>
</html>
