
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 456</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/appl/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/appl/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 # 456 - Oct 04, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5605">JavaOne 2010 Latin America Call-for-Papers</a></h2>
						<p style="margin-left:8px;">
						Fancy a trip to Brasil? The call-for-papers for <b>JavaOne Latin America 2010</b> is now open! Share your tips and tricks for using Java technology, leveraging the Java programming language, and extending the Java platform. But hurry--the deadline to submit proposals is <b>Friday, October 8th</b>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5606">New NetBeans Poll: When Life Needs "Code Completion"</a></h2>
						<p style="margin-left:8px;">
						Take the latest NetBeans Community Poll and tell us for which real-world scenario you would most appreciate "code completion"!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5600">Jaroslav Tulach & Toni Epple in London - October 14</a></h2>
						<p style="margin-left:8px;">
						In this free SkillsMatter event, Jaroslav Tulach, Toni Epple, and Geertjan Wielenga will introduce you to the NetBeans Platform. <i>(Thursday, October 14, at 18:30)</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5602">Using the NetBeans Debugger Architecture</a></h2>
						<p style="margin-left:8px;">
						When creating a custom editor, providing a custom debugger can be a very powerful feature. Andreas Stefik explains how to get started.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5604">Using JavaFX Graphic Resources in JavaFX Composer</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows how to use NetBeans IDE's JavaFX Composer to handle JavaFX Format graphics in a JavaFX application and animate it.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5608">Getting the Most from Maven in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						James Selvakumar explains in detail all the features that NetBeans IDE provides for Maven developers.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5601">Monitoring Finances on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						In the financial world, it is quite common to have desktop consoles for managing stocks and shares and for analyzing current trading results. Mark Phipps introduces you to an application of this kind on the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5603">Setting up a JRuby on Rails 3 + NetBeans Dev Environment</a></h2>
						<p style="margin-left:8px;">
						Set up a development environment in the NetBeans IDE for JRuby projects with this outline from Manish Chakravarty.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5607">San Francisco NetBeans Platform Training</a></h2>
						<p style="margin-left:8px;">
						A group of students from enterprises in the US attended a NetBeans Platform training in San Francisco. Read this blog entry to find out all about this event!</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> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2010-10-04.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>