
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 546</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 # 546 - Jul 16, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7543">NetBeans IDE 7.2 Gets Greenlight for Release</a></h2>
						<p style="margin-left:8px;">
						Is <a href="https://netbeans.org/community/releases/72/">NetBeans IDE 7.2</a> ready for release? According to 91% of you who responded to the <a href="http://qa.netbeans.org/processes/cat/72/ca_results.html">NetBeans 7.2 community acceptance survey</a>, the answer is <b>YES</b>. To who participated: The NetBeans team appreciates your valuable feedback!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7545">Download the Essential JavaFX 2.0 Cheat Sheet</a></h2>
						<p style="margin-left:8px;">
						DZone's latest reference card helps you get started writing JavaFX applications. It also doubles as a useful guide to some of the more advanced APIs.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7549">Quorum 1.5 Released with Robotics Controller for Blind Students</a></h2>
						<p style="margin-left:8px;">
						The team behind <a href="http://sodbeans.sourceforge.net/">Sodbeans</a>, the blind accessibility programming environment, has released an update to the Quorum programming language. A main highlight of the release is integration of a robotics controller for visually impaired developer students.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7541">Creating and Accessing a Session Bean in a Web Application</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6893&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;'/>
						Enterprise JavaBeans technology is the server-side component architecture for developing and deploying business applications in Java EE. In this tutorial, you will create a JEE 6 Web Application and add the following components to it: Stateless Session Bean, a Servlet, and a JSP.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7544">Video: Scene Builder 1.0 with NetBeans IDE 7.2</a></h2>
						<p style="margin-left:8px;">
						This video shows improvements made to Scene Builder integration in NetBeans IDE 7.2.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7548">Integrating Workflows into the NetBeans RCP</a></h2>
						<p style="margin-left:8px;">
						In this NetBeans Platform tutorial, you are shown how to create a pluggable infrastructure as the basis for a workflow application.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7540">New Blog: Java Training Beat</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6892&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='53' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The Java Curriculum Developers, a group of dedicated training developers for Java who are located in the US, India, and now Mexico, have a new blog called the Java Training Beat.  Check it out for new training content and events that might be of interest to Java developers, and post your comments and suggestions to the team.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7547">John Yeary's JSF Tips</a></h2>
						<p style="margin-left:8px;">
						A collection of JSF tips by JavaEE evangelist and blogger John Yeary:<br>
<a href="http://javaevangelist.blogspot.co.uk/2012/07/jsf-tip-of-day-creating-composite.html">JSF Tip of the Day: Creating Composite Components</a><br>
<a href="http://javaevangelist.blogspot.co.uk/2012/07/jsf-tip-of-day-usage-example.html">JSF Tip of the Day: <ui:repeat /> Usage Example</a><br>
<a href="http://javaevangelist.blogspot.co.uk/2012/07/jsf-tip-of-day-viewscoped-and.html">@ViewScoped and @ConversationScoped Usage</a><br>
<a href="http://javaevangelist.blogspot.co.uk/2012/07/custom-primefaces-tree-example.html">JSF 2.1 Custom PrimeFaces 3.3 Tree Example</a><br>
<a href="http://javaevangelist.blogspot.co.uk/2012/07/primefaces-ajax-enabled.html">PrimeFaces AJAX Enabled <p:selectOneMenu/></a></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7542">Adam Bien, JAX 2012 Top Java Ambassador!</a></h2>
						<p style="margin-left:8px;">
						The JAX Innovation Awards votes are in, and NetBeans Dream Team member and Java EE expert <a href="http://about.adam-bien.com/"><b>Adam Bien</b></a> is the top Java ambassador for 2012. Congratulations Adam!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7546">Vote for Duke's Choice Awards Community Winner</a></h2>
						<p style="margin-left:8px;">
						The Duke's Choice Awards celebrate extreme innovation in the world of Java technology. For the first time, the Duke's Choice Award program includes a Community Choice winner. Cast your vote today and decide who wins the first Community Choice distinction. <b>The poll closes Friday, July 20th.</b></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-07-16.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>