
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 402</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 # 402 - Jul 28, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3959">NetBeans IDE 6.7.1 with JavaFX Now Available!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3202&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans Team is pleased to announce the release of the NetBeans IDE 6.7.1 with support for JavaFX 1.2 and an upgrade of the GlassFish v3 integration. It also includes important improvements in the Java Editor and project scanning areas that community members had asked for. <a href="https://netbeans.org/community/releases/67/">Learn more</a> about the new release and <a href="https://netbeans.org/downloads/index.html">download NetBeans IDE 6.7.1</a> today!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3957">Get NetBeans-Ready Java EE Samples From Kenai</a></h2>
						<p style="margin-left:8px;">
						Java EE expert and dream team member Adam Bien started sharing his collection of Java EE sample projects on Kenai--and he is still adding new ones! We don't know how many used the NetBeans Kenai integration to check out and run Adam's Netbeans-ready sample projects. But we do know that with over 100 members, it is one of the most popular and fastest growing Kenai projects. Join today and learn from the experts!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3962">Get Your Name Listed in the NetBeans Credits!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3203&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='75' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						You might have heard about NetCAT, the NetBeans Community Beta testing program. In an open source project like NetBeans it's no surprise there is a variety of other ways to contribute: You can help us fix bugs as NetFIX team member, or even cooperate on the development of new features under the new NetDEV program for the upcoming NetBeans IDE 6.8. Wanna get your hands dirty with source code and implement your favorite enhancement? Join NetDEV today!</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3956">eWeek Review: NetBeans IDE 6.7 Provides Effective Integration with Project Kenai</a></h2>
						<p style="margin-left:8px;">
						"The latest version of the NetBeans IDE is a x.7 release, but it includes so many new features it could rightfully receive a full version increment. What may be the biggest improvement is full integration with Project Kenai, a site Sun built for open-source collaboration, and that’s what this review will focus on."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3960">Watching Birds With JavaFX Developer Fabrizio Giudici</a></h2>
						<p style="margin-left:8px;">
						Reviews Interactive recently spoke with JavaFX developer Fabrizio Giudici, a prominent and highly-respected blogger in the JavaFX community, who writes regularly for both Java.net and DZone. Fabrizio said he is particularly interested in using JavaFX on mobile devices, and thanks to JavaFX, he created a working prototype of his latest application for bird watchers in only one week!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3961">Keeping Time With the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						When System and Software Architect Hermann didn't find a time keeping application suitable for the needs of all the roles typically involved in his projects, he used the NetBeans Platform to write his own: "I use a lot of NetBeans Platform modules for features which I otherwise would have to write myself. And I'm not sure if I would be able to implement them with the same level of quality as I get (and for free!) from the NetBeans Platform."</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3954">Localize This: NetBeans Platform Applications</a></h2>
						<p style="margin-left:8px;">
						No excuses anymore! Localizing applications built on top of the NetBeans Platform is actually quite simple, since you can use the GUI form editor for NetBeans Platform Applications, too. Learn all about internationalization with NetBeans IDE 6.1, 6.5 and 6.7 in this easy-to-follow tutorial.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3958">Free JavaFX Programming (with Passion!) Course</a></h2>
						<p style="margin-left:8px;">
						The 2nd session of the "Free 15-week JavaFX Programming (with Passion!)" online course will start August 25, 2009. The whole course is free and can be taken online by anyone who signs up to the mail alias. Participants will  study the presentation material, go through provided hands-on labs, and do weekly homework assignments. Feel free to use the class email alias to ask (and answer) JavaFX questions!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3955">NetBeans at JavaOne 2009 Redux: Demos, Labs & Podcasts</a></h2>
						<p style="margin-left:8px;">
						If you were not able to attend this year's JavaOne conference to learn about NetBeans and all the other great Sun technologies, there's still a chance to catch up on some of the great sessions and content that you missed: We will show you where you find the sought-after <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1408">downloads, hands-on labs, screencasts and podcasts</a> from this year's conference!</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-07-28.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>