<html>
    <head>
        <title>NetBeans Software Day 2007 - Highlights and Agenda</title>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <meta name="description" content="Information about NetBeans Software Day at the 2007 JavaOne Conference - talks, schedules, BOFs and more">
        <link rel="stylesheet" type="text/css" href="../../../../netbeans.css">
    </head>

    <body>

<p><br>
 <!--    <a href="https://www28.cplan.com/pls/pg_sun/c158_reg.nb_login">
                <object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
                        codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=5,0,0,0"
                        width="610" height="90" id="nb-day-2007-clock-small.swf" align="middle">
                    <param name="allowScriptAccess" value="sameDomain" />
                    <param name="movie" value="https://netbeans.org/files/documents/4/1363/nb-day-2007-clock.swf" />
                    <param name="quality" value="high" />
                    <param name="bgcolor" value="#ffffff" />
                    <embed src="https://netbeans.org/files/documents/4/1363/nb-day-2007-clock.swf"
                           quality="high" bgcolor="#ffffff"  width="610" height="90"
                           name="nb-day-2007-clock-small.swf" valign="right" allowScriptAccess="sameDomain"
                           type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer" />
            </object></a>
            </p> -->

        <h1>NetBeans Software Day<br>
        at the 2007 JavaOne Conference</h1>

<table cellspacing="16">
<tr>
  <td valign="top">
    <img src="../../../../images_www/javaone/nb_day/nbday2006-crowd-small.jpg"
    style="float:right; margin-top:0px; margin-left:15px; margin-bottom:6px; border:1px solid #0E1B55;"
    width="220" height="149" alt="NetBeans Day San Francisco 2006" align="right" title="NetBeans Day San Francisco 2006"></a>
  </td>

  <td valign="top">
            <div style="font-size:120%">
                <b><br /><a href="nb-day-report.html"><b>Read what happened</b></a></b>
                <br /><br />    
                <br />Monday, May 7, 2007
                <br />10 am - 6 pm
                <br /><a href="http://www.moscone.com/"><b>Moscone Center</b></a>,
                <br />San Francisco, California
                <br />

           </div><br>
	<!-- <a href="https://netbeans.org/about/contact_form.html?to=1&subject=NB%20Day%20SF%20Registration"><span style="font-size:100%">Registration problems?</span></a>) -->
	</td>
	<td style="padding-left:60px;" class="align-center">
	<a href="https://netbeans.org/files/documents/4/1404/NBDay-flier.pdf">
	<img alt="NetBeans Day/JavaOne Session Flier" src="../../../../images_www/javaone/2007/flier.jpg" width="228" height="150" border="0"><br>
	NetBeans Day/JavaOne Session Flier</a>
        </td>

</tr></table>

	<a name="whatisit"></a><h2>What Is It?</h2>

        <p>
        <b>NetBeans&trade; Software Day is FREE - you do not have to be registered for JavaOne to attend.</b></p>
        
        <p>
      On Monday, May 7, the day before the 2007 JavaOne Conference,
      the NetBeans Software Team hosted a FREE companion event at the Moscone Center.
      See how the NetBeans IDE continues to lead with the latest technology.
      Learn from the experts about what's new and what's coming: JRuby Scripting,
      Swing GUI Building with Matisse, the new installer, editor improvements
      and more. Find out what a Schliemann is!</p>

      <p>
      Hear from the experts. James Gosling, the father of Java&trade, discussed the
      future of Java and developer tools. The NetBeans Evangelism Team was there,
      along with the Java Posse.
      There also were keynotes by
      Jonathan Schwartz, President and CEO of Sun Microsystems, and Rich Green,
      Sun's Executive Vice President for Software. <!--Last year it was standing room only, so
            <a href="https://www28.cplan.com/pls/pg_sun/c158_reg.nb_login">
            register now! 	(<a href="https://netbeans.org/about/contact_form.html?to=1&subject=NB%20Day%20SF%20Registration"><span style="font-size:100%">Registration problems?</span></a>)</a> -->
        </p>

        <a name="highlights"></a><h2>Highlights</h2>

<table>
<tr>
<td>

        <P>
            <ul>
                <li>Listen to <a href="#james-gosling">James Gosling</a> - the
                    father of Java technology, as well as other Java technology luminaries,
                    will be present to discuss the future of Java developer tools and the
                    rich client platform.  </li>
                <li>Chat with the <a href="http://javaposse.com/">Java Posse</a> 
                    (Dick Wall, Tor Norbye, Carl Quinn and Joe Nuxoll)
                    who will record a special episode of their Java Posse
                    podcast live during NetBeans Day. They will be looking for NetBeans developers
                    and enthusiasts to interview. </li>
                <li>See demos of <a href="../../../../kb/docs/screencasts.html">NetBeans IDE</a> 6.0 - 
                    the new Installer, Editor, Profiler, and Schliemann.</li>
                <li>Learn about
                    <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1015">Ruby and JRuby</a>
                    scripting language support in the NetBeans IDE.</li>
                <li>Enjoy Sun SPOT robots and the NetBeans toy show --
                    get inspiration to create applications that are as useful as they are funny.
                    </li>
                <li>Meet the <a href="../../../teams/evangelism/">NetBeans Evangelism Team</a> 
                    (Roman, Brian, Tim, Gregg, Ashwin, Matt, Dave, and Bruno) and
                    ask them tough questions.</li>
                <!-- <li>Join the unconference hosted by the 
                <a href="../../../contribute/dreamteam.html">NetBeans Dream Team</a> - 
                community members and highly skilled NetBeans users.</li>-->
        </ul></p></td>


        <td>
	 <img src="../../../../images_www/javaone/nb_day/javaposse-small.jpg"
          style="float:right; margin-top:0px; margin-left:15px; margin-bottom:6px; border:1px solid #0E1B55;"
             height="180" width="138" alt="The Java Posse" align="right" title="The Java Posse"></a></td>
          </tr>
 <tr>

</table>

            <a name="freebook"></a><h2>Free Book! Free Flash Drives! Free T-shirts!</h2>

<table>
    <tr>

        <td>  <p><img src="../../../../images_www/javaone/rcpbook.jpg"> </td>


        <td><p>The first 400 attendees will receive
            a <b>free</b> copy of <a href="../../../../books/rcp.html"><em>Rich Client Programming:
            Plugging into the NetBeans Platform</em></a>. We will also be giving out 
            <b>1 GB USB flash drives</b>, loaded with the latest NetBeans 6.0 Milestone.
            Throughout the day, we will be giving out a special edition
            <b>NB 6.0 T-shirts</b> and NetBeans cubes. Pay attention, you
            may have to earn your T-shirt by asking or answering a question. </p></td>
    </tr>
</table>
<!--
        <a name="register"></a><h2>Registration</h2>
        
        <p>NetBeans Day is a companion event to the <a href="index.html">JavaOne 2007 Conference</a>
        which begins the following day. You do not need to be registered for JavaOne
        &mdash; NetBeans Software Day is free for anyone who wishes to attend,
        so <a href="https://www28.cplan.com/pls/pg_sun/c158_reg.nb_login">register now</a>!


        <p>If you're going to JavaOne as well, check the
            <a href="http://www28.cplan.com/cc158/sessions_catalog.jsp?ilc=158-1&ilg=english&isort=&isort_type=&is=yes&icriteria1=+&icriteria2=+&icriteria7=+&icriteria9=&icriteria8=NetBeans&icriteria3=">
        full schedule of NetBeans sessions and BOFs.</a></p>

-->

 <!--  <a name="logo"></a><h2>Share the Good News!</h2>

                <p>Put this logo on your web site and help us make this the biggest and
                best NetBeans Day yet!</p>
                <img SRC="../../../../images_www/javaone/nb_day/netbeans-day-logo.png"
                border:2px align="center">
  -->

        <p style="clear;both;">

        <a name="presentations"></a><h2>Agenda</h2>

        <p>The most current schedule can always be found in the
        <a href="http://wiki.netbeans.org/wiki/view/NetBeansDaySF2007">NetBeans wiki</a>.

        <p><table border="0" cellspacing="0" cellpadding="10">
        <tr bgcolor="#F2F2F2"><th>11:00 - 12:00</th>
          <td align="center" colspan="2"> General Session with Schwartz and Green</td></tr>
        <tr bgcolor="#FAFAFA"><th>12:00 - 01:00</th>
          <td align="center" colspan="2">Lunch break with the Java Posse - Live Podcast!   </td></tr>
        <tr bgcolor="#F2F2F2"><td>&nbsp;</td>
          <td align="center"> <b>Track A:<br> NetBeans&nbsp;Innovations</b> </td>
          <td align="center"> <b>Track B:<br> NetBeans&nbsp;Everywhere</b></td></tr>
        <tr bgcolor="#F2F2F2"><td>&nbsp;</td> 
          <td align="center"> <b>Gateway 102/103, Moscone Center</b> </td>
          <td align="center"> <b>Gateway 104, Moscone Center</b> </td></tr>
        <tr bgcolor="#FAFAFA"><th>01:30 - 02:25</th>
          <td align="center"> NetBeans 6.0: Installer, Editor, <br>Profiler, and Schliemann. <a href="http://wiki.netbeans.org/wiki/view/NetBeansDaySF2007#section-NetBeansDaySF2007-NetBeans6.0">More...</a></td>
          <td align="center">Partner Showcase <br><a href="http://http://www.collab.net/">Collabnet</a>:
Subversion and the NetBeans IDE <BR> <a href="http://www.yasutech.com/">Yasu Technologies</a>:
Architecting Apps using BRMS and Open-ESB</td></tr>
        <tr bgcolor="#FAFAFA"><th>02:40 - 03:35</th>
          <td align="center"> Swing GUI Building with Matisse. <br><a href="http://wiki.netbeans.org/wiki/view/NetBeansDaySF2007#section-NetBeansDaySF2007-SwingGUIBuildingWithMatisseChapterII">More...</a></td>
        <td align="center"> NetBeans Mobility, including <br>Sun SPOTs for robots. <a href="http://wiki.netbeans.org/wiki/view/NetBeansDaySF2007#section-NetBeansDaySF2007-NetBeansMobility">More...</a></td></tr>
        <tr bgcolor="#F2F2F2"><th>03:35 - 04:00</th>
          <td align="center" colspan="2"><em>(Break)</em></td></tr>
        <tr bgcolor="#FAFAFA"><th>04:00 - 04:55</th>
          <td align="center"> JRuby: Understanding the Fuss <BR>
          <a href="http://wiki.netbeans.org/wiki/view/NetBeansDaySF2007#section-NetBeansDaySF2007-JRuby">More...</a>  </td>
        <td align="center"> Partner Showcase <br><a href="http://intland.com/">Intland</a>: NetBeans and Codebeamer<BR>
            <a href="http://www.xoetrope.com/">Xoetrope</a>: Rapid RIA with XUI and NetBeans</td></tr>
        <tr bgcolor="#F2F2F2"><th>05:00 - 05:55</th>
          <td align="center" colspan="2"> Closing Session with James Gosling<br>Featuring NetBeans toy show and the Dream Team</td></tr>
        <tr bgcolor="#FAFAFA"><th>06:00 - 08:00</th>
          <td align="center" colspan="2"> Free food &amp; drinks<br>Have a chat with fellow developers</td></tr>
        </table>

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

        <br style="clear: both;"/>
        <a name="james-gosling"></a>
        <p><img src="../../../../images_www/javaone/james-gosling.png" width="98"
                style="float:left; margin-right:15px; margin-top:10px; margin-bottom:10px; 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>.
        <br>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.
        <br>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.</p>
        <br style="clear: both;"/>

        <a name="RichGreen"></a>
        <p><img src="../../../../images_www/javaone/2007/rich-green.jpg" width="98"
                style="float:left; margin-top:10px; margin-right:15px; margin-bottom:16px; border:1px solid #0E1B55"
                alt="Rich Green" title="Rich Green">

        <h3>Rich Green</h3>
        Sun's Executive Vice President for Software, Rich Green, is responsible for the overall operational leadership
        of Sun's software division, which has delivered some of the computer industry's most innovative technologies
        and business models. Mr. Green oversees the Solaris Enterprise System, including the Solaris Operating System,
        the Java Enterprise System suites, N1 management software, Sun Studio and Java Studio developer tools.
        In addition, he leads a variety of industry-standards efforts and open source communities.

        <br><br>As Sun's chief Java advocate, Green played an essential role in the company's negotiations
        leading to its landmark $1.6 billion settlement and 10-year collaboration agreement with Microsoft.
        Green also spearheaded the development of such critical technological advancements
        as Java Studio Creator and was instrumental in driving adoption for Sun's Java Virtual Machine software.
        Previously, Green served as vice president and general manager of the Solaris products organization.</p>
        <br style="clear: both;"/>

        <a name="tornorbye"></a>
        <p><img src="../../../../images_www/javaone/2007/tor.png" width="98"
                style="float:left; margin-top:10px; margin-right:15px; margin-bottom:6px; border:1px solid #0E1B55"
                alt="Tor Norbye" title="Tor Norbye">

        <h3>Tor Norbye</h3>
        Sun Senior Staff Engineer Tor Norbye is responsible for the NetBeans Ruby support.
        Before that he worked on Java Studio Creator's visual page designer.
        <br><br>He <a href="http://blogs.sun.com/tor/">blogs</a> frequently
        on Ruby and Java related topics and is a member of the
        <a href="http://javaposse.com/">Java Posse</a>.</p>
        <br style="clear: both;"/>

        <a name="CharlesNutter"></a>
        <p><img src="../../../../images_www/javaone/2007/cnutter.jpg" width="98" height="110"
                style="float:left; margin-top:10px; margin-right:15px; margin-bottom:6px; border:1px solid #0E1B55"
                alt="Charles Nutter" title="Charles Nutter">

        <h3>Charles Oliver Nutter</h3>
        Charles Nutter has been a Java developer since 1996 and he currently works full-time on JRuby at Sun Microsystems.
        He led the open-source LiteStep project in the late 90s and came to Ruby in the fall of 2004.
        Since then he has been a member of the JRuby team, helping to make it a true alternative Ruby platform.
        Charles presented JRuby at RubyConf 2005 and co-presented at JavaOne 2006 with Thomas Enebo.
      Charles blogs on Ruby and Java at <a href="http://headius.blogspot.com/">headius.blogspot.com</a>.</p>
        <br style="clear: both;"/>

        <a name="jonathan-schwartz"></a>
        <p><img src="../../../../images_www/javaone/2007/jonathan-schwartz.png" width="98"
                style="float:left; margin-top:10px; margin-right:15px; margin-bottom:26px; border:1px solid #0E1B55"
                alt="Jonathan Schwartz" title="Jonathan Schwartz">

        <h3>Jonathan Schwartz</h3>
        Jonathan Schwartz is president and chief executive officer of Sun
        Microsystems. He became Sun's CEO in 2007, 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><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><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>

