
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 384</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/appl2/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/appl2/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 # 384 - Mar 23, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3453">Help Test NetBeans 6.7 - Join NetCAT!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2683&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Give something back to your favorite IDE by helping the NetBeans team test NetBeans 6.7. Sign up for the latest cycle of NetCAT, the <i>NetBeans Community Acceptance Testing program</i>. What's needed? A few hours a week in April and May. Join other volunteers and help get the next release into tip-top shape!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3449">Create. Develop. Win. Take the JavaFX Coding Challenge!</a></h2>
						<p style="margin-left:8px;">
						There is no limit to break-through thinking. Design and submit a new application using JavaFX and you could win up to $25,000! The contest is open to professional developers and students. Get the details from the <a href="http://www.javafx.com/challenge/?intcmp=2678">JavaFX.com</a>, and also check out the <a href="https://netbeans.org/features/javafx/index.html">NetBeans IDE for JavaFX</a>.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3452">Webinar: Develop MySQL-Backed Java Apps with NetBeans, JRuby-on-Rails & GlassFish</a></h2>
						<p style="margin-left:8px;">
						Join Arun Gupta, "GlassFish Guy" at Sun Microsystems, for this informative technical webinar in which he will demonstrate how to leverage the latest version of the NetBeans IDE to quickly and easily develop and deploy MySQL and GlassFish backed applications using the JRuby-on-Rails framework. 
<br><br>
WHEN: <b>Thursday, March 26, 2009</b>, 10:00 am PDT, 1:00 pm EDT, 17:00 GMT. <i>(The presentation will be approximately 45 minutes long followed by Q&A.)</i></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3450">Creating a RESTful Web Service and JavaFX Client</a></h2>
						<p style="margin-left:8px;">
						Learn how to use the NetBeans IDE with GlassFish and MySQL to create a RESTful web service. You'll also learn how to use the NetBeans IDE with JavaFX support to run a JavaFX client for the web service.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3454">Deploying PHP to a Server-only OpenSolaris Web Stack</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows an alternative to     configuring PHP, MySQL, Apache, and XDebug on your computer. Instead, deploy PHP applications to a server-only OpenSolaris image with a pre-configured PHP web stack in a Virtual Box.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3448">NetBeans Platform CRUD Application Tutorial</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows you how to integrate a MySQL database into a NetBeans Platform application. By the end, you will have learned about a range of NetBeans Platform features that can help you create similar applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3451">Twitter Search in PHP</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2652&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A quick intro to creating a PHP application that searches Twitter and displays its results in a Yahoo UI chart.</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3456">NetBeans 6.7 and Glassfish v3: Synergy for Pragmatic JavaEE 6 Development</a></h2>
						<p style="margin-left:8px;">
						Watch Adam Bien in action at Sun's CommunityOne East event. "No slides, just code: From nothing to a maintainable Java EE / RIA application, with hacks, best practices and workarounds."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3455">NetBeans and Web Services</a></h2>
						<p style="margin-left:8px;">
						User Moz writes that NetBeans is a great tool for web services, and devotes this entry to creating a web service client in just a few clicks.</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/2009-03-23.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>