<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="Content-Type"
 content="text/html; charset=windows-1252">
  <link rel="stylesheet" type="text/css"
 href="https://netbeans.org/netbeans.css" media="screen">
  <meta name="Tinuola Awopetu" content="NetBeans, NetBeans IDE, Xoetrope">
  <title>NetBeans Day Partner Showcase - Xoetrope</title>
</head>
<body>
<h1><a
 href="https://netbeans.org/community/articles/javaone/2007/nb-day.html"><img
 alt="NetBeans Day Registration"
 src="../../../../images_www/javaone/2007/nb-day-200.jpg"
 style="border: 0px solid ; width: 200px; height: 99px;" align="right"
 hspace="5" vspace="5"></a>NetBeans
Day 2007 Partner Showcase</h1>
<div style="text-align: justify;"><span style="font-style: italic;">NetBeans
recognizes companies that have made significant contributions to the
NetBeans Project through its <a
 href="https://netbeans.org/community/partners/">Partner Program</a>
and with speaking invitations to NetBeans Day. Attend these Partner
sessions that showcase exciting and new plug-ins, and discover ways
to extend and get
the most out of the NetBeans IDE!</span><br>
<br>
</div>
<a href="http://www.xoetrope.com/"><img alt="Xoetrope"
 src="../../../../images_www/partners/nbpartner-logo-xoetrope.gif"
 style="border: 0px solid ; width: 183px; height: 88px;" vspace="5"></a><br>
<h4>Speaker: Luan O'Carroll<br>
Session: <a href="http://www28.cplan.com/cc158/session_details.jsp?isid=288596&ilocation_id=158-1&ilanguage=english">Rapid
RIA with XUI and NetBeans (S288596)</a><br>
</h4>
<br>
<img alt="Luan O'Carroll, Xoetrope"
 src="../../../../images_www/javaone/2007/xoetrope-luan-ocarroll.jpg"
 style="width: 208px; height: 156px;" align="left" hspace="5" vspace="5">
<h4>What do you do at Xoetrope?</h4>
I'm the lead developer on the XUI project, and also the CEO.
<br>
<br>
<h4>As a partner, how has your company contributed to the NetBeans
Project?</h4>
We have built the Kaideoscope plug-in, an Open Source editor for XUI.
We have also built the Carousel plug-in. Carousel is a collection of
add-ons for XUI and NetBeans; it adds lots of components and tools to
ease the process of building enterprise level applications.
<br>
<br>
<h4>Tell us about your NetBeans Day Presentation.</h4>
I'm going make a presentation on building Rich Internet Applications
(RIA) using NetBeans and our plug-ins. RIAs can offer the best of the
Internet and the Desktop, but sometimes they don't live up to their
name. So in the presentation I will show some of the things we do to
ensure that we produce compelling applications.
<br>
<br>
<h4>What's the top point that developers should know about your session?</h4>
This will be the first public showing of XUI 3.0 and the new NetBeans
plug-ins. We will demo the new software, showing some of the highlights
in the process.
<br>
<br>
<h4>What are the benefits to the community?</h4>
All the tools are open-source (although the Carousel components require
a license for redistribution), so developers can try them out and use
them for free. The tools take care of much of the plumbing needed to
build RIAs, and developers can use all their normal Java skills. So,
it's a great way to get started with RIAs.
<br>
<br>
<h4>What is the main message you want a developer to get after
attending your session?</h4>
That by using XUI and NetBeans you can very quickly build great desktop
applications.
<br>
<br>
<h4>Why did you submit your session to be presented at NetBeans Day?
</h4>
NetBeans is our platform of choice, not just because we have plug-ins
for NetBeans but because of all the other facilities available. Without
NetBeans we would have had to reinvent lots of things. <br>
<br>
<h4>What features do you enjoy working with in NetBeans?</h4>
We are pretty intensive users of NetBeans and we use a wide range of
features from the basic Java coding through to the profilers and
deployment tools. The Profiler is one of my favorites.
<br>
<br>
<h4>How does working in Java compare with other technologies?</h4>
For us, Java is really the only choice. Many of the customer
applications we build need an efficient computing platform and one that
spans devices from handhelds to servers. Not only does Java give us
this, but it also gives us many of the capabilities that are essential
for RIAs. The Java platform also offers a level of consistency that we
would not have had with some of the other options, and this opinion is
reinforced almost every time we have to use something other than Java.
<br>
<br>
Of course, that's not to say there aren't things we can learn from
other platforms and on the desktop this sort of competition is really
intense. We keep an eye on new developments for inspiration, but
fortunately there is such a range and depth of possibilities in Java
that there's usually a way of achieving similar results in Java. <br>
<br>
</body>
</html>
