
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 642</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 # 642 - Jun 02, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9272">Java Magazine May/June 2014 Issue</a></h2>
						<p style="margin-left:8px;">
						The latest Java Magazine has a lot of articles about NetBeans IDE. From working with Java 8, to using the Oracle Java Cloud Service, to open source NetBeans Platform work done in South Africa. And it's free! Get hold of it right away.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9271">NetBeans Plugin: ANTLRWorks 2</a></h2>
						<p style="margin-left:8px;">
						The ANTLRWorks 2 plugin, created by the ANTLR team, provides IDE support for ANTLR, versions 3 and 4, as well as the StringTemplate 4 template language.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9268">Java 8, Lambdas, and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Read a brand new article about all the new refactoring tools in NetBeans IDE 8 for converting your applications quickly and efficiently to Java SE 8.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9267">Oracle Java Cloud and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Harshad Oak, a Java Chamion and Oracle ACE Director, explains how to quickly build and deploy applications to the Oracle Java Cloud Service with NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9266">GWT, Cordova, and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Get started with the first part of a new series on how to develop mobile apps with GWT, Cordova, and NetBeans IDE.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9265">NetBeans Community Tweets: @armelnene</a></h2>
						<p style="margin-left:8px;">
						"Working as lead software architect developer, I want my team to work with the right tool for the job, the reason why I always recommend #netbeans."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9264">NetBeans Community Tweets: @SarmadAAltaie</a></h2>
						<p style="margin-left:8px;">
						"NetBeans: Maven support – it's just fantastic and its auto-complete feature is fantastic."</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9269">Bitwise Courses on NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Join in with Huw Collingbourne from bitwisecourses.com as he reveals tips and tricks about NetBeans IDE in on-line YouTube clips full of interesting NetBeans insights.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9270">NetBeans IDE 8 Crash Course (German)</a></h2>
						<p style="margin-left:8px;">
						Ralph Steyer from video2brain.com guides you through all the features of NetBeans IDE 8. This is a great course for NetBeans newbies, especially those switching from other IDEs.</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-06-02.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>