
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 430</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 # 430 - Mar 09, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4834">Join the NetBeans Community Testing Program!</a></h2>
						<p style="margin-left:8px;">
						Our popular community testing programs, NetCAT and NetFIX, are starting again for the release 6.9 release cycle. To help test NetBeans IDE 6.9 development builds, and report bugs and RFEs, sign up for <a href="http://wiki.netbeans.org/NetCAT">NetCAT</a>. Experienced Java developers who enjoy contributing code are encouraged to join the <a href="http://wiki.netbeans.org/NetFIX">NetFIX</a> program. Sign up today!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4833">NetBeans Platform Training in Belgrade</a></h2>
						<p style="margin-left:8px;">
						Geertjan and Toni are on their way to Belgrade where the local <a href="http://www.netbeans-serbia.org/">NetBeans User Group</a> will be porting <a href="http://netbeans.dzone.com/articles/neuroph-smart-java-apps-neural-1">Neuroph</a> to the NetBeans Platform. They'll be delivering a <a href="http://edu.netbeans.org/courses/nbplatform-certified-training/">NetBeans Platform Certified Training</a> there, making use of the large <a href="http://edu.netbeans.org/contrib/slides/netbeans-platform/">library of NetBeans Platform training slides</a>. Feel free to <a href="http://edu.netbeans.org/courses/nbplatform-certified-training/">contact us for upcoming training info</a>, or use the materials yourself to deliver trainings, either for fun or for profit.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4835">Free Webinars: Mobile Websites with Netbeans and Netbiscuits</a></h2>
						<p style="margin-left:8px;">
						Netbiscuits is the mobile publishing platform that enables eBay and many other major brands for the mobile Web. To learn more about creating next generation mobile websites with Netbeans and Netbiscuits, register for the upcoming free webinars!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4837">Making the Most of the JavaFX Composer</a></h2>
						<p style="margin-left:8px;">
						Learn how to create smart GUIs that connect to data sources and visualize data with image browsers and charts. Try webstartable demos and mobile phone samples, and learn how to create these visually rich applications yourself!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4830">NetBeans Platform Quick Start Using Maven</a></h2>
						<p style="margin-left:8px;">
						This document is a quick demonstration of how to create a simple NetBeans Platform application. You will use Maven archetypes to create the NetBeans Platform application and module. You will use the Swing UI toolkit and the "Matisse" GUI Builder to create a window component in the module.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4831">Code Assistance in C/C++ Projects</a></h2>
						<p style="margin-left:8px;">
						Code assistance is a set of IDE features that help you navigate and edit source code: Code completion, search for usages, hyperlinking to declaration, viewing current file structure in the Navigator window, investigating a class inheritance hierarchy, viewing header's include hierarchy, viewing a type hierarchy, and so on. This document shows how to configure code assistance when creating a C/C++ project from existing code.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4836">Over 60 New Hints in the NetBeans IDE 6.9 Java Editor</a></h2>
						<p style="margin-left:8px;">
						Let's set an end to well-known performance traps, immature coding habits, and common (but wrong) assignment issues: NetBeans IDE can detect many "Probable Bugs" and suggest how to fix them. The documentation of what each of these hints means is contained within the same dialog where you specify whether you want to use the hint or not. Check it out!</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/2010-03-09.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>