
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 303</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 # 303 - Aug 06, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1301">NetBeans World Tour 2007-2008: Meet the Only IDE You Need!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans World Tour is back for another great season! After a thrilling JavaOne finale in San Francisco in May, the tour took a brief break to rev up for 2007-2008. You'll be glad we did.<br><br>
We are back with 14 destinations around the globe this new season! This means there is a NetBeans Software Day for everyone. Join us again as we come to you with demos of upcoming features, IDE tips & tricks, special guests such as James Gosling, and more.<br><br>
The first stop on the World Tour this season? <b>BOSTON!</b> As always, <a href="https://www21.cplan.com/pls/pg_sun/reg_sun_std_entry.reg_185X001">registration</a> for NetBeans Day is free!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1297">First Flash Demo Using the NetBeans IDE in Brazilian Portuguese!</a></h2>
						<p style="margin-left:8px;">
						Paulo Canedo Costa Rodrigues, a member of the Brazil NetBeans localization team, created a demo in Brazilian Portuguese using the localized NetBeans IDE 5.5.1!<br><br>
The tutorial: "Using Java Persistence with NetBeans to Create a Simple Application" shows how to use the Java EE Persistence API, and how to install new components for NetBeans 5.5.1 using Apache Derby as an example. By the end of the tutorial, the user will be able to easily create a simple price list application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1300">Dilbert Plugin For NetBeans</a></h2>
						<p style="margin-left:8px;">
						A daily dose of humor delivered through your NetBeans IDE? Evangelist Roman Strobl has created a plugin that displays the latest Dilbert comic strip in your NetBeans IDE. The Dilbert plugin is available from the <a href="http://plugins.netbeans.org/PluginPortal/faces/MainPage.jsp">Plugin Portal</a>.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1295">Installing NetBeans on Ubuntu Desktop</a></h2>
						<p style="margin-left:8px;">
						A Community Docs contribution from Lee Tambiah. This quick guide shows you how to install NetBeans on your Ubuntu desktop.<br><br>Do you have tutorials, Flash demos, or tips&tricks to share with the NetBeans Community? Visit the <a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">Community Docs wiki</a> to learn how to contribute.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1299">Adding Functionality to Buttons: A Beginners Guide</a></h2>
						<p style="margin-left:8px;">
						A quick beginners' guide to building a simple GUI with back-end functionality. The application created? A simple but functional calculator.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1294">Instant JChem: An IDE for Scientists, Built on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Code. Chemical structure. Developers and scientists appear to have little in common, right? Turns out they need a similar tool to manage their data: an integrated environment. Learn about <a href="http://www.chemaxon.com/instantjchem/">Instant JChem</a>, a development and database management tool for scientists built on the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1293">Get to Know the NetBeans Test Tools</a></h2>
						<p style="margin-left:8px;">
						The time has come to test your Java application, but are you aware of all the various tools that the NetBeans IDE puts at your disposal? And it's a lot more than just JUnit. Read this blog entry by Geertjan Wielenga, where he introduces you to the NetBeans testing tools and a lot of helpful links for further reading.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1298">Screencast #Web4: Display RSS Feed in jMaki Widgets</a></h2>
						<p style="margin-left:8px;">
						This screencast from Arun Gupta shows you how to pull an RSS feed from a blog entry and display it in two different jMaki widgets. The NetBeans IDE is used for tooling and the jMaki-enabled web application is deployed on GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1296">VW Flash Demo: Setting Up Page Navigation</a></h2>
						<p style="margin-left:8px;">
						Learn how to set up page navigation using the NetBeans Visual Web 5.5 in this multi-part Flash demo from Community Docs manager James Branam.</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-06.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>