
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 518</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 # 518 - Dec 19, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7006">End of Year Message 2011</a></h2>
						<p style="margin-left:8px;">
						It's been a very active year in the NetBeans world. New releases, features, conferences, and more. To wrap everything up, here's an end of the year greeting from the NetBeans Team.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7012">JavaOne Latin America: Videos and Podcasts</a></h2>
						<p style="margin-left:8px;">
						JavaOne Latin America was held two weeks ago. What happened there? Here are videos and podcasts that were recorded there, giving you the feeling of being there yourself!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7007">Plugin: Cubeon 1.2.0.1 Released</a></h2>
						<p style="margin-left:8px;">
						Anuradha announces a new release of Cubeon, the NetBeans task management plugin, including updated task context support and new automatic features for you to try out!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7014">NetBeans RCP: Displaying Java’s Memory Pool Statistics</a></h2>
						<p style="margin-left:8px;">
						Java Champion Kirk Pepperdine walks through a complete example of how to extend VisualVM to display Java’s memory pool statistics.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7013">NetBeans RCP: Maltego CaseFile</a></h2>
						<p style="margin-left:8px;">
						Intelligence gathering analysts, this is for you! Maltego CaseFile for dataming and analyzing human data, read this article for more info, as well as a video that puts it all in context.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7011">New: org.netbeans.api.actions.Savable</a></h2>
						<p style="margin-left:8px;">
						A new NetBeans API class, org.netbeans.api.actions.Savable, is introduced in this article. If you're using SaveCookie, this article was written for you!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7005">New Project: JavaFX RCP</a></h2>
						<p style="margin-left:8px;">
						Sven Reimers has started a new project to create an application framework for JavaFX applications, reusing the core features of the NetBeans Platform. Join the project because your help is needed.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7004">New Project: AVR Microcontroller Development</a></h2>
						<p style="margin-left:8px;">
						Want to develop with AVR microcontrollers in NetBeans IDE? Ingmar Hendriks has launched a new project to let you do exactly that. Join the project because your help is needed.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7010">Video Tutorial: RichFaces and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Watch as NetBeans Dream Team member John Yeary shows you how to use RichFaces 4.1.0 with NetBeans IDE 7.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7008">Spring to Java EE Migration Using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						CTO and ardent Java EE fan David Heffelfinger demonstrates how easy it is to develop the data layer of an application using Java EE, JPA, and the NetBeans IDE instead of the Spring Framework.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7009">Creating a Simple Activity Stream with Apache Abdera2, Java, NetBeans 7, Maven</a></h2>
						<p style="margin-left:8px;">
						Chad Lung continues his series of articles that combine multiple different technologies together with Maven and NetBeans IDE.</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-12-19.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>