
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 321</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 # 321 - Dec 10, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1496">Sun Announces Open Source Community Innovation Awards Program</a></h2>
						<p style="margin-left:8px;">
						Develop projects that benefit open source communities and get paid as a result! Sun has announced a $1 Million Open Source Community Innovation Awards Program which will foster innovation and recognize the most interesting initiatives within open source communities worldwide. Details on how to participate will be announced mid-January 2008. Stay tuned!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1486">Download JavaFX Script Plugin for NetBeans IDE 6.0 FCS</a></h2>
						<p style="margin-left:8px;">
						The JavaFX Script plugin for the NetBeans IDE 6.0 release is available for download from the NetBeans Beta Update Center. The plugin includes newly added features in the source editor: code folding and code completion, and several bug fixes.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1493">Webinar: Building Java-Based Mobile Applications on Real Devices</a></h2>
						<p style="margin-left:8px;">
						From December 10 - 21, join NetBeans and Mobile Complete technology experts for an on-demand webinar on how to develop and deploy Java-based applications on mobile handsets faster and more efficiently than ever before!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1497">NetBeans at PanamaJUG 2007 - Dec. 13 & 14</a></h2>
						<p style="margin-left:8px;">
						Attend the PanamaJUG Congress and learn about NetBeans 6.0. Members of the NetBeans team—Tomasz Slota, Fabiola Rios, Rodrigo Andueza Gallardo—will be giving presentations. Also, learn about joining the translation efforts for <a href="http://wiki.netbeans.org/wiki/view/SpanishTranslation">NetBeans 6.0 into Spanish</a>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1494">What is Your Favorite NetBeans IDE 6.0 Feature? (JavaLobby)</a></h2>
						<p style="margin-left:8px;">
						There are many who worked behind the scenes to make NetBeans 6.0 the stellar tool that it is. In this JavaLobby feature, they—NetBeans Engineers, Developers, Doc Writers, Dream Team members and Evangelists—tell us their favorite features in the IDE.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1487">Video: Visual Mobile Designer & Web Services in NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						This demo starts with a simple MIDP application on a mobile phone, and adds access to a web service for authorization. Several of the new Visual Mobile Designer features are used while modifying the application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1488">Tor Norbye Uses Live Code Templates in NetBeans Ruby Support</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=587&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;'/>
						Tor Norbye shows a few examples of the live code templates that are available in the NetBeans Ruby Support. See the <a href="http://ruby.netbeans.org/codetemplates-ruby.html">NetBeans Code Templates for Ruby</a> page for a complete list of the templates.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1489">Video: Swing Application Framework & Beans Binding with NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						The Swing Application Framework (JSR 296) and the Beans Binding Framework (JSR 295) provide support for common operations in Java applications. This demo shows how the NetBeans IDE makes it easy to quickly build a desktop application with these frameworks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1490">Connecting to a MySQL Database</a></h2>
						<p style="margin-left:8px;">
						MySQL is a popular Open Source relational database management system (RDBMS) commonly used in web applications due to its speed, flexibility and reliability. This tutorial demonstrates how to configure the MySQL database server on your computer and set up a connection to it from NetBeans IDE.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1492">An Intro to Using AJAX with Rails: Take 2</a></h2>
						<p style="margin-left:8px;">
						In this entry, Brian applies lessons learned to present a better alternative to the AJAX implementation of the Ruby Web Log sample application. No longer is the entire list of comments refreshed, rather a new comment is efficiently inserted into the bottom of the list.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1491">Adding Metro Quality-of-Service to Contract-First Endpoint</a></h2>
						<p style="margin-left:8px;">
						This tip from Arun Gupta explains how to add Reliability and Security to a Contract-First Endpoint using the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1495">Ruby According to Tor, the Divas, Arun & Charles</a></h2>
						<p style="margin-left:8px;">
						Tor Norby gives us another screenshot of the week; this one on <a href="http://blogs.sun.com/tor/entry/ruby_screenshot_of_the_week23">Quick Fix Previews</a>. Arun Gupta writes up his Metro, jMaki, JRuby, and Glassfish <a href="http://blogs.sun.com/arungupta/entry/metro_jmaki_jruby_glassfish_q">Q&A session</a> from presentations that he made in Toronto and Montreal. The Tutorial Divas ask <a href="http://blogs.sun.com/divas/entry/how_do_you_rubh">How Do You Ruby?</a> And, Charles Nutter writes about <a href="http://headius.blogspot.com/2007/12/groovy-in-ruby-implement-interface-with.html">Groovy in Ruby</a>.</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-12-10.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>