
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 502</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 # 502 - Aug 29, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6712">Make NetBeans IDE 7.1 Great: Join NetCAT 7.1!</a></h2>
						<p style="margin-left:8px;">
						Do you enjoy playing with software and hunting for defects? If you are an experienced NetBeans IDE user and you have a few hours per week from September through November, you can join other community volunteers in the NetCAT 7.1 program. Get your NetBeans bug(s) fixed and make friends along the way.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6713">Plugin: Struts2 Support</a></h2>
						<p style="margin-left:8px;">
						The Struts2 support plugin for NetBeans IDE has recently been updated to support NetBeans IDE 7.0 and 7.0.1. Download it, install it, and provide feedback on the plugin's page!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6716">Dutch Software Consultancy on NetBeans</a></h2>
						<p style="margin-left:8px;">
						Rotterdam harbor monitored via NetBeans? When Ordina, a leading software consultancy in the Netherlands, needed software to be both available and reliable, they found NetBeans with Java Web Start to be the perfect solution.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6717">Italian ERP System on NetBeans</a></h2>
						<p style="margin-left:8px;">
						Network outages on Christmas eve could cost much more than the entire application. A safer bet is to create highly versatile Java desktop applications, argues an architect from an Italian software company. Read more in this article.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6719">Dream Team: John Yeary</a></h2>
						<p style="margin-left:8px;">
						John Yeary, a NetBeans Dream Team member, has a great blog with many interesting insights, tips, and tricks. In his latest blog entry, he examines some interesting aspects of the Java 7 Project Coin enhancements.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6718">Clever Code Completion for try/catch</a></h2>
						<p style="margin-left:8px;">
						The NetBeans PHP team blog continually reports on the latest enhancements in the NetBeans PHP editor. In the latest blog entry, you're shown how code completion is being optimized and finetuned.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6720">Add Project vs. Add Cluster</a></h2>
						<p style="margin-left:8px;">
						NetBeans RCP developers frequently wonder about the difference between "Add Project" and "Add Cluster" in their application projects. In this blog entry, the difference is explained.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6714">Software Quality Tools for NetBeans</a></h2>
						<p style="margin-left:8px;">
						FindBugs, PMD, CheckStyle, and Dependency Finder are great & very popular tools used throughout the software development industry. How do you use them in NetBeans IDE? Dustin Marx explains how to set everything up and optimize your software quality experience.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6715">XML Schema Editor for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Did you know there's a plugin providing a complete & visual XML schema editor for NetBeans IDE 7.0 and 7.0.1? Read this article for all the details.</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/2011-08-29.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>