
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 521</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 # 521 - Jan 23, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7064">NetBeans at Free Virtual Developer Days!</a></h2>
						<p style="margin-left:8px;">
						Starting this week, several virtual developer days will be held. NetBeans will be present too. Watch presentations and follow hands on labs where the IDE will be used for rapid Java EE 6 development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7068">Java Spotlight Episode 64: NetBeans 7.1 Release</a></h2>
						<p style="margin-left:8px;">
						A very recent edition of Roger and Terrence's Java podcast focuses on the newest and coolest features in NetBeans IDE 7.1. Take a listen!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7066">Plugin: Jindent</a></h2>
						<p style="margin-left:8px;">
						Jindent is a powerful source code formatter for Java and C/C++. Jindent empowers you to transform any foreign Java/C/C++ source code to meet your preferred coding style or any common Java code convention.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7067">Microchip’s MPLAB X IDE Wins ECN Readers’ Choice Tech Award</a></h2>
						<p style="margin-left:8px;">
						In a matter of months, Microchip's NetBeans-based IDE has won its second award. Congratulations Microchip, from the NetBeans Team!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7069">Running RichFaces 4.1.0 on WebLogic 12c and NetBeans</a></h2>
						<p style="margin-left:8px;">
						Markus Eisele loves JSF and steps you through a scenario using RichFaces and WebLogic via NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7070">Interfaces on Demand with CDI and EJB 3.1</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Adam Bien writes: "Interfaces are no longer required with Java EE 6, so you can use them more consciously for the realization of business logic."</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7065">NetBeans Poll: How Do You Create Rich Web UIs?</a></h2>
						<p style="margin-left:8px;">
						jQuery? DOJO? What do you use to implement rich web UI in your application? The NetBeans Team would like to know what your preferences are, please let us know!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7071">Video: Apache Commons IO 2.0 from JDK 5 to JDK 7</a></h2>
						<p style="margin-left:8px;">
						John Yeary shares a video showing how to use NetBeans IDE 7.1 to migrate Apache Commons IO 2.0 from JDK 5 to JDK 7.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7072">Debugging GUIs Just Became Easier</a></h2>
						<p style="margin-left:8px;">
						Hermien Pellissier has a number of interesting blog entries. In this one is a quick hint about a new NetBeans IDE feature!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7073">Javac AST Visualization on NetBeans</a></h2>
						<p style="margin-left:8px;">
						Starting a new NetBeans blog, Martin Skurla shares how he uses NetBeans APIs to visualize the Javac abstract syntax tree.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7074">NetBeans and Ceylon</a></h2>
						<p style="margin-left:8px;">
						Ceylon is a new JVM language. Read this blog entry about a project that's already created editor coloring for the Ceylong syntax.</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-01-23.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>