
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 539</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 # 539 - May 28, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7405">NetBeans IDE 7.2 Beta: Built for Speed!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6696&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;'/>
						The Beta release of NetBeans IDE 7.2 is available! Featuring massive performance boosts and new Java editor features, including FindBugs integration, you can download it and try it out today!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7406">NetBeans IDE 7.2 Beta: Comments from an Eclipse User</a></h2>
						<p style="margin-left:8px;">
						Bruce Phillips has been using Eclipse for over 5 years. He used NetBeans IDE 7.2 Beta on a large project last week... with great results! He liked the performance, FindBugs integration, and more. Read all about it here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7416">Plugin: Codename One</a></h2>
						<p style="margin-left:8px;">
						Develop true native mobile applications in Java for iOS, Android, Windows Phone 7, Blackberry etc.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7411">Running Web Applications on the Oracle Cloud</a></h2>
						<p style="margin-left:8px;">
						What's the Oracle Cloud and how does it relate to NetBeans IDE 7.2? A new NetBeans article explains it all, including how to register the Oracle Cloud and deploy applications to it.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7407">The Most Frequently Asked Java EE 6/NetBeans Question</a></h2>
						<p style="margin-left:8px;">
						Did you know that when you use NetBeans IDE, you can regenerate your JPA entity classes from tables in a database, without destroying the changes you made to the JPA entity classes you initially generated? This article discusses this very commonly asked question!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7408">Best Practices for JavaFX 2.0 Enterprise Applications</a></h2>
						<p style="margin-left:8px;">
						In part 1 of a series, JavaFX expert James Weaver examines a Tweet browser while illustrating some best practices for enterprise application development in JavaFX 2.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7414">Vaadin, Maven, and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Petter Holmström from the Vaadin team describes a great combination of tools and technologies: Vaadin, Maven, and NetBeans IDE. Read on to find out why these three work so well together!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7410">Print Java Source as HTML</a></h2>
						<p style="margin-left:8px;">
						"File | Print to HTML" is a frequently overlooked menu item in NetBeans IDE. NetBeans Dream Team member Adam Bien explains in his blog that NetBeans is able to output Java source code as HTML, very easily indeed.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7409">JavaFX Scene Builder Docs Updated</a></h2>
						<p style="margin-left:8px;">
						The "Java Tutorials Weblog" is a great resource providing up to date info on the world of official Java tutorials. In this blog entry, you learn what parts of the JavaFX Scene Builder 1.0 Developer Release documentation have been updated with the promotion of development build 38.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7412">Alt-Shift-F & Formatting Multiple Source Files</a></h2>
						<p style="margin-left:8px;">
						In NetBeans IDE 7.2 Beta, you can format multiple source files across multiple projects simultaneously. In this blog entry, you learn about an enhancement to this feature, set to be released with the final release of NetBeans IDE 7.2.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7413">29 - 30 May: Croatian Oracle User Group</a></h2>
						<p style="margin-left:8px;">
						The first Java developer conference organized by the Croatian Oracle User Group is being held in Tuhelj, Croatia, this week. NetBeans demos and presentations will be done there too!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7415">30 May: Oracle Technology Network Developer Day</a></h2>
						<p style="margin-left:8px;">
						A free day-long event of Java hands-on labs and sessions at Oracle Headquarters in Redwood Shores, California.</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-28.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>