
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 523</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 # 523 - Feb 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=7110">NetBeans Calendar</a></h2>
						<p style="margin-left:8px;">
						Virtual Developer Days are scheduled this week, as well as Java Day St. Petersburg. NetBeans will be represented at all these events, so looking forward to seeing you there!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7109">JavaOne 2011 Rock Stars Announced!</a></h2>
						<p style="margin-left:8px;">
						The most warmly received JavaOne 2011 presentations were recently awarded with "JavaOne Rock Star" awards. The NetBeans Team would like to congratulate everyone receiving this well-deserved award!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7107">Upcoming PHP Feature: Doctrine2 Support</a></h2>
						<p style="margin-left:8px;">
						If you're a PHP developer, you really need to follow the NetBeans PHP Team blog! In this blog entry, they report on the upcoming support for the Doctrine2 PHP ORM framework.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7108">Upcoming Java Feature: Generate Implementing/Extending Class</a></h2>
						<p style="margin-left:8px;">
						Geertjan's blog regularly provides news about new features being developed by the NetBeans Java Editor Team. In this blog entry, read about a very handy new feature that will speed up your development work considerably.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7102">Built on NetBeans: Microchip Awards</a></h2>
						<p style="margin-left:8px;">
						Microchip's IDE created on top of NetBeans has won a number of industry awards over the past months. Congratulations Microchip!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7100">Built on NetBeans: Praxis Available for Download</a></h2>
						<p style="margin-left:8px;">
						The first full release of Praxis, the modular framework for working with video, images, audio, and other media, is now available! Feel free to download it, play with it, and provide feedback.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7101">Built on NetBeans: AgroSense.nl Available in English</a></h2>
						<p style="margin-left:8px;">
						The texts on the AgroSense site, which is the portal for all information dealing with the open-source modular farm management solution created on NetBeans, have been translated into English. Now everyone can find out what this cool project is all about -- and participate in it!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7105">Taking The New Wicket Plugin For NetBeans For A Test Ride</a></h2>
						<p style="margin-left:8px;">
						TheWicketEvangelist blog examines the NetBeans/Wicket plugin and concludes that NetBeans is "the preeminent IDE for Wicket development".</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7106">A Docking Framework & Module System for JavaFX</a></h2>
						<p style="margin-left:8px;">
						JavaFX is really cool but wouldn't you like to have a windowing system to present multiple detachable views? And a module system to organize your code? Read this blog entry on how you can achieve this!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7103">Austin JUG: Java EE 6 & NetBeans</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta recently visited the Austin JUG, showing of Java EE 6 together with NetBeans, which was very warmly received.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7104">NetBeans Traing at MIT, Boston</a></h2>
						<p style="margin-left:8px;">
						A NetBeans API course was recently held in Boston, for students from MIT and Harvard. Read all about it here and feel free to leave a comment asking for a free NetBeans API course to be held at your university too!</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-02-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>