
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 329</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 # 329 - Feb 18, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1582">NetBeans Day Hyderabad (February 29)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=692&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 NetBeans WorldTour returns! Join us in Hyderabad, India for a look at what's new and cool in the NetBeans IDE. Registration for NetBeans Day is FREE, but reserve your seats now!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1575">Ruby on Rails QuickStart Seminar - San Francisco (February 20-21)</a></h2>
						<p style="margin-left:8px;">
						Learn to build Ruby on Rails applications using the NetBeans IDE at a two-day Ruby on Rails seminar with Michael Slater and Christopher Haupt, of BuildingWebApps.com and the LearningRails.com. The seminar will let web designers and developers with only minimal programming experience get up to speed in Rails.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1583">NetBeans Innovators Grants - Deadline is March 3!</a></h2>
						<p style="margin-left:8px;">
						Get paid for ideas that help the NetBeans Project! As part of Sun Microsystems' open source initiative, the NetBeans Innovators Grants program will help make your best ideas a reality and reward you. Need hints? Work on a module. Develop an application on top of the NetBeans Platform. Even work on translations. Submit your proposals today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1579">New Update Center for Translation Communities</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=684&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='35' width='45' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans Localization team is pleased to announce the release of a new Update Center for translation communities. The release is the result of a close collaboration with the NetBeans Build Engineering team. Highlights include:<br>
<ul>
<li>Fast and easy installation of translated resources through a localization plugin install.
<li>Updated localization resources are packed to the localization plugin TWICE a day from the resource bundle repository.</ul>
Visit the <a href="http://wiki.netbeans.org/wiki/view/TFLocalizationDevelopmentUC">  Localization Development Update Center wiki</a> for detailed information.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1576">JavaFX Script Plugin for the NetBeans IDE 6.0.1</a></h2>
						<p style="margin-left:8px;">
						An update release of the JavaFX Script plugin for the NetBeans IDE 6.0.1 is available for download from the NetBeans Beta Update Center. This release includes several bug fixes and functionality improvements made to the plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1584">Early Access: Clearcase Integration into NetBeans</a></h2>
						<p style="margin-left:8px;">
						A new plugin for the Clearcase Versioning system is available from the NetBeans 6.1 development update center. Download the plugin and give the NetBeans VCS team your feedback.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1577">Adding and Defining UML Elements...in 99 Seconds</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=682&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;'/>
						This NetBeans.TV video illustrates how to use the UML icons from the Modeling Palette to create interfaces, packages, attributes, and operations in the NetBeans 6.0 IDE.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1581">Real-Life Rails: Develop with NetBeans, Deploy on Linux</a></h2>
						<p style="margin-left:8px;">
						In this article by Mark Watson for DevX.com, find out how to leverage the Ruby and Rails support in NetBeans IDE 6.0, and then learn techniques for deploying Rails applications on a Linux server efficiently.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1580">CRUD Wizard in NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						Adam Bien describes automatic CRUD EJB 3 generation from existing Entities in NetBeans 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1578">Rails Application with PostgreSQL Database Using NetBeans</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta provides steps for creating a Rails application that accesses PostgreSQL database using NetBeans IDE 6.0.</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-18.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>