
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 397</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 # 397 - Jun 23, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3809">Community Agrees NetBeans 6.7 Is Ready for Prime Time</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3053&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='90' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						We are pleased to announce the results of the NetBeans IDE 6.7 Community Acceptance Survey: 79% of 144 respondents agree that NetBeans 6.7 Release Candidate is stable enough to be shipped! The NetBeans engineers fixed the 3 most critical reported issues, and we plan to deliver the other fixes via the Update Center soon. We are in contact with the most critical respondents to make certain that all important issues are covered. Overall, this is great news for NetBeans 6.7 from the community. Thank you for your expert feedback!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3806">GlassFish ESB v2.1 released - includes NetBeans 6.5</a></h2>
						<p style="margin-left:8px;">
						The open source project OpenESB has published its latest version, GlassFish ESB v2.1. The release includes NetBeans IDE 6.5.1 as the design tool and GlassFish as the runtime. The download contains the very latest SOA tools for NetBeans 6.5.1 such as the BPEL editor, the WSDL editor, and several wizards, that are not yet available from the NetBeans download site. <a href="http://open-esb.dev.java.net/Downloads.html">Get them now!</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3813">How the NetBeans Platform Helps with Semiconductor Validation</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga talked to Chad Dorkin about a real-world usecase of the NetBeans platform: A tool for designing and validating semiconductor chips! Chad chose to build the validation tools on top of the NetBeans platform because he needs his applications to be scalable and modular. He also made good use of the NetBeans Window system as you can see in the screenshots--check them out!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3811">Kenai.com: The Movie</a></h2>
						<p style="margin-left:8px;">
						You are ready to start an open-source project, but you never got around to setting up an issue tracker and version control system? With NetBeans and Kenai, you get free project hosting for you team and a fully integrated development tool. In this short series of screencasts, Ken Ganfield demonstrates how to create and share a new project, how to open and join and existing project, and how to use the issue tracker integration.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3807">Netbeans, JavaScript, Ant, Hudson, and JSLint: Oh my!</a></h2>
						<p style="margin-left:8px;">
						In his blog, Ari Shamash describes how he integrated the JavaScript code quality tool JSLint into his continuous build / integration environment. He explains how he modified his NetBeans project's properties and build.xml  files and added an Ant target that makes the jslint task part of the regular build.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3805">Cloud Computing & NetBeans RCP Enable US Army Defense Project</a></h2>
						<p style="margin-left:8px;">
						Dream Team member Fabrizio Giudici first met Dennis Reedy when he participated in the Real Time Telemetry Service (RTTS) for Formula 1 cars--now Dennis works on a simulation evaluating the survivability of US Army vehicles! The core services are hosted on the cloud, and the client was built on top of the NetBeans platform. In his blog, Fabrizio shares with us a conversation he had with Dennis about cool, yet real-world projects.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3808">Student projects wanted!</a></h2>
						<p style="margin-left:8px;">
						The story of Peter, Philip and Kate, who start another student project. Only this time, everything is different! They do not have to set up another bug tracker, wiki, versioning repository, or mailing list. Instead they create a project in the NetBeans IDE, and share it on Kenai.com. Read their story on Petr Dvorak's weblog!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3812">Java EE Patterns and Best Practices - Sample Repository Initiated</a></h2>
						<p style="margin-left:8px;">
						As previously announced, the Kenai.com project <a href="http://kenai.com/projects/javaee-patterns/">Java EE Patterns And Best Practices</a> has now been initiated. Download an expert collection of NetBeans-ready samples and templates for the Java EE 5 and 6 platforms. All projects have been tested on Glassfish v2/v3 and partially on openEJB and JBoss 5. Use the NetBeans IDE 6.7 chat and the Kenai forum to discuss best practices for Java EE and <a href="http://kenai.com/projects/javaee-patterns/">join today!</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3810">Erlang and Scala Plugins for NetBeans 6.7 Released</a></h2>
						<p style="margin-left:8px;">
						Caoyuan Deng announces the release of the <a href="http://blogtrader.net/dcaoyuan/entry/erlang_plugin_version_1_for">Erlang plugin</a> (version 1) for NetBeans IDE 6.7 (RC3 or better). It is now written in Scala instead of Java, and it supports code completion for keywords, functions and variables. Also check out the <a href="http://blogtrader.net/dcaoyuan/entry/scala_plugin_version_1_for">Scala plugin</a> that he released earlier this month!</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-06-23.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>