<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 318</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 # 318 - Nov 19, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1454">NetBeans IDE 6.0 Release Candidate 1 Available!</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0 Release Candidate 1 is now available for download. The final NetBeans IDE 6.0 release is planned for late 2007. Highlights include a faster, smarter editor, improved Swing development, Ruby/JRuby/Ruby on Rails support, and more. Download it today, and let us know what you think!<br><br>
NetBeans IDE 6.0 <a href="https://netbeans.org/community/releases/60/index.html">Release Page</a><br>
NetBeans IDE 6.0 <a href="https://netbeans.org/kb/60/index.html">Tutorials and Documentation</a><br>
NetBeans IDE 6.0 <a href="http://wiki.netbeans.org/wiki/view/NewAndNoteWorthy">Detailed Feature List</a><br></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1456">AspectJ Plugin Updated for NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						The AspectJ Development Environment (AJDE) module extension to the NetBeans IDE 6.0 is based on AspectJ Version 1.5.3. The module lets you compile AspectJ and Java files within the IDE, browse the structure of your AspectJ program in a tree structure, and by means of annotation markers in the editor gutter and error stripe, set up a compile configuration that determines which files will be passed to the compiler. Both the Aspectj annotation based style and the Aspectj dialect are supported. The module provides basic editor support for the Aspectj dialect.<br><br>
Check out <a href="http://www.jroller.com/ramlog/entry/using_the_aspectj_plug_in1">Ramon Ramos's blog</a> for installation instructions and how to use the AspectJ plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1457">Add Property Module Available in the NetBeans Plugin Portal</a></h2>
						<p style="margin-left:8px;">
						From <a href="http://blogs.sun.com/scblog/entry/add_property_module_on_netbeans">Sandip Chitale</a>, a simple UI to create properties and related boilerplate code. The code generation can be configured with the freemarker template using the <b>Tools:Templates</b> menu item.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1455">NetBeans Day Frankfurt - Dec. 3</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=553&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. For more of what to expect in Frankfurt check out the agenda. <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>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1459">My First JRuby App in Glassfish</a></h2>
						<p style="margin-left:8px;">
						There are a few memorable programming firsts—your first language, your first running application, your first crash.... Let Arun Gupta's screencast help with another first: Developing your first JRuby application in the NetBeans IDE and deploying it on Glassfish—glitch-free, of course.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1465">Using Databound Components to Access a Database</a></h2>
						<p style="margin-left:8px;">
						In this tutorial, use the NetBeans IDE to create and deploy a web application that displays master-detail data from a database that is bundled with the IDE. Then in the application, select a person from a drop-down list, and the application displays a table that shows all the trip records for that person.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1460">Developing a Desktop App With the JRuby & Java Swing APIs</a></h2>
						<p style="margin-left:8px;">
						This Community Docs contribution from <a href="http://blogs.sun.com/branajam/entry/nb_community_docs_spotlight_teera">Teera Kanokkanjanarat</a> has all the right stuff—clarity, visuals, usefulness—as it shows how to leverage JRuby, Swing API and the Netbeans IDE to create a desktop application with the Ruby programming language. Terra has been a NetBeans user since 4.1; he was also a Sun campus ambassador. Learn more about him in this <a href="http://blogs.sun.com/divas/entry/confessions_of_a_netbeans_ruby">interview</a> by the Tutorial Divas.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1462">Full Life-Cycle Support for End-to-End Processes</a></h2>
						<p style="margin-left:8px;">
						The November issue of <i>IEEE Computer</i> is all about Service Orientation; Prakash Narayan and Bernhard Steffen contributed an article that discusses methodologies and platforms that support end-to-end and round-trip engineering experiences at the user level, and how NetBeans can be used to achieve them.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1458">Where are the JSF Pages Wizard & Auto-Comment Tool?</a></h2>
						<p style="margin-left:8px;">
						Two features available in NetBeans 5.5 and 5.5.1: "Generate JSF Pages from Entities" wizard and the auto-comment tool, will be missing in the 6.0 release. Roman Strobl's blog entry explains why this has happened and offers possible workarounds.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1463">Ruby Shortcuts, Screenshots, FAQs & More</a></h2>
						<p style="margin-left:8px;">
						In Tor Norbye's <a href="http://blogs.sun.com/tor/entry/extract_method_introduce_variable_introduce">Ruby Screenshot of the Week</a> he shows off some new quick fix refactorings—extract method, introduce variable, and introduce constant. Arun Gupta provides updated instructions on how to <a href="http://blogs.sun.com/arungupta/entry/mephisto_with_glassfish_v3_gem">deploy Mephisto on GlassFish V3</a>. The Tutorial Divas talk about <a href="http://blogs.sun.com/divas/entry/netbeans_ruby_shortcuts">NetBeans Ruby Shortcuts</a>.  Gregg Sporar answers some <a href="http://weblogs.java.net/blog/gsporar/archive/2007/11/ruby_tuesday.html">frequently asked Ruby questions</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-11-19.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>