
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 628</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 # 628 - Feb 25, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9039">21st NetBeans Governance Board Elected!</a></h2>
						<p style="margin-left:8px;">
						Congratulations to <b>Tim Boudreau and Zoran Sevarac</b>--the new community-elected members of the 21st Governance Board! They are joined by Ashwin Rao (NetBeans Senior Product Management Group Manager) as the Oracle-appointed third member.<br><br>
Thank you to all the great nominees and to the NetBeans community for voting!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9032">NetBeans Podcast 68: Java 8 & Angular Support in NetBeans</a></h2>
						<p style="margin-left:8px;">
						Australian developer Brett Ryan and NetBeans software engineer Petr Pisl discuss Java 8 and AngularJS support in NetBeans. University of Nevada professor Andreas Stefik returns to speak about creating Quorum, the world's first evidence-oriented programming language.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9041">NetBeans Community Tweets: @h0mieT</a></h2>
						<p style="margin-left:8px;">
						<i>It's amazing how much NetBeans is better then visual studios! I would be stuck here for years waiting for this code to compile in VS.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9040">NetBeans Community Tweets: @iMezied</a></h2>
						<p style="margin-left:8px;">
						<i>The #best #IDE for #PHP is #NetBeans #forever</i>.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9035">Video: JPA Modeler in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A new plugin (in development) that allows developers to create, design and edit Java Persistence Application business models as graphical diagrams. Get a preview of the plugin in action.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9037">Video: NetBeans Android SDK Tutorial</a></h2>
						<p style="margin-left:8px;">
						A quick tutorial on installing the Android SDK on NetBeans IDE and using the NBAndroid plugin.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9038">5 Java Formatting Options in NetBeans You Probably Missed</a></h2>
						<p style="margin-left:8px;">
						There's always something new to discover in NetBeans. Mark Stephens writes about how participating in the NetCAT testing program led him to five Java formatting options he now uses in the IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9033">Quote Your Price: NetBeans Platform Book for Beginners</a></h2>
						<p style="margin-left:8px;">
						Co-authors Jason Wexbridge and Walter Nyland are finalizing their NetBeans Platform book for newbies. They have a request: Download a sample of the book, read it, and tell them how much you would pay for the finished book.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9034">Series: Top Five NetBeans IDE Features</a></h2>
						<p style="margin-left:8px;">
						More and more developers are chiming in about features they appreciate in NetBans IDE. This week, the IDE's database support, GUI builder, search features and code generators are among the favorites for <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-djameltorche">Djamel Torche</a> and <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-matiazanella">Matia Zanella</a>.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9036">Change Line Endings on Save</a></h2>
						<p style="margin-left:8px;">
						This plugin allows users to change or specify the line endings of files when saving them.</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-25.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>