
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 288</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 {text-align:center; padding-top:50px; 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 # 288 - Apr 23, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1145">15 Days and Counting Until NetBeans Day San Francisco</a></h2>
						<p style="margin-left:8px;">
						NetBeans Day San Francisco is fast approaching! Register for your spot at the Moscone Center, May 7th, and you are guaranteed: sessions with Java luminaries James Gosling and Jonathan Schwartz, exciting demos of NetBeans 6.0 IDE and more, chats with NetBeans Evangelists and the Java Posse, a NetBeans Toy Show, and chances to win cool giveaways! Registration is FREE. Reserve your space now and get there early!</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1146">Sun Supports Linux Community with Ubuntu 7.04 Release</a></h2>
						<p style="margin-left:8px;">
						Sun and Canonical announce the immediate availability of a complete, production quality Java technology stack and developer tools with the latest release of Ubuntu, v7.04, making it easier for GNU/Linux developers to leverage the Java platform in their applications. The stack is comprised of key popular Java technologies such as GlassFish v1, Java Platform, Standard Edition (JDK 6), Java DB 10.2 and NetBeans IDE 5.5.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1148">Introducing the NetBeans Sample Catalog!</a></h2>
						<p style="margin-left:8px;">
						Browse the all new NetBeans Sample Catalog for a comprehensive collection of NetBeans sample applications spanning the latest enterprise, web, mobile, and desktop technologies. See how you can develop a weblog  in less than 10 minutes using Ruby, create a mobile-to-Web service application using Java ME, and produce UML class diagrams from existing Java code. Get Started with the Top 5 New Samples by visiting the NetBeans Update Center directly within your NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1151">How to Plug Memory Leaks in Java Applications</a></h2>
						<p style="margin-left:8px;">
						Are you plagued by slow-running Java applications? You could have a memory leak. The latest issue of <i>Software Test & Performance Magazine</i> features an article by NetBeans Evangelist Gregg Sporar and A. Sundararajan on how to plug memory leaks in Java applications.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1143">NetBeans Podcast #27 - Interview with Adam Myatt</a></h2>
						<p style="margin-left:8px;">
						Listen in as Roumen and Gregg talk with Adam Myatt, author of the new book <i>Pro NetBeans IDE 5.5 Enterprise Edition</i>.  Several topics are discussed: NetBeans features, Java technologies, technology trends, and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1150">Fun with CrEme Apps</a></h2>
						<p style="margin-left:8px;">
						Can't tell your Fahrenheit from your Celsius? PCM Reddy decided to have a bit of fun with NISCom CrEme VM and NetBeans 5.5.1 RC CDC pack, and created a simple temperature conversion application that he ran on his mobile device. Check out the video demo as well.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1149">Have You Tried NetBeans 6.0 Milestones Yet?</a></h2>
						<p style="margin-left:8px;">
						What's the buzz on the Blogosphere about NetBeans 6.0? Roman comments on the latest development of NetBeans 6.0, reactions of developers who tried the latest milestones and which important features are still getting developed.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1147">Traditional Chinese PlanetNetBeans Blog Site Launched!</a></h2>
						<p style="margin-left:8px;">
						NetBeans users who work in Traditional Chinese now have a destination where they can get and share NetBeans news, tips and more: their own Planet NetBeans site in Traditional Chinese! This new site brings the total number of languages featured on Planet NetBeans to 9. Visit Planet NetBeans to learn more about starting a site in your language.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1144">Community Docs Contribution: Complete SOA Application with NetBeans 5.5</a></h2>
						<p style="margin-left:8px;">
						Antonio Pintus has contributed a tutorial and demo to the Community Docs Wiki: <i>A Complete SOA Application with NetBeans 5.5: From Web Service Creation to BPEL Orchestration.</i> Both the tutorial and demo are a must-see for the NetBeans Community.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1152">Using Hibernate-specific Features with JPA</a></h2>
						<p style="margin-left:8px;">
						The Java Persistence API offers a powerful standard for persisting POJOs. It includes all the most important features which you would expect from an object-relational mapping tool, but there are still some areas where you might need to use vendor-specific features. In this tutorial, learn how to use Hibernate-specific features for validating and querying while using the standard API for the rest.</p>
					</div>
	<div class="edited">
	This week's 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-04-23.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>