
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 391</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 # 391 - May 13, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3657">Join Sun's Developer Cloud: Project Kenai</a></h2>
						<p style="margin-left:8px;">
						Did you know there are over 6,000 developers collaborating on 450 open-source projects hosted on kenai.com? Users of the NetBeans 6.7 Beta already benefit from the IDE's unique Kenai  integration, including access to source code management (Subversion, Mercurial, and Git), issue tracking (Jira and Bugzilla), team wikis and forums, download hosting--and there is even more to come! Join us on <a href="https://kenai.com/people/new">http://kenai.com</a> and start your project today.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3658">Sneak Preview: Java Card tools for NetBeans 6.7</a></h2>
						<p style="margin-left:8px;">
						Ever looked at an ATM card or mobile SIM card and thought, I could run a Java Applet on that? The Java Card is a tiny, secure Java Platform intended for chip cards and other small embedded devices. Tim Boudreau and the Java Card team now created a Java Card plugin for NetBeans IDE 6.7. It's not released yet, but Tim's got some screen shots in his blog to whet your appetite. Learn more in our special session on <a href="http://www28.cplan.com/cc230/session_details.jsp?isid=304639&ilocation_id=230-1&ilanguage=english">Step-by-Step Development of an Application for the Java Card™ 3.0 Platform</a> at JavaOne 2009!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3655">No Fear - Taking the Complexity out of Java EE</a></h2>
						<p style="margin-left:8px;">
						Blogger Brian Silberbauer discusses how when he’s teaching a course on Java EE, he begins with NetBeans. He notes, “This is a great help to the students as it gives them the overview of what we will be working with and shows them how quick and easy it is to create a JEE application in NetBeans - It takes the complexity fear out of them (to a certain extent).” :-)</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3656">Converting Legacy Rails Apps to Grails</a></h2>
						<p style="margin-left:8px;">
						Alex Kotchnev has completed his extensive series of tutorials on how to migrate a legacy Rails application to Grails using the NetBeans IDE. After <a href="http://www.troymaxventures.com/2008/10/converting-legacy-rails-apps-to-grails.html">General Project Setup</a>, and <a href="http://www.troymaxventures.com/2008/10/converting-legacy-rails-apps-to-grails_31.html">Migrating the Domain Objects</a>, he now shows us how to <a href="http://www.troymaxventures.com/2009/05/converting-legacy-rails-apps-to-grails.html">Migrate the Controllers</a>. Next week we will have a look at how to <a href="http://www.troymaxventures.com/2009/05/converting-legacy-rails-apps-to-grails_05.html">Migrate the Views</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3660">Refactor the World!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Refactoring Roundtrip demonstrates all the available refactorings from the NetBeans IDE. The screencast starts with a well-known "Hello World!" application, but it rapidly expands to a real OO application using different refactorings.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3653">Why Are PHP Developers Switching to NetBeans?</a></h2>
						<p style="margin-left:8px;">
						In his review of the PHP support in NetBeans, Charles Ditzel gives thumbs up to all the key features such as syntax highlighting, PHPunit support, code coverage, parameter hints, and the PHP debugger integration. "NetBeans" he adds, "fared especially well in a comparison with other PHP IDEs when it came to code editing and code completion." Check out the tutorials he recommends and get started with PHP!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3654">Debugging Grails in NetBeans 6.7 Beta</a></h2>
						<p style="margin-left:8px;">
						Dean at Grails Blog thinks that NetBeans IDE 6.7 Beta is a great release for the Grails community. He is impressed that “NetBeans' support of Grails functionality is nearly on par with that of IntelliJ 8.1.” In his blog he points out a nifty feature: Did you know you can attach the NetBeans debugger to a Grails application?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3659">My First NetBeans Plugin: UnicodeConverter</a></h2>
						<p style="margin-left:8px;">
						Mina Shokry published his first NetBeans plugin: It allows you to convert Strings containing non-ASCII characters to Unicode format and back. Using unicode strings in Java applications solves common problems of character encoding, and this plugin makes it very easy for you to convert strings on the fly. <a href="http://www.online-brain.com/sites/default/files/com-online_brain-netbeans-unicodeconverter.nbm">Download the plugin</a> from the blog entry's attachment section and try it today!</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<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_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2009-05-13.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>