
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 556</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 # 556 - Sep 24, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7757">Nominations Open for the NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						There's another election on the horizon this season--the 20th term of the NetBeans Governance Board! Get involved by nominating NetBeans community members that you think should be considered for the Board. You can even nominate yourself!
<br><br>
The <b>deadline for nominations is Monday, October 8</b>, at <a href="http://www.timeanddate.com/worldclock/fixedtime.html?msg=NetBeans+Governance+20th+Term+Nomination+Deadline&iso=20121008T2355&p1=1033">midnight in the last time zone</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7759">NetBeans Speakers to Watch at JavaOne 2012</a></h2>
						<p style="margin-left:8px;">
						JavaOne 2012 is less than a week away. Still need convincing about which sessions to attend? Listen to four conference speakers sum up why their sessions should be at the top of your conference schedule builder.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7761">Four Days, Two Schedules at JavaOne 2012</a></h2>
						<p style="margin-left:8px;">
						What does a NetBeans Product Manager do at JavaOne 2012? Geertjan Wielenga shares details of his schedule at this year's conference. Check out <a href="http://www.adam-bien.com/roller/abien/entry/my_javaone_2012_and_community">Adam Bien's equally packed speaking schedule</a> as well. If you have a schedule or list to share send us a tweet! (@netbeans)</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7755">JavaOne Latin America 2012 Call for Papers</a></h2>
						<p style="margin-left:8px;">
						Olá! The call-for-papers for JavaOne Latin America 2012 is ongoing. Submit your best proposals for topics ranging from JavaFX to Java EE, Web Services, Java ME and more. <b>Submission deadline is Friday, October 4, 2012</b>. Good luck!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7762">Free Java Certification Resources</a></h2>
						<p style="margin-left:8px;">
						The Greenville Java Users Group has launched an Oracle Certified Java Programmer Boot Camp, with training modules available to the public. The project is Apache and Creative Commons licensed for free use by anyone who wants to use it as the basis for providing certification training to their JUG members. (Visit GreenJUG president John Yeary's blog to download <a href="http://javaevangelist.blogspot.co.uk/2012/09/java-certification-boot-camp-object.html">module 3</a> and <a href="http://javaevangelist.blogspot.co.uk/2012/09/java-certification-boot-camp-generics.html">module 4</a>.)</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7754">Using Asynchronous Servlets for Push Notifications</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7102&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='79' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Asynchronous Servlets is a feature of the Servlet 3.0 Specification in the Java EE 6 environment. Using Asynchronous Servlets allows you to interact between requests and responses from different threads and free the request handling thread to optimize the performance of the server. This tutorial will guide you through the process of creating a simple application that will use Asynchronous Servlets for push notifications.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7758">Adding JavaFX Component to a NetBeans RCP Application</a></h2>
						<p style="margin-left:8px;">
						Learn to create a JavaFX component built with Scene Builder and FXML, and add it to a NetBeans RCP TopComponent window alongside a simple Swing JLabel.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7756">Why NetBeans? Productivity, Great Features, and Fun</a></h2>
						<p style="margin-left:8px;">
						Adam Bien is open about why he often demoes with the NetBeans IDE; now he turns the tables on Geertjan Wielenga to find how the Oracle Product Manager convinces others to use the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7760">Java Musings from 2012 JAX Innovation Awards Winners</a></h2>
						<p style="margin-left:8px;">
						The four grand prize winners of the 2012 JAX Innovation Awards share their thoughts on the current Java ecosystem.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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/2012-09-24.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>