
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 282</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 # 282 - Mar 12, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1085">NetBeans Day Paris - March 19, 2007</a></h2>
						<p style="margin-left:8px;">
						Brush up on your French for the next stop on the <a href="https://netbeans.org/community/articles/worldtour/index.html">NetBeans worldTour</a>: Paris! 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. Reserve your spot today AND show up early!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1086">NetBeans Day San Francisco - Register Now!</a></h2>
						<p style="margin-left:8px;">
						Registration is open for NetBeans Software Day 2007, which will take place on Monday, May 7, at the Moscone Center in San Francisco. Discover the latest news about the NetBeans IDE and platform; meet James Gosling, Jonathan Schwartz, Rich Green and other Java luminaries; watch demos of the next generation of NetBeans software, and more. NetBeans Day is free, so register now and save the date!</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1083">Advanced Refactoring Talk at JavaOne</a></h2>
						<p style="margin-left:8px;">
						Attending JavaOne and interested in refactoring? Make a note to drop in on a session with Tom Ball. His JavaOne proposal: "TS-9861: Advanced Java Programming Language Refactoring: Pushing the Envelope" has just been accepted. <i>Do you have a JavaOne talk that's received the green light? Let <a href="mailto:Tinuola.Awopetu@sun.com">NB Weekly editors</a> know about it.</i></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1080">NetBeans Governance Board Elections - Voting Begins</a></h2>
						<p style="margin-left:8px;">
						The nominations are in for the NetBeans Governance Board; now it's time to cast your votes for the community members you wish to elect to the board. Visit the <a href="https://netbeans.org/community/articles/nbelections.html">Board Elections</a> page to learn more about the candidates and voting instructions. The voting period runs through March 21, 2007, midnight in the last time zone.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1087">Contribute to NetBeans with the NetBeans Community Docs Program</a></h2>
						<p style="margin-left:8px;">
						Sign up to contribute to NetBeans! The NetBeans Community Docs program lets you write about NetBeans in any form you want: tutorials, white papers, FAQs, tips and tricks, blogs or Flash demos. Visit the <a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">NetBeans Community Docs Wiki</a> to learn how to contribute content and even request contributions.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1081">Translating NetBeans 5.5 for Taiwanese Users</a></h2>
						<p style="margin-left:8px;">
						First came Brazilian Portuguese, now the <a href="http://translatedfiles.netbeans.org/">Translation Project</a> has helped deliver the NetBeans 5.5 IDE in Traditional Chinese. Why is this latest release unique? The translation was a solo effort by James Yu, a PhD candidate in molecular and medical pharmacology.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1082">Free Access to Select Online Training with Sun Learning Services</a></h2>
						<p style="margin-left:8px;">
						Sun Learning Services is offering a selection of FREE web-based courses as a "benefit of membership" associated with the Sun Developer Network. Take advantage of Sun's expertise with free access to recently released online training courses such as: Introduction to Developing Rich Client Applications, Overview of Java Application Security, Overview of XML, Web Services Enabling Technologies, and more. New courses are added each month, so check back frequently.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1088">Community Docs Contribution:  Component Creation at Runtime Tutorial</a></h2>
						<p style="margin-left:8px;">
						Sapankumar Parikh has contributed a tutorial to the Community Docs Wiki: The Component Creation at Runtime Tutorial. Understand the process of creating components and their action events at run time.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1089">Visual Web Pack:  Developing a Media Management Application</a></h2>
						<p style="margin-left:8px;">
						Learn how to develop a media management application using the Visual Web Pack. This article demonstrates how to design the pages and write the code for an application that stores and manipulates media files. The article comes with a working application that you can download and use.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1079">Building Ruby Apps with Derby and NetBeans</a></h2>
						<p style="margin-left:8px;">
						Brian Leonard's tutorial shows how to rapidly produce a web application with NetBeans jRuby and Derby. Does it look familiar? It's a blow-by-blow of Roumen Strobl's <a href="https://netbeans.org/download/flash/jruby_on_rails/jruby_on_rails.html">Ruby on Rails</a> Flash demo, but with a twist--Leonard uses the Derby database that comes with JDK 6 in place of MySQL. (<i>Thanks to <a href="http://cld.blog-city.com/cutting_edge__building_ruby_apps_with_derby_and_netbeans.htm">Charles Ditzel</a> for the tip.</i>)</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1084">Swing Application Framework & Swing Databinding Demo</a></h2>
						<p style="margin-left:8px;">
						Curious about how NetBeans 6 will support JSR-295 and JSR-296? Watch Roumen's latest (and funny) Flash demo about the Matisse GUI Builder.</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-03-12.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>