
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 516</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 # 516 - Dec 06, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6969">Your Feedback: Is NetBeans 7.1 Release Ready?</a></h2>
						<p style="margin-left:8px;">
						Have you been using the release candidate builds? What's your opinion of the current state of your favorite NetBeans areas? Is the IDE fast and performant in your environment? The NetBeans team needs to know. Fill in this short form today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6970">NetBeans IDE 7.1 Release Candidate 2 Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6295&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A new, faster, and more stable candidate build of NetBeans IDE 7.1 is now available. Download it and try it out and give the NetBeans team your feedback on what you find.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6971">NetBeans Podcast 58: Countdown to 7.1; Meet the 19th Governance Board</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 7.1 is almost here; what's the community's verdict? Chats with Sven Reimers and Zoran Sevarac, the members of the 19th NetBeans Governance Board. And a new API Design book from Jarda Tulach as well.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6974">Offshore Simulation Software on NetBeans</a></h2>
						<p style="margin-left:8px;">
						Simulation software is well suited for the Java desktop. Read here what a team of Norwegian developers are doing to support a large training framework for oil and rig platforms.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6973">Adam Bien Video: Clean Java EE 6 Coding</a></h2>
						<p style="margin-left:8px;">
						See NetBeans Dream Team member Adam Bien in action at JAX London Nov 2011. His slides, his voice, his entire presentation on Java EE 6 principles are shown here in full context.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6975">NetBeans Buzz: Batch Refactoring</a></h2>
						<p style="margin-left:8px;">
						Several NetBeans users have reported on the interesting and powerful inspect & transform feature in the upcoming NetBeans IDE 7.1. Read here what the buzz is about!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6968">Devoxx 2011 Interviews by Oracle Technology Network</a></h2>
						<p style="margin-left:8px;">
						Tori Wieldt from OTN interviewed during Devoxx 2011 many Java Community members including several leading Java engineers from Oracle. Watch her interviews here!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6972">Java Magazine Looking for Interview Candidates</a></h2>
						<p style="margin-left:8px;">
						For the March/April 2012 issue of Java Magazine, the editorial team is looking for interview candidates for a cover story tentatively entitled "The New Java Developers". For each candidate selected, they will publish a short bio/profile and photo. Read more here!</p>
					</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="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-12-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>