
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 713</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 # 713 - Mar 02, 2016
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10408">March 31, 2016: NetBeans Day in Munchen, Germany</a></h2>
						<p style="margin-left:8px;">
						Sign up today, for free! The NetBeans community invites you to another great free NetBeans Day, with speakers including Adam Bien, Jaroslav Tulach, Anton Epple, Thomas Kruse, Geertjan Wielenga, and more! Meet the community and learn about microservices, Truffle/Graal, DukeScript, Angular, Oracle JET, and more!</p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10411">IDR Solutions, Jelastic, and NetBeans</a></h2>
						<p style="margin-left:8px;">
						Last time Georgie Ingham from NetBeans partner IDR Solutions wrote about the Oracle Cloud, this time she shows how to to create a web application, test it locally, and then deploy the application to the Jelastic cloud through NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10410">Payara and NetBeans</a></h2>
						<p style="margin-left:8px;">
						In this short video, Steve Millidge, Payara Founder & Technical Director, shows you how easy it is to create a ‘hello world’ RESTful web server using the Payara Server with NetBeans, following a few simple steps.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10407">Open Sourced: Oracle JET, An Enterprise-Ready JavaScript Toolkit</a></h2>
						<p style="margin-left:8px;">
						Announced at JavaOne and OpenWorld last year, and open sourced this week, Oracle JavaScript Extension Toolkit (Oracle JET) is an enterprise-ready JavaScript solution for developers working on client-side applications. Official tooling is available for NetBeans IDE 8.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10409">Tweet of the Week: @TinPotRay</a></h2>
						<p style="margin-left:8px;">
						I really love @netbeans for PHP… all the git features just make bug detection so much easier. Flirtation with Atom well and truly over!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10406">NetBeans Java EE Tip #3: RESTful Web Services from Database</a></h2>
						<p style="margin-left:8px;">
						NetBeans allows developers to create RESTful solutions even more productively by providing tools such as the ability to generate RESTful Web Services from a database. Find out more from NetBeans Dream Team member Josh Juneau, in the latest in a series of technical NetBeans tips.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10404">Eclipse Code Formatter for Java: Support for Workspace Mechanic</a></h2>
						<p style="margin-left:8px;">
						In the last few days, NetBeans Dream Team member has been busy enhancing the Eclipse Code Formatter NetBeans plugin. The main focus has been to support the Eclipse Workspace Mechanic configuration file to be in compliance with his co-workers. Read more here and learn about this great new feature.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10405">Interactive Java using Nashorn (Part II)</a></h2>
						<p style="margin-left:8px;">
						In his last blog, NetBeans Dream Team member Michael Mueller showed how to invoke Nashorn, how to add a Java class, and how to invoke a method on it. In the current blog entry, he shows how to perform queries on a bigger amount of data with Nashorn.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10412">YouTube: What's Oracle doing with JavaScript?</a></h2>
						<p style="margin-left:8px;">
						In 15 minutes, follow a quick session at Jfokus in Stockholm, Sweden, in which you're introduced to the new Oracle JavaScript Extension Toolkit, including a demo and motivation of the toolkit, by Oracle product manager Geertjan Wielenga.</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/2016-03-02.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>