
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 328</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 # 328 - Feb 11, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1566">NetBeans IDE 6.0.1 Now Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans has released the <a href="https://netbeans.org/community/releases/60/index.html">NetBeans IDE 6.0.1</a>, which is a small update to the NetBeans IDE 6.0. The release includes the following changes:<br>
<ul>
<li>Addition of Japanese, Simplified Chinese, and Brazilian Portuguese localizations
<li>Glassfish V2 is replaced with Glassfish V2 UR1
<li>The integration of several <a href="http://wiki.netbeans.org/wiki/view/NetBeans6.0PatchesInfo">bug fixes</a></ul>
<i>If you have already installed the NetBeans IDE 6.0, you can get these fixes through the IDE's Plugin Manager without downloading the 6.0.1 version.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1569">NetBeans Innovators Grants - Get Paid to Code!</a></h2>
						<p style="margin-left:8px;">
						NetBeans wants your best open source ideas and will pay you for them! The NetBeans Innovators Grants program is part of Sun Microsystems' initiative to give cash awards to open source developers across the globe to work on their favorite Sun-sponsored project. Approved and completed NetBeans projects can receive up to US$ 11,500! <br><br><b>The deadline for the NetBeans Innovators Grant program is March 3. Submit your proposals now!</b></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1572">Solaris Express Developer Edition 1/08</a></h2>
						<p style="margin-left:8px;">
						Sun Microsystems releases Solaris Express Developer Edition 1/08, its free OpenSolaris-based distribution targeted at developers running on x86 systems. Major highlights of this release include:
<ul>
<li>NetBeans 6.0
<li>Integrated web stack (Apache, MySQL, Ruby, Php, PostgreSQL)with start/stop service controller for MySQL and Apache. You can bring up a test MySQL/Apache environment in a matter of minutes—a huge improvement over any previous Solaris release
<li>Interoperability with Microsoft's CIFS protocol</ul>
As always, NetBeans, Sun Studio tools, and other developer tools are automatically installed during OS installation. <a href="http://developers.sun.com/sxde/">Learn more.</a></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1568">NetBeans Podcast, Episode #40</a></h2>
						<p style="margin-left:8px;">
						Tune in to hear Roman and Gregg talk about the NetBeans Innovators Grants program, NetBeans 6.1 Milestone 1, future milestone dates, a recent chat in Second Life, and much more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1571">On the Road with NetBeans in China</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=681&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;'/>
						Catch up with NetBeans Road Crew and their latest adventures in China, where they talk to programmers about the open source movement, explore <i>Hutongs</i>—Beijing's ancient neighborhoods, and debunk a travel guidebook's claims.</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1573">Consuming a MySQL Database in a RESTful Web Service</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows you how to use NetBeans IDE to expose a MySQL database as a RESTful web service endpoint. You will deploy the "sakila" sample database on GlassFish v2 using the RESTful Web Services plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1567">Nick Sieger Uses RSpec with NetBeans Ruby Support</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=677&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;'/>
						<a href="http://blog.nicksieger.com/">Nick Sieger</a> demonstrates behavior driven development using RSpec in the NetBeans Ruby support. He tests the Ruby Weblog application by using the Red/Green refactor cycle of running, modifying, saving, and running tests.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1570">Developing Web Application Using NetBeans 6.0 & Web Stack on SXDE 01/08</a></h2>
						<p style="margin-left:8px;">
						Radhika Gehant discusses how to develop a Web Application with SXDE 1/08 features. Using an existing Web Application tutorial for NetBeans, she demonstrates how to use NetBeans 6.0 with the Web Stack on SXDE 1/08.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1564">Locating the Hidden Hippie in NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						Gregg Sporar explains "hippie" completion—a great (and mysteriously named) feature in the NetBeans IDE's Editor that is often overlooked.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1574">JavaFX Client Invoking a Metro Endpoint</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta shows how a JavaFX client can invoke a Metro endpoint using NetBeans 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1565">What is the Minimal Footprint of a Netbeans RCP Application?</a></h2>
						<p style="margin-left:8px;">
						The NetBeans RCP framework provides infrastructure for building interactive and rich clients. But what is its overhead? How big is the initial footprint? A curious Adam Bien decides to find out.</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/2008-02-11.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>