
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 309</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 # 309 - Sep 17, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1367">NetBeans 6.0 Now Available in Beta!</a></h2>
						<p style="margin-left:8px;">
						NetBeans.org is proud to announce the availability of <a href="https://netbeans.org/community/releases/60/index.html">NetBeans IDE 6.0 Beta</a>. <a href="http://dlc.sun.com/netbeans/download/6_0/beta1/"><b>Download</b></a> it now and see why it's the only IDE you need. The focus of NetBeans IDE 6.0 is improved developer productivity through a smarter, faster editor, and the integration of all NetBeans products into one IDE. Highlights of the NetBeans IDE 6.0 release include:<br><br> 
* Swing GUI Builder<br>
* Intelligent Editor <br>
* Ruby on Rails Support <br>
* Visual JSF Design <br>
* Web Services & SOA <br>
* XML Schema Editor, XSLT Designer <br>
And <a href="http://wiki.netbeans.org/wiki/view/NewAndNoteWorthy"><b>more</b></a>.<br><br>
The final NetBeans IDE 6.0 release is planned for late 2007. As always, we welcome and encourage your feedback about your experience using the NetBeans IDE on our <a href="https://netbeans.org/community/lists/top.html">mailing lists</a> and in your blogs!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1359">NetBeans IDE Wins BOSSIE Award!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=442&column=image&table=story&type=image/gif&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='56' width='75' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						InfoWorld has awarded the NetBeans IDE a BOSSIE award for Best Enterprise IDE. BOSSIE stands for the Best of Open-Source Software. The InfoWorld staff concluded: "For its commitment to quality over quantity and for the courage to rip and replace modules to improve developer productivity, we salute the NetBeans team and its stellar IDE."</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1355">NetBeans - The Platform of Babel?</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=444&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Janice Campbell is the Globalization Program Manager at Sun, meaning she's in charge of facilitating and directing all of the language localization efforts for NetBeans. Find out how you can get involved with her team, and why the <a href="http://translatedfiles.netbeans.org/">Translation Projects</a> are so important to the growth of NetBeans!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="">Get on NetBeans.tv, Win a Sony Ericsson z750 Mobile Phone!</a></h2>
						<p style="margin-left:8px;">
						Introduce yourself to the NetBeans community on NetBeans.tv and you just might win one of many cool prizes, including the grand prize: a Sony Ericsson z750 Mobile Phone and dinner with James Gosling! How? Shoot a video or post photos of your city, your work, your friends and yourself, and tell us a bit about yourself. We are looking for the best entries, so get creative!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1363">NetBeans Day Rome & Milan: Sept. 24 & 26</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=455&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;'/>
						Join the NetBeans WorldTour on its European leg in Rome and Milan next week. Mingle with members of the NetBeans team who will demonstrate and discuss new features in NetBeans 6.0, such as Ruby on Rails support and the smarter, faster editor. The WorldTour is FREE, but space is limited so <a href="http://www2.sun.de/dct/forms/reg_it_2208_888_0.jsp"><b>reserve</b></a> your spot today!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1358">jMaki, NetBeans, GlassFish in Rails Conf Europe: Sept. 17</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team will be present at the Rails Conference Europe 2007 (Berlin) the week of September 17. Attend our technical sessions and discover how the NetBeans 6.0 IDE provides a complete development environment for Rails application.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1366">Consuming StrikeIron Web Services in Web Applications</a></h2>
						<p style="margin-left:8px;">
						NetBeans 6.0 Beta includes new functionality that allows users to consume partner web services from the IDE. These services can be consumed from web applications. StrikeIron, a NetBeans partner, hosts web services that solve business problems. This tutorial shows how to use these web services from StrikeIron to build a Visual Web application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1360">Sun Tech Days Event Map: Creating a Real-life RIA Using jMaki</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta's latest screencast shows how to create a real-life RIA using jMaki plugin in NetBeans. What's extra cool about this demo? The end-result is an event map that displays Sun Tech Days venues in an interactive web page. Try it!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1356">Sun IDM Takes NetBeans 5.5 as Their IDE for Development Process</a></h2>
						<p style="margin-left:8px;">
						The 1st session of the free "Sun Java System Identity Manager (with Passion!)" online course will start on September 17th, 2007.
<br><br>
The Identity Manager IDE is a fully integrated NetBeans plugin that was designed to replace the Identity Manager's Business Process Editor (BPE) application.The NetBeans plugin enables you to view, customize, and debug Sun Java™ System Identity Manager (Identity Manager) objects in your deployment.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1357">What Happened to My Shortcuts?</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0 includes many enhancements and new features.  To make room for all of them, the default keyboard shortcuts had to be modified. Gregg Sporar discusses the impact in this blog entry.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1361">A Quick Primer on Java FX</a></h2>
						<p style="margin-left:8px;">
						What is Java FX? What is Java FX Script? Blogger Joshua Marinacci tries to clear some of the confusion surrounding Java FX and what this new language means for the future of application development.</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-09-17.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>