
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 418</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/appl/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/appl/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 # 418 - Dec 01, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4461">Download NetBeans IDE 6.8 Release Candidate 1!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3675&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans Team is pleased to announce that the first release candidate build of NetBeans IDE 6.8 is now available for download. Give the build a try and provide feedback by taking the <a href="https://netbeans.org/community/netcat/ca_survey_68.html">NetCAT survey</a> or joining discussions on the <a href="https://netbeans.org/community/lists/top.html">NetBeans mailing lists and forums</a>. The final release of NetBeans IDE 6.8 is planned for December.<br><br>
<b>NetBeans IDE 6.8: Get Tomorrow Today!</b></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4468">Is NetBeans 6.8 Release Candidate Ready for FCS?</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3730&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Is NetBeans IDE 6.8 ready for FCS release? Download the latest <a href="http://download.netbeans.org/netbeans/6.8/rc/">Release Candidate build</a>, take the NetBeans Community Acceptance Survey and tell us about your experience! The survey will be opened until <b>December 9th</b>.</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4463">Enhance Your JavaFX Application by Applying Transformations</a></h2>
						<p style="margin-left:8px;">
						This article discusses the basic transformations available in the JavaFX SDK. Learn how to rotate, scale, or translate objects in your application with the visual patterns and code samples provided.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4469">REST Web Services on Google App Engine Using NetBeans 6.7</a></h2>
						<p style="margin-left:8px;">
						A tutorial from developer Armel Nene showing how to develop a REST based web services that works with the Google App Engine using NetBeans 6.7 and Jersey API.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4464">Tech Tip: PHP Remote Debugging with NetBeans 6.8</a></h2>
						<p style="margin-left:8px;">
						A quick tip on remote debugging your PHP code with the NetBeans IDE 6.8.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4467">Upcoming Java EE 5/6 Workshops with Adam Bien</a></h2>
						<p style="margin-left:8px;">
						Adam Bien will present workshops about Java EE and speak at various events, including a "Pragmatic Enterprise Architectures" workshop in Munich, a talk about Cloud Computing, and a Java EE 6 workshop in January. He will be at JUG sessions in February as well. Subscribe to Adam's blog for more details.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4462">Enterprise Financial Management on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Geertjan interviews NetBeans Platform developer Craig Marshall from Experian Ltd who provides tools and support for the financial sector. Read how he makes use of the NetBeans Visual Library API and the MemoryFileSystem, and why they are distributing their application via Java Web Start.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4460">What's New in NetBeans 6.8 For Ruby Developers?</a></h2>
						<p style="margin-left:8px;">
						An overview of several new features and enhancements in NetBeans 6.8's Ruby support.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4466">When Buttons Stop Working…It's NetBeans to the Rescue!</a></h2>
						<p style="margin-left:8px;">
						A blogger from TechnologyTales.com made the switch to NetBeans after Eclipse stopped working with his Ubuntu 9.10 upgrade. He said: “Things seemed to go smoothly and it looks to have replaced Eclipse for PHP development duties.”</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4465">Redesigning an App With NetBeans</a></h2>
						<p style="margin-left:8px;">
						When blogger Quintin Beukes had to redesign an application from scratch he tackled the front-end using the NetBeans RCP Platform. He selected NetBeans for its Maven support and for "features that are far more complete and of much higher quality” than other IDEs.</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-12-01.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>