
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 344</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 # 344 - May 03, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2042">NetBeans worldTour at Jazoon 08 (June 23, Zurich)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1211&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;'/>
						Attend Jazoon for a chance to see what's new in the NetBeans IDE. NetBeans team members will demonstrate how NetBeans supports the hottest scripting languages, makes building Rich Internet Applications and applications for mobile phones and PDAs a snap, and how you can reuse existing code from the NetBeans platform to quickly create your own desktop applications. Register today for Jazoon 08 to connect with other community members, interact with the NetBeans team, meet Java luminaries, and have some fun!</p><br style="clear:both;"/>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2048">Students: Final Week to Review NetBeans IDE & Win!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1217&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='75' width='91' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Students, score some much needed cash by using the NetBeans IDE! The steps are easy: <br><ul><ul>
<li>Download <a href="../../../downloads/index.html">NetBeans 6.1</a> and/or <a href="http://www.opensolaris.com/get">OpenSolaris OS</a>.<br>
<li>Test the product and post a review!<br>
<li>Submit the URL of your review before June 6, 2008.</ul></ul><br><br>
You could win the grand prize: a $250 Visa Debit Card, or one of five $100 Visa Debit Cards. Hurry, the contest ends this week!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2043">A Swarm of Pixels Wins Swedish Mobile Game Award</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1212&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						<a href="http://gameawards.se/entry/102">Swarm</a>, a mobile game built with the NetBeans IDE, is one of the winners of the Swedish Game Awards 2008! Swarm is a racing mobile game in which you navigate a swarm of pixels through a maze. Congratulations to team <b>Mazapan</b> (Carl-Johan Sevedag, Henrik Namark and Kian Bashiri) who will also receive a monetary award of 10,000SEK. <a href="http://www.fz.se/filer/?id=6060">Download Swarm.</a></p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2041">Free 20-Week "Ruby on Rails" Online Course - July 15th</a></h2>
						<p style="margin-left:8px;">
						Introducing a new learning opportunity for fans of Sang Shin's Javapassion courses: a free, online 20-week course for Ruby, JRuby, and Rails Application Development, starting from July 15th, 2008.
<br><br>
The course will cover a comprehensive set of topics including Ruby meta programming, Ajax, RESTful Web services, Testing, Integration with Java, and deployment. Attendees will also be exposed to many sample applications. The course will use the NetBeans IDE as a development tool of choice.  For more information, visit the <a href="http://www.javapassion.com/rubyonrails/">Javapassion</a> course website.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2045">Building Collaborative CRUD Applications with ICEfaces & NetBeans</a></h2>
						<p style="margin-left:8px;">
						Learn to build CRUD applications with the latest release of the ICEfaces plugin (1.7) for the NetBeans IDE. The tutorial illustrates all the key concepts needed to build sophisticated collaborative applications with ICEfaces and NetBeans and provides inspiration for future application development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2046">Introduction to SunSpot Development Using NetBeans</a></h2>
						<p style="margin-left:8px;">
						A beginner's how-to for building a simple demo Sun SPOT application in the NetBeans IDE. Sun SPOT (Sun Small Programmable Object Technology) is a wireless sensor network mote (an electronic communication device meant to be the size of a particle of dust) developed by Sun Microsystems.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2047">Vote for Your NetBeans Governance Board Members!</a></h2>
						<p style="margin-left:8px;">
						The voting period has started for the NetBeans Governance Board Elections. From May 27 through June 9, cast your vote(s) for the community members you wish to elect to the Board. The candidates are:<br><br>
Aristides Villarreal<br>
Glenn Holmer<br>
Lim Chooi Hoe<br>
Masoud Kalali<br>
Paul Clevett<br>
Tom Wheeler<br>
Wade Chandler<br><br>
Learn more about the <a href="https://netbeans.org/community/articles/election_profiles.html">candidates</a> and the <a href="https://netbeans.org/about/os/governance.html">NetBeans Governance Board</a>.
<i>Note: You need to be logged into NetBeans.org in order to vote.</i></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2044">Read-Only Editors Mode Module</a></h2>
						<p style="margin-left:8px;">
						Control the editable property of text editors with the Readonly Editors Mode module from <a href="http://blogs.sun.com/scblog/">Sandip Chitale</a>. The initial state of the editable property of text editor is controlled by the <b>Tools:Options:Miscellaneous:Read Only Editors Mode:Open editors in read-only mode</b> option. The user can toggle the read-only mode using the editor toolbar action (button with open/closed lock icon). The default key binding for the toggle action is CTRL+R. <i>Note: Many of Sandip's modules are now available from the <a href="http://plugins.netbeans.org/PluginPortal/faces/MainPage.jsp">NetBeans Plugin Portal</a>.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2049">Updated: VisualVM Series and Other Documentation</a></h2>
						<p style="margin-left:8px;">
						By reader demand, Geertjan Wielenga has updated his VisualVM blog series with the latest VisualVM APIs, as well as the VisualVM API Quick Start. Also his new module <a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=10000">VisualVM Sample Collection</a> provides a set of samples for learning how to use the VisualVM APIs.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2050">Ruby Screenshot of the Week #28: Unit Testing & Color Themes</a></h2>
						<p style="margin-left:8px;">
						There are some new features coming in NetBeans 6.5, and Tor Norbye gives a sneak preview in this blog post.</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 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-06-03.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>