
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 466</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 # 466 - Dec 13, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5886">Cobertura Support for Maven Projects in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE now supports code coverage for Maven projects through the Cobertura Maven plugin. Learn how to display test coverage in the IDE, and for <a href="http://blogs.sun.com/geertjan/entry/new_cobertura_feature_for_netbeans">NetBeans RCP applications on Maven</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5887">Improvements to NetBeans 7.0 PHP Editor Performance</a></h2>
						<p style="margin-left:8px;">
						The NetBeans PHP team has been implementing fixes to performance issues in the PHP editor for NetBeans 7.0. (Download the <a href="http://bits.netbeans.org/download/trunk/nightly/latest/">nightly builds</a> to get the changes.) To continue to improve the editor, the team wants to receive more performance use cases. Read the team blog for details.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5890">Plugin: Gmail Notify</a></h2>
						<p style="margin-left:8px;">
						This NetBeans plugin enables notification in the IDE when new Gmail messages become available.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5894">Interview: Caoyuan Deng on the NetBeans Scala Plugin</a></h2>
						<p style="margin-left:8px;">
						Developer Caoyuan Deng speaks about the origin of the Scala plugin for NetBeans, the current status and future of the project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5895">Swiss Air Traffic Control Takes Off on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Last year, SkyGuide, a Swiss aviation software company went through the NetBeans Platform training course and ported several of their applications to the NetBeans Platform. In this follow-up article, software engineer Julien Piaser introduces <b>Crystal</b>, a NetBeans Platform application that manages air traffic information.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5892">The Spam Stops Here! Interview with Holger Stenzhorn</a></h2>
						<p style="margin-left:8px;">
						Holger Stenzhorn, a NetBeans community moderator, gives an account of his spam-fighting days on the NetBeans mailing lists.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5885">New Version of Kojo (Scala Learning Environment) Available</a></h2>
						<p style="margin-left:8px;">
						Created in Scala on the NetBeans Platform, Kojo is a learning environment that teaches children the basics of programming and helps them to explore concepts in Math, Sciences and the Arts. Learn more about new features in the latest release of this impressive open-source project.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5891">JDK 7 Support in NetBeans IDE 7.0 Tutorial</a></h2>
						<p style="margin-left:8px;">
						A short guide to using JDK 7 features in NetBeans IDE 7.0. Also includes information on setting up the JDK.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5893">Devoxx Video: Creating Lightweight Apps with Vanilla Java EE 6</a></h2>
						<p style="margin-left:8px;">
						Revisit JavaEE expert Adam Bien's <a href="
http://www.devoxx.com/display/Devoxx2K10/Creating+Lightweight+Applications+With+Nothing+But+Vanilla+Java+EE+6">Devoxx talk</a>, now in in video, and a related <a href="
http://www.adam-bien.com/roller/abien/entry/pets_and_aliens_in_a">blog entry</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5889">Using the Embedded EJB Container to Test Enterprise Applications</a></h2>
						<p style="margin-left:8px;">
						A tutorial on how using EJB 3.0 technology in the NetBeans IDE to develop an enterprise application.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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/2010-12-13.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>