
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 412</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 # 412 - Oct 12, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4266">NetBeans IDE 6.8 Milestone 2 Available for Download</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team is pleased to announce the availability of NetBeans IDE 6.8 Milestone 2. Visit the <a href="http://wiki.netbeans.org/NewAndNoteworthyNB68">New and Noteworthy page</a> to learn more about this <a href="http://bits.netbeans.org/netbeans/6.8/m2/">milestone release</a>. The final release of NetBeans IDE 6.8 is planned for late Fall 2009.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4260">Win $2000 in the JavaFXpert RIA Challenge</a></h2>
						<p style="margin-left:8px;">
						Create an application in JavaFX that exemplifies the appearance and behavior of a next-generation enterprise RIA (rich internet application) and win $2000! The participating graphic designers and application developers have time to submit their entries in the form of a NetBeans project by 10 January 2010. Read more about the <a href="http://learnjavafx.typepad.com/weblog/2009/10/announcing-the-javafxpert-ria-exemplar-challenge.html">contest rules</a> here.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4267">Elect the 17th NetBeans Governance Board!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Governance Board nomination period has ended. Who are the nominees and how are they involved in the NetBeans Community? <a href="https://netbeans.org/community/articles/election_profiles.html">Read their profiles</a>, <a href="https://netbeans.org/community/">log on to netbeans.org</a>, and <a href="https://netbeans.org/community/articles/nbelections.html">vote for your favorite candidates</a>! The voting period runs through midnight, Wednesday, October 21 in the last time zone. The results and the new board will be announced Monday, October 26.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4262">NetBeans 6.8 Community Translation Started</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Translatedfiles community has started localizing the latest NetBeans release. All necessary projects are now available in our Community Translation Interface (CTI). Have a look at the status and roadmap, join our community, and help translate NetBeans into your language!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4265">Sven Reimers: Winner of the Duke Award 2009</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Sven Reimers leads the team that developed the NetBeans Satellite Tracking System. Basing their complex desktop application on the NetBeans Platform helped Sven's team to stay on top of the 1000 modules necessary to communicate with real satellites. Read more about how Sven's team has won the Duke Award 2009 in the category “Java Technology in Network Solutions”!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4268">Arun Gupta Takes NetBeans to Oracle Open World 2009</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta reports from the Oracle Open World conference in San Francisco! He has set up his NetBeans demos on the booth machine and is ready to wow the audience with Java EE 6 in the exhibitor hall for the next 3 days! You can follow Arun's adventures in his blog, or meet him at the Unconference on Monday.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4261">Writing JUnit Tests in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Testing an application is an integral part of the development cycle, and writing and maintaining unit tests can help ensure that the individual methods in your source code work correctly. The NetBeans IDE's integrated support for the JUnit unit testing framework enables you to quickly and easily create JUnit tests and test suites.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4263">Getting Started with Java EE 6 Applications</a></h2>
						<p style="margin-left:8px;">
						Let the NetBeans IDE get you started with the new features of the Java EE 6 specification: In this tutorial you will create a simple Java EE 6 web application that contains an EJB 3.1 stateless session bean. The generated session bean uses queries that are defined in the Criteria API that is part of JPA 2.0. You will then create a named managed bean that accesses the session facade and a presentation layer that uses the Facelets view framework as specified in JSF 2.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4264">JSF 2.0 Support in NetBeans 6.8 M2</a></h2>
						<p style="margin-left:8px;">
						The NetBeans 6.8 Milestone 2's new support of  JavaServer Faces 2.0 comes with versatile editor enhancements for Facelets pages, including syntax highlighting and error checking for JSF tags, documentation support, and code completion for EL expressions, core Facelets libraries and namespaces.</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-10-12.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>