
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 362</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 # 362 - Oct 06, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2725">NetBeans Day Seoul, South Korea - October 17</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1913&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='77' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans Day Seoul is less than two weeks away and seats are filling up fast! Register now to be a part of the NetBeans Deep Dive on October 17. The day will offer a preview of enhanced support for scripting languages such as PHP and Groovy in NetBeans 6.5, web application development with Javascript, and more. Attend and network with the NetBeans team and other developers. Registration is FREE.</p><br style="clear:both;"/>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2727">NetBeans 6.5 Localization Plugins Available!</a></h2>
						<p style="margin-left:8px;">
						Good news for NetBeans Translation Teams: Localization plugins are now available for NetBeans 6.5! With a few clicks it is now possible to get the latest changes committed by translation communities to the Mercurial repository. Additional details can be found on <a href="http://blogs.sun.com/katakai/entry/l10n_dev_l10n_uc_6">Masaki Katakai's blog</a> and the <a href="http://blogs.sun.com/netbeansfr/entry/localization_update_centre_le_centre">NetBeans French blog</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2726">Q&A with Lorent Foret, IvyBeans Developer & Innovators Silver Award Winner</a></h2>
						<p style="margin-left:8px;">
						Developer Lorent Foret's IvyBeans project nabbed a silver medal award in the NetBeans Innovators Grant contest. In this interview, discover how he used the NetBeans IDE for his project, his reaction to his win, and plans for his windfall.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2728">Cross Your T's, Dot Your I's - Guidelines for NetBeans Community Contributions</a></h2>
						<p style="margin-left:8px;">
						Since its inception the NetBeans Community Docs has amassed an impressive 220 community-authored tutorials, and the contributions continue to flow in! Do you have a tutorial to submit? The program now has a style guide to help get your tutorials in perfect form to be published on NetBeans.org and read by the community. Check it out.
<br><br>
<i>Many thanks to Catherine Pawlick, a Sun Microsystems editor based in St. Petersburg, Russia, for creating the guidelines.</i></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2721">Enhancing a Structured Document Using jQuery</a></h2>
						<p style="margin-left:8px;">
						Learn to enhance the usability and appearance of structured web documents using the jQuery JavaScript library in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2722">Understanding Scope and Managed Beans</a></h2>
						<p style="margin-left:8px;">
						Develop a web application using the NetBeans IDE 6.5's  Visual Web functionality that demonstrates the request scope, session scope, and application scope of a web application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2723">Converting and Validating Web Application Data</a></h2>
						<p style="margin-left:8px;">
						In this tutorial validate web application input against specified criteria and convert data between two formats using Visual Web JSF coverters and validators.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2724">Tech Tip: NetBeans Platform Ant-based Build System Trick</a></h2>
						<p style="margin-left:8px;">
						The flexibility of the NetBeans Platform's Apache Ant-based build system allows developers many leeways. Take advantage of this flexibility with a tech tip from Tonny Kohar that overrides the build-zip ant target to let you add your own files.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2729">Playing with SVG Rich Components in NetBeans Mobility 6.5</a></h2>
						<p style="margin-left:8px;">
						NetBeans Visual Mobile Designer Karol Harezlak gives a visual (could it be anything else?) overview of a few new features in NetBeans Mobility 6.5.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2730">All You Ever Wanted to Know About Compile On Save</a></h2>
						<p style="margin-left:8px;">
						Compile on Save in NetBeans 6.5: What it is and what it is not. The NetBeans Quality Assurance team blog links to documents that have answers and that  clear up any confusion about if Compile on Save is for you.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2731">Feedback Needed: NetBeans.next and DB Schema Management</a></h2>
						<p style="margin-left:8px;">
						NetBeans 6.5 is around the corner, but we're already looking ahead to the next big release. David Van Couvering is conducting research on database tooling in NetBeans.next and would like feedback from users about Schema Management. Get more details from his blog.</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-10-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>