
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 703</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 # 703 - Sep 15, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10246">New: "Beginning NetBeans IDE For Java Developers"</a></h2>
						<p style="margin-left:8px;">
						"Beginning NetBeans IDE for Java Developers" is your new and authoritative guide for getting started learning and using the free and open source NetBeans IDE. Written by Geertjan Wielenga, who has worked on the NetBeans Team since 2004, it shows you what the IDE is all about and how to use it with real-world case studies built from the ground up as you learn all about the IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10245">New: "Mastering NetBeans"</a></h2>
						<p style="margin-left:8px;">
						"Mastering NetBeans" will teach you to ace NetBeans IDE and make use of it in creating Java business and web services. Written by David Salter, who has been active in the NetBeans community for many years, this book will help you to become a proficient developer and use NetBeans for software development. You will learn effective third-party interaction and enable yourself for productive database development.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10242">Maven Runner for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Eclipse has a great plugin call "Eclipse Runner", which NetBeans itself does not have. So Peter, a developer from Hong Kong, has developed this feature for NetBeans. You can add Maven goals under the tree node of any project and double-click a goal name to run Maven in NetBeans.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10243">Oracle Cloud Day Netherlands: October 6, 2015</a></h2>
						<p style="margin-left:8px;">
						The Cloud is everywhere, but how do you get into it? Java developers everywhere are being told every day that the Cloud is important and that "everything is moving to the Cloud". What does that mean? In this interactive workshop, you will see many demos -- with code -- and very few slides, and a lot of discussion, to introduce you to many new and exciting tools and technologies integrated into NetBeans that help you climb into the Cloud. For example, you will learn and discuss about version control systems in the Cloud, continuous build servers in the Cloud, and deployment of applications into the Cloud. And what about developing applications in the Cloud? What does that mean, does it make sense, and what can tools do for you to help you there? Let's discuss! In the NetBeans session during Oracle Cloud Day in the Netherlands, the focus is on Java developers, or any other kind of developers, who are interested in discussing what the Cloud can mean for them.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10244">NetBeans Day Paris: October 16, 2015</a></h2>
						<p style="margin-left:8px;">
						La communauté NetBeans vous invite pour une conférence gratuite d'une journée. Venez rencontrer d'autres utilisateurs de NetBeans, découvrir ou apprendre à utiliser NetBeans. Cette conférence se concentre sur NetBeans et les technologies utilisées par NetBeans -- plus spécifiquement Java, JavaScript, PHP et bien d'autres!</p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10241">Aspose Extends the Aspose Plugin for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Thanks to Aspose, a NetBeans partner, which has updated its integration of Aspose Examples in NetBeans IDE, you don’t need to manually download Aspose Java API code as it is available through the plugin’s Aspose New Example wizard within NetBeans IDE.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10239">Vimeo: JavaScript Landscape for Java Developers</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga did an overview of the JavaScript landscape at JavaZone in Norway, last week Thursday, 10 September. He'll be doing a similar presentation at JAX London next month.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10240">YouTube: Debugging Multiple Languages Simultaneously</a></h2>
						<p style="margin-left:8px;">
						Find out from Jaroslav Tulach about a new and unique feature being worked on for NetBeans IDE 8.1 -- integration with Truffle, which is a set of APIs to build custom language interpreters that gets special treatment by Graal, which is an alternative version of the HotSpot VM.</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-09-15.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>