
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 520</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 # 520 - Jan 16, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7059">ApiGen Support Added to NetBeans for PHP</a></h2>
						<p style="margin-left:8px;">
						Create professional-looking API documentation of your projects with ApiGen support in NetBeans. The NetBeans PHP Team blog contains more details and how to download daily builds to try out this new feature.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7055">NetBeans Plugin: Prefixr for CSS3</a></h2>
						<p style="margin-left:8px;">
						Automatically update CSS3 properties with the necessary browser prefixes.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7054">Virtual Developer Day: Oracle WebLogic Suite 12c (Jan. 24)</a></h2>
						<p style="margin-left:8px;">
						In this virtual workshop, Java developers and architects can learn how to use Java EE 6, Oracle WebLogic Server 12c, Oracle Coherence, Oracle Enterprise Pack for Eclipse, NetBeans, Maven, and Hudson in hands-on labs and sessions while interacting with Oracle product experts in live moderated chats.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7060">NetBeans IDE 7.1 Review: JavaFX support</a></h2>
						<p style="margin-left:8px;">
						NetBeans Platform trainer and consultant Toni Epple provides a closer look at the new and improved features of JavaFX support in NetBeans IDE 7.1.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7057">Video: Inspect and Transform Refactoring Feature in NetBeans IDE 7.1</a></h2>
						<p style="margin-left:8px;">
						A demo about support for the new Inspect and Transform refactoring feature in NetBeans IDE 7.1. The demo shows how to to perform a code review using inspections with refactoring, and also how the NetBeans Java Editor helps refactor code on the selected scope of files.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7063">Video: Java EE 6 Using WebLogic 12c, NetBeans, MySQL</a></h2>
						<p style="margin-left:8px;">
						Oracle WebLogic Server 12c is now available, and this video shows how to develop and deploy a Java EE 6 application on WebLogic 12c using NetBeans, as well as how to configure MySQL database in NetBeans and use it for accessing the database tables in the Java EE 6 applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7062">New Documentation Available for JavaFX 2.0.2</a></h2>
						<p style="margin-left:8px;">
						A set of new documentation for using the latest update to the JavaFX SDK.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7056">NetBeans IDE 7.1 Profiler: Comparing Heap Dumps</a></h2>
						<p style="margin-left:8px;">
						A new Profiler feature in NetBeans IDE 7.1 is the ability to compare two heap dumps. Dustin Marx shows how.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7058">How To Compile JavaFX 2 Applications with Maven 3</a></h2>
						<p style="margin-left:8px;">
						A quick tip from Java EE expert Adam Bien.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7061">7 Habits for Better Coding in 2012</a></h2>
						<p style="margin-left:8px;">
						What are your techie resolutions for the new year? Be a more efficient programmer in 2012? Check out tips to help that goal in this blog entry.</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/2012-01-16.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>