
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 437</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 # 437 - Apr 29, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5018">NetBeans IDE 6.9 Stabilization Update</a></h2>
						<p style="margin-left:8px;">
						Since 2004, every NetBeans release is Beta tested by a group of 60-90 volunteers who enjoy playing with new features in their daily development and providing early feedback: We call them the NetCAT team. Other community members prefer contributing code, they are the NetFIX team. Learn more about these efforts in this article by Jiri Kovalsky.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5019">Movie: Interview with Gunnar Reinseth, NetBeans Platform Expert in Norway!</a></h2>
						<p style="margin-left:8px;">
						While in Oslo recently, Toni Epple and Geertjan interviewed NetBeans Platform developer Gunnar Reinseth. The topics discussed include, of course, NetBeans Platform, but also modularity, GlassFish, OSGi, EMF, and much much more. Enjoy!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5012">New French NetBeans IDE & NetBeans Platform Articles</a></h2>
						<p style="margin-left:8px;">
						Mike Francois has started translating and writing articles about the NetBeans 6.9 Platform, and about using NetBeans IDE 6.9 with OSGi and Java Mail. If you want to join Mike in this translation effort, feel free to post articles and translations in your language on dzone or the wiki.netbeans.org!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5017">Norway's Institute of Marine Research Gets NetBeans Platform Certified</a></h2>
						<p style="margin-left:8px;">
						Toni Epple and Geertjan Wielenga completed the delivery of the training/workshop at the Institute of Marine Research (IMR) in Bergen, Norway. The first three days were spent doing the NetBeans Platform Certified Training, followed by a very intensive  2-day workshop. Then it all turned into a hands-on porting session: Read more about this successful adventure.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5015">Getting Started with Contexts and Dependency Injection and JSF 2.0</a></h2>
						<p style="margin-left:8px;">
						Contexts and Dependency Injection (JSR-299) provides an architecture that allows Java EE components such as servlets, enterprise beans, and JavaBeans to exist within the lifecycle of an application with well-defined scopes. This is a demonstration of how to set up a JSF 2.0 project with CDI support in NetBeans IDE 6.9.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5014">Polish JUG on NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						The Polish JUG organized a NetBeans Platform Certified Training, which was held over the last few days in Krakow (Poland) by Anton Epple, Karol Harezlak, and Geertjan Wielenga. If your Polish is up to it, you can read all about this training on the Polish JUG site.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5010">Tech tip: Localizing JavaHelp in NetBeans Platform Applications</a></h2>
						<p style="margin-left:8px;">
						This tip is very handy to anyone localizing their JavaHelp sets who wants to test the localized versions of the docs live in the application during development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5011">How to Use States in a JavaFX Application</a></h2>
						<p style="margin-left:8px;">
						In JavaFX, a state represents a set of property values in your application. If you switch to another state, new values are assigned to all the components. Using states, it is easy to create multiple screens, zoom effects, sidebars, etc. This blog also contains some best practices how to work with the master state.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<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-04-29.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>