
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 286</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 # 286 - Apr 10, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1126">Need Another Reason to Attend NetBeans Day San Francisco?</a></h2>
						<p style="margin-left:8px;">
						NetBeans Day is already packed with incentives to come but if you need more motivation check out the cool giveaways! Be one of the lucky attendees and receive a copy of <b><i>Rich Client Programming: Plugging into the NetBeans Platform</i></b>, a <b>1GB USB flash drive</b> preloaded with the latest NetBeans 6.0 Milestone and last but not least a special edition <b>NB 6.0 T-shirt</b> to match. You heard it here first!</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1125">NetBeans IDE 5.5.1 RC Now Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 5.5.1 Release Candidate is available in English and has been localized into simplified Chinese, Japanese, and Brazilian Portuguese. In order to download localizations first go to the 5.5.1 NB download page and then click on Other Systems & Languages.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1124">UML Modeling Module Ships</a></h2>
						<p style="margin-left:8px;">
						The NetBeans 5.5, UML Modeling module is now available for download from the NetBeans Update Center. The module provides UML modeling features to the NetBeans IDE. It allows analysts and designers to design applications using a standard modeling language. Developers are then able to generate source code from the UML model and update the model from changes made in their source code.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1133">Securing Communications in Web Services: A Tutorial</a></h2>
						<p style="margin-left:8px;">
						This tutorial takes you through the process of securing communications between the service's client and server with Sun Java System Access Manager, NetBeans IDE 5.5, and the Java Application Platform Software Development Kit (SDK) with Tools bundle.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1130">A Mobile MSN Project</a></h2>
						<p style="margin-left:8px;">
						Project "tJOP-tJOP" is a Mobile MSN Application that runs on almost every phone (Midp 1.0, Midp 2.0, Symbian). In this white paper, NetBeans community author Mehmet Ecevit shares the 13-month-story of a pure Java project that contains various Java technologies (j2me, j2ee etc.) and how the NetBeans IDE helped make it possible. Get and stay connect to your data (email, o email, news, instant messaging, business reports and charts, and web search) from anywhere. Mehmet has contributed his white paper to the Community Docs Wiki.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1127">New Book Available: Pro NetBeans IDE 5.5 Enterprise Edition</a></h2>
						<p style="margin-left:8px;">
						Hot off the press!  A new book by Adam Myatt that covers NetBeans IDE 5.5 has just been released.  Gregg Sporar has a full review available in his blog entry and if you go to Amazon.com, as announced in <a href="http://blogs.sun.com/geertjan/date/20070405">Geertjan's blog</a>, you can pick up "Rich Client Programming" together with Romain and Chet's "Filthy Rich Clients"... a once in a lifetime offer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1132">Building a Ruby Sample for NetBeans</a></h2>
						<p style="margin-left:8px;">
						We're in the process of creating some sample applications to ship with the NetBeans Ruby module, one of which will be based on the screencast, Putting Flickr on Rails. You can just download and run the sample project (you'll have to set your Flickr API Key), or build it from scratch as documented here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1129">Rails and Database Migrations</a></h2>
						<p style="margin-left:8px;">
						Rails is so easy because the framework defines conventions, which if followed, allow rails to do its magic. This entry is a reprise of an earlier web blog example entry, now brought to you in a more Rails conventional way.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1131">Screencast: Download, Install & Get Started with Sun Web Developer Pack</a></h2>
						<p style="margin-left:8px;">
						This screencast shows download options for the recently released Sun Web Developer Pack. Also find out how to install and get started (including NetBeans plug-in installation).</p>
					</div>
	<div class="edited">
	This week's issue was brought to you by: Robert Demmer<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-10.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>