
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 414</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 # 414 - Oct 26, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4334">NetBeans IDE 6.8 Beta Available for Download!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3481&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans team is pleased to announce the availability of <a href="http://download.netbeans.org/netbeans/6.8/beta/?intcmp=3442"><b>NetBeans IDE 6.8 Beta</b></a>, the first IDE to offer support for the entire Java EE 6 spec! Java EE 6 highlights include support for JSF 2.0/Facelets, Java Persistence 2.0, EJB 3.1 including using EJBs in web applications, RESTful web services, and GlassFish v3. The release also includes improved support for PHP, JavaFX, Project Kenai, Maven, Ruby, and C/C++. <a href="https://netbeans.org/community/releases/68/">Learn more</a>!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4338">VisualVM 1.2 Available for Download</a></h2>
						<p style="margin-left:8px;">
						VisualVM 1.2 introduces many new features, including:
<ul><li>Sampling CPU and memory profiler
<li>Redesigned charts with dynamic tooltips
<li>Enhanced support for jstatd connections
<li>Customizable proxy settings
<li>Using the latest NetBeans Platform and NetBeans Profiler 6.7.1 
</ul>
This release also extends the API for plugins and fixes several bugs, and is available in Japanese and Simplified Chinese.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4341">Java EE and MonkeyBars on Kenai.com!</a></h2>
						<p style="margin-left:8px;">
						Developers can find many cool projects on Kenai.com, including Adam Bien's <b>Java EE Patterns and Best Practices</b>, one of the fastest growing Java EE projects on the service. If you're into Monkeybars, join the <a href="http://kenai.com/projects/monkeybars"><b>Monkeybar project</b></a> to learn more about how to use the library to write GUI apps using JRuby and Swing. And to get more out of Kenai.com check out ways to utilize the <a href="http://kenai.com/projects/kenaiapis/pages/Home">Kenai Web APIs</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4336">NetBeans Governance Has a New Board!</a></h2>
						<p style="margin-left:8px;">
						Congratulations to <b>Toni Epple</b> and <b>Fabrizio Giudici</b>, the two community-elected members of the 17th NetBeans Governance Board! <b>Jeff Rubinoff</b> is the Sun-appointed third member of the board.<br><br>
The NetBeans Team thanks all the terrific nominees (including Ryan de Laplante, Michel Graciano, Tushar Joshi, Annabel Melongo, Kristian Rink) for participating in the election, as well as the community for voting.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4333">Code Assistance Features in the Java Editor</a></h2>
						<p style="margin-left:8px;">
						The IDE has numerous features that make your work more productive and simplify the coding process. This document is a short reference guide that introduces the most important code assistance features of the Java Editor.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4335">Symfony Framework Support in NetBeans IDE 6.8</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates the built-in support for the Symfony framework in NetBeans IDE 6.8 for PHP. It shows how to set up the IDE to use Symfony, how to create a PHP project that uses the Symfony framework, and a number of tips.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4340">How to Create a Cross-Platform Application with NASA WorldWind & NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						A mini tutorial on how to create an application based on the NetBeans Platform that uses the WorldWind Java virtual globe.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4337">Test Your Java Skills with the Java Developer's Quiz (Part 3)</a></h2>
						<p style="margin-left:8px;">
						These quiz questions taken from several java.sun.com articles aspire to reflect the intellectual curiosity and spirit of fun in the Java community. Prepare to be challenged, informed, and entertained.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4339">Empowering Farmers with FarmLinx (NetBeans Platform App)</a></h2>
						<p style="margin-left:8px;">
						Ram Vijapurap, co-founder & technical director of FieldLinx, a New Zealand software design & development firm, discusses how his company uses the NetBeans Platform.</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-10-26.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>