
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 421</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 # 421 - Dec 21, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4575">NetBeans Podcast #52: NetBeans IDE 6.8 Debuts!</a></h2>
						<p style="margin-left:8px;">
						It's been a busy month for the NetBeans team: The NetBeans IDE 6.8 debuts with support for Java EE 6 and GlassFish v3, und the NetBeans Platform returns to the spotlight. Other topics include new Java+MySQL resources, the NetBeans Voice of the Community, interviews with John Clingan from GlassFish, and David Konecny from the Java EE team, and lots more. -- Listen now!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4577">Griffon and NetBeans IDE 6.8</a></h2>
						<p style="margin-left:8px;">
						The latest <a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=18664">Griffon plugin</a> for the NetBeans IDE 6.8 is now available for download. When installed into a distribution of NetBeans IDE 6.8 that includes Groovy support, it will let you create desktop applications based on the Griffon framework. The plugin comes with a lot of useful tooling, such as a dialog for accessing and installing Griffon plugins.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4571">JavaFX Composer for NetBeans 6.8 - First Smoke Test</a></h2>
						<p style="margin-left:8px;">
						Adam Bien installed the JavaFX Composer for NetBeans IDE 6.8 and quickly tells us what he thinks about usability, generated code, state transitions, using data sources, visual data binding and converters, and templates.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4576">South African National Defence Force on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Dale Thoma supervises application development for tactical communication. His team is currently implementing several projects on top of the NetBeans Platform for the South African National Defence Force (SANDF). Read more about why he chose the NetBeans Platform in this Dzone interview!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4578">NetBeans Unit Test Creation better than Eclipse?</a></h2>
						<p style="margin-left:8px;">
						In his blog, Phil evaluates the NetBeans Unit Test support and considers it "a little better than Eclipse": NetBeans automatically creates the secondary source tree, and it separates the Test Libraries from the regular Libraries. Also, when NetBeans creates a unit test from an existing class, it generates more test code than Eclipse. Read on to learn more about about best practices in unit testing!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4573">Get the NetBeans IDE 6.8 DZone Refcard!</a></h2>
						<p style="margin-left:8px;">
						This DZone Refcard by Geertjan Wielenga lists all the keyboard shortcuts in carefully thought out categories and it provides a thorough exposition of optimal handling of Java code in the editor, covering viewing, navigation, source handling, and refactoring. A must have for anyone using NetBeans IDE 6.8.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4572">How to Create a Web Service Client with Groovy and NetBeans Platform 6.8</a></h2>
						<p style="margin-left:8px;">
						In this article you will learn how to leverage the best of Groovy together with the best of the NetBeans Platform. Groovy will be used to access a Shakespeare quotation web service and parse its payload. The NetBeans Platform will be used to create a modular GUI in Swing for interacting via Groovy with the web service.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4574">Java EE 6 and GlassFish v3 Conference - Replay</a></h2>
						<p style="margin-left:8px;">
						The Java EE 6 and GlassFish v3 Virtual Conference took place on December 15, 2009. Due to the overwhelming success of the event, the sessions are now available as replay, including slides. (Free registration required.) The Virtual Conference provides an exclusive look into the Java EE 6 and Sun GlassFish Enterprise Server v3, and also related IDE support - tune in now!</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-12-21.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>