
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 489</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 # 489 - May 31, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6471">JavaFX 2.0 Beta Plugin for NetBeans IDE 7.0 Now Available for Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5779&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='57' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The much-anticipated <a href="http://javafx.com">JavaFX 2.0</a> release is now <a href="http://javafx.com/downloads">available in public beta</a> —which means you can take advantage of all the new benefits that JavaFX 2.0 brings to the Java platform. This release is the latest development in <a href="http://javafx.com/roadmap">Oracle’s long-term commitment</a> to making JavaFX a premier rich client platform.<br><br>The JavaFX 2.0 Beta Plugin for NetBeans IDE 7.0 is available for download from javafx.com. Please help us make JavaFX successful by testing it at an early stage and <a href="http://javafx-jira.kenai.com">report any issues</a> you encounter. Check out <a href="http://download.oracle.com/javafx">detailed tutorials and API documentation</a>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6473">NetBeans IDE 7.0 Patch 1 Now Available</a></h2>
						<p style="margin-left:8px;">
						The patch includes bug fixes in modules for PHP, C/C++, Editor, Maven, Debugger, JavaEE, Database, and Java Card. To obtain the fixes, the NetBeans IDE must be installed and running; an update notification will appear. <i>(Click the alert-box to install the updates.)</i> You can also download the fixes through the IDE's Plugin Manager.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6470">NetBeans Plugin: NBScala 2.8.x</a></h2>
						<p style="margin-left:8px;">
						The Scala plugin is available for NetBeans IDE 7.0 and also works with Scala 2.8.x. New to Scala or curious about the language? Check out this recent Dzone article: <a href="http://www.dzone.com/links/r/why_java_folks_should_look_forward_to_scala.html">Why Java Folks Should Look Forward to Scala</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6474">Listen to NetBeans Podcast Episode 55</a></h2>
						<p style="margin-left:8px;">
						Feedback for NetBeans IDE 7.0; a look ahead at NetBeans 7.0.1. An interview with Alex Kotchnev, Software Architect and NetBeans Dream Teamer. API design tip with Jarda Tulach. Jirka Kovalsky introduces the new NetBeans Plugin Portal.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6475">NetBeans Poll: Using NetBeans Plugins</a></h2>
						<p style="margin-left:8px;">
						How do you find plugins for the NetBeans IDE and how would you describe your overall experience using them? Tell us in the latest NetBeans Community Poll.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6468">NetBeans IDE 7.0 Cookbook</a></h2>
						<p style="margin-left:8px;">
						A new book from Packt Publishing that offers over 70 highly focused practical recipes (solutions to real world problems) to help maximize your output with NetBeans IDE 7.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6476">Coming in July: All-New, All-Digital, Free Java Magazine</a></h2>
						<p style="margin-left:8px;">
						There's a new, free magazine about Java technology launching in July. To be published bi-monthly in digital and mobile formats, <i>Java Magazine</i> will provide essential information about Java technology, the language, and Java-based applications. Sign up today to receive the first issue and stay informed on all things Java.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6469">How to Contribute Samples to the NetBeans Wicket Plugin</a></h2>
						<p style="margin-left:8px;">
						Submitting sample applications to the NetBeans Wicket plugin is a simple process. Find out how and help to build a collection of sample applications demonstrating best practices for a wider audience.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6472">Local and Remote PHP Debuging in NetBeans with Xdebug on Google Chrome</a></h2>
						<p style="margin-left:8px;">
						A short tutorial about PHP Debugging in the NetBeans IDE with Xdebug on Google Chrome.</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/2011-05-31.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>