
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 709</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 # 709 - Jan 06, 2016
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10356">NetBeans Knowledge Base</a></h2>
						<p style="margin-left:8px;">
						Have you looked at the long list of tutorials and guides on NetBeans.org recently? Hundreds of documents are available on a wide range of topics, to help you get started with development of applications with Java EE, JavaScript, PHP, and much more. The knowledge base is waiting for you to explore it further!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10351">Updated NetBeans Platform Showcase</a></h2>
						<p style="margin-left:8px;">
						Many new NetBeans RCP applications have been added to the showcase. For the first time, you can search NetBeans Platform applications per country. A set of featured applications are highlighted, from NATO, NASA, and more. Send in your screenshots to webmaster@netbeans.org and share with the world what you are doing with the NetBeans Platform!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10350">Updated NetBeans Connector for Chrome</a></h2>
						<p style="margin-left:8px;">
						<b>Note:</b> With the release of NetBeans IDE 8.1, several enhancements and fixes have been included in the 1.1.5 version of the NetBeans Connector plugin for Chrome. Make sure to use NetBeans IDE 8.1 together with the 1.1.5 version of the plugin to get the most out of the seamless integration between NetBeans IDE and Chrome!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10347">NetBeans Days in 2016</a></h2>
						<p style="margin-left:8px;">
						Just like last year, but even better, there will be many NetBeans Days this year. See the tentative plans here and get involved!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10348">New NetBeans Dream Team Members</a></h2>
						<p style="margin-left:8px;">
						Several enthusiastic NetBeans users have joined the NetBeans Dream Team. A very warm welcome to Cagatay Civici (Turkey), Ivar Grimstad (Sweden), Johannes Weigend (Germany), Jose Pereda (Spain), Ken Fogel (Canada), Michael Mueller (Germany), and Nebrass Lamouchi (France)!</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10354">Code Outline for NetBeans IDE 8.1</a></h2>
						<p style="margin-left:8px;">
						Missing the code outline from tools like Sublime? Try out this recently updated plugin, by Benno Markiewicz, providing the code outline feature for NetBeans IDE 8.1.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10349">Oracle JET: Getting Started With Modern Web Development</a></h2>
						<p style="margin-left:8px;">
						While there are many JavaScript frameworks and libraries to choose from,  few cover all the typical requirements for enterprise applications. This article by Oracle ACE Director Andreas Koop examines Oracle JET’s potential as an enterprise-grade framework for end-to-end client-side web application development, and then shows you how to get started building your first Oracle JET application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10355">NetBeans & Java EE: Localized Bean Validation</a></h2>
						<p style="margin-left:8px;">
						Bean Validation is part of the Java EE 7 specification and can be useful for validation in JSF too. Read what Michael Mueller, one of the new NetBeans Dream Team members, has discovered about this topic.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10353">YouTube: AirHacks and Java Speech API</a></h2>
						<p style="margin-left:8px;">
						Watch as Adam Bien teaches you some things you probably never knew about the Java Speech API, together with NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=10352">YouTube: Using the Base Distribution of Oracle JET</a></h2>
						<p style="margin-left:8px;">
						Getting started with Oracle JET is easy and the base distribution provides a great starting point, as this new screencast shows in a few simple steps.</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-01-06.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>