
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 694</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 # 694 - Jun 24, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10088">Try Out Java 9 with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A new development build of NetBeans IDE is available. It is a development build taken from the NetBeans jdk9 branch and is a prototype to support JDK9, namely its modular system (Project Jigsaw). It is intended for early adopters of Java 9. Try it out today and give the JDK team and the NetBeans team feedback on your experiences!</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10094">NetBeans Platform for Beginners</a></h2>
						<p style="margin-left:8px;">
						Walter Nyland and Jason Wexbridge made available a fantastic resource, last year, for developers getting started with the NetBeans Platform as the basis of their software. If you haven't got hold of this book yet, with many samples, and a lot of code, do so today and get started creating industrial software on the Java desktop.</p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10089">WakaTime: Keeping Track of Time</a></h2>
						<p style="margin-left:8px;">
						A new release of the plugin by NetBeans partner WakaTime is available. This plugin shows how long you worked in each project, down to how long you spent in each syntax language, and even how long you worked on each file.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10090">IDR Solutions: Convert Ant-Based Plugin to Maven-Based Plugin</a></h2>
						<p style="margin-left:8px;">
						NetBeans partner IDR Solutions shows you step by step how to convert Ant-based NetBeans modules to Maven.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10093">Get Started with HTML5 in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Many features have been introduced into NetBeans IDE for JavaScript developers, including integration with the Chrome browser. Follow this tutorial to get started today with JavaScript, HTML, and CSS in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10091">Integrate New JavaScript Frameworks into NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Many new JavaScript frameworks exist. NetBeans APIs exist to integrate new items from any JavaScript framework into the code completion box in NetBeans IDE. Find out how to get started via a new template on GitHub.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10092">"Everything a Java developer should know about the JavaScript landscape"</a></h2>
						<p style="margin-left:8px;">
						NetBeans product manager Geertjan Wielenga is available to present an overview of the JavaScript landscape to groups of engineers familiar with Java. In the Netherlands, such an overview was presented to a group organized by Blue4IT, a software consultancy that runs sessions including speakers such as Adam Bien and Martijn Verburg.</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/2015-06-24.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>