
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 607</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 # 607 - Sep 30, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8676">Is NetBeans IDE 7.4 Ready for Release?</a></h2>
						<p style="margin-left:8px;">
						If you have already downloaded and tested the latest Release Candidate build, we would like to know what you think about it! Take the NetBeans IDE 7.4 Community Acceptance Survey and tell us about your experience. The survey will be opened until October 6th.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8675">James Gosling: NetBeans Community Success Story</a></h2>
						<p style="margin-left:8px;">
						James Gosling, father of Java and chief software architect at Liquid Robotics, is the newest addition to the NetBeans Community Success Stories page. Does your organization want to be listed too? Write to webmaster@netbeans.org and let us know!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8677">Plugin: Vaadin</a></h2>
						<p style="margin-left:8px;">
						During NetBeans Day, Vaadin tied the knot when Sami from the Vaadin team launched the official Vaadin plugin for NetBeans. Try it today!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8678">NetBeans Community Awards 2013</a></h2>
						<p style="margin-left:8px;">
						Congratulations to John Yeary and Benno Markiewicz for being the recipients of this year's NetBeans community awards. Watch the YouTube video of the small ceremony.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8679">Duke's Choice Awards 2013</a></h2>
						<p style="margin-left:8px;">
						Four NetBeans Platform projects are among this year's Duke's Choice Award winners! Congratulations to Ayman, Sean, Zoran, and Guillaume for their great work with Java, NetBeans IDE, and the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8681">Cay Horstmann: JavaOne Trip Report</a></h2>
						<p style="margin-left:8px;">
						"My favorite Java tool of the show is NetBeans 7.4," writes Cay Horstmann. "The HTML 5/JavaScript implementation is awesome." Read his article "JavaOne for the Impatient" for all the details.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8680">Shai Almog: JavaOne Trip Report</a></h2>
						<p style="margin-left:8px;">
						Shai from the Codename One team, one of the speakers at NetBeans Day, had an excellent time throughout JavaOne and reports on it in detail. Missed JavaOne? Read Shai's report and you'll feel like you were there yourself.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8682">NetBeans Party in 19 Seconds</a></h2>
						<p style="margin-left:8px;">
						Did you not make it to the NetBeans Party? This exclusive event for NetBeans speakers throughout the JavaOne conference was a great start to the week. Turn your speakers down because the party was loud and noisy indeed!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8683">YouTube: Maven, Java EE 7, and Backbone.js Mashup</a></h2>
						<p style="margin-left:8px;">
						Can Backbone.js and Java EE be combined, together with Maven? Watch this video to see if it can be done!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8684">YouTube: Maven, Java EE 7, and PrimeFaces Mashup</a></h2>
						<p style="margin-left:8px;">
						Get ready for NetBeans IDE 7.4 by seeing step by step how Java EE and PrimeFaces are supported out of the box.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Geertjan Wielenga<br/>If you do not want to receive this newsletter, you can <a href="http://www.netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="http://www.netbeans.org/community/news/newsletter/index.html">English</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="http://www.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="http://www.netbeans.org/community/news/newsletter/2013-09-30.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>