
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 406</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 # 406 - Aug 25, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4095">NetBeans PHP users: We Need Your Help</a></h2>
						<p style="margin-left:8px;">
						We are searching for all PHP NetBeans users who would like to help us with testing our new experimental build. If you would like to participate in this test, download this special build, and send your feedback by the end of August 2009. Learn about the details in the NetBeans PHP blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4096">Smart Java Apps with Neural Networks & NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team interviewed Zoran Sevarac from Neuroph, the open-source neural network framework. We talk about what neural networks look like, how they do their magic, and why the NetBeans IDE was the natural choice for the Neuroph development team. In part two we have a closer look at use cases and what neural networks can do for Java developers.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4094">Video: Josh Marinacci Shows the New Java Store</a></h2>
						<p style="margin-left:8px;">
						Josh Marinacci describes how to upload and post applications to the new Java Store. The Java Store is a JavaFX-powered storefront that provides an easy and secure means of discovering and acquiring compelling Java and JavaFX applications. See <a href="http://store.java.com">store.java.com</a> for more information.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4097">JavaFX Programming (with Passion!) Online Course</a></h2>
						<p style="margin-left:8px;">
						On August 25, Sang Shin and Jim Weaver are starting a new round of their free 15-week online course, JavaFX Programming With Passion! To graduate, download the sample projects and slides, share tips and tricks on the mailing list, and submit your homework solutions by the end of this year. Joining is easy, just sign up for the mailing list.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4101">Five Days with NetBeans 6.8 M1, JSF2.0, EJB3.1, Maven & Glassfish</a></h2>
						<p style="margin-left:8px;">
						Dream Team member Adam Bien tested the Netbeans 6.8 Milestone 1. He switched some Java EE 6 projects to the new build of NetBeans and crash-tested the new set-up for a while. See what features he tested and how the experiment worked out in his blog!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4098">Improving Kenai Services in NetBeans 6.8 Projects</a></h2>
						<p style="margin-left:8px;">
						After you check out a project from Kenai and open it in your NetBeans IDE, you no longer need a "Share on Kenai" context-menu action for it. In NetBeans IDE 6.8, you will see a new "Kenai" submenu instead. Use this menu for navigating to the associated Kenai project in the Kenai dashboard, or to file bugs for this Kenai project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4099">Introduction to JSF 2 Using NetBeans 6.8 and GlassFish v3</a></h2>
						<p style="margin-left:8px;">
						It's becoming much easier to write Enterprise Applications using annotations: This article is a brief introduction to JSF 2 and creating JSF 2 managed beans without XML--just using annotations. You'll also learn how to localize a JSF 2 application and how to use the Bean Validation Framework to add server side validation onto POJOs.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4100">Java EE 6 in NetBeans IDE 6.8 Milestone 1</a></h2>
						<p style="margin-left:8px;">
						The next iteration of the Java Enterprise Edition 6 is nearing completion. Many key  specifications, including Java Persistence 2.0, JavaServer Faces 2.0, and EJB 3.1 are now in the Proposed Final Draft phase. Read more about the new Java EE 6 platform support in NetBeans IDE 6.8 Milestone 1!</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-08-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>