
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 605</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 # 605 - Sep 16, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8650">NetBeans Day Update: James Gosling, Kirk Pepperdine, and More!</a></h2>
						<p style="margin-left:8px;">
						During NetBeans Day, watch performance problems being identified and solved with James Gosling, Kirk Pepperdine, and Glenn Holmer sharing their experiences using the NetBeans Profiler, and other power tools that NetBeans IDE provides for free, in their daily development tasks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8651">Plugin: Additional Java hints for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						"Join literals", "Copy joined literals to clipboard", "Split the String on linebreaks", and more! Benno Markiewicz provides a new set of Java hints for easy usage in NetBeans IDE.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8652">4 things to do this week if you are attending JavaOne 2013</a></h2>
						<p style="margin-left:8px;">
						Mark Stephens from idrSolutions provides 4 great hints for getting up and running effectively during JavaOne 2013!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8647">JavaOne 2013: Brain Hacking with Java</a></h2>
						<p style="margin-left:8px;">
						The "Java Mind Reader" session at Java One 2013 explains how to use Java open source tools for signal processing, visualization, and recognition. It  gives general guidelines on signal recognition and a demo of how to use the Java neural network framework Neuroph for signal classification.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8648">Java EE and NetBeans 7 Video Course -- Author Interview</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8072&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='110' width='93' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Six-time author David Heffelfinger ventures into new territory with a video course about Java EE development and NetBeans 7. Find out how Heffelfinger uses the new course to demonstrates the latest Java EE technologies and APIs supported by NetBeans IDE.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8649">Java in Africa Series: Mark Clarke, Jozi JUG</a></h2>
						<p style="margin-left:8px;">
						Mark Clarke is a founding member of Jozi JUG, the largest and most active Java User Group in South Africa. In this first interview in a series about Java developers and communities in Africa, Clarke addresses the developer culture in South Africa and the opportunities available through free software such as Java.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8654">Social Translation of a NetBeans Platform Application</a></h2>
						<p style="margin-left:8px;">
						How to get your developer community involved in the translation of your NetBeans Platform application? Enrico Scantamburlo investigates  the options and gives you the results.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8653">Java EE 7: Applying JSF 2.2 Faces Flows in a Web Application</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8073&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;'/>
						This tutorial covers the steps required to apply the Java Server Faces 2.2 (JSF 2.2) Faces Flow feature in a customer registration procedure for a web application.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8655">Java EE 7: Using the JAX-RS Client API to Consume RESTful Web Services</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8056&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 create a sticker story web application in which users can collaborate to create a story by dragging images into a book or canvas. When a sticker is dropped onto the canvas, it is rendered in all other web browsers that are connected to the server.</p><br style="clear:both;"/>
					</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-16.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>