
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 306</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;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 306 - Aug 27, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1322">Introducing the New NetBeans.tv!</a></h2>
						<p style="margin-left:8px;">
						In an effort to better support our growing number of community videos, NetBeans.tv has undergone a major face lift and now includes additional functionality.<br><br>
To celebrate the launch of NetBeans.tv, we hope that you will visit and join the community section of the site. Doing this also means a chance to win prizes! Include your video or photo, tell us how you use NetBeans and why James Gosling should visit you in your hometown.
<br><br>NBTV is just getting started, so if you have content for the other sections of the site contact us using the provided form. Help us grow!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1323">Make NetBeans 6.0 Rock - Join NetCAT 6.0!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=412&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Do you want to help shape NetBeans? Then join NetCAT! NetCAT (NetBeans Community Acceptance Testing program) is a team of select community members who provide feedback on product usability, quality and performance of the NetBeans IDE.<br><br>
NetBeans 6.0 is entering its stabilization phase and we need your help with testing. If you have experience with the NetBeans IDE and want to help make 6.0 the best IDE around, then join NetCAT! All we ask for is your time and effort. But <b>hurry!</b> The deadline for applications is Wednesday, August 29th.</p><br style="clear:both;"/>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1331">Register for NetBeans Day Boston - September 11</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=415&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;'/>
						The first stop on the <a href="https://netbeans.org/community/articles/worldtour/index.html">NetBeans worldTour 2007-2008</a> is Boston! Attend NetBeans Day Boston and discover the latest in developer tools, and how NetBeans can boost your productivity regardless of what type of Java technology development you do or what language you work in. Meet other NetBeans users and experts, and see demos of the next generation of NetBeans software. Learn more about what to expect on NetBeans Day, and remember: <a href="https://www21.cplan.com/pls/pg_sun/reg_sun_std_entry.reg_185X001">Registration is free</a>!<br><br><a href="https://netbeans.org/community/articles/worldtour/index.html">More dates and stops on the NetBeans WorldTour 2007-2008.</a></p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1324">Contest: CODE FOR FREEDOM (India)</a></h2>
						<p style="margin-left:8px;">
						Sun India has launched a unique contest called the "CODE FOR FREEDOM CONTEST" to encourage students in India to adopt open source technologies and contribute to them. NetBeans IDE is one of the open source technologies covered by this contest, so check out the contest details and spread the news, especially if you're a student in India!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1327">Dream Team Profile: Wade Chandler</a></h2>
						<p style="margin-left:8px;">
						Developer Wade Chandler is an admitted NetBeans junky. Find out why he stands by his addiction in this latest installment of the <a href="http://wiki.netbeans.org/wiki/view/NetBeansDreamTeam">NetBeans Dream Team</a> Profile Series.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1329">Demo: Simple Authentication Against a Database</a></h2>
						<p style="margin-left:8px;">
						Check out this Flash demo on authentication (form based) from Anuradha, a community member in Sri Lanka. <br><br><i>Do you have tutorials, Flash demos, or tips & tricks to share with the NetBeans Community? Follow Anuradha's lead and visit the <a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">Community Docs wiki</a> to learn how to contribute.</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1330">Extending the NetBeans Tutorial JSF-JPA-Hibernate Application</a></h2>
						<p style="margin-left:8px;">
						Using the framework of two previous NetBeans tutorials that demonstrate the ease of JSF-JPA-Hibernate application, developer <a href="http://weblogs.java.net/blog/maxpoon/">Max Poon</a> decides to explore the flexibility and power of JSF in the web-tier. This is part one of a multi-part tutorial.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1328">Native Ruby Development on NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						Let Amit Kumar Saha acquaint you with native Ruby development in NetBeans 6.0 with this quick basic tutorial.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1325">How to Write a Groovy Editor</a></h2>
						<p style="margin-left:8px;">
						Schliemann, the new, fast and powerful declarative approach for creating editor features, is being applied to... Groovy. And Geertjan is providing all the code as he writes it. Maybe you can extrapolate from his code to your own language? Especially if you're creating an editor for a scripting language, this new blog series is worth spending some time on.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1326">A Creative Use of the NetBeans Visual Library</a></h2>
						<p style="margin-left:8px;">
						Dream Team-er Fabrizio Giudici, gave NetBeans's Visual Library a try after watching one of Roman Strobl's <a href="http://www.javalobby.org/eps/netbeans_visual_library/">screencast</a>. Giudici's assessment? "The Visual Library is one of the coolest things that the NetBeans guys delivered with NetBeans 6. It is a rich API which allows you to create a sort of "blackboard" where objects can be added, removed, edited, moved, resized, and connected in a visual graph." Read his blog entry for more on how he used the Visual Library to implement a new feature in his open source digital photo management system, <a href="http://bluemarine.tidalwave.it/">blueMarine</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1332">Eclipse Ruined My Day: A NetBeans Switch Story</a></h2>
						<p style="margin-left:8px;">
						Nitin Pai was having a very bad day learning Swing Framework, until he switched to NetBeans 5.5: "I thank God for giving me NetBeans. I don’t know if anyone elsewhere thinks in the same way. But the fact is that it took me just one day to dump Eclipse, and go back to NetBeans. Long live the developers of NetBeans!" Read on to discover what went wrong and how NetBeans saved the day.<br><br> <i>Check out more <a href="https://netbeans.org/switch/why.html">reasons to switch to NetBeans</a>.</i></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-08-27.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>