
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 535</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 # 535 - May 01, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7331">Available: NetBeans IDE 7.1.2</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6675&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Get it today: NetBeans IDE 7.1.2 provides Java SE 7u4 Support (the first Oracle JDK release for Mac OS X), JavaFX 2.1 Support, Ant upgrade to version 1.8.3, integration of recent patches, and minor performance improvements.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7336">Available: JDK 7 Update 4</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Adam Myatt outlines the new update release of JDK 7.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7337">Plugin: EasyPmd 2.8</a></h2>
						<p style="margin-left:8px;">
						Performs Java code analysis by using PMD and shows the results in the Tasks window.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7330">Spring to Java EE Migration</a></h2>
						<p style="margin-left:8px;">
						Read the recently released 4th part of David Heffelfinger's OTN series explaining how to migrate from the Spring Framework to Java EE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7334">Game Deck Manager on NetBeans</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Javier Ortiz describes a new game organizer he's creating on NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7335">Bug Fix Release of Intermedia System on NetBeans</a></h2>
						<p style="margin-left:8px;">
						A new release is announced of the Praxis intermedia system, an open-source software project by artist and technologist Neil C Smith.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7338">JavaOne India</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta blogs about JavaOne India coming up this week. Be there or be square!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7339">Navigator Integration for Images</a></h2>
						<p style="margin-left:8px;">
						The upcoming 7.2 release of NetBeans IDE provides a quick view of images in your project, as explained here.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7332">SaaS in PHP: Google Map Service Tutorial</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE supports Software as a Service (SaaS) applications in PHP. This tutorial uses the Google Map service to demonstrate SaaS PHP support.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7333">Testing a Maven Enterprise Application</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how to test a simple enterprise application using NetBeans IDE and Maven archetypes.</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-05-01.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>