
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 323</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 # 323 - Jan 07, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1517">Two Days Till NetBeans Day Atlanta! (January 9)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=612&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;'/>
						Register now for the first stop on the NetBeans WorldTour in 2008. Join us in Atlanta's Cobb Galleria Center for a day of <a href="http://developers.sun.com/events/techdays/2008/US_ATL_agenda.jsp">demos and talks</a>, and discover firsthand how NetBeans IDE 6.0 can take your projects to the next level this year!</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1512">Ruby News: JRuby 1.0.3 and Rails 2.0.2</a></h2>
						<p style="margin-left:8px;">
						Last month, JRuby 1.0.3 and Rails 2.0.2 made their debuts. In a recent <a href="http://blogs.sun.com/tor/entry/require_gem">blog entry</a>, Tor writes about the latest development efforts to support these releases and how to grab the NetBeans Ruby updates. He also talks about a quick fix that he added to handle the now obsolete require_gem method.<br><br>
Several people have asked about how to set the Ruby interpreter configuration back to JRuby after they set it to use their own Ruby interpreter. Martin Krauskopf has added a <a href="http://wiki.netbeans.org/wiki/view/FaqRubySettingBundledJRuby">FAQ</a> to show the easiest way to do so.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1513">NetBeans Podcast, Episode #38</a></h2>
						<p style="margin-left:8px;">
						Tune in to hear Roman and Gregg talk about NetBeans 6.0, JasperReports, Groovy support, screencasts, and much more.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1515">Enabling CDC Application Development in NetBeans 6.0 Mobility</a></h2>
						<p style="margin-left:8px;">
						Previous versions of NetBeans Mobility Pack for CDC had the Sun Java Toolkit for CDC bundled into the IDE. However, NetBeans 6.0 requires developers to manually install a CDC platform emulator in order to develop apps for Java ME CDC mobile phones. This installation guide shows how to download, install, and register the toolkit and other popular SDKs for CDC development in the IDE to enable application development for this increasingly popular device platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1510">Video: Accessing Web Services from a Visual Web Application in NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						Building web applications with the NetBean IDE's visual tools is easier in 6.0. Accessing web services is also simpler. This brief demo shows how to build a web application that uses a web service. <i>(Interested in other screencasts about what you can do in NetBeans 6.0, then check out our <a href="https://netbeans.org/kb/60/intro-screencasts.html">archive</a>.)</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1518">Adding a Popup Window to a NetBeans 6.0 Visual Web Page</a></h2>
						<p style="margin-left:8px;">
						The Tutorial Divas have updated their popular pop-up mini-tutorial for NetBeans 6.0 Visual Web projects. The guide offers steps for creating a pop-up window for users to lookup values.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1514">New & Cool in NetBeans 6.0: GUI Builder Updates</a></h2>
						<p style="margin-left:8px;">
						Roman Strobl highlights updates to the GUI Builder in NetBeans 6.0 with this demo that shows how to quickly and easily build data driven applications with the new Matisse and JSR-295 support (bean binding).</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1509">Map Out Your World with AlterSIG (Built on the NetBeans Platform)</a></h2>
						<p style="margin-left:8px;">
						French developer Johann Sorel is the sole driver behind AlterSIG, a Geographic Information Systems (GIS) application for turning geographic data into viewable maps. In this interview, Sorel discusses his introduction to the NetBeans Platform and his work on AlterSIG.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1511">Testing Rails Applications</a></h2>
						<p style="margin-left:8px;">
						All well developed applications are supported by tests. In this entry, Brian Leonard extends the web log he's been building to include some unit, functional and integration tests.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1516">Metro 1.1 with GlassFish v2 UR1 & NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta describes how to install Metro 1.1 on GlassFish v2 UR1 (which comes with Metro 1.0 baked in) for use with the NetBeans IDE 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1519">NetBeans 6.0 Ruby & Rails Cheat Sheet</a></h2>
						<p style="margin-left:8px;">
						Blogger Jason Lapier compiles a list of useful shortcuts and tips in the NetBeans 6.0 IDE for Ruby and Ruby on Rails development.</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/2008-01-07.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>