
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 442</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 # 442 - Jun 09, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5138">See NetBeans in Action on the Java Road Trip Tour!</a></h2>
						<p style="margin-left:8px;">
						<i>Java Road Trip: Code to Coast</i> is a 20-city tour across the United States showcasing Oracle's commitment to everything Java. Come watch Java technologists demonstrate the latest Java software such as the NetBeans IDE! First stop on the tour is New York City on June 14. Visit the tour page for destinations and dates near you.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5140">Top 5 Enhancements in NetBeans Platform 6.9</a></h2>
						<p style="margin-left:8px;">
						Developers of Swing Java desktop applications can look forward to the latest enhancements in the NetBeans Platform 6.9, such as API improvements, more sample projects, and a new NetBeans Platform 6.9 Developer's Guide. Get details from Geertjan's blog entry.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5141">OAuth Support in NetBeans IDE 6.9</a></h2>
						<p style="margin-left:8px;">
						OAuth is a security protocol that lets users authorize client applications to access their web resources. NetBeans engineer Milan Kuchtiak demonstrates OAuth support in the NetBeans IDE using a Twitter Client web app tutorial.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5133">Tips for Developing JavaFX TV Applications</a></h2>
						<p style="margin-left:8px;">
						The nature of the television platform affects the way you design effective user interfaces to run on it. This article describes some of the ways in which the television platform differs from the desktop platform and provides tips and guidelines for designing effective television applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5137">NetBeans Code Coverage Plugin Tutorial</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Code Coverage Plugin provides an interactive way to see testing coverage results within the NetBeans IDE. This enables developers to quickly identify the portions of Java code that aren't covered by their unit tests.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5139">Applying @Alternative Beans and Lifecycle Annotations</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how to take advantage of the @Alternative annotation to configure applications for different deployments, and also shows how to use managed bean lifecycle annotations.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5134">JavaFX Composer to Support Grid Container</a></h2>
						<p style="margin-left:8px;">
						JavaFX 1.3 brings the new Grid container which simplifies the organization of controls in form-like layouts. This blog provides an overview of how to make the most of this new container in the NetBeans JavaFX Composer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5136">Getting Started With Creating Workflow Editors</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows how to get started with creating a workflow editor application with the NetBeans Platform. The finished app will show a scene where you can create new nodes and drag nodes to connect them.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5135">Swedish Defense Research on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						When the Swedish Defense Research Agency needed to create a Scenario Tool application they chose the NetBeans Platform. This two-part article documents their experience.</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/2010-06-09.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>