
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 629</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 # 629 - Mar 03, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9053">Available: NetBeans IDE 8.0 Release Candidate</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8488&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans IDE 8.0 is one step closer to being released. Lambda converters, Raspberry Pi, PrimeFaces, AngularJS, and more. The latest editors and tools are ready for you to try out, today!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9060">Plugin: Gradle</a></h2>
						<p style="margin-left:8px;">
						Allows opening directories containing a "build.gradle" or "settings.gradle" file as a project in NetBeans IDE. The opened project then can be used as a usual Java project.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9055">New Book: "Exercises in Porting to the NetBeans Platform"</a></h2>
						<p style="margin-left:8px;">
						In this book, you will see a continual work in progress. It will never be complete! The content is determined by you, the reader. Together with the intro, the first exercise is available for free. Download it immediately to get a feel of what you can expect from subsequent exercises.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9056">New Book: "NetBeans Platform for Beginners"</a></h2>
						<p style="margin-left:8px;">
						Whether a complete newbie to the NetBeans Platform or interested in refreshing your knowledge and filling in the gaps, this is for you! The main themes of the book are modules, file systems, windows, nodes, and actions... and everything in between. Start your modular development process with the best set of texts and exercises available today.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9057">Aspose for Java Integration and Partnership with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Aspose has made changes to its existing NetBeans plugin for NetBeans IDE and onwards to integrate it more smoothly in the native flow of project and file creation. Read all about it here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9058">How to Create a Border Glow Effect in JavaFX Leave a reply</a></h2>
						<p style="margin-left:8px;">
						IDRSolutions, a NetBeans partner, has a great blog with many tips and tricks. In this article,  they demonstrate how to produce a glowing border effect which you can apply to any JavaFX Node.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9061">NetBeans Vaadin Webinar April 2014</a></h2>
						<p style="margin-left:8px;">
						Join Geertjan Wielenga from the Oracle NetBeans team and Matti Tahvonen from Vaadin for a Webinar on how to build a fullstack Vaadin + JPA + Glassfish application in minutes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9062">NetBeans Platform Training  April 2014</a></h2>
						<p style="margin-left:8px;">
						Benno Markiewiczz reports there are two open seats for the NetBeans Platform training in April 2014 in Leipzig/Germany.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9052">NetBeans Community Tweets: @sem0597</a></h2>
						<p style="margin-left:8px;">
						Now using #NetBeans RC as my main #Java IDE. Very stable and some great new features!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9054">NetBeans Community Tweets: @SeanMiPhillips</a></h2>
						<p style="margin-left:8px;">
						One of my coworkers saw <a href="http://t.co/Cv0VVOVvv2">this screenshot</a> said "Wow... I feel like I'm in the future!" I said... "Well yes, I used NetBeans 8".</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9059">Video: NetBeans IDE, Knockout, and JQuery</a></h2>
						<p style="margin-left:8px;">
						In this video you will learn to build a web-based single page application for e-mail, using NetBeans IDE, Knockout.js, and jQuery.</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-03-03.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>