<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta name="DESCRIPTION" content="NetBeans worldTour -- Agenda for Bangkok, Thailand">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<title>NetBeans Day Bangkok</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body>

<h1>NetBeans Day Bangkok, Thailand</h1>

<h2>Date and Venue</h2>

<p>Thursday, January 26th, 2006</p>

<p>NetBeans Software Day will be held at Conrad Hotel Bangkok

<p>
Conrad Bangkok, Bangkok<br />
All Seasons Place, 87 Wireless Road,<br /> 
Bangkok, THAILAND<br />
Tel: +66 (0) 2690 9999<br />
Fax: +66 (0) 2690 9000<br />
Mail: <a href="mailto:bangkokinfo@conradhotels.com">bangkokinfo@conradhotels.com</a><br />
WWW: <a href="http://www.conradhotels.com">www.conradhotels.com</a><br />
</p>

<p>
Register online today. Onsite Registration: 10:00 a.m. to 11:00 a.m.
</p>

<p><h2>Agenda</h2>
<p>
<ul>
<li> 10:00-11:00  <em>Registration</em>
<li> 11:00-12:00  What makes NetBeans the best?
<li> 12:00-1:00   <em>Lunch</em>
<li> 1:00-1:45    Plug-in development and Rich Client Platform
<li> 1:45-2:30    What makes NetBeans the best IDE for J2ME development?
<li> 2:30-3:15    What makes NetBeans the best IDE for J2EE development?
<li> 3:15-4:00    <em>Closing keynote with James Gosling</em>
</ul>
</p>

<h2>Abstracts</h2>

<h3>What makes NetBeans the Best?</h3>

<p>Is NetBeans
a platform or an IDE? NetBeans is both. It's a platform for developing rich client
applications <em>and</em> it's an
award-winning Integrated Development Environment (IDE). This session
provides an introduction to the world of
NetBeans, including a tour of
the distinguishing features in the IDE. It also highlights the most
important new features in the upcoming
NetBeans 5.0 release:
enhancements to the editor, new CVS support, more types of refactoring,
module development support, and the
highly-anticipated Project Matisse.

<h3>Plug-in Development and Rich Client Platform</h3>

<p>NetBeans 5.0
offers comprehensive support for building IDE plug-in 
 modules and rich client applications on
the NetBeans platform. A lot of   
support for extending the IDE and creating applications on top of the 
 NetBeans Platform is provided. Using
brand new templates in the New   
Project wizard and New File wizard, you can generate all the basic files 
 and code you need. The Project
Properties dialog box lets you configure 
 API dependencies, MANIFEST.MF entries,
and other project metadata. Code 
 completion and other standard support
provided by the Source Editor is 
 available for plug-in modules too. In
this session, these features are 
 explained and demonstrated.</p>

<h3>What Makes NetBeans the Best IDE for J2ME Development? </h3>

<p>J2ME development requires a specific set of tools. The 
 NetBeans IDE provides a first class set
of tools for developing mobile   
Java applications. This session is an introduction to J2ME and 
 demonstrates the features of the
NetBeans IDE Mobility Pack. The   
ultra-cool visual designer will be
demonstrated, along with wizards that 
 support wireless connection and procide
a unique solution to the device   
fragmentation problem.</p>  

<h3>What makes NetBeans the Best IDE for J2EE Development? </h3>

<p>NetBeans provides a trouble-free out-of-box experience for 
 J2EE developers. There's no need to
search for plug-ins; the NetBeans 
 IDE provides you with the tools you need
to start being productive right   
away. These include: sample J2EE code &amp; blueprints with
documentation,   tight
integration with a growing list of application servers, and lots 
 of powerful tools: editors, debuggers,
profilers, wizards, etc.</p>

</body>
</html>
