
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 392</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 # 392 - May 19, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3675">NetBeans at CommunityOne and JavaOne (June 1-5)</a></h2>
						<p style="margin-left:8px;">
						Spend a week with the NetBeans team at the 2009 CommunityOne and JavaOne conferences! Learn about the latest enhancements to NetBeans and the integration with Project Kenai, see previews of the upcoming 6.7 release and discover how to get the most of the IDE's multilingual support. And as always, attend for a chance to mingle with other developers and grow your network. Register today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3676">Webinar: The New MySQL Connector/C++ (May 20)</a></h2>
						<p style="margin-left:8px;">
						MySQL Connector/C++ is the latest Connector for MySQL, and it differs from other connectors in following the well-designed JDBC specification with adaptations for the C++ world. Tune in to this webinar to learn about the connector from its creators, Andrey Hristov and Ulf Wendel, and how using it can ease your development of C++ database applications.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3673">Get the Brand New NetBeans Platform eBook</a></h2>
						<p style="margin-left:8px;">
						Author Heiko Boeck's translated <a href="http://www.apress.com/book/view/9781430224174">NetBeans Platform</a> book is available as an eBook. Get it while it's hot! The hard copy version will be available at the JavaOne conference bookstore, and there will be a book signing as well.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3670">Web Service Application Passing Binary Data</a></h2>
						<p style="margin-left:8px;">
						This learning trail shows how to create and consume a web service that delegates to an EJB and sends binary data via SOAP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3672">Screencast: NetBeans Platform Crash Course</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2904&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A cool screencast that gives you a quick start to the basics of the NetBeans Platform and desktop development for complex Swing applications.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3669">Defining Your C/C++ Project's Development Environment</a></h2>
						<p style="margin-left:8px;">
						A short tutorial that demonstrates how to use local or remote tool collections to develop C/C++ projects in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3671">JavaFX App-O-Rama: Applications from the Community</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2905&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='51' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This article highlights some of the applications that the JavaFX community has developed and provides insights from the authors about their experiences using the JavaFX platform.</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3674">Converting Legacy Rails Apps to Grails</a></h2>
						<p style="margin-left:8px;">
						The final entry from Alex Kotchnev's series on migrating a legacy Rails application to Grails using the NetBeans IDE. After <a href="http://www.troymaxventures.com/2008/10/converting-legacy-rails-apps-to-grails.html">General Project Setup</a>, <a href="http://www.troymaxventures.com/2008/10/converting-legacy-rails-apps-to-grails_31.html">Migrating the Domain Objects</a>, and <a href="http://www.troymaxventures.com/2009/05/converting-legacy-rails-apps-to-grails.html">Migrating the Controllers</a>, he ends with <a href="http://www.troymaxventures.com/2009/05/converting-legacy-rails-apps-to-grails_05.html">Migrating the Views</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3677">NetBeans 6.7 Beta + Maven = Heaven (More than Promising)</a></h2>
						<p style="margin-left:8px;">
						Adam Bien explores Maven support in the NetBeans 6.7 Beta release and records his observations.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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-19.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>