
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 452</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 # 452 - Sep 07, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5429">NetBeans at the JavaOne 2010 Conference</a></h2>
						<p style="margin-left:8px;">
						Do you want to see the NetBeans IDE in action at JavaOne? Browse our list of sessions that will feature the IDE. Also make sure to visit the NetBeans booth to talk to the NetBeans team!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5435">A Guide to GlassFish at JavaOne</a></h2>
						<p style="margin-left:8px;">
						Check out this guide for all things GlassFish-related (Sessions, Hands-on-Labs, and BOFs) at the upcoming JavaOne conference.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5434">Running a JavaServer Faces 2.0 Web Application on Oracle WebLogic Server</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how the NetBeans IDE can generate robust and easily maintainable code when generating JSF pages from entity classes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5425">How to Create an SQL Editor in Swing</a></h2>
						<p style="margin-left:8px;">
						A step by step article showing you how you can create your own SQL editor, by assembling it from existing NetBeans modules.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5430">The NetBeans E-commerce Tutorial - Adding Language Support</a></h2>
						<p style="margin-left:8px;">
						The latest installation of the NetBeans E-commerce tutorial series describes how to create multilingual pages for web applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5426">NetBeans RCP Training, September 27, San Francisco</a></h2>
						<p style="margin-left:8px;">
						IT training firm Marakana will hold a 3-day NetBeans RCP training directly after JavaOne, in San Francisco. Learn to leverage the power and simplicity of the NetBeans Platform and create rich client applications. Anton Epple will be leading.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5431">Jaroslav Tulach in London, 14 October</a></h2>
						<p style="margin-left:8px;">
						"NetBeans Platform: No Slides, Just Code!", after the recent very successful NetBeans RCP SkillsMatter event, here is another one, with Jaroslav Tulach, Toni Epple, and Geertjan Wielenga.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5424">How to Lookup without Losing Focus</a></h2>
						<p style="margin-left:8px;">
						Ernest Lotter, fresh from attending a NetBeans Platform training, proposes a new Lookup mechanism for communicating between modules.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5432">3D Animation Builder on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Read about Giovanni Dal Maso's cool new NetBeans Platform application for authoring and publishing complex and fully interactive 3D animations.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5428">Video: Why Use the NetBeans Platform?</a></h2>
						<p style="margin-left:8px;">
						Chris Bohme from PinkMatter.com explains the central benefits of creating desktop applications on the NetBeans Platform</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5427">Video: NetBeans IDE for Blind Programmers</a></h2>
						<p style="margin-left:8px;">
						Andreas Stefik presents project news on extensions to NetBeans IDE that help the blind learn to program.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5433">Inventory System on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Charles Bedon from Colombia presents project news on the latest release of Kuwaiba, the open inventory system created on the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5436">Trip Reports: NetBeans Platform Trainings in South Africa</a></h2>
						<p style="margin-left:8px;">
						There's more than wine in Stellenbosch, South Africa! A NetBeans Platform training was held there recently. Check out pictures on Geertjan's blog. 
<a href="http://netbeanstraining.co.za/">Jumping Bean</a>, a South African-based training firm also organized a 3-day Platform training course in partnership with <a href="http://eppleton.sharedhost.de/">Eppleton</a>.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Geertjan Wielenga<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-09-07.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>