
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 314</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 # 314 - Oct 23, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1418">NetBeans IDE 6.0 Beta2 Available Now!</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0 Beta 2 is now available for download. Beta 2 comes bundled with MySQL and PostgreSQL drivers, and contains improvements to Ruby code completion and Woodstock 4.1 Build 14.
<br><br>
NetBeans IDE 6.0 features Ruby/JRuby/Ruby on Rails support, enhancements for improved Swing development, a new Visual Game Designer, updated Data Binding support, integrated Profiling, and more. Plus the new installer lets you customize your download preferences--choose the features and runtimes you need in one go.<br><br> There's only one way to discover why NetBeans 6.0 is the only IDE you need: <a href="../../../downloads/index.html">Download it today!</a><br><br>
The final NetBeans IDE 6.0 release is planned for late 2007. As always, we welcome and encourage your feedback about your experience using the NetBeans IDE on our <a href="https://netbeans.org/community/lists/top.html">mailing lists</a> and in your <a href="http://www.planetnetbeans.org/">blogs</a>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1409">Take the NetBeans Database Features Survey!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=498&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='71' width='95' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Database Experts: What database tooling features would you like to see in the next release of NetBeans? The NetBeans Database Team wants your feedback. Your input will help them decide on areas to focus on. The survey will only take a few minutes. And remember, surveys like these help us to improve NetBeans for you!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1412">JFugue Music NotePad Supports JFugue API 3.2</a></h2>
						<p style="margin-left:8px;">
						The JFugue Music NotePad, a graphic music application based on the NetBeans Platform, now runs on JFugue API 3.2. This is the latest release of the JFugue API. The project is a work in progress and is in need of additional participants. Visit the project site for details on how to contribute.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1416">8 Experts, 5 Days, All Your NetBeans Questions Answered!</a></h2>
						<p style="margin-left:8px;">
						Are you new to NetBeans software or have a black belt in Java IDEs? Do you want to know more about the NetBeans 6.0 editor, or if NetBeans is planning to support PHP? Whatever your level of expertise or question, this week is your chance to pick the brains of those who know NetBeans the best!
<br><br>
Starting <b>Monday, October 22 through Friday, October 26</b>, key members of the NetBeans Evangelism team: Judith Lilienfeld, <a href="http://weblogs.java.net/blog/bleonard/">Brian Leonard</a>, and <a href="http://blogs.sun.com/david/">David Botterill</a>, will be taking your questions about the IDE as part of Sun's "Ask the Experts" series. All you need to do is post your questions to the <a href="http://java.sun.com/developer/community/askxprt/">"Ask the Experts" page</a>. Selected questions and corresponding responses from Judith, Brian and David, will be posted periodically throughout the week.<br><br>

If instant feedback is more of your thing, why not try a <b>LIVE</b> chat? On <b>Tuesday, October 23</b>, join five of NetBeans's top engineers for a <a href="http://nettalk.sun.com/bhive/t/1000/chat_details.jsp?content_id=1398&cid=222963">LIVE Net Talk chat</a> about what makes NetBeans software the premier choice for web, enterprise, mobile, and desktop application development.<br><br>

Net Talk Panelists will be:<br><ul>
* Trey Spiva, UML Architect<br>
* Pavel Buzek, NetBeans Architect<br>
* Martin Ryzl, Engineering Manager, Mobility Tools<br>
* David Folk, Product Line Manager, Sun Grid<br>
* Sergey Lunegov , Engineering Manager, SOA Tools
</ul>
<i>Registration is required for Net Talk.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1414">Reserve Your Copy of the New Pro NetBeans 6 Book!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=503&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='83' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans convert and author <a href="http://www.pronetbeans.com/">Adam Myatt</a> has a new Pro NetBeans book: <b>Pro NetBeans IDE 6 Rich Client Platform Edition</b>. This latest release covers the new and updated features of the NetBeans 6.0 IDE and desktop Java development. Myatt is <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1132">convinced</a> his book will make NetBeans converts out of skeptics. He would know--he's a former Eclipse user. Pro NetBeans 6.0 will be available December 2007. Pre-order your copy today!</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1411">10 Handy Editor Shortcuts in NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0 Beta 2 is here and packed full of headline-worthy features that improve developer productivity. But what about the extra little ways 6.0 can help your work, like the cool keyboard shortcuts that can make your life easier or, at least, speed up your coding? In this article, 10 of the coolest keyboard shortcuts are outlined, with an illustrative screenshot accompanying each explanation.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1417">NBTV: NetBeans AML & Collaboration Module</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=501&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;'/>
						codeBeamer's NetBeans ALM and collaboration module brings ALM, project management and communication into the NetBeans IDE. This quick presentation shows a complete change/commit scenario using NetBeans and SVN.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1410">Using Ajax With Ruby on Rails</a></h2>
						<p style="margin-left:8px;">
						In this tutorial, you add Ajax support to a NetBeans Ruby on Rails project. The example shows how to dynamically append comments to a weblog.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1415">NetBeans Application Installer Generator</a></h2>
						<p style="margin-left:8px;">
						Vadiraj Deshpane, based in Bangalore, has recently announced that he and his team are wrapping up the NetBeans Application Installer Generator. In this blog entry, he outlines everything you'll want to know and also provides some pictures to show what you can expect from his installer generator.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1413">Four Ruby Blogs to Read</a></h2>
						<p style="margin-left:8px;">
						Ruby bloggers are an active bunch: Arun Gupta discusses a <a href="http://blogs.sun.com/arungupta/entry/totd_14_how_to_generate#comments">controller-creation bug</a> in a JRuby on Rails application using Rails 1.2.5 on Windows and provides a workaround. Tor Norbye demonstrates <a href="http://blogs.sun.com/tor/entry/ruby_screenshot_of_the_week20">ActiveRecord code completion</a>. The Tutorial Divas provide a chart that shows the <a href="http://blogs.sun.com/divas/entry/chart_for_netbeans_ruby_database">steps for accessing databases</a> using NetBeans Ruby support, which covers various configurations. And Charles Nutter talks about his work on <a href="http://headius.blogspot.com/2007/10/another-performance-discovery-rexml.html">JRuby performance improvements</a>.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Jan Pirek<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-23.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>
