
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 531</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 # 531 - Apr 02, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7259">NetBeans JavaScript Support: Code Folding</a></h2>
						<p style="margin-left:8px;">
						There's new life in JavaScript support in NetBeans IDE. Read about the latest updates. If you write JavaScript code, download the daily builds and give the NetBeans team feedback.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7260">IMPT: NetBeans Plugin Owners, Updates Required for Your NetBeans Plugins</a></h2>
						<p style="margin-left:8px;">
						Do you own a plugin on the NetBeans plugin portal? New changes to the portal now require all plugins to identify at least one version of the NetBeans IDE that they function with. Learn more about how to make this update before the <b>April 16th deadline</b>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7258">NetBeans Poll: Your Applications and Mobile Devices</a></h2>
						<p style="margin-left:8px;">
						How are you targeting mobile devices with your current applications? Share your methods in the latest NetBeans Community Poll.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7264">Video: Using the Visual Debugger in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates how to use the Visual Debugger in NetBeans IDE to locate and debug the code for visual elements in your GUI application. You can use the visual debugger in Java and JavaFX GUI applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7262">Tech Tip: NetBeans Java Hints</a></h2>
						<p style="margin-left:8px;">
						Ever wonder what those hints in the NetBeans IDE mean?</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7261">Spring to Java EE Migration, Part 3</a></h2>
						<p style="margin-left:8px;">
						Part 3 of a series by Java EE fan David Heffelfinger, demonstrating 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=7263">Java FX 2 Linear Gradients</a></h2>
						<p style="margin-left:8px;">
						A closer look at working with multiple linear gradients in JavaFX.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7265">Learning NetBeans Platform For Building Java Applications</a></h2>
						<p style="margin-left:8px;">
						Developer Steve Jin--founder of the VI Java API project--is testing out the NetBeans Platform and so far finds it simpler than Eclipse, and also recommends the "great documentation and samples" available on NetBeans.org!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7266">Slides and Video: Netbinox at OSGiCon</a></h2>
						<p style="margin-left:8px;">
						NetBeans architect Jarda Tulach recently presented at OSGiCon, detailing the trial and triumph of Netbinox. Get the slides and watch the demo of the "fastest OSGi container on the planet!"</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7267">Trip Report: NetBeans at Oracle Dev Days Poland and Romania</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga has already logged an impressive number of miles this year giving presentations about Java and the NetBeans IDE at developer events across Europe. Get the scoop on his recent stops in <a href="https://blogs.oracle.com/geertjan/entry/oracle_developer_day_poland_2012">Poland</a> and <a href="https://blogs.oracle.com/geertjan/entry/oracle_developer_day_romania_2012">Romania</a> for Oracle Developer Days.</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-04-02.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>