
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 562</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 # 562 - Nov 06, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7854">Give Your Feedback About NetBeans IDE 7.2!</a></h2>
						<p style="margin-left:8px;">
						Are you getting the best coding experience when using NetBeans IDE 7.2 or NetBeans IDE 7.2.1? Are there features or enhancements the NetBeans team should consider in future releases? Tell us in this short survey.  It should only take about 3-5 minutes to complete.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7858">Plugin: Gradle Support</a></h2>
						<p style="margin-left:8px;">
						You can now install the excellent NetBeans Gradle plugin by Attila Kelemen by going to Tools | Plugins in NetBeans IDE 7.2!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7852">20th NetBeans Governance Board: Anton Epple and Hermien Pellissier</a></h2>
						<p style="margin-left:8px;">
						The 20th NetBeans Governance Board Election is over. Congratulations to the new community members of the board, Anton Epple and Hermien Pellissier!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7851">Reflections on JavaOne 2012 by the NetBeans Community</a></h2>
						<p style="margin-left:8px;">
						The NetBeans community turned out in full strength at JavaOne this year. From packed out sessions at NetBeans Day to NetBeans-oriented panel discussions throughout JavaOne, NetBeans users were everywhere. In this article, some of them reflect on what they experienced at JavaOne!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7853">NetBeans Poll: Your Biggest Projects in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						What's the biggest project you've developed using NetBeans IDE? Let the NetBeans Team know via the latest community poll.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7862">Project Easel for Easy HTML5 Debugging</a></h2>
						<p style="margin-left:8px;">
						Mark Stephens discusses the new support NetBeans IDE 7.3 provides for HTML5 development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7855">How to Get Involved in Open Source Projects</a></h2>
						<p style="margin-left:8px;">
						John Yeary, NetBeans Dream Team member and Greenville JUG leader, writes: "If you want to participate in any project, or technology just ask. The smart project owners/leads will find a place in their project for you. And, eventually, you may lead your own project."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7861">UNHCR Receives Duke's Choice Award</a></h2>
						<p style="margin-left:8px;">
						Read about what the UNHCR is doing with NetBeans IDE and the NetBeans Platform to help refugees, which won them a Duke's Choice Award at the recent JavaOne 2012.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7863">PHP Application Development with NetBeans</a></h2>
						<p style="margin-left:8px;">
						A book review of a brand new technical book on PHP development with NetBeans IDE.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7857">November: NetBeans at Devoxx</a></h2>
						<p style="margin-left:8px;">
						Petr Jiricka, NetBeans Java EE team lead, hosts a session at Devoxx where he will discuss how Java EE 7 will enable both incremental improvements of existing tools, as well as new tools that support the new application model.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7856">December: NetBeans at JDays Sweden</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga, NetBeans product manager, will show how NetBeans IDE makes Java EE development with Maven a simple and painless task!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7859">Unified Maven View</a></h2>
						<p style="margin-left:8px;">
						Install a new plugin into NetBeans IDE 7.3 Beta and all Maven submodules will be merged into the Maven parent's node hierarchy.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7860">Overridable Method Call in Constructor</a></h2>
						<p style="margin-left:8px;">
						Dustin Marx, who always provides great tips on Java editor usage in NetBeans IDE, looks at why having an overridable method called from a parent class's constructor is not a good idea and how NetBeans can help.</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-11-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>