
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 337</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 # 337 - Apr 14, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1775">Download NetBeans IDE 6.1 Release Candidate!</a></h2>
						<p style="margin-left:8px;">
						NetBeans.org is proud to announce the availability of the NetBeans IDE 6.1 Release Candidate! The release includes new features and enhancements for JavaScript editing, using the Spring web framework, tighter MySQL integration, sharing libraries among dependent projects, and <a href="https://netbeans.org/community/releases/61/">many other highlights and fixes</a>.<br><br>
Download the release candidate today and let us know what you think on our <a href="https://netbeans.org/community/lists/top.html">mailing lists</a>. Remember that <a href="https://netbeans.org/competition/blog-contest.html">blogging</a> about the IDE could even get you $500USD! The final NetBeans IDE 6.1 release is scheduled for late April.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1776">Take Our Survey: Is NetBeans IDE 6.1 Ready for FCS?</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.1 Release Candidate is out and we want your feedback. Download and use the release and then take our Community Acceptance Survey. Hurry and have a say in helping to make the NetBeans IDE the only IDE a developer needs! The deadline for the survey is <b>Wednesday, April 16</b> at midnight in the last timezone.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1777">Last Week to Blog About NetBeans IDE 6.1 & Win $500!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=916&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						There are only five days left to blog about the NetBeans IDE 6.1 (now in Release Candidate) for a chance to win $500USD! We've received many entries in different languages from NetBeans users and bloggers around the world. Click <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1216">here</a> to read some of the cool posts that contestants have submitted. Get inspired, download the NetBeans IDE and blog, blog, blog! The deadline for the contest is <b>Friday, April 18th</b>!</p><br style="clear:both;"/>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1778">You're Invited to NetBeans Day at Community One - May 5th!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=900&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Join us at our fifth annual NetBeans™ Software Day on Monday, May 5th, at the Moscone Center and discover why the NetBeans IDE continues to generate great buzz! Whether you are new to developing with the NetBeans IDE or a seasoned user, NetBeans Software Day will inspire you with insights and tips to take your project to the next level. Don't miss it! Check out our <a href="https://netbeans.org/community/articles/javaone/2008/nb-day.html">agenda</a>. <b>Registration is FREE</b> but seats go fast!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1781">Must-See Sessions at JavaOne - Scripting & Java Mobility</a></h2>
						<p style="margin-left:8px;">
						JavaOne is three weeks away, but it's not too early to start planning your conference calendar. The NetBeans IDE will be featured in many sessions, and every week till the big event the NetBeans team will spotlight these sessions for you! This week check out our picks for Scripting and Java Mobility Development.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1783">Video: A Day in the Life of Five Evangelists</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=920&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;'/>
						NetBeans evangelists will go to great lengths to deliver the NetBeans gospel. Braving a nine-hour bus ride, for example. For your viewing pleasure: the adventures of five evangelists and their quest to get from Buenos Aires to Cordoba, Argentina, during Sun's South American University Tour.</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1779">Building an Ajax Chat Room with the Ajax Transaction Dynamic Faces Component</a></h2>
						<p style="margin-left:8px;">
						This tutorial provides instructions for building an Ajax chat room web application using the Dynamic Faces component library.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1780">Creating a Ruby Web Application with NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						Learn how to use Ruby support in the NetBeans IDE 6.1 to create and run a simple database web application. By completing the steps in this tutorial, you learn to do the following tasks:<br><br>
-Use Rake tasks and migration files to create and update database tables<br>
-Use the scaffold generator to generate a basic create, read, update, delete (CRUD) database web application<br>
-Edit views to fine tune the web pages</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1782">Quick Start Guide to CLDC/MIDP Development in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Get the basics of using the NetBeans IDE to create a Java™ Platform, Micro Edition (Java™ ME platform), Mobile Information Device Profile (MIDP) application. This tutorial also offers a quick look at many Mobility features for CLDC/MIDP development.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1784">NetBeans 6.1 : Building in a Killer JavaScript IDE</a></h2>
						<p style="margin-left:8px;">
						Charles Ditzel's blog entry provides a set of useful links for developers looking to get the most out of the NetBeans IDE 6.1's improved JavaScript feature set and support.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1785">NetBeans on Swing under Linux</a></h2>
						<p style="margin-left:8px;">
						According to Ramon Ramos, the current JDK 1.6 and NetBeans 6.0 now make complaints about the look of Swing and of NetBeans under Linux a thing of the past. Check out his entry for detailed guidance on how to configure NetBeans to take care of this old peeve.</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_zh_CN.html">Chinese - simplified</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-04-14.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>