
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 602</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 # 602 - Aug 26, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8580">Take the NetBeans IDE 7.3 Satisfaction Survey!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team needs your feedback about your experience using NetBeans IDE 7.3 or its update release, NetBeans IDE 7.3.1. Are you getting the best coding experience when using NetBeans IDE 7.3 or NetBeans IDE 7.3.1? Are there features or enhancements the NetBeans team should consider in future releases? Let us know!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8588">Video: JavaFX 8 DatePicker and NetBeans IDE 7.4</a></h2>
						<p style="margin-left:8px;">
						This video demonstrates how to use NetBeans 7.4 Beta to create a JavaFX application from scratch that also contains a DatePicker. It also touches on using Java lambda expressions to simplify event handling.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8589">Video: Qt, NetBeans IDE and Ubuntu</a></h2>
						<p style="margin-left:8px;">
						Create a Qt GUI application using Netbeans IDE 7.3.1 and Ubuntu.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8591">Eclipse Formatter for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Read about a new plugin that makes it possible to integrate an Eclipse XML formatting file into the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8593">Customizing the NetBeans Installer</a></h2>
						<p style="margin-left:8px;">
						This blog entry outlines how to use Maven to customise the NetBeans Installer when creating NetBeans Platform based applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8587">Java Scrapbook for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Thanks to a new module from Geertjan Wielenga, now you can keep track of sample code snippets, which are stored in a scrapbook file in the 'private' folder of a NetBeans project.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8590">NetBeans Success Stories: PrimeFaces and JFreeChart</a></h2>
						<p style="margin-left:8px;">
						Did you know that PrimeFaces and JFreeChart were created using the NetBeans IDE? Read about the growing list of companies and projects that are using NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8592">NetBeans Community Tweets: @TurcuCiprian</a></h2>
						<p style="margin-left:8px;">
						<i>Seriously, after installing the Zen coding plugin, NetBeans for PHP is just an awesome IDE, I have all I need out of the box.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8594">NetBeans Community Tweets: @nicolas_valle</a></h2>
						<p style="margin-left:8px;">
						<i>After an intensive research, between Codeblocks, Ecplise and NetBeans I definetly prefer NetBeans as IDE. Its code completion is awesome!</i></p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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-08-26.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>