
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 346</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 # 346 - Jun 16, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2042">NetBeans worldTour at Jazoon 08 (June 23, Zurich)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1211&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;'/>
						Attend Jazoon for a chance to see what's new in the NetBeans IDE. NetBeans team members will demonstrate how NetBeans supports the hottest scripting languages, makes building Rich Internet Applications and applications for mobile phones and PDAs a snap, and how you can reuse existing code from the NetBeans platform to quickly create your own desktop applications. Register today for Jazoon 08 to connect with other community members, interact with the NetBeans team, meet Java luminaries, and have some fun!</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2112">New NetBeans Governance Board Elected</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team members Wade Chandler and Tom Wheeler have earned a second term on the NetBeans Governance Board! The third member and Sun Microsystems appointee to the Governance Board will be announced shortly. Congratulations to Wade and Tom and all of our fine nominees!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2111">Varun Nischal - Mining Blogs for Cool NetBeans Tutorials</a></h2>
						<p style="margin-left:8px;">
						Recently, we announced that the NetBeans Community Docs program had gained a new coordinator. Learn more about Varun Nischal, how he contributes to the Community and why great blog entries about NetBeans make him happy. And if you have an insightful blog entry about NetBeans expect to hear from Varun!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2113">Java EE Programming (with Passion!) Graduates 80</a></h2>
						<p style="margin-left:8px;">
						Congratulations to the 80 graduates of Sang Shin's "Java EE Programming (with Passion!)" online course that ended in May. The graduates are attendees who submitted all 22 homeworks during the course. Here are some of what the new JEE programmers had to say about the course which is now in its 13th cycle:<br><br>
<i>"This course is a great and very useful initiative!! I've learned a lot about J2ee fundamentals, excellent for the beginners." - Maciek Opala, Poland</i><br><br>
<i>"Again, many thanks for offering up this program.  It had an excellent course syllabus, with very challenging and interesting lessons. Obviously you put a lot of work into this.  Many thanks for offering up this service!" - LB Corney, USA</i></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2114">Epictetus Database Manager (Built on the NetBeans Platform)</a></h2>
						<p style="margin-left:8px;">
						Konstantin Chikarev is interviewed on Javalobby about a new database manager that is being developed in Moscow. Find out why Chikarev chose the NetBeans Platform and how Epicetus was created.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2106">Guided Tour of ClearCase for NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						With NetBeans IDE 6.1 you can now perform versioning tasks using Rational ClearCase. Get the basic steps involved in using ClearCase in NetBeans IDE and an introduction to some of the new versioning features included in the IDE since version 6.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2108">Debugger Improvements in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Expression Stepping and Heap Walking are two major debugger improvements in the NetBeans IDE. This document offers a quick summary of how to leverage these features for debugging projects.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2109">Checkout Java.net Projects Using NetBeans</a></h2>
						<p style="margin-left:8px;">
						This tutorial provides a visual guide for using CVS support in NetBeans to check-out a project hosted on Java.net.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2107">Using Beans Binding to Search in a Table</a></h2>
						<p style="margin-left:8px;">
						NetBeans technical writer Patrick Keegan has been blogging a lot about beans binding (JSR-295). In this entry, he explains how you can search records in a desktop database app using mechanisms that exist in Swing and the Beans Binding library.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2110">Get Your Plugins into the NetBeans Plugin Manager</a></h2>
						<p style="margin-left:8px;">
						Maybe you have plugins on the NetBeans Plugin Portal. Did you know that it is now possible to get them into the NetBeans IDE's Plugin Manager automatically? First, you'll have to get your plugins verified as explained in this blog entry by Geertjan Wielenga.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2115">New Blog: NetBeans for PHP</a></h2>
						<p style="margin-left:8px;">
						The team behind the development of PHP Support in the NetBeans IDE have started a new blog. Follow their progress as they write about working on features for NetBeans 6.5. And use the blog to give them feedback.</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 class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</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-06-16.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>