
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 311</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 # 311 - Oct 01, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1384">A Plugin to Make You Filthy Rich...</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=473&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='84' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						....with sample codes, that is. There's a new NetBeans 6.0 plugin that installs all the samples from Romain Guy and Chet Hasse's <i>Filthy Rich Clients</i> book straight into New Project wizard. Note: You need to be in a NetBeans 6.0 build, such as Beta 1, to make use of this plugin.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1386">Participate in Intland's codeBeamer-NetBeans ALM Module Project</a></h2>
						<p style="margin-left:8px;">
						<a href="http://www.intland.com/">Intland</a>, a NetBeans strategic partner, is inviting NetBeans users to participate in its <i><a href="https://codebeamer.com/cb/proj/doc.do?proj_id=346">codeBeamer - NetBeans ALM Module</a></i> project. The NetBeans plugin provides a complete view of any codeBeamer artifact and gives the user the possibility of assigning a Source Code commit to an existing Task (SCM Loop).
<br><br>
Interested in participating? Contact <a href="mailto:Jean-Pierre.Berchez@Intland.com">Jean-Pierre.Berchez@Intland.com</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1380">Feature Viewer: A Plugin for Listing Plugins</a></h2>
						<p style="margin-left:8px;">
						Want a quick, printable overview of all the plugins that are installed in your IDE, together with all those that are available in your Plugin Manager? Geertjan Wielenga has created a new plugin that provides this information in a table.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1383">Project Packager Plugin for NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						Thanks to Charlie Hunt, there's a Project Packager plugin available for NetBeans 6.0.  Originally developed by Roman Strobl, the Project Packager plugin allows you to import & export NetBeans projects with ease. You can also e-mail an exported NetBeans project. <br><br><b>Visit the <a href="http://plugins.netbeans.org/PluginPortal/">NetBeans Plugin Portal</a> to get the Project Packager and the other cool plugins mentioned in this issue!</b></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1381">How to Use jMaki on Rails in NetBeans 6.0 IDE</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=470&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='80' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This tutorial shows the steps to building the Rails project described in  an <a href="http://blogs.sun.com/arungupta/entry/screencast_web8_jmaki_on_rails">Arun Gupta jMaki screencast</a>. Add both a Yahoo table and a Dojo table to a page and fill them with data from a database table. Then add two buttons and use the publish/subscribe mechanism so that the buttons can talk to the tables.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1387">Video: NetBeans Ruby Editor Code Completion</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=478&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;'/>
						In this quick NetBeans.tv piece, Tor Norbye demonstrates the code completion feature of the NetBeans Ruby Editor. Visit <a href="https://channelsun.sun.com/category/playlist?id=81">NetBeans.tv</a> for more Ruby tips from Tor and for other cool demos and screencasts.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1385">Running Woodstock JSF Components in Portlet Environment</a></h2>
						<p style="margin-left:8px;">
						This tutorial gives you a brief overview on how to use the Project Woodstock component set and NetBeans to build portlets.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1379">Rails and JPA (Instead of ActiveRecord)</a></h2>
						<p style="margin-left:8px;">
						NetBeans Evangelist Brian Leonard wondered what it would take to replace ActiveRecord with JPA in the classic Ruby on Rails blog demo. Read on to see the results.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1382">Creating Extensible Applications With the Java Platform</a></h2>
						<p style="margin-left:8px;">
						A technical article introducing you to extensibility in Java applications. It makes use of key concepts in the Java Platform and in particular, the NetBeans Platform.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1388">Get the New NetBeans 6.0 Icons and Banner!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=479&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='32' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Promote NetBeans on your websites and blogs with our new collection of NetBeans 6 icons and banners.</p><br style="clear:both;"/>
					</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-10-01.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>