<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<title>Destination: Tokyo, Tales From the NetBeans Day worldTour</title>
<meta name="DESCRIPTION" content="Description of NetBeans Day - Tokyo">
<meta name="NAV_LINK" content="NetBeans worldTour">
<meta content="Gregg Sporar" 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>Destination: Tokyo - More Tales from the NetBeans Day WorldTour</h1>

<div class="articledate" style="margin-left:0px;">Released: 07 Nov 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">

The NetBeans worldTour continues! Our latest event took place on Monday, 7 November in Tokyo, Japan. Unlike our previous NetBeans Days in San Francisco and 
Beijing, <a href="http://blogs.sun.com/roller/page/jag">James Gosling</a> was unable to attend. In his place, he sent an excellent substitute: <a href="http://java.sun.com/developer/technicalArticles/Interviews/jackson_qa.html">Jeff 
Jackson</a>, his boss and Sun Microsystems' Vice President of Java Enterprise Platforms and Developer Products. Jackson served as keynote speaker for the 
developers who gathered at the Tokyo International Forum to hear presentations, meet other NetBeans community members, and stock up on t-shirts and CDs.</p>

<p>In his keynote address, Jackson gave an overview of NetBeans and described some of the exciting things happening in the NetBeans community including  
positive feedback from developers, good reviews in industry magazines, and increasing interest from third parties. The highlight of his keynote, 
though, was when he invited two luminaries from the Japanese NetBeans community up on to the stage. 
<a href="http://www.fk.urban.ne.jp/home/kishida/">Kishida-san</a> is the driving force behind <a href="http://www.netbeans.jp">www.netbeans.jp</a> and has 
written a soon-to-be-published book about NetBeans. 
<a href="http://cropcrusher.web.infoseek.co.jp/index_en.html">Shimizu-san</a> who is known in the community as Noniko, is the writer of the famous 
“housewife and Java” blog <a href="http://www.jroller.com/page/Noniko/Weblog">NoniWeblog</a>. Jackson wrapped up his keynote by using a giant 
Gosling-designed slingshot to send t-shirts into the audience.</p>

<p>Jackson was followed by NetBeans Evangelist <a href="http://weblogs.java.net/blog/gsporar/">Gregg Sporar</a> who did a presentation on what 
distinguishes NetBeans from the competition. Sporar started by defining NetBeans as two distinct things - a 
<a href="https://netbeans.org/features/platform/index.html">platform</a> and an <a href="https://netbeans.org/features/ide/index.html">Integrated Development 
Environment</a> (IDE). The NetBeans platform is used around the world by many organizations to develop rich-client applications. Sporar showed several 
example applications and then turned his attention to the NetBeans IDE. He gave a quick tour of the IDE and then described some of its distinguishing 
features. These included the Ant-based project system, superior out-of-box web and enterprise development support, an integrated profiler, excellent 
mobile application development support, and really cool code-aware collaboration tools.  Sporar then switched to describing some of the important new 
features in the upcoming version 5.0 of the NetBeans IDE. This portion included several demos, capped off by a quick look at 
<a href="https://netbeans.org/servlets/NewsItemView?newsItemID=642">Project Matisse</a> the powerful new  visual editor that is coming in 
NetBeans 5.0.  His demo of Project Matisse showed an application running in English and then in Japanese.</p>

<p>Next up was Java Technology Evangelist <a href="http://java.sun.com/developer/technicalArticles/Interviews/cmlee_qa.html">Chuk Munn Lee</a> with 
an in-depth demo of the mobile application development tools in the NetBeans IDE. Lee showed how easy it is to do mobile development with the IDE. 
He began his demonstration by building an application that makes appointments and then showed the application running in several different emulators. 
Lee used the Visual Mobile Designer to drag and drop MIDP components, making it easy to define the program flow. He also used the IDE's excellent 
device fragmentation support to define different code for different types of phones. Finally, Lee used the IDE's wireless connection wizard to 
connect the mobile application to a web application.</p>

<p>Gregg Sporar then came back onstage to describe the J2EE support in the NetBeans IDE. “NetBeans knows about the specifications of J2EE and handles 
most of those details, so you can focus on writing your application,” Sporar said. NetBeans supports J2EE developers by providing tight integration 
with web servers and application servers, and cool tools like a JSP editor and web services wizards. He showed how developers can view, open, and run 
<a href="http://java.sun.com/reference/blueprints/index.html">Java BluePrints</a> from within NetBeans. Sporar also showed NetBeans support for web 
services, Enterprise JavaBeans, and a demo of the enhanced Struts support that will be in version 5.0 of the NetBeans IDE. He finished by describing 
how the NetBeans IDE will support the forthcoming Java EE 5 specification.</p>

<p>Sporar was followed by <a href="http://blogs.sun.com/roller/page/cbeckham">Charles Beckham</a>, Sun's Technical Director for Tools. Beckham told 
the audience about the history of the <a href="https://netbeans.org/projects/obsolete/index.html">collaboration feature</a> and how it took awhile to educate 
everyone on the vision that he had for collaboration. That discussion was followed by a demo of the collaboration features in NetBeans, after which 
Beckham described <a href="http://developers.sun.com/prodtech/javatools/jsenterprise/">Java Studio Enterprise</a>, 
another IDE developed by Sun that is built on top of NetBeans.</p>

<p>The final demo of the day was given by <a href="http://blogs.sun.com/dan">Dan Roberts</a>, Sun's Director of Product Marketing for Tools. Roberts 
presented a brief demo of Sun's <a href="http://developers.sun.com/prodtech/javatools/jscreator/">Java Studio Creator</a> IDE that is also built on 
top of NetBeans and is designed to provide a drag-and-drop development environment for creating web applications. Roberts showed Creator's easy and 
intuitive features that are used to bind backend data services to the controls on a web page.</p>

<p>To wrap things up, Jackson took the stage again and invited Kishida-san and Shimizu-san back up to help him launch the remaining Gosling-signed 
t-shirts into the audience. That was followed by a beer bust where a good time was had by all!</p>

<p>Our next stop will be in Toronto this December. For more information on NetBeans Day Toronto and other upcoming venues, see the 
NetBeans worldTour site.</p>

</body>
</html>


