
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 633</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 # 633 - Apr 01, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9124">Vaadin/NetBeans Webinar, 3 April</a></h2>
						<p style="margin-left:8px;">
						There's still time to sign up for the Vaadin/NetBeans Webinar. Learn about the great synergy between NetBeans and Vaadin, in a webinar to be held on April 3rd. You'll learn how to leverage NetBeans and the Vaadin plugin at the same time and have a chance to ask questions live!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9117">Plugin: Scala for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Caoyuan Deng has upgraded the Scala plugin for NetBeans 8! Get started with it today.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9118">Resource Library Contracts with NetBeans 8 and PrimeFaces</a></h2>
						<p style="margin-left:8px;">
						Josh Juneau tells you about how PrimeFaces includes a layout component that makes it easy to select the most fitting layout for your application. Find out how to use it with NetBeans 8.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9122">Debugging Maven Mojo Plugin</a></h2>
						<p style="margin-left:8px;">
						Benno Markiewicz explains how NetBeans 8 helps with correctly and efficiently configuring the Maven Mojo plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9123">Code Folding in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Robert Liguori has created many short movies about NetBeans features. In this one, he goes through the features of code folding.  The goal is for you to be able to completely understand the feature so you can use it efficicently in the workplace.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9120">Java Magazine, March-April 2014</a></h2>
						<p style="margin-left:8px;">
						A new issue of the Java Magazine has been released. Read detailed articles from experts in the Java ecosystem about the new features in Java 8. And the Java Magazine is free!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9119">New NetBeans Blog</a></h2>
						<p style="margin-left:8px;">
						Popular author David Salter has started a new category in his blog, all about NetBeans. Read about his work on new plugins, as well as tips for WildFly, JBoss, TomEE, and more!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9121">NetBeans Community Tweets: @rchouinard</a></h2>
						<p style="margin-left:8px;">
						<i>Just upgraded to NetBeans 8.0. Looks like another solid release from the @netbeans team!</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9125">NetBeans Community Tweets: @monacotoni</a></h2>
						<p style="margin-left:8px;">
						<i>#eclipse foundation announces the shutdown of Eclipse IDE due to e4 failure and recommends #netbeans as alternative <a href="http://goo.gl/z2sBE">http://goo.gl/z2sBE</a></i></p>
					</div>
	<div class="edited">
	NetBeans Weekly Newsletter is brought to you by the NetBeans Team.<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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2014-04-01.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>