
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 320</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 # 320 - Dec 03, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1477">NetBeans IDE 6.0 Now Available!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=585&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans.org is proud to announce the availability of NetBeans IDE 6.0! Get superior developer productivity with a smarter, faster editor, and the integration of all NetBeans products in one IDE! NetBeans IDE 6.0 features include Ruby/JRuby/Ruby on Rails support, enhancements for improved Swing development, a new Visual Game Designer, updated Data Binding support, integrated Profiling, and more. Discover why NetBeans 6.0 is the only IDE you need: Download it today!<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="https://netbeans.org/features/index.html?cid=921887">Detailed Feature List</a><br><br>
We welcome and encourage your feedback about the NetBeans IDE on our <a href="https://netbeans.org/community/lists/top.html">mailing lists</a> and in your <a href="http://www.planetnetbeans.org/">blogs</a>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1483">NetBeans Magazine Issue Four is Here!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=582&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='82' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Where can you find 62 pages of in-depth technical articles that showcase the new and improved features of NetBeans 6.0? In the latest issue of NetBeans Magazine! Learn about module building with Maven 2 and NetBeans; about using Ruby features for dynamic web development. Interested in profiling? There's a tutorial that applies profiling techniques and best practices. We could go on, but we'd rather you read the magazine and find out!</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1471">Korean Planet NetBeans Launches!</a></h2>
						<p style="margin-left:8px;">
						More developers worldwide are discovering NetBeans and blogging about their experiences. The proof is in the number of language sites we continue to add to Planet NetBeans—our directory of NetBeans-related blogs. And we've just added a new site in Korean! Do you know Korean users who blog about NetBeans? Encourage them to register their blogs with Planet NetBeans!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1482">Video: Three Profiling Features in NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						Get acquainted with three of the new profiler features in the NetBeans IDE 6.0: a drill down graph that makes it easier to see which categories your application is spending time in, profiling points that allow you to control the profiler's actions from within your application, and a heap walker for tracking down memory leaks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1481">Video: Java Editing Enhancements in NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						Discover some of the enhancements and new features in the NetBeans IDE's Java editor, including code completion, code insertion, editor hints, occurrence highlighting, and inline rename. You'll also see the diff viewer, local history, runtime configurations, and some windowing tricks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1476">Getting Started With Ruby & Ruby on Rails</a></h2>
						<p style="margin-left:8px;">
						Let this tutorial by Chris Kutler take you on a whirlwind tour of Ruby and Ruby on Rails application development in NetBeans 6.0. Learn how to use the IDE's Ruby support to perform some of the typical phases of application development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1478">Secure & Reliable Web Services Using Metro/GlassFish</a></h2>
						<p style="margin-left:8px;">
						In this screencast, Arun Gupta shows you how to develop secure and reliable web services using Metro and the GlassFish application server. Metro stands for projects that use JAX-WS reference implementation and WSIT/Tango together.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1479">New Features of NetBeans Mobility Pack 6.0</a></h2>
						<p style="margin-left:8px;">
						For those interested in changes to Mobility features in NetBeans 6.0, Lukas Hasik has compiled a comprehensive list of new and changed features, and discusses their benefits. Screenshots included.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1480">Integrating Seam with Maven, NetBeans & GlassFish</a></h2>
						<p style="margin-left:8px;">
						A four-part series from Wouter van Reeven that explores the possibilities of Maven, NetBeans and GlassFish. In this entry—the last of the articles—van Reeven explains how to setup Seam from a Maven perspective and a NetBeans perspective.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1484">JPDA (Java) Debugger Threads View Enhancements Module</a></h2>
						<p style="margin-left:8px;">
						This module from Sandip Chitale unifies Threads and Call stack view. The module is available for download from the NetBeans Plugin Portal, and more details about its function can be found on <a href="http://blogs.sun.com/scblog/entry/jpda_java_debugger_threads_view">Sandip's blog</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1485">Groovy and Grails in NetBeans</a></h2>
						<p style="margin-left:8px;">
						Martin Adamek works on the Java EE NetBeans team and has been working on a new plugin for Groovy. From his blog: "Groovy and Grails support in NetBeans has been enabled in the Development Update Center."</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-03.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>