
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 551</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 # 551 - Aug 20, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7646">NetBeans @ JavaOne 2012</a></h2>
						<p style="margin-left:8px;">
						Coming to JavaOne this year? In addition to NetBeans Day on 30 September, there's many more opportunities to get involved in the NetBeans community at JavaOne. Here's a list of all the sessions throughout JavaOne that deal with NetBeans IDE in one way or another. See you there!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7653">NetBeans PHP Team: New JavaScript Editor</a></h2>
						<p style="margin-left:8px;">
						The NetBeans PHP Team has been working on a completely new and rewritten JavaScript editor. In this blog entry, you're invited to download it and give it a try, your feedback would be highly appreciated!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7648">Plugin: NetBeans/Ubuntu Unity Integration</a></h2>
						<p style="margin-left:8px;">
						The Ayatana plugin integrates the NetBeans menu bar with Unity, as well as letting you use accelerators and keyboard shortcuts, as well as Unity's Heads Up Display.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7644">10 Time-Savers in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						The Oracle Java curriculum development group has compiled a list of ten time saving features in NetBeans IDE, features that make the development of Java software a lot easier!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7645">5 Tips for Arabic Java Desktop Developers</a></h2>
						<p style="margin-left:8px;">
						When creating Java software systems in Arabic, you'll encounter several stumbling blocks, which are discussed and solved in this article.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7647">Earth Observation & Monitoring on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						From construction site damage control to avalanche prediction, GRID-IT in Austria is focused on earth observation and monitoring. In this article, three cool business applications on the NetBeans Platform are discussed.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7655">NetBeans 7.2 Refactoring Enhancements</a></h2>
						<p style="margin-left:8px;">
						Dustin Marx has a great blog that frequently focuses on NetBeans IDE. Recently, he's described <a href="http://marxsoftware.blogspot.nl/2012/08/nb72-refactor-constructor-factory.html">how to refactor a constructor as a static factory</a> and <a href="http://marxsoftware.blogspot.nl/2012/08/netbeans-72-refactoring-builder.html">how to refactor a paramterized constructor as a builder</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7652">Ruby Ready for NetBeans IDE 7.2</a></h2>
						<p style="margin-left:8px;">
						Start using Ruby and Rails support in NetBeans IDE 7.2 today, via the upgraded community Ruby plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7654">Functional Testing, Maven, and the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Hermien Pellissier reports on how to get started setting up functional tests for Mavenized NetBeans Platform applications. Get set up, kick off the test process, and watch your application get clicked!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7649">Video: Java EE 6 with PrimeFaces and Maven</a></h2>
						<p style="margin-left:8px;">
						In this video, you see an end-to-end demonstration of a Java EE 6 application created on Maven, with PrimeFaces as the component library, and Maven as the build system.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7650">Video: Two Hidden NetBeans Features</a></h2>
						<p style="margin-left:8px;">
						Features enabled via drag 'n drop are hard to discover but, nonetheless, very powerful. In this video you learn about two of them.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7651">Video: Simple Palette for Custom FileTypes</a></h2>
						<p style="margin-left:8px;">
						In this article and video, you learn how to integrate a palette with a multiview element.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Geertjan Wielenga<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 class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://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="https://netbeans.org/community/news/newsletter/2012-08-20.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>