<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<title>Tales From the NetBeans Day worldTour First Stop: Beijing</title>
<meta name="DESCRIPTION" content="Description of NetBeans Day - China">
<meta name="NAV_LINK" content="NetBeans worldTour">
<meta content="Tori Wieldt" name="AUTHOR">
<link rel="stylesheet" type="text/css" HREF="../../../netbeans.css">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>

<body>
<h1>First Stop: Beijing - Tales from the NetBeans Day WorldTour</h1>

<div class="articledate" style="margin-left:0px;">Released: 13 Sept 2005</div>

<br/>
<p><img src="https://netbeans.org/images_www/banners/nb-world-tour-265-79.jpg" 
width="265" height="79" style="margin-right:15px; float:left;" alt="NetBeans WorldTour">

After the success of  NetBeans Day - San Francisco, NetBeans Team has hit the road for a ten city 
around-the-world tour. Our first stop was in Beijing on Monday, 12 September. Over 500 developers gathered at the 
city's Hotel Nikko to hear presentations from our finest technicians, meet other community members, and stock up 
on t-shirts, CDs, and other related tsotchkes.</p>

<p><img src="https://netbeans.org/images_www/articles/worldtour/nbchina-attendees2.jpeg" 
width="320" height="240" style="margin-left:15px; float:right" alt="NetBeans day China -- the crowd"></a>

Sun Tools architect and distinguished engineer <a href="http://blogs.sun.com/roller/page/brewin">Bob Brewin</a> 
was scheduled to moderate the event. Unfortunately, the weather did not cooperate and he was stranded in Japan. 
<a href="http://blogs.sun.com/roller/page/jag">James Gosling</a> stepped in and hosted the day. As the crowd 
ate their hamburgers and French fries, Gosling gave an overview of Java technology and NetBeans. He explained 
that Java provides a homogenous view of the heterogeneous environment developers typically have to work in. 
&ldquo;Rather than &lsquo;write once, run anywhere&rsquo;, what is more important to developers is 
&lsquo;<i>Learn</i> once, work anywhere&rsquo;,&rdquo; he said. As the crowd asked for more information on the 
next release of the Java platform, Gosling explained that it's the community that makes Java work. Even he doesn't 
know what will be in the next release because the Java developer community ultimately determines the platform's 
features through their involvement in the <a href="http://www.jcp.org">Java Community Process</a>.</p>

<p>Netbeans Evangelist <a href="http://weblogs.java.net/blog/timboudreau">Tim Boudreau</a> explained the new 
features in Netbeans 4.1. He also gave several demonstrations that showed how to import an existing project with 
an Ant build script into NetBeans, profile code, and quickly create unit tests. Boudreau finished with a quick 
peak of <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=642">Matisse</a>, the powerful new GUI 
feature coming in NetBeans 5.0. He said cross-platform layout is a challenge for all developers, and while the 
grid-bag layout is powerful, it's also hard to use. While he dragged and dropped components into place, Boudreau 
explained that GUIs built in Matisse will know and follow the guidelines for a particular platform (Windows, Mac, 
Java) and adjust accordingly.</p>

<p>
<img src="https://netbeans.org/images_www/articles/worldtour/nbchina-stage.jpeg" 
width="320" height="240" style="margin-left:15px; float:right" alt="NetBeans day China -- Gregg Sporar, James Gosling"></a>

Boudreau's presentation was followed up with a lively Q and A session. Attendees asked questions about the 
Visual Editor, JavaServer Faces support, struts, Maven, and plug-in support. He was also asked to describe the 
differences between NetBeans and two other leading Java IDEs: 
<a href="http://developers.sun.com/prodtech/javatools/jscreator/index.jsp">Sun's Java Studio Creator</a> and IBM's 
Eclipse. One attendee in particular asked him &ldquo;what are the three most important reasons for me to switch 
from Eclipse to NetBeans?&rdquo; Boudreau responded by describing NetBeans improved usability and four other 
specifics:</p>

<ol>
<li>NetBeans is standards-based (for example, the new GUI builder, Matisse)</li>
<li>Increased productivity (Ant-based projects)</li>
<li>J2EE support</li>
<li>J2ME support</li>
</ol>

<p>NetBeans Evangelist <a href="http://weblogs.java.net./blog/gsporar/">Gregg Sporar</a> came next and wowed the 
crowd when he opened his presentation with &ldquo;Hello, I'm sorry, I don't speak Chinese,&rdquo; in Mandarin. He then went on 
to describe the J2EE support in NetBeans. &ldquo;NetBeans knows about the plumbing of J2EE so you don't have to,&rdquo; Sporar 
said in English. NetBeans supports the J2EE developer with tight integration with web servers and app servers, and 
cool tools like a J2EE editor and a deployment descriptor wizard. He finished his presentation by showing how you can view, 
open, and run <a href="http://java.sun.com/reference/blueprints/index.html">Java BluePrints</a> from within NetBeans.</p>

<p><img src="https://netbeans.org/images_www/articles/worldtour/nbchina-gosling2.jpeg" 
width="320" height="240" style="margin-left:15px; float:right" alt="NetBeans day China attendees chatting with James Gosling"></a>

Up next came engineer Martin Ryzl who showed the mobility support in NetBeans. Ryzl demonstrated building a mobile app in 
the Visual Mobile Designer by dragging and dropping MIDP components like text boxes and a progress bar. He then showed how 
to create &lsquo;conditional text&rsquo; based on the target device. The crowd also showed a lot of interest in 3-D graphics.</p>

<p>NetBeans Day - China ended with a Java community event. Gosling and the other presenters came back on stage for a final 
Q and A session. The attendees asked them many tough questions, but one in particular resonated with the entire audience: 
how can improvements in a Western IDE meet the needs of Chinese developers? Boudreau took the question by describing 
academic research efforts on usability and the opportunity for Chinese developers to become involved in future NetBeans 
usability studies. Most important, he emphasized, was that Chinese developers get involved and become active members of the 
NetBeans <a href="https://netbeans.org/community/index.html">community</a>. As all NetBeans Day China attendees received 
a NetBeans CD, with 4.1 in Simplified Chinese, they are well on their way 
to becoming part of our growing, dynamic community.</p>

<p>The next stop of our worldTour is Tokyo in November. For more information on this and other upcoming venues, see 
our NetBeans worldTour site.</p>

</body>
</html>

