
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 358</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 # 358 - Sep 08, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2593">New Multilingual BlueJ Support in NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1786&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Available from the NetBeans Update Center: A new multilingual version of the first full release of the BlueJ plugin for NetBeans IDE 6.1. The plugin replaces the 5.5-based NetBeans BlueJ Edition, and provides a smoother transition for BlueJ users to take advantage of the extensive features in NetBeans. Download the plugin in English, Japanese, Simplified Chinese and Brazilian Portuguese languages.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2594">Patch3 for NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						A new patch is available for NetBeans IDE 6. The update includes bug fixes in modules for BPEL, C/C++, Composite Application, Database, Editing Files, GUI Builder, GlassFish, IDE Platform, Java, Java EE, Java Persistence, NetBeans Plugin Development, Platform, RESTful Web Services, SOA, TAX Library, WSDL, Web Services, XML Productivity Tools, XML Schema Support, XML Tools Java Ext, XML and Schema and XSL Support. <br><br>The release is available in English, Japanese, Simplified Chinese and Brazilian Portuguese languages, and can be downloaded using the NetBeans IDE's Plugins Manager.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2590">See NetBeans at JavaZone 2008 - Oslo (September 17-18)</a></h2>
						<p style="margin-left:8px;">
						JavaZone is the largest developer conference in Scandinavia. Join NetBeans Engineers Karol Harezlak and Lukas Hasik for a presentation about the current state and future of JavaME development. Other recommended sessions include: <a href="http://javazone.no/incogito/session/JRuby+Sm%C3%B6rg%C3%A5sbord.html">JRuby Smörgåsbord</a> with Ola Bini and Charles Nutter, and JavaFX sessions by <a href="http://javazone.no/incogito/session/Adding+Animation+and+Media+to+JavaFX+and+Java+Applications.html">Raghavan N. Srinivas</a> and <a href="http://javazone.no/incogito/session/Project+Hydrazine%3A+JavaFX+Open+Cloud+Computing+Platform.html">Bernard Traversat</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2591">NetBeans Continuous Integration Camp - Munich (September 19)</a></h2>
						<p style="margin-left:8px;">
						Continuous Integration makes team work easier, and today developers are using tools like Hudson or CruiseControl to automate their build and test processes. Join NetBeans users in Heimstetten (near Munich) for a FREE camp that explores good practices, cool tools and team development. <i>(Website is in German.)</i></p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2598">Celsius v5 - Test Hassle Free Mobile Development & Porting Directly from within NetBeans IDE!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1788&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Without leaving the NetBeans environment, learn to easily create mobile applications with the Celsius v5 plugin from Mobile Distillery, a NetBeans Strategic Partner. Automatically port different optimized versions of your applications from a single source code to over 1,000 Java and BREW devices. Celsius takes full advantage of the IDE's tools and with its high level API allows Java developers, even non JavaME experts, to embrace large scale mobile development. Register for FREE Celsius v5 training sessions and get a feel for the Parametric Development Real Experience (a one-month full license included)!</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2596">Creating an Ajax Autocompletion Textfield with Dynamic Faces</a></h2>
						<p style="margin-left:8px;">
						Create, retrieve, update, and delete database rowsets in NetBeans IDE 6.5. This tutorial uses the Woodstock JSF 1.2 Text Field component with Ajax functionality provided by the Project Dynamic Faces component library.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2595">Simple GUI-Based Parser Using StringTokenizer</a></h2>
						<p style="margin-left:8px;">
						Learn how to create a NetBeans plugin that opens in a window of its own. To add functionality to the GUI the user implements a little parser using the StringTokenizer class.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2592">RESTful Web Services and Comet</a></h2>
						<p style="margin-left:8px;">
						Users can interact remotely with a Comet web application. Learn how to build one with Dojo, Java EE technologies, and GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2599">Tech Tip: Create JavaBean Properties Using Code Templates</a></h2>
						<p style="margin-left:8px;">
						Custom code templates make inserting code templates as easy as typing a shortcut. NetBeans Dream Team member Wade Chandler shows three ready-to-use code snippets for creating JavaBean properties.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2597">Testing NetBeans 6.5's UML Support</a></h2>
						<p style="margin-left:8px;">
						Java EE expert Adam Bien gives his first impression of the refactored UML plugin in NetBeans 6.5 (available from the NetBeans 6.5 Update Center).</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2600">NetBeans 6.5 PHP Support & sNews</a></h2>
						<p style="margin-left:8px;">
						Developer Toni Epple puts PHP support in NetBeans 6.5 to the test creating a project with sNews, a lightweight content management system.</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 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>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-09-08.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>