
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 405</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 # 405 - Aug 17, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4065">Webinar: The Right Time For The New iReport (August 19)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3311&column=image&table=story&type=image/gif&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						With the v3.5 release of the Jaspersoft Business Intelligence Suite, Jaspersoft introduced a major upgrade to iReport and it's companion product, JasperReports. iReport 3.5 features a far more robust and pluggable environment than the original iReport, as well as support for the new functionality of the latest release of JasperReports. Join iReport founder Giulio Toffoli on <b>Wednesday, August 19, 10amPT/1pmET</b>, for an interactive session demonstrating the powerful new features in iReport 3.5.</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4071">Play the Tech Test Train and Learn JavaFX!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3314&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='51' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Get a hands-on introduction to JavaFX technology by playing the Tech Test Train interactive eLearning game—built entirely with JavaFX 1.2 technology. Ride the train, test your knowledge of JavaFX technology, and earn points.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4064">Java EE 6 Pet Catalog with NetBeans, GlassFish & MySQL</a></h2>
						<p style="margin-left:8px;">
						This Pet Catalog app explains a web application that uses JSF 2.0, Java EE 6, with NetBeans, GlassFish v3 preview, and MySQL.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4070">Creating a Simple Orkut Application</a></h2>
						<p style="margin-left:8px;">
						Orkut APIs are now available in Zembly, and using the <a href="https://netbeans.org/kb/docs/websvc/zembly-wag.html">Zembly-NetBeans plugin</a>, developers can consume Orkut APIs to create Orkut apps. This tutorial gives step-by-step instructions on how to create your first Orkut app using Zembly.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4072">Embedded Browser in NetBeans IDE 6.8 Milestone 1</a></h2>
						<p style="margin-left:8px;">
						In NetBeans IDE 6.8 Milestone 1, a browser based on Mozilla XULRunner is now a part of the NetBeans IDE. Read why this is useful for NetBeans IDE users and Platform developers.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4069">When You Blog You Win! Java VisualVM Blog Contest Winners</a></h2>
						<p style="margin-left:8px;">
						The winners of the Java VisualVM Blogging Contest have been announced! Jan Smuk, Kiev Gama and Rejeev Divakaran are the lucky first-place winners of USD$500 gift certificates. Learn about all the other winners and read their winning entries.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4066">Java Store Support for Griffon in NetBeans</a></h2>
						<p style="margin-left:8px;">
						Griffon is a framework for creating Java Swing applications, Web Start applications, and Applets, using the Groovy language. The Griffon plugin for NetBeans IDE 6.7.1 is now ready. It allows you to create Griffon applications in NetBeans IDE, run other standard Groovy scripts used by Griffon from within the IDE, and package applications in single JAR files, making the apps ready for distribution via the Java Store.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4063">Getting Started with Java EE 6 Using NetBeans 6.8 M1 & GlassFish v3</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta's 93rd TOTD (Tip of the Day) shows how to create a simple web application using JPA 2.0 and Servlet 3.0 and deploy on GlassFish v3. Arun expands on the exercise in TOTD <a href="http://blogs.sun.com/arungupta/entry/totd_94_a_simple_java">94</a> and <a href="http://blogs.sun.com/arungupta/entry/totd_95_ejb_3_1">95</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4067">Code Completion for PHP Namespaces</a></h2>
						<p style="margin-left:8px;">
						The NetBeans for PHP blog brings you a brief overview of how to use code completion for namespaced elements in NetBeans IDE 6.8.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4068">How to Reuse an Already Open TopComponent</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Masoud Kalali shows in a code snippet how to reuse an already opened TopComponent in a NetBeans RCP application instead of creating a new one.</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-08-17.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>