
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 290</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 # 290 - May 08, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1164">NetBeans IDE 6.0 Preview (Milestone 9) Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans is proud to announce the availability of NetBeans IDE 6.0 Preview (Milestone 9). Many of the new features of 6.0 have been implemented in M9. Highlights include: Ruby/JRuby/Ruby on Rails Support, a Smarter and Faster Editor, Integrated Profiling and more. Download NetBeans 6.0 Preview, check it out and give us feedback!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1166">NetBeans Magazine Issue 3 Now Available</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=238&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='108' width='80' alt='nb-magazine-issue3-small.jpg' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						To commemorate the largest NetBeans Day ever, we’ve put together a special issue of NetBeans Magazine with a whopping 84 pages of in-depth technical articles! Issue Three showcases the flexibility and versatility of the IDE and Platform, and the upcoming features in NetBeans 6.0. You can view the magazine as a whole or as individual articles. And now you’re also able to access simplified HTML versions of each article (but you’ll want to look at the PDFs for the full visual experience!)</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1160">GlassFish Contest: FISH FOR A FLAT SCREEN TV</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=232&column=image&table=story&type=image/gif&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='l2_glassfish-blogger.gif' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Blog about GlassFish for a chance to win a 52-inch LCD HD TV! How? Download and install Java EE 5 SDK Update3 Preview or GlassFish v2, try its new and exciting features, blog about the experience and provide a link to your blog entry. The contest starts May 1 and ends June 15, 2007.</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1169">Report: NetBeans Software Day 2007 in San Francisco</a></h2>
						<p style="margin-left:8px;">
						What happens when 1000 NetBeans enthusiasts gather together in one massive center? Take a look back at a successful NetBeans Day!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1168">NetBeans Sprouting New Features</a></h2>
						<p style="margin-left:8px;">
						The preview release of the NetBeans IDE 6.0 leaves very little doubt that NetBeans has come a long way since its early days as Xelfi. Check out two recent press articles that examine the IDE's growth and new features: <a href="http://www.sdtimes.com/article/special-20070501-01.html">Software Development Times'</a> write-up of NetBeans's evolution and <a href="http://www.infoworld.com/article/07/05/04/netbeans-ruby_1.html">InfoWorld's</a> preview of scripting support in NetBeans 6.0.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1170">Blogging from NetBeans Day San Francisco 2007</a></h2>
						<p style="margin-left:8px;">
						What were the <a href="http://weblogs.java.net/blog/gsporar/archive/2007/05/netbeans_day_sa_1.html">highlights</a> of this year's NetBeans Day San Francisco? Was it the banter between Jonathan Schwartz and Rich Green during the <a href="http://blogs.sun.com/geertjan/entry/netbeans_day_2007">keynote</a>? The LIVE <a href="http://blogs.sun.com/roumen/entry/notes_from_netbeans_day_in">podcast</a> with the Java Posse? Demos of new features in NetBeans 6.0? Diving for stress balls? Attending a partner session? Getting a first look at NetBeans TV and the third issue of <a href="http://weblogs.java.net/blog/felipegaucho/archive/2007/05/interview_with.html">NetBeans Magazine</a>? Or the demo of D.O.R.K v1.1 Beta? Get the details and <a href="http://blogs.sun.com/lukas/entry/javaone_2007_day_0">pictures </a>from blog entries written by some of this year's attendees. And find out what D.O.R.K means!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1167">NetBeans 6.0 Preview: Building a Java Desktop Database Application</a></h2>
						<p style="margin-left:8px;">
						Now that NetBeans 6.0 Preview Build is available, why not try putting some of the available features to work? This tutorial that shows how to create a desktop Java application through which you can access and update a database takes advantage of support in NetBeans IDE 6.0 for the following technologies: Java Persistence API, Beans Binding (JSR-295) and the Swing Application Framework (JSR-296).</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1165">An Introduction to Intland's CodeBeamer Module for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Looking to manage software development projects effectively and maintain developer productivity, devnull software inc. decided to pair the NetBeans IDE with <a href="http://www.intland.com/">Intland's CodeBeamer</a>. Read more about the inception of the project, how the two tools were selected, and what benefits were realized from using them.</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-05-08.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>