
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 609</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 # 609 - Oct 15, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8709">NetBeans Day 2013</a></h2>
						<p style="margin-left:8px;">
						Maybe you missed NetBeans Day this year. In the first part of a new series, find out what James Gosling and others discussed during NetBeans Day in San Francisco!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8710">Plugin: CoffeeScript</a></h2>
						<p style="margin-left:8px;">
						Install this plugin and you will have advanced syntax highlighting, error checking, and much more for CoffeeScript, a language that compiles into JavaScript.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8716">Poll: Your IDE for PrimeFaces Applications</a></h2>
						<p style="margin-left:8px;">
						Do you develop PrimeFaces applications? Take the PrimeFaces poll and let their team know which IDE you use for daily development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8711">Reflections on JavaOne 2013 by the NetBeans Community (Part 2)</a></h2>
						<p style="margin-left:8px;">
						The NetBeans community turned out in full strength at NetBeans Day and JavaOne 2013. In this article, Shai Almog, Thomas Kruse, and Zoran Sevarac reflect on their experiences during the conference.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8712">Video: JavaFX with CoC, DI, and SceneBuilder</a></h2>
						<p style="margin-left:8px;">
						Watch NetBeans Dream Team member Adam Bien as he shows how to build enterprise JavaFX applications with Convention over Configuration, Dependency Injection, Maven, NetBeans and Scene Builder.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8715">Don't Reinvent the Wheel, Use the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						After trying using NetBeans Platform, Djamel Torche reports that he is impressed by what it provides in features, component/code re-usability and best practices. Read the results of his research here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8713">New NetBeans Application: CaseLnk</a></h2>
						<p style="margin-left:8px;">
						CaseLnk Case Management System, by CaseForge Technology, is a new NetBeans application for improving office productivity, user collaboration, and customer satisfaction. It supports cases, documents, tasks, events, processes, and contacts.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8714">New NetBeans Application: Validation Manager</a></h2>
						<p style="margin-left:8px;">
						Javier Ortiz reports on Validation Manager, which is a tool created on the NetBeans Platform to handle all the cumbersome paperwork of regulated environment validations, including validation plans, protocols, executions, and exceptions, while keeping everything in one place and, best of all, paperless.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8708">Java SE 8: Lambda Quick Start</a></h2>
						<p style="margin-left:8px;">
						This free webcast <b>(Date: Wednesday, October 16th, 2013 Time: 8:00 am US/Pacific time)</b> provides an introduction to the forthcoming lambda expressions syntax added to Java 8. Learn how lambda expressions replace anonymous inner classes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8707">Java EE 7: JMS 2.0 Producer & Receiver</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=8106&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='79' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This tutorial covers Java Messaging Service 2.0 (JMS 2.0), a new API for sending and receiving messages in Java Platform, Enterprise Edition 7 (Java EE 7) web applications by using GlassFish  and NetBeans.</p><br style="clear:both;"/>
					</div>
	<div class="edited">
	This issue was brought to you by: Jan Pirek<br/>If you do not want to receive this newsletter, you can <a href="http://www.netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="http://www.netbeans.org/community/news/newsletter/index.html">English</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="http://www.netbeans.org/community/news/newsletter/2013-10-15.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>