<html>
<head>
<title>NetBeans Software Day at the 2006 JavaOne Conference</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<META NAME="description" CONTENT="Information about NetBeans Software Day at the 2006 JavaOne Conference - talks, schedules, BOFs and more">
<link rel="stylesheet" type="text/css" href="../../../../netbeans.css">
<script type="text/javascript" language="javascript" src="../../../../images_www/js/lytebox-compressed.js"></script>
<link rel="stylesheet" href="../../../../lytebox.css" type="text/css" media="screen" />
</head>

<body>

<h1>NetBeans Software Day at the 2006 JavaOne Conference</h1>

<div class="feedback-box">NetBeans Day 2006 was a huge success - <a href="nb-day-report-2006.html">Read all about it!</a></div>

<p><br /></p>
<p>
<div style="float:left;">
<img src="../../../../images_www/articles/worldtour/NB_250px.gif" alt="[NetBeans Day logo]" style="margin-right:10px;" alt="NetBeans Software Day 2006" title="NetBeans Software Day 2006"></div>
<div style="margin-top:13px;">
<font size="+1"><b>Monday, May 15, 2006<br />
10 am - 6 pm</b></font><br />
<a href="http://www.argenthotel.com/">Argent Hotel</a>, San Francisco
</p>
<p><br /></p>


<p style="clear;both;">
<a href="../../../../images_www/articles/worldtour/India/chennaiCrowd-small.jpg" rel="lytebox" title="The crowd at NetBeans Software Day 2006 in Chennai, India"><img SRC="../../../../images_www/articles/worldtour/India/chennaiCrowd-small.jpg" WIDTH="200" HEIGHT="133" BORDER="0" ALT='The crowd at NetBeans Software Day 2006 in Chennai, India' align="right"></a>
Learn from the experts what's happening with the NetBeans IDE and
platform at the third annual NetBeans Software Day! <a href="#james-gosling"> James Gosling</a> - the
father of Java technology -- as well as other Java technology luminaries
were present to discuss the future of Java developer tools and the
rich client platform. NetBeans Day featured a keynote by 
<a href="#joshua-bloch">Joshua Bloch</a> and <a href="#neal-gafter">Neal Gafter</a> 
who are also known as "Click and Hack - The Type-It Brothers."   
The event is also a great opportunity for
community members to meet each other face-to-face, see demos of the next
generation of NetBeans software and learn how easy it is to develop
NetBeans plug-ins and extend the NetBeans platform.

<p>
<a href="http://www.amazon.com/gp/product/0132395525/sr=8-2/qid=1145548826/ref=pd_bbs_2/104-0345409-4621524?%5Fencoding=UTF8"><img src="../../../../images_www/articles/fieldguide2.jpg" style="margin-right:10px; border:1px solid black;" align="left" width="90" height="100"/></a>
NetBeans Software Day 2006 took place on Monday, May 15,
the <a href="http://www.argenthotel.com/">Argent Hotel</a> in San Francisco.
It is a companion event to the <a href="index.html">JavaOne 2006 Conference</a>
which began the following day. You do not need to be registered for <a href="index.html">JavaOne</a> 
&mdash; NetBeans Software Day is free for anyone who wishes to attend.

<p>
The first 400 attendees received not only a <b>256 MB USB drive</b> but also
a complimentary copy of the second edition of the soon to be
published <a href="https://netbeans.org/community/articles/interviews/NBFieldGuide.html">NetBeans IDE Field Guide</a> covering all the new 5.0 features!
A reception was held immediately after the event,
you are invited to come and meet NetBeans software partners and developers.
</p>
<p><br /></p>

<a name="presentations"></a><h2>Presentations 2006</h2>

<br/><p><table style="width: 100%; text-align: left;" border="0" cellpadding="7" cellspacing="7">

<tbody>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">10:00<br>
</td>
<td colspan="3" rowspan="1" style="vertical-align: top; text-align: center; width: 45%; background-color: rgb(230, 230, 250);">Registration opens.<br>
</td>
</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">12:00<br>
</td>
<td colspan="3" rowspan="1" style="vertical-align: top; text-align: center; width: 45%; background-color: rgb(230, 230, 250);">Opening Keynote:  <a href="#jonathan-schwartz">Jonathan Schwartz</a> and <a href="#tim-cramer">Tim Cramer</a> reveal past, present and future of NetBeans IDE.<br>
</td>
</tr>
<tr>
<td style="vertical-align: top; width: 40px; text-align: center; background-color: rgb(176, 196, 222);"><br>
</td>
<td style="vertical-align: top; font-weight: bold; text-align: center; width: 45%; background-color: rgb(176, 196, 222);">Track&nbsp;A <br>
<span style="font-weight: normal;">
<b>NetBeans IDE: Developing Applications for the Enterprise and Beyond.</b>
<p>
<font size="1">
These sessions describe the IDE's
 capabilities for developing enterprise and mobile applications.  Java ME
 and EE development tools will be demonstrated, along with tools for
 creating Service Oriented Architecture applications.</p>
</font>
</span></td>
<td style="vertical-align: top; width: 5px;"><br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(176, 196, 222);">
<div style="text-align: center;"><span style="font-weight: bold;">Track&nbsp;B</span><br>
<b>NetBeans IDE: Developing Client Applications.</b>
<p>
<font size="1">
These sessions focus on current and upcoming tools for building user
 interfaces and client applications. Java SE and EE development tools will be
 demonstrated, along with an in-depth description of how to build on the
 NetBeans Platform.
</font>
</div>
</td>
</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">1:30<br>
</td>

<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);"> NetBeans Mobility Pack<br>
<font size="1"><ul>
<li> Accessing web services from a mobile phone
<li> Using Project Matisse in CDC applications on smart phones
<li> Profiling mobile applications
<li> <b>Prizes</b>!
</ul></font>
</td>
<td style="vertical-align: top; width: 5px;"><br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);">Visual Development Tools
<ul>  <font size="1">
  <li>Project Matisse Roadmap:
  <ul>
   <li> Planned enhancements and overall direction for the GUI builder.
   <li> New Swing frameworks
   <li> Demos!
  </ul></li>
  <li>Visual Design Tools for Creating Web Applications
  <ul>
    <li>Rapid web application development in the NetBeans IDE
    <li>WYSIWYG web page editor including page flow and outline views
    <li>Leverage the power of Java Server Faces and AJAX
    <li>Drag-and-drop to bind page components to data sources
  </ul></li>
<li> Simplified creation of smart web clients using XTT</li></font></ul>
</td>
</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">2:30<br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);">Java EE 5 development with NetBeans IDE
<ul>
  <font size="1">
  <li> Using the new Java EE tools in  the NetBeans IDE for:
  <ul>
  <li>Object/Relational mapping
  <li>Rapid application development
  <li>JAX-WS 2.0
  <li>Project Tango (Web Services Interoperability Technology)
  <li>Inline verification via editor hints
  </ul>
  <li>Debugging Java EE applications
  <li>Profiling Java EE applications
</font></ul></td>
<td style="vertical-align: top; width: 5px;"><br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);">Developing on the NetBeans Platform, Part 1
<font size="1"><ul>
<li> What is the NetBeans Platform?
<li> What can you do with the NetBeans Platform?
<li> Developing simple applications on the NetBeans Platform
</ul>
</font>
</td>

</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">3:30<br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);">NetBeans Enterprise Pack:<br /> Get a head start on developing Service Oriented Architecture applications.
<font size="1"><ul>
<li> Creating services for existing applications
<li> Orchestrating services to create a composite application
<li> Using the UML and XML tools
</ul>
</font></td>
<td style="vertical-align: top; width: 5px;"><br>
</td>
<td style="vertical-align: top; width: 45%; background-color: rgb(230, 230, 250);">
Developing on the NetBeans Platform, Part 2
<font size="1"><ul>
<li> Advantages of using the modular architecture of the NetBeans Platform
<li> What is a module?
<li> How to integrate a module into the NetBeans IDE
<li> Demo: Lattix LDM
</ul></font></td>
</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">4:40<br>
</td>
<td colspan="3" rowspan="1" style="vertical-align: top; text-align: center; width: 45%; background-color: rgb(230, 230, 250);">
<a href="../../../../images_www/javaone/nb_day/IMG_5734.jpg" rel="lytebox" title="NetBeans Software Day 2005: Community Awards Session"><img SRC="../../../../images_www/javaone/nb_day/small_IMG_5734.jpg" WIDTH="200" HEIGHT="133" BORDER="0" ALT='NetBeans Software Day 2005: Community Awards Session' align="center"></a>
<br>Closing keynote: James Gosling awards very special prizes to NetBeans Community members.
</td>
</tr>
<tr>
<td style="vertical-align: top; font-weight: bold; width: 40px; text-align: center; background-color: rgb(176, 196, 222);">5:30<br>
</td>
<td colspan="3" rowspan="1" style="vertical-align: top; text-align: center; width: 45%; background-color: rgb(230, 230, 250);">Free drinks.<br>
</td>
</tr>
</tbody>
</table>
<p><font size="1">Agenda is subject to change.</font></p>
<p>See also: <a href="./index.html">NetBeans sessions and BOFs at JavaOne 2006 Conference</a></p>
<p><br /></p>



<p><h2>Speaker Bios</h2>

<br style="clear: both;"/>
<a name="joshua-bloch"></a>
<p><img src="../../../../images_www/javaone/joshua-bloch.png" width="140" height="212" style="float:left; margin-top:10px; margin-right:10px; margin-bottom:6px; border:1px solid #0E1B55" alt="Joshua Bloch" title="Joshua Bloch">
<H3>Joshua Bloch</h3>
Joshua Bloch is chief Java architect at Google and author of the Jolt Award-winning book, "Effective Java." He is coauthor of "JavaPuzzlers: Traps, Pitfalls, and Corner Cases." He was previously a Distinguished Engineer at Sun Microsystems and a Senior Systems Designer at Transarc. Josh led the design and implementation of numerous Java platform features, including JDK 5.0 language enhancements and the award-winning Java Collections Framework. He holds a Ph.D. in computer science from Carnegie Mellon University.

<br style="clear: both;"/>
<a name="tim-cramer"></a>
<p><img src="../../../../images_www/javaone/tim-cramer.png" width="140" height="166" style="float:left; margin-top:10px; margin-right:10px; margin-bottom:6px; border:1px solid #0E1B55" alt="Tim Cramer" title="Tim Cramer">

<H3>Tim Cramer</h3>
Tim Cramer has been at Sun for 13 years.  Currently, he is the Senior Director of Java Tools after being the Engineering Director for NetBeans.
Prior to that, he managed the Java performance group,
worked on the dynamic compilers, and also did static compilers.   Prior to
Sun he worked on  supercomputers for Supercomputer Systems, Inc and Lawrence
Livermore National Lab.  Tim  is very excited to help shepherd the resurgence of NetBeans.
He will MC NetBeans Day.

<br style="clear: both;"/>
<a name="neal-gafter"></a>
<p><img src="../../../../images_www/javaone/niel-gafter.png" width="140" height="159" style="float:left; margin-top:10px; margin-right:10px; margin-bottom:6px; border:1px solid #0E1B55" alt="Neal Gafter" title="Neal Gafter">
<H3>Neal Gafter</h3>
Neal Gafter is a software engineer and Java evangelist at Google. He was previously a senior staff engineer at Sun Microsystems, where he led the development of the Java compiler and implemented the Java language features in releases 1.4 through 5.0. Neal is coauthor of "Java Puzzlers: Traps, Pitfalls, and Corner Cases." He was a member of the C++ Standards Committee and led the development of C and C++ compilers at Sun Microsystems, Microtec Research, and Texas Instruments. He holds a Ph.D. in computer science from the University of Rochester. </p>

<br style="clear: both;"/>
<a name="james-gosling"></a>
<p><img src="../../../../images_www/javaone/james-gosling.png" width="135" height="202" style="float:left; margin-right:10px; margin-top:10px; margin-bottom:6px; border:1px solid #0E1B55" alt="James Gosling" title="James Gosling">
<h3>James Gosling</h3>
James Gosling received a BSc in Computer Science from the <a href="http://www.cpsc.ucalgary.ca/">University of Calgary</a>
Canada in 1977. He received a PhD in Computer Science
from <a href="http://www.cs.cmu.edu/">Carnegie-Mellon University</a> in
1983. The title of his thesis was "The Algebraic Manipulation of Constraints".
He is currently a VP & Fellow at <a href="http://www.sun.com/">Sun Microsystems</a>. He has
built satellite data acquisition systems, a multiprocessor version of Unix,
several compilers, mail systems and window managers. He has also built a WYSIWYG
text editor, a constraint based drawing editor and a text editor called `Emacs'
for Unix systems. At Sun his early activity was as lead engineer of the NeWS
window system. He did the original design of the <a href="http://java.sun.com">Java programming language</a>
and implemented its original compiler and virtual machine.
He has recently been a contributor to <a href="http://www.rtj.org">the Real-Time Specification for Java</a>,
and most recently was a researcher <a href="http://www.sun.com/labs">at Sun labs</a>
where his primary interest was software development
tools. He is now the Chief Technology Officer of Sun's Developer Products group.

<br style="clear: both;"/>
<a name="jonathan-schwartz"></a>
<p><img src="../../../../images_www/javaone/jonathan-schwartz.png" width="135" height="202" style="float:left; margin-top:10px; margin-right:10px; margin-bottom:6px; border:1px solid #0E1B55" alt="Jonathan Schwartz" title="Jonathan Schwartz">
<H3>Jonathan Schwartz</h3>
<p>
Jonathan Schwartz is president and chief executive officer of Sun Microsystems. He became Sun's CEO in 2006, succeeding the Company's co-founder and current chairman of the board of directors, Scott McNealy.  Schwartz was promoted to president and chief operating officer in 2004 and managed all operational functions at Sun - from product development and worldwide marketing, to global sales and manufacturing. An inveterate <a href="http://blogs.sun.com/jonathan">blogger</a>, Schwartz has led Sun's drive toward transparency and openness in everything the organization stands for.
<br />A leader behind many of Sun's open source and standard setting initiatives, from the open sourcing of Sun's flagship Solaris operating system and UltraSPARC microprocessor, to the Liberty Alliance, a cross industry effort to drive royalty free standards for secure network identity, Jonathan's been an outspoken advocate for the network as a utility with more than just value for the computing industry - but as a tool for economic, social and political progress.
<br />He joined sun in 1996 after the Company acquired Lighthouse Design, where he was CEO and co-founder. Prior to that, Schwartz was with McKinsey &amp; Co. in New York City. Schwartz received degrees in economics and mathematics from Wesleyan University.
</p>
</body>
</html>
