
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 330</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 # 330 - Feb 25, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1610">NetBeans Innovators Grants - Submit Your Proposals by March 3!</a></h2>
						<p style="margin-left:8px;">
						Time is running out to submit those fantastic project ideas for the NetBeans Innovators Grants program. <b>The deadline is March 3!</b> Your project can be a module, an application on top of the NetBeans platform, or even non-code related (books or translations). Stumped about what to work on? Browse our <a href="http://wiki.netbeans.org/GrantProjectIdeas">list of project ideas</a>!<br><br>
<i><a href="http://www2.sys-con.com/webinararchive.cfm?pid=wc_02-18-08_souza&registered=on">Listen</a> to Community Manager Bruno Souza discuss the grant program on Sys-con TV.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1606">NetBeans 6.0.1 Bug Fixes Now Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0.1 Patch1 is a small update to the NetBeans IDE 6.0. The update includes several bug fixes in modules for: Mercurial SCM Plugin, GlassFish Integration, IDE Platform, Java, Java EE, Java Persistence, Java Profiler, JSF, Mobility, Ruby and Rails, Struts, UML, Visual JSF, and Web Applications.<br><br>
<i>To obtain the fixes, the NetBeans IDE 6.0 must be installed and running. You can download the fixes through the IDE's Plugin Manager.</i></p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1611">NetBeans Day - Hyderabad (Feb. 29), Sydney (Mar. 6)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=721&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;'/>
						Join us in Hyderabad, India, February 29, and then in <a href="http://au.sun.com/sunnews/events/2008/techdays/index.jsp">Sydney, Australia, March 6th</a>. NetBeans Day is a great way for fans of the NetBeans IDE and new users to keep tabs on updates to the IDE, learn about how the IDE can help their projects, and to mingle with the NetBeans team. Registration for NetBeans Day is FREE, but the seats go fast!</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1609">Order Pro NetBeans 6 Rich Client Platform Edition!</a></h2>
						<p style="margin-left:8px;">
						Author Adam Myatt returns with his second Pro NetBeans book: Pro NetBeans 6 Rich Client Platform Edition. The book covers the new and improved features of the NetBeans IDE 6.0, as well as rich client platform development. Get your copy today from <a href="http://www.apress.com/book/view/1590598954">Apress Books</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1601">Share Your NetBeans Knowledge at NetBeans Zone!</a></h2>
						<p style="margin-left:8px;">
						New and ready for your contributions! NetBeans Zone. A place where you can flaunt your skill and expertise in NetBeans, share your tips, write technical articles, and more. Geertjan Wielenga, one of the NetBeans Zone leaders, has the details to get you started.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1602">Indonesian PlanetNetBeans Site is Live!</a></h2>
						<p style="margin-left:8px;">
						Our 12th PlanetNetBeans language site is live and ready for Indonesian developers! If you blog about NetBeans in Indonesian (or would like to), add your blog to the new site. Click <a href=" http://www.planetnetbeans.org/add.html">here</a> for details.<br><br>
<i>Many thanks to Martinus Ady H for help with this latest addition!</i></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1604">Mozilla Application Add-on Development in NetBeans</a></h2>
						<p style="margin-left:8px;">
						A very cool community contributed tutorial from Siddharth Agarwal. A step-by-step guide to creating add-ons for Mozilla Firefox using the NetBeans IDE 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1607">Getting Started With NetBeans & Native Ruby on Solaris</a></h2>
						<p style="margin-left:8px;">
						Solaris Express Developer Edition (SXDE) 01/08 comes with both a native Ruby implementation and the NetBeans IDE 6.0 pre-installed. This tutorial describes initial configuration steps for a smooth experience using native Ruby with NetBeans in SXDE 01/08.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1605">NetBeans Mobility 6.1 M1 on Macs</a></h2>
						<p style="margin-left:8px;">
						NetBeans Mobility 6.1 Milestone 1 now makes it easier to work with MPowerPlayer. With the IDE, you can add the MPowerPlayer emulator just like any other Java ME emulator. Get the details from Lukas Hasik's blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1608">Reusing NetBeans Plug-ins in Standalone Apps & in the IDE</a></h2>
						<p style="margin-left:8px;">
						Inspired by news of JasperSoft's NetBeans plug-in and the standalone iReport designer tool based on the NetBeans Platform, Technology Evangelist Tim Boudreau goes over a few tips & tricks for those interested in creating similar projects.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1603">Configuring Multiple Ruby Platforms in NetBeans 6.1 M1</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta shows to configure multiple Ruby/JRuby platforms in the NetBeans IDE.</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-25.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>