
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 450</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 # 450 - Aug 16, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5359">NetBeans 6.10 Plan</a></h2>
						<p style="margin-left:8px;">
						The NetBeans 6.10 plan is available, including an overview of the release themes and schedule.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5361">NetBeans: Fastest OSGi Container</a></h2>
						<p style="margin-left:8px;">
						Jaroslav Tulach shows that the NetBeans Platform + Equinox equals the world's fastest OSGi container.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5355">Released: NetBeans Platform 6.9 Developer's Guide</a></h2>
						<p style="margin-left:8px;">
						The community project to translate Jurgen Petri's German NetBeans Platform developer's guide has resulted in a brand new book published this week by Packt: "NetBeans Platform 6.9 Developer's Guide". Congrats to all the translators involved in this project!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5356">Released: Wicket Support in NetBeans IDE 6.9.1</a></h2>
						<p style="margin-left:8px;">
						The latest developments of the Wicket plugin are outlined, including the availability of the plugin for Wicket application development in NetBeans IDE 6.9.1.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5349">Using Annotation Processors in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This two-part tutorial demonstrates a built-in support for custom annotation processors. Starting from NetBeans IDE 6.9, you can conveniently specify annotation processors to run with your project and see the results of annotation processing directly in the Java Editor through code completion and navigation.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5358">Configuring a NetBeans PHP Project for WordPress</a></h2>
						<p style="margin-left:8px;">
						The NetBeans PHP Team's blog announces new information about getting started with WordPress via the NetBeans PHP editor.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5352">Bioinformatic Research on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Nils Hoffmann's PhD thesis at the Bielefeld University in Germany, which includes a NetBeans Platform application relating to gas and liquid chromatography mass spectrometers is introduced.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5353">Sustainable Urban Development on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Pablo Estrada from the Universidad de Zaragoza in Spain explains how urban energy demands can be calculated and evaluated via a Swing application created on the NetBeans Platform.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5360">NetBeans Platform at JavaOne</a></h2>
						<p style="margin-left:8px;">
						Anton Epple lists the presentations at JavaOne that will deal with the NetBeans Platform in various ways.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5354">SkillsMatter Video of "Intro to NetBeans Platform"</a></h2>
						<p style="margin-left:8px;">
						SkillsMatter in London has released a 90 minute video recording of a presentation by Geertjan Wielenga and Tim Dudgeon, introducing you to the NetBeans Platform and showing you how ChemAxon's Instant JChem benefits from being based on top of it.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5351">South Africa NetBeans Platform Training</a></h2>
						<p style="margin-left:8px;">
						From the 23rd of August (Johannesburg) and the 1st of September (Stellenbosch) NetBeans Platform Trainings will be held in South Africa. There is still time to register for these courses!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5357">Free NetBeans Platform Training in Goettingen</a></h2>
						<p style="margin-left:8px;">
						A NetBeans Platform Training will be held on 31 August and 1 September at the Source Talk Tage in Goettingen, Germany. The training is free for students, while others will have to pay a small fee.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5350">Munich NetBeans Platform Training</a></h2>
						<p style="margin-left:8px;">
						Open source training organization Eppleton is holding the first of a series of NetBeans Platform trainings in Munich on September 8th, 2010.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5365">San Francisco NetBeans Platform Training</a></h2>
						<p style="margin-left:8px;">
						Directly after JavaOne 2010, a NetBeans Platform training will be held in San Francisco, featuring several members of the NetBeans Platform team and community.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5364">How to Use Hibernate on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Constantine Drabo from Burkina Faso explains how to integrate Hibernate in a NetBeans Platform application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5362">Visual Library Part 1: Creating Widgets</a></h2>
						<p style="margin-left:8px;">
						A simple scenario is shown to illustrate how to create new widgets in a Visual Library scene.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5363">Visual Library Part 2: Connecting Widgets</a></h2>
						<p style="margin-left:8px;">
						The blog series continues, showing how to create more useful widgets and how to connect them together.</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-08-16.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>