
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 319</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 # 319 - Nov 26, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1473">Register for NetBeans Day Frankfurt - Dec. 3!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=570&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;'/>
						NetBeans Day Frankfurt is the last stop on the WorldTour for 2007. Join us at the Frankfurt Congress Center for highlights of what's new and cool in NetBeans, such as our support for the hottest scripting languages, and tools and technologies that simplify your work. <a href="http://www.parthen-impact.com/eventure/welcome.do?type=participant&congress=37_40&page=index">Register today!</a></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1475">Develop Rich Client Apps with NetBeans & Swing at Bulgarian JUG - Nov. 28</a></h2>
						<p style="margin-left:8px;">
						A notice to developers in Bulgaria: The Bulgarian Association of Software Developers and the Bulgarian Java User Group (BGJUG) kindly invite you to a seminar: <b>Creating Rich Client Applications Using NetBeans 6.0 and Java Swing</b>. Discover how easy it is to develop Rich Client applications using NetBeans 6.0 and Swing.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1468">NetBeans Community Greenlights NetBeans 6.0!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=565&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='91' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The results of the NetBeans IDE 6.0 Community Acceptance Survey are here: 93% of respondents agree that NetBeans 6.0 Release Candidate is stable enough to move into FCS! Check out the survey results and comments. Thank you for your feedback!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1466">Highlight Boxing Unboxing Varargs Module</a></h2>
						<p style="margin-left:8px;">
						Sandip Chitale has uploaded the Highlight Boxing Unboxing Varargs Module to the NetBeans Plugin Portal. The module reveals where the Java compiler silently applies boxing and unboxing to primitive types and corresponding reference types in your code. It may also help to diagnose mysterious NPEs when a reference type null value is attempted to be unboxed at runtime. Get more details from <a href="http://blogs.sun.com/scblog/entry/highlight_boxing_unboxing_varargs_module">Sandip's blog</a>.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1470">Write a Tutorial for NetBeans!</a></h2>
						<p style="margin-left:8px;">
						Are you brimming with ideas for tutorials, or tips & tricks for working in the NetBeans IDE? The NetBeans Community Docs Program just might be the thing for you. Learn more about sharing your know-how with other NetBeans users in this interview with program manager <a href="http://blogs.sun.com/branajam/">James Branam</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1461">Migrating Netbeans Class Libraries Between Different Versions</a></h2>
						<p style="margin-left:8px;">
						While creating, using, and removing class libraries are easy tasks in NetBeans, moving them from one version of the IDE to another is not for the faint-of-heart. In this tutorial, <a href="http://blogs.sun.com/teera/">Teera Kanokkanjanarat</a> shows you how to get around this sisyphean task.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1474">Writing Unit Tests with NetBeans Ruby Support</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=571&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						From NetBeans TV: Tor Norbye demonstrates writing and running unit tests using the NetBeans Ruby Support in this 3-minute screencast.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1467">Midnight Cookie Tutorial for NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						The Midnight Cookie tutorial has been updated to work with NetBeans 6.0. The tutorial provides an end-to-end scenario for web development in the NetBeans IDE, including internationalization and advanced usage of the HTTP Monitor. A link to the completed sample is also provided. Feel free to pass comments back to the authors, via the link at the bottom of the tutorial, because they're looking for feedback on this one!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1472">New Improvements for Building NetBeans RCP Apps</a></h2>
						<p style="margin-left:8px;">
						Dream Team-er Fabrizio Giudici continues his blog series about optimizing the way large NetBeans RCP projects are built. Plus, get more information about OpenBlueSky, a collection of tools and components factored out of blueMarine, his platform for managing photo flow. And when it comes to blueMarine always expect a cool-looking screenshot!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1469">Getting Your Feet Wet With Java in JRuby</a></h2>
						<p style="margin-left:8px;">
						If you haven't tried calling Java classes from a JRuby application yet, the Tutorial Divas have a simple code snippet to get you started.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1464">Arun Gupta's Tip: Optimizing Metro Stubs</a></h2>
						<p style="margin-left:8px;">
						This tip from Arun Gupta explains how a WSDL can be locally packaged to improve the overall performance of Metro stubs. Arun has many <a href="http://blogs.sun.com/arungupta/tags/totd">more tips</a> to share on his blog "Miles to Go...". Check them out or suggest ones you'd like to see.</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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-11-26.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>