
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 285</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 {text-align:center; padding-top:50px; 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;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 285 - Apr 02, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1119">NetBeans Day San Francisco, May 7</a></h2>
						<p style="margin-left:8px;">
						Registration is open for the Biggest NetBeans Day of them all! Monday, May 7 at the Moscone Center in San Francisco. Join fellow NetBeans users, engineers, evangelists, Java luminaries Jonathan Schwartz and James Gosling, and many others for a jam-packed day of all things NetBeans. Come find out why the NetBeans Project continues to earn rave reviews and fans worldwide.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1118">Discover NetBeans at FISL, April 12 - 14</a></h2>
						<p style="margin-left:8px;">
						Could there be a more ideal place to learn about NetBeans, a FREE IDE, than at FISL, one of the biggest free software events in the world? We think not. NetBeans Evangelists and Dream Team members will be presenting at the 8th International Free Software Forum, April 12 - 14 in Porto Alegre, RS, Brazil.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1123">NetBeans Day St. Petersburg & Sao Paulo</a></h2>
						<p style="margin-left:8px;">
						The NetBeans WorldTour is still in full swing with two stops on the map this April: St. Petersburg on April 13, and Sao Paulo on April 18. Mingle with NetBeans experts and enthusiasts. Watch cool demos of available and upcoming features. Pick up a few IDE tips & tricks. Get the latest on NetBeans, and more. The WorldTour is FREE, but space is limited, so reserve your spot today.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1113">Get New Modules from NetBeans Update Center</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=181&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='63' width='60' alt='gears.png' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Do you need server integration that is not part of standard NetBeans distribution? Are you looking for Maven support? Don't waste time  searching elsewhere, connect instead to the NetBeans Update Center.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1117">GWT Support Plugin Graduates from Java.net Incubator</a></h2>
						<p style="margin-left:8px;">
						The GWT4NB project aims to enable developers to take advantage of both the superior support for creating Web Applications built into the NetBeans IDE and the power of GWT (Google Web Toolkit). GWT is an open source Java software development framework that makes writing AJAX applications easy. Write your front end in the Java programming language, and the GWT compiler converts your Java classes to browser-compliant JavaScript and HTML.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1120">Charlie Nutter on Ruby, JRuby, and JRuby on Rails</a></h2>
						<p style="margin-left:8px;">
						According to Java and Ruby export, Charlie Nutter: "Java and Ruby go together very well, a bit like chocolate and peanut butter combinations." Find out what else this scheduled NetBeans Day speaker has to say about Ruby, JRuby, and JRuby on Rails.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1114">NetBeans Tips and Tricks Contest - Win a Book!</a></h2>
						<p style="margin-left:8px;">
						ProNetBeans.com is sponsoring a 'NetBeans Tips and Tricks' contest for the month of April.  Enter to win a brand new copy of the book <i>Pro NetBeans IDE 5.5 Enterprise Edition</i> by submitting a NetBeans tip, trick, or best practice. Contest ends April 31, 2007 at 11:59 PM Eastern time.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1111">Discovering the New 6.0 Keyboard Shortcuts</a></h2>
						<p style="margin-left:8px;">
						When 6.0 comes out, there'll be a new Keyboard Shortcut card, available from the Help menu. However, read this tip to find out how you can locate the new/changed/deleted shortcuts yourself... with a little bit of investigative detective work.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1112">NetBeans Podcast Episode #26</a></h2>
						<p style="margin-left:8px;">
						Tune in to listen to Roman and Gregg talk about NetBeans 6.0 Milestone 8, NetBeans 5.5.1 beta releases, the Jolt! awards, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1122">Using IRB in NetBeans</a></h2>
						<p style="margin-left:8px;">
						The NetBeans 6.0 Ruby module includes the IRB (Interactive Ruby Shell) Console. Generally, IRB is started from the command prompt in the directory containing your scripts. However, in NetBeans, it's launched from the NetBeans installation directory. Brian Leonard has some tips on using IRB in NetBeans.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1115">Introducing the Java Pet Store 2.0 Application</a></h2>
						<p style="margin-left:8px;">
						To help understand exactly what Web 2.0 is and how Ajax works to improve the user experience, the <a href="http://blueprints.dev.java.net/">Java BluePrints program</a> team developed the Java Pet Store 2.0 reference application. This application illustrates how you can use the Java Platform, Enterprise Edition 5 (Java EE 5) to develop an Ajax-enabled Web 2.0 application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1116">VWP:  Using a Drop Down List to Display Data</a></h2>
						<p style="margin-left:8px;">
						Find out how to use the Drop Down List component to display selection data from database tables along with dummy, hard-coded values.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1121">Instant Rails with NetBeans</a></h2>
						<p style="margin-left:8px;">
						As the name implies, Instant Rails gets you up and running with Ruby on Rails in an instant. In this tutorial, Brian Leonard walks users through the steps to use an Instant Rails installation with NetBeans.</p>
					</div>
	<div class="edited">
	This week's 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-04-02.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>