
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsleter, Issue # 299</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 # 299 - Jul 10, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1258">Download NetBeans IDE 6.0 Milestone 10 (M10)!</a></h2>
						<p style="margin-left:8px;">
						NetBeans is proud to announce the availability of NetBeans IDE 6.0 Milestone 10 (M10). Additions to Milestone 10 include:<br><br>
* Ruby Debugger enhancements<br>
* Plugin Manager allows you to distribute groups of IDE components<br>
* Visual Designer with a new look and feel<br>
* More Ajax enabled components from Project Woodstock<br>
* Struts 1.3.x files are recognized by the IDE<br>
* UML Source Code Synchronization<br>
* <a href="http://wiki.netbeans.org/wiki/view/NewAndNoteWorthyMilestone10">And More</a><br><br>
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>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1254">NetBeans User Group, Munich - July 12</a></h2>
						<p style="margin-left:8px;">
						Thursday, July 12th, at 7 p.m, there will be a meeting of the NetBeans User Group in Munich. Join other NetBeans users in the Munich area and listen to NetBeans Tech Writer <a href="http://blogs.sun.com/geertjan/">Geertjan Wielenga</a> talk about porting a Java application to the NetBeans Platform.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1252">NetBeans Podcast Episode 31</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.0 Milestone 10 is the big news, but there are additional topics discussed as well: Roman's report from Cologne, support for NetBeans in Spanish and German, a chapter from the platform book, and more.  Tune in to hear Roman and Gregg talk things over.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1257">Contribute to Project Grizzly and Win a T-Shirt!</a></h2>
						<p style="margin-left:8px;">
						<a href="http://grizzly.dev.java.net/">Project Grizzly</a> is looking for contributors and NetBeans users are strongly encouraged to participate. Submit a tutorial and win a t-shirt.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1251">Bienvenida & Willkommen to NetBeans 5.5.1</a></h2>
						<p style="margin-left:8px;">
						The NetBeans community is proud to announce NetBeans IDE 5.5.1 in Spanish and German. These two localizations join the growing list of NetBeans language versions currently available in Japanese, Brazilian Portuguese, Traditional and Simplified Chinese. Read about the efforts of the Spanish and German team, and learn how to join the Translation Project.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1253">An Introduction to using AJAX with Rails</a></h2>
						<p style="margin-left:8px;">
						The Rails framework comes bundled with the Prototype and Scriptaculous JavaScript libraries. In this blog entry, Brian Leonard explains how to use those libraries in a Rails application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1256">New Blog: Land of 1000 Demos</a></h2>
						<p style="margin-left:8px;">
						A new blog from Jeff Stein is devoted to Flash demos on NetBeans, the Sun Java(TM) Composite Application Platform Suite, and other fun products. Check out Demo #1 of a projected <i>1000</i>! Feel free to suggest demos and help Jeff meet his target!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1255">Video: OpenOffice.org Calc Plugin for NetBeans</a></h2>
						<p style="margin-left:8px;">
						You can write various extensions to OpenOffice.org using Java, and the NetBeans IDE makes extending OpenOffice.org very easy. You can add functionality to OpenOffice.org and also create new applications which reuse OpenOffice.org APIs. Watch this 4-minute demo on how to create a new function for the Calc spreadsheet software using the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1249">Java ME development with Solaris x86</a></h2>
						<p style="margin-left:8px;">
						This tutorial provides information about setting up an environment to use Solaris OS for developing Java ME application using BrandZ (Branded Zones), J2ME Wireless Toolkit 2.2 and NetBeans Mobility Pack 5.5. Branded Zones allow Linux applications to run on Solaris unmodified.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1250">Dynamic Data in jMaki Widgets Using JPA</a></h2>
						<p style="margin-left:8px;">
						jMaki provides a rich set of data widgets that can be embedded in a web application. For most of the widgets to be useful, they need to be tied to a database backend. For example, a Table widget displaying data from a stock ticker. Arun Gupta explains the steps to creating a Web application using NetBeans, deployed on GlassFish V2, that contains a jMaki-wrapped Yahoo Data Table widget pulling data from JavaDB.</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-07-10.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>