
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 291</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 # 291 - May 14, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1174">Sun's Java Development Kit (JDK) Source with the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Several more pieces of Sun's Java Development Kit (JDK) have been open-sourced and are now available for you to download, browse, and build. The NetBeans team is working closely with the OpenJDK team to provide tight integration between the source code and the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1180">JavaFX and NetBeans</a></h2>
						<p style="margin-left:8px;">
						JavaFX is a new family of Sun products based on Java technology and targeted at the high impact, rich content market and is initially comprised of JavaFX Script and JavaFX Mobile. <a href="http://openjfx.dev.java.net/">Project OpenJFX</a> is a project of the OpenJFX community for sharing early versions of the JavaFX Script language and for collaborating on its development. Plug-ins are already available through the Update Centers for both NetBeans 5.5 and NetBeans 6.0 Milestone 9. There are install instructions on the <a href="http://openjfx.dev.java.net/">Project OpenJFX</a> site.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1172">Get on TV; NetBeans.TV</a></h2>
						<p style="margin-left:8px;">
						A developer orders a NetBeans CD. The post office fails in getting it to the developer. We send two guys on the road to hand deliver it! Experience the misadventures that takes our wacky guys to three countries meeting NB developers along the way. Watch the trailer that was played at <a href="https://netbeans.org/community/articles/javaone/2007/nb-day.html">NetBeans Software Day</a> or follow their trip entry by entry from the road.
<br>
<br>
<b>What's next? Your video!</b> - Take part in a video competition to win prizes and have Micah & Martin come to your town with their camera bearing gifts. Get your 15 minutes of fame!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1178">New Dynamic Faces Component Library Enables You to Ajaxify Plain Old Java Server Faces Components</a></h2>
						<p style="margin-left:8px;">
						The Update Center now offers a new Dynamic Faces component library that enables you to employ Ajax techniques with Visual Web Pack JavaServer Faces components. Dynamic Faces technology is an extension to the JavaServer Faces framework. Its purpose, in short, is to submit a subset of web page inputs via an Ajax request, execute over a subset of nodes in the server-side component tree, and emit an Ajax response that causes a subset of nodes in the web page Document Object Model (DOM) to be re-rendered.
<br>
<br>
Also available from the Update Center is a Currency Trader sample application that demonstrates the Dynamic Faces technology. To learn more, see <a href="https://netbeans.org/kb/55/vwp-instcurrencytrader.html">Installing the Currency Trader Sample Application</a> available from the <a href="https://netbeans.org/kb/55/vwp-index.html">NetBeans Visual Web Pack 5.5 Documentation page<a>.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1176">Here Is Our Book!</a></h2>
						<p style="margin-left:8px;">
						A FedEx package arrived in Prague, just before many of the NetBeans team departed for JavaOne recently. And what was in it? Read this blog and look at the happy pictures to find out!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1177">Getting Started with NASA's World Wind Java SDK</a></h2>
						<p style="margin-left:8px;">
						Geertjan gives you a step-by-step introduction to World Wind Java SDK in his blog. At the end, 7 steps later, you have the World Wind Globe spinning happily in a Java application. You can zoom and pan as well. And all for three lines of code!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1173">Using NetBeans BPEL, JBI and Web Service Development Features</a></h2>
						<p style="margin-left:8px;">
						NetBeans Enterprise pack 5.5.1 provides several new features in as well as those ones in version 5.5. One of the most important features is related to ESB. Masoud Kalali covers some of NetBeans capabilities to develop application based on the SOA paradigm.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1175">Call for Testing : NetBeans 5.5 Spanish</a></h2>
						<p style="margin-left:8px;">
						The localization team will be releasing NetBeans IDE 5.5 Spanish version this month. Aristides Villarreal Bravo, David Alvarez Leon and great Spanish team in NetBeans translatedfiles project finally completed all UI messages for 5.5. Please help test & provide feedback.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1179">NetBeans Plug-in for Network.com</a></h2>
						<p style="margin-left:8px;">
						Rob Englander developed a NetBeans plug-in that enables access to <a href="http://www.network.com/">Network.com</a> directly from within NetBeans IDE. Rob demonstrated this in James Gosling's Toy Show on Friday at JavaOne 2007. You can see a replay starting around 17 minutes and 30 seconds into <a href="http://java.sun.com/javaone/sf/sessions/general/index.jsp#GS2">Toy Show Part 1</a>. Also of interest is the segment before which highlights Project D-Light which is planned to become a NetBeans module.</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-05-15.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>