
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 390</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 # 390 - May 05, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3634">The Secret Tool: Try Java VisualVM for a Chance to Win $500!</a></h2>
						<p style="margin-left:8px;">
						Try the best kept secret in the Java JDK—Java VisualVM—blog about it and you could win a $500 American Express Gift Certificate. VisualVM is a FREE visual tool integrating several command-line JDK tools and lightweight profiling capabilities. Use it both during development and with live apps to profile memory consumption, display thread dumps, browse heap dumps, analyze core dumps, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3633">Take MySQL's Quick Survey for a Chance to Win $150!</a></h2>
						<p style="margin-left:8px;">
						Are you a commercial software and appliance developer or product manager? Help the MySQL team understand how it can provide best value to you by taking a three-minute survey about your product's development cycle. Complete the survey and you'll be entered to win a $150 Amazon.com gift certificate.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3629">Portability and Performance Improvements in JAX-WS Clients Created in NetBeans 6.7</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates new features in NetBeans IDE 6.7 that make JAX-WS web service clients faster and more portable. The improved speed and portability come about because the client no longer has to find and parse a remote WSDL file. Instead, when you create a client from a WSDL, the IDE generates a copy of this WSDL and saves it in your project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3632">Best Practices for Improving Performance of JavaFX Mobile Apps</a></h2>
						<p style="margin-left:8px;">
						Sun engineer Michael Heinrichs captures lessons learned while preparing the JavaFX Mobile release and provides some hints on how to improve the performance of mobile applications built with the tool.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3631">Creating, Publishing a RESTful API Using NetBeans IDE and Zembly</a></h2>
						<p style="margin-left:8px;">
						Learn how to create an API for a RESTful web service, using the NetBeans IDE WADL Designer plugin. Then learn how to publish this API to <a href="http://zembly.com/">Zembly</a> using Zembly's Bring Your Own API (BYOAPI)  feature.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3630">Securing a Web Application in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows the basics of adding security to a web application that is deployed to either the Tomcat server or the Sun Java System Application Server. The user configures security authentication using a basic login window and also uses a login form in a web page.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3635">Using GlassFish v3 in NetBeans 6.7... Now Even Easier</a></h2>
						<p style="margin-left:8px;">
						Vince Kraemer has created a "marker" module that gives users an easy way to register GlassFish v3 builds in NetBeans 6.7.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3636">Introduce Variable Feature</a></h2>
						<p style="margin-left:8px;">
						When is the Introduce Variable hint invoked? Get the answer from the NetBeans PHP team blog and also give the team feedback about the feature.</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-05-05.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>