
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 393</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}

#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl2/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl2/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}
.align-center {text-align:center;}
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>


<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 393 - May 28, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3726">Register for CommunityOne and JavaOne, Save $200! (June 1 - 5)</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Team is ready to roll for CommunityOne and JavaOne 2009, and we hope to meet you there! Attend both conferences to learn about the latest technologies, see our cool demos and chat with experts and fellow community members! There's a bonus this year for attendees: Register for <a href="http://java.sun.com/javaone/"><b>JavaOne</b></a> and save $200. As always, <a href="http://developers.sun.com/events/communityone/2009/west/index.jsp"><b>CommunityOne</b></a> is FREE for all. If you're a student, attend both CommunityOne and JavaOne for <a href="http://java.sun.com/javaone/2009/students_and_educators/index.jsp">FREE</a>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3725">The NetBeans Guide to CommunityOne and JavaOne 2009</a></h2>
						<p style="margin-left:8px;">
						<p>Whether you are interested in cloud services, mobile games, web applications, or desktop tools, there is always something new to learn at the JavaOne conference. Every year, experts are invited to share their experiences with fellow developers, so don't miss this unique opportunity to get a head start on the latest technologies! If you want to know what's new and cool this year, check out our NetBeans Guide to CommunityOne and JavaOne:<br><br> - <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1383">NetBeans Connects Developers at CommunityOne 2009</a><br>- <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1382">Make the Most of Your Mobile Apps at JavaOne 2009</a><br>- <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1381">New and Cool Java Desktop and Swing Apps at JavaOne 2009</a><br>- <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1380">Become an Expert on Web and Enterprise Apps at JavaOne 2009</a><br>- <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1384">Connect to the Cloud at JavaOne 2009</a><br>- <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1379">Learn from the NetBeans Community at JavaOne 2009</a></p></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3703">Developing Database Applications Using MySQL Connector/C++</a></h2>
						<p style="margin-left:8px;">
						This tutorial will show you the essential steps to build and install the new MySQL Connector/C++ driver, with simple examples to connect, insert, and retrieve data from a MySQL database. Application developers who are relatively new to MySQL Connector/C++ but not to C++ programming and MySQL database are the target audience of this tutorial.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3723">NetBeans RSS Reader For iPhone and iPod Touch!</a></h2>
						<p style="margin-left:8px;">
						NetBeans community member Siegfried published his first application on the Apple iTunes Store: He created a nifty RSS feed reader that lets you browse your favorite news, the NetBeans.org and the Aquarium feeds! See creenshots and learn more i this dzone article.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3696">Passing Binary Data Via a Web Service</a></h2>
						<p style="margin-left:8px;">
						In this advanced multi-part tutorial, you learn how to makes binary data (such as images) available via a web service. You also create a Java application that connects to the web service to display the images in an album created from Swing components.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3697">NetBeans JavaScript Debugger User's Guide</a></h2>
						<p style="margin-left:8px;">
						The NetBeans JavaScript debugger provides you with a set of tools that aid in the process of inspecting, monitoring and editing JavaScript code. You can use the debugger to identify errors, or step through execution and explore the state of your application at any given moment.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3698">NetBeans Wizard Module Tutorial</a></h2>
						<p style="margin-left:8px;">
						In NetBeans Platform applications, many different kinds of wizards can be created. This tutorial shows how you create a general wizard that appears when you click a button in the toolbar.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3704">Tapestry 5, NetBeans 6.7, Maven, and Jetty: Really!</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Alex Kotchnev shows you in his blog how he set up Tapestry 5 live class and template reloading with NetBeans in a few easy steps. Apache Tapestry is an open-source web application framework that Alex uses together with the Jetty web server. Read more in his blog!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3724">Browse XML Files With the New XPath Plugin</a></h2>
						<p style="margin-left:8px;">
						Michael Bien just released a plugin that makes browsing through large XML documents a bit easier. Just start typing a XPath expression and the plugin shows matches in the XPath window. Check it out now, it even supports code completion!</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<br/>If you do not want to receive this newsletter, you can <a href="https://netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2009-05-28.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>