
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 341</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 # 341 - May 13, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1922">Ask the Experts: JRuby Support in NetBeans IDE 6.x</a></h2>
						<p style="margin-left:8px;">
						Got a question about the JRuby support in NetBeans IDE 6? Post it to the Ask the Experts page during the week of May 19 and get answers from three experts: Tor Norbye, Charles Oliver Nutter, and Brian Leonard.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1929">JUG: Pragmatic Java EE 5 Hacking</a></h2>
						<p style="margin-left:8px;">
						Join Adam Bien in Hamburg, Germany on May 19th for "Pragmatic Java EE 5 Hacking - Rethinking Best Practices." After a short introduction into Java EE 5 / Java EE 6, NetBeans Dream Team member Adam Bien will walk you through concepts, patterns, best practices and more for Java EE 5/6. This session will be interactive</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1915">Blogging Contest Winners</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1082&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='61' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						We would like to thank everyone who participated in the NetBeans IDE Blogging Contest! We had nearly 300 entries. The top 10 entrants will receive a $500 American Express gift certificate. The top 100 entrants will receive a NetBeans T-shirt. All winners will be contacted via email in the next two weeks (by May 23) to confirm mailing address. So who won? <a href="http://services.netbeans.org/newsletter/story.php?id=1915">Find out here</a>!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1918">Portal Pack 2.0 is Now Available</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1088&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='76' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The Portal Pack 2.0 final version for NetBeans 6.1 is now available for download. It supports the new JSR 286 portlet specification.There are many new features which will help developers to write portlets quickly using JSR 286(Portlet 2.0) features. These plug-ins are also available at NetBeans 6.1 Auto-Update Center and with Java Tools Bundle Update 5 .</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1924">NetBeans Governance Board Elections - Nominations Open</a></h2>
						<p style="margin-left:8px;">
						It's time to elect the new NetBeans Governance Board. The nomination period is open from May 13-26 and the voting will take place from May 27-June 9. The new governance board members will be announced to the community on June 11, 2008.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1917">Event Recap - NetBeans Day at CommunityOne 2008</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1055&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						One week after the release of NetBeans IDE 6.1, an enthusiastic crowd met to celebrate the fifth NetBeans Day in San Francisco, and the second NetBeans Day to be held at CommunityOne in the Moscone Center. Find out what took place.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1920">NetBeans Day Recorded Video</a></h2>
						<p style="margin-left:8px;">
						If want to do more than read about NetBeans Day @ CommunityOne, you can actual watch the recorded video. Be aware that the footage is a bit rough and shaky but the audio is clear. To watch in sequence with NB Day use the seven USTREAM.tv boxes below the media player. Begin the day from the second row on the far right and advance through the day by playing clips to the left.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1914">blueMarine @ JavaOne 2008</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1083&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='82' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This is an introductory video for blueMarine used at the JavaOne 2008 presentation by Fabrizio Giudici, author of blueMarine and member of the NetBeans Dream Team. This is a beautiful open source digital workflow application that leverages the NetBeans Platform and NASA World Wind.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1921">NekoBean's NetBeans Travel</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1089&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This movie named, NetBeans Travel features NekoBean - A Mascot of NetBeans Japanese community. The author of the movie <a href="http://hibiki.imprix.net/">Hibiki</a>, who is a community member of <a href="http://ja.netbeans.org/">ja.netbeans.org</a>. Thank you Hibiki-san for the cool movie!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1931">New Contribution Coordinator for NB Community Docs: Varun Nischal</a></h2>
						<p style="margin-left:8px;">
						Varun Nischal has been appointed the new Contribution Coordinator for the NetBeans Community Docs program. Varun takes the place of Amit Kumar Saha, who has become an employee for Sun Microsystems India. Varun has already contributed several docs to the program. Welcome, Varun!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1919">2008 Tech Days Hands-On Labs</a></h2>
						<p style="margin-left:8px;">
						Did you miss JavaOne 2008? The hands-on labs (HOLs) from 2008 tech days are available as self-paced labs. You can download the labs and use the step-by-step tutorial to try out new technologies at home.</p>
					</div>
				<h1>Reviews</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1925">NetBeans Extension Makes Simple Work of PHP</a></h2>
						<p style="margin-left:8px;">
						Pan Pantziarka from The Register dives into NetBeans IDE Early Access for PHP. Pan writes, "Having walked through the main NetBeans IDE, I thought it worth looking inside the PHP update to see what it offers one of today's most popular languages."</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1916">NetBeans Ruby IDE: You Thought Rails Development Was Fun Before</a></h2>
						<p style="margin-left:8px;">
						Ed Ort provides a nice summary of a technical session from JavaOne 2008 presented by Tor Norbye and Brian Leonard. If you have not yet tried NetBeans  for Ruby, JRuby, and Ruby on Rails you might want to take another look.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1913">NetBeans as a Scala IDE</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1084&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='69' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Caoyuan's great work on his Scala plug-in is looking more and more impressive. This article is an overview of what you can currently do with Scala in NetBeans IDE, as well as instructions for getting started. For screenshots and more information visit <a href="http://blogtrader.net/page/dcaoyuan/">Caoyuan's Blog</a>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1930">Cloning Using Mercurial In NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						This tutorial by Tushar Joshi shows you how to clone a NetBeans IDE project using Mercurial. Mercurial support is constantly changing in the IDE, and this tutorial shows you how to clone in NetBeans 6.1.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1928">RichFaces in NetBeans: Open Sourced</a></h2>
						<p style="margin-left:8px;">
						The plugin demonstrated at NetBeans Day, for RichFaces support in the IDE, is open sourced on java.net. You are extremely welcome to download the sources, add to them, and contribute them back to the project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1927">Javadoc Analyzer for NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Adam Myatt tells you about a cool tool for analyzing Javadoc, over on NetBeans Zone.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1926">Getting Started with Facelets and Seam in NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						David Salter explains what you need to do to get going with Facelets and Seam in 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1923">NetBeans Talk in Second Life</a></h2>
						<p style="margin-left:8px;">
						Read about the talk Roman Strobl gave in Second Life on the great features in the NetBeans IDE, what cool features are coming, and what new developers should learn about the Java platform.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Robert Demmer<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 class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</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-05-13.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>