
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 622</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 # 622 - Jan 14, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8935">Nominees Wanted for the NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						NetBeans needs a new duo for the next NetBeans Governance Board! Do you want to work closely with the NetBeans team, contribute to the NetBeans project and build your profile? Then consider running for a spot on the Board! <b>Nomination deadline is Tuesday, January 28.</b></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8938">Develop Java Embedded Applications Using a Raspberry Pi - Starts February 2014</a></h2>
						<p style="margin-left:8px;">
						Have you wondered what the future of embedded devices looks like? Have you ever wanted to create your own weather station or design a device to control the lights in your home automatically? All of these questions will be answered in this practical hands-on 5-week virtual course that introduces Java developers to the world of embedded devices and the internet of things.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8940">Java EE 7: Applying JPA to Stored Procedures</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8349&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 demonstrates how to invoke a stored procedure residing in a database by using Java Persistence API 2.1 (JPA 2.1).</p><br style="clear:both;"/>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8939">TestFairy and NetBeans</a></h2>
						<p style="margin-left:8px;">
						Using NetBeans IDE for your Android apps development? This one's for you. The NetBeans TestFairy plugin simplifies the process of uploading Android apps to TestFairy.com and distributing URLs to testers.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8933">WildFly in NetBeans IDE 8.0</a></h2>
						<p style="margin-left:8px;">
						WildFly can now be tested in daily builds of NetBeans IDE 8.0.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8936">Free Graphs to Manage Maven Complexities</a></h2>
						<p style="margin-left:8px;">
						You can look forward to more clarity in Maven with a new feature that's coming up in NetBeans IDE 8.0: the ability to change graph layouts.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8937">Coming Soon: NetBeans Platform Book for Beginners</a></h2>
						<p style="margin-left:8px;">
						The NetBeans APIs, explained from scratch! Get a free sample excerpt. Plus an added twist: Tell the authors how much you would pay for the published book.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8934">Take the Java EE 8 Community Survey</a></h2>
						<p style="margin-left:8px;">
						Help set the direction for Java EE 8. Give feedback about planned features, and voice your opinion on topics such as Cloud, Security, Logging, Deployment, Testability, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8931">NetBeans Community Tweets: @joeperks</a></h2>
						<p style="margin-left:8px;">
						<i>Loving @netbeans as a PHP/HTML5 editor. All for the price of free.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8932">NetBeans Community Tweets: @x3chaos</a></h2>
						<p style="margin-left:8px;">
						<i>Just picked up netbeans in day one of my java class and WHY HAVE I BEEN USING ECLIPSE ALL THESE YEARS.</i></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="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/2014-01-14.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>