
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 459</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 # 459 - Oct 25, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5664">"You are the Future of Java" - New York, November 4</a></h2>
						<p style="margin-left:8px;">
						Discover the power and flexibility of Java at Oracle Developer Day in New York City. Network with peers, see cutting edge demonstrations from Oracle experts, and code your way through hands-on workshops.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5658">Virtual NetBeans Platform Training at NetBeans User Group Nagpur</a></h2>
						<p style="margin-left:8px;">
						NetBeans User Group Nagpur will host a 2-day NetBeans Platform Certified Training session on November 27th and 28th. The course, led by Geertjan Wielenga, will be conducted via Skype and Webex. Participants from Togo will also be joining the event.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5660">Screencast: NetBeans 7.0 M2 and GlassFish 3.1 Features</a></h2>
						<p style="margin-left:8px;">
						NetBeans 7.0 Milestone 2 comes pre-bundled with GlassFish 3.1. This screencast demos several features that have been added to the build.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5661">Embedding a Visual HTML Editor in the NetBeans RCP</a></h2>
						<p style="margin-left:8px;">
						Step-by-step instructions from Christian Michelsen that outline how to visually design HTML pages on the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5659">How to Integrate EJBs with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Tim Sparg shows how he integrated EJBs into his NetBeans Platform application on Maven.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5662">UDDI Browser on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Interested in SOA? Joseph Okharedia, a student in South Africa, describes an open-source UDDI Browser he is building on the NetBeans Platform!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5663">Selector Based Lookup</a></h2>
						<p style="margin-left:8px;">
						Rémi Emonet describes an extension to the Lookup concept and Jaroslav Tulach responds with this thoughts in the comments.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5666">Account Management Tool on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Creating account management tools is a typical first step when learning Java. But Henning Krüp, a student in Germany describes doing this on the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5665">UNESCO on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						UNESCO has been eagerly awaiting JWebPane, but is now using DJ Native Swing instead, as explained in this blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5667">NetBeans Platform Applications from Argentina</a></h2>
						<p style="margin-left:8px;">
						A list of screenshots, contributed by Gustavo Santucho, of applications created on the NetBeans Platform in Argentina.</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-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>