<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 312</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 # 312 - Oct 08, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1392">Download Portal Pack 2.0 Beta</a></h2>
						<p style="margin-left:8px;">
						Portal Pack 2.0 Beta is now available. New features in this release include:<br><br>
* Support for both Portlet 1.0 (JSR 168) and 2.0 (JSR 286 Public Draft 1)<br>
* Option for adding a new Public Render Parameter through UI<br>
* A new wizard to create portlet filters, and more.<br>
<br><br></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1393">NetBeans OpenLaszlo Support Plugin</a></h2>
						<p style="margin-left:8px;">
						The NetBeans OpenLaszlo Support  plugin adds support for <a href="http://www.openlaszlo.org/">OpenLaszlo</a>, a Flash-based Rich Internet Application web framework that allows you to develop RIA applications using XML and Javascript on the UI and Java on the server, without any knowledge of Flash itself. Current features include:<br><br>
* Bundling the OpenLaszlo 4.0.2 library into NetBeans's libraries list<br>
* Recognizing .lzx files as XML and opening them in the XML editor with full Navigator support<br>
* Providing XML code completion, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1398">Resolved: SQE/FindBugs Plugin Issues with NetBeans IDE 6.0 Beta</a></h2>
						<p style="margin-left:8px;">
						The SQE/FindBugs plugin for NetBeans IDE 6.0 Beta 1 has addressed its update center issues. The SQE update center and its plugins can be added to NetBeans IDE 6.0 by following the instructions <b><a href="http://grizzly.dev.java.net/tutorials/sqe-nb6-tutorial/index.html">here</a></b>.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1390">Video:  NetBeans Ruby Debugger</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=485&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;'/>
						Roman Strobl demonstrates the NetBeans Ruby Debugger and highlights many debugging features in this fast-paced screencast.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1391">Building Relationships Between Rails Models</a></h2>
						<p style="margin-left:8px;">
						This tutorial describes how to build relationships (one-to-one and one-to-many) between models in a NetBeans Ruby on Rails project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1396">Secure & Reliable Web Service Using Metro/GlassFish & NetBeans IDE 6</a></h2>
						<p style="margin-left:8px;">
						This screencast from Arun Gupta shows how a Secure and Reliable Web service can be easily developed, deployed and invoked using NetBeans 6.o.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1397">Profiling NetBeans 6.0 with the NetBeans Profiler</a></h2>
						<p style="margin-left:8px;">
						Adam Myatt, author of the Pro NetBeans book series, puts the performance of the NetBeans 6.0 IDE Beta to the test by profiling it with itself. Read on for the results!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1395">Amit Kumar Saha: NetBeans Community Docs Coordinator</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=451&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='109' width='92' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans Community Docs program is growing--<a href="http://blogs.sun.com/branajam/entry/52_community_docs_contributions">52 contributions</a> and counting! To handle the influx of docs--and find more great ones--Community Docs manager James Branam has tapped Amit Kumar Saha to be the Community Docs Contribution Coordinator. Find out more about Amit and about contributing to the Docs program.<br><br>
<i>Welcome to the NetBeans Community Docs Team, Amit!</i></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1394">Meet the New NetBeans Governance Board Members</a></h2>
						<p style="margin-left:8px;">
						The votes have been counted and the new community representatives of the Autumn 2007 NetBeans Governance Board are Wade Chandler and Tom Wheeler, both of the <a href="http://wiki.netbeans.org/wiki/view/NetBeansDreamTeam">NetBeans Dream Team</a>. The third member and Sun Microsystems appointee is NetBeans Evangelist <a href="http://weblogs.java.net/blog/bleonard/">Brian Leonard</a>.
Congratulations to Wade, Tom and Brian, and to all our fine nominees!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1399">NetBeans Day Shanghai - October 25, 2007</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=488&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The <a href="https://netbeans.org/community/articles/worldtour/index.html">NetBeans WorldTour</a> lands in Asia in two weeks! Join the NetBeans team and fans at the Shanghai International Convention Center on October 25 to discover why NetBeans is the only IDE you need. The WorldTour is FREE, but space is limited so reserve your spot today!<br><br></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1400">NetBeans at SubConf 2007, Munich, Germany</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans Developers Arseniy Kuznetsov, Tomas Stupka, and Maros Sandor at the Subversion Conference 2007, October 16, in Munich, Germany.<br><br>
NetBeans IDE 6.0 comes with built-in support for Subversion. Their presentation: <i>Subversion and NetBeans: Integration Matters</i>, 
 will focus on the advantages of tight integration of Subversion tooling into common IDE workflow. Learn how to work effectively on versioned projects including initial setup, an optimized 'Edit, Diff, Commit' cycle, solving common source code archeology cases such as searching for commits and making clean rollbacks or backports--and more.</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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-10-08.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>