
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 627</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 # 627 - Feb 18, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9016">Two IDE Polls, One Conclusion?</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE has done really well recently in two different polls, one on java.net and the other at jaxenter.de. Read all about it!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9018">Plugin: Aspose File Format</a></h2>
						<p style="margin-left:8px;">
						The Aspose team have produced seamless integration for their file format APIs, such as PDF and Excel rendering, for NetBeans IDE. Download and install it today!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9019">Top 5 Favorite NetBeans Features</a></h2>
						<p style="margin-left:8px;">
						Gradle, Git, GUI builders, and more! Read the features that <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-markwilmoth">Mark Wilmoth</a> and <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-scottpalmer">Scott Palmer</a> appreciate most about NetBeans</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9020">Score Card: NetBeans Governance Board #20</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Governance Board has come to the end of its term. Hermien and Toni share their experiences.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9021">Using a Raspberry Pi to Deploy JavaFX Applications</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8435&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 how to configure a Raspberry Pi as a development platform for the JavaFX platform.</p><br style="clear:both;"/>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9017">New Book: Java EE & HTML5 Enterprise Application Development</a></h2>
						<p style="margin-left:8px;">
						The latest greatest book on Java EE, HTML5, and NetBeans IDE is set to be published. Buy yours today!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9022">Register today for the Oracle Java ME Embedded MOOC!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8436&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='31' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						We are pleased to announce that the Oracle Massive Open Online Course: Develop Java Embedded Applications Using a Raspberry Pi is open for enrollment. This free course, designed for Java developers, is delivered over 5-weeks. Take the course at your own pace - weekly we will add new lessons, quizzes and homework assignments. 

The course will start March 31st!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9014">NetBeans Platform Training in Germany (April 14-16)</a></h2>
						<p style="margin-left:8px;">
						Join Geertjan Wielenga (Oracle) and Toni Epple (Eppleton) for a two-day NetBeans Platform training in Leipzig, Germany. The training blends theory and practice--you learn the fundamentals behind the NetBeans API and then start to develop applications. Register today. Training is FREE for students.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9015">Programming in Quorum Workshop (July 17-23)</a></h2>
						<p style="margin-left:8px;">
						The Experience Programming in Quorum (EPIQ) Workshop is an international professional development workshop for educators to learn the foundational skills necessary to teach students computer science using the Quorum programming language.</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-02-18.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>