
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 554</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 # 554 - Sep 11, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7715">NetBeans Podcast #61 - JavaOne Editon</a></h2>
						<p style="margin-left:8px;">
						It's all about JavaOne 2012 in this latest episode of the NetBeans podcast. Tune in for chats with Çağatay Çivici and Timon Veenstra, architects for PrimeFaces and Agrosense, respectively. Both will be at JavaOne, and speaking at <a href="https://netbeans.org/community/articles/javaone/2012/netbeans-day-2012.html"><b>NetBeans Community Day</b></a>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7714">NetBeans Poll: Will You Attend NetBeans Community Day?</a></h2>
						<p style="margin-left:8px;">
						NetBeans Community Day returns to JavaOne with a full lineup of talks and demos from Java EE, JavaFX, and NetBeans Platform experts. Will you be there? Let the NetBeans team know!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7720">Join the NetBeans PHP Community Council</a></h2>
						<p style="margin-left:8px;">
						A community-iniated user group is forming around NetBeans' PHP support. Conceived by Timur Poperecinii, the project will extend support for PHP by creating and testing plugins. Interested? <a href="http://wiki.netbeans.org/NetBeans_PHP_Community_Council">Learn more and get details about how to join</a>.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7710">Face Recognition in Java at JavaOne 2012</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans Dream team member Zoran Sevarac at JavaOne for a fascinating look at developing artificial neural networks in Java.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7712">How Many Java Experts Can You Fit in a Room?</a></h2>
						<p style="margin-left:8px;">
						Attend the User Group meetings, Sunday, September 30th at JavaOne and get practical tips and tricks for Java EE, JavaFX and Java SE development from experts such as Adam Bien, PrimeFaces lead Çağatay Çivici, JavaFX authors Paul and Gail Anderson, and other top names in the Java community.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7718">New Java EE Book from Adam Bien</a></h2>
						<p style="margin-left:8px;">
						A completely rewritten, second edition of Adam Bien's Java EE tome: <i>Real World Java EE Patterns--Rethinking Best Practices</i>, is now available. With an additional 171 pages, there are tons of new patterns to dive into, and much more about efficient Java EE development.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7709">Creating Asynchronous Methods in EJB 3.1</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7072&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;'/>
						In this tutorial, you will create a Java EE 6 Web Application and add the following components to it - a Stateless Session Bean with two asynchronous methods.  We define a Servlet to call the asynchronous methods and to keep track of the invocation and completion times to demonstrate the asynchronous nature of the method calls. The index.jsp will contain a form with a submit button, Run allowing you to execute the application. The form will submit to the Servlet which invokes the asynchronous methods defined in the session bean and the response is re-directed to response.jsp. Information about the asynchronous handling procedure is displayed to users.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7716">Installing, Configuring, and Testing WebLogic Server 12c Developer Zip Distribution in NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7073&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;'/>
						Oracle WebLogic Server 12c is an application server for building and deploying enterprise Java EE applications and it is now available for download. The zip distribution for development offers Java EE 6 Full Profile development; it includes WebLogic Server only. With NetBeans IDE you can create web applications and deploy them to the Oracle WebLogic Server.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7713">Video: Advanced Tricks for NetBeans Visual Library Users</a></h2>
						<p style="margin-left:8px;">
						Three new tips for using the NetBeans Visual Library.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7717">Presentation Plugin for NetBeans IDE 7.2</a></h2>
						<p style="margin-left:8px;">
						A new plugin lets you open PDF files as images in the NetBeans IDE. It's still in Alpha mode, but worth a try.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7719">JSF 2.1 Tip: Using &lt;iframe&gt; Elements with PrimeFaces</a></h2>
						<p style="margin-left:8px;">
						 An example of easy implementation of &lt;iframe/&gt; elements in PrimeFaces. Subscribe to John Yeary's blog for useful JSF tips such as these.</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-11.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>