
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 487</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 # 487 - May 16, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6421">Java Magazine - Looking for Technical Women Contributors</a></h2>
						<p style="margin-left:8px;">
						Do you know women working in technology, or are you one? Oracle is launching a new online Java Magazine, and is looking for women contributors for a section called "Java Nation". Submission format can include podcasts, videos or written interviews. Visit Oracle Technology Network's <i>Women in Technology</i> site for more information.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6419">Tips for JavaOne 2011 Session Submissions</a></h2>
						<p style="margin-left:8px;">
						The deadline for submitting papers to JavaOne is only a week away--May 23. Read some tips on how to make your submission(s) stand out to the JavaOne session  committee. Also listen to a <a href="
http://blogs.sun.com/javaspotlight/entry/java_spotlight_episode_27_sharat">Java Spotlight Podcast with Sharat Chander, JavaOne Program Committee Chairperson</a> to learn more about the CFP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6427">Java ME Website New Look and Feel</a></h2>
						<p style="margin-left:8px;">
						Explore the new look and feel of the Java ME website. Download the Java ME SDK and get started with your mobile application development.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6425">NetBeans Platform Gesture Collection Infrastructure Tutorial</a></h2>
						<p style="margin-left:8px;">
						Do you know what your users are doing with your NetBeans Platform application? What windows they open? What actions they commonly invoke? In this tutorial, discover how to analyze usage of your Java desktop application on the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6426">Java ME Getting Started Video Series</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5699&column=image&table=story&type=image/pjpeg&db=services&db_type=pear&id_col=story_id'
		height='110' width='80' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Watch the new Getting Started With Java ME video series to learn how to develop mobile applications using the Java ME SDK. (<i>Login required.</i>)</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6420">JavaFX 2.0 in NetBeans RCP</a></h2>
						<p style="margin-left:8px;">
						Get a quick look at the current state of integration between JavaFX 2.0 and the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6424">NetBeans-Based Logging Software Released by Chinese Energy Firm</a></h2>
						<p style="margin-left:8px;">
						China National Petroleum Corporation has released CIFLOG, a new multi-platform logging software based on the NetBeans Platform, for its oil & gas exploration projects in Beijing.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6428">Visual Proteogenomics Analysis on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						VESPA is a biological science research software for analyzing proteogenomics data. Read about the technical challenges that inspired a migration to the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6422">Tech Tip: Fix Fast Debugger (ruby-debug-ide) on Windows 7</a></h2>
						<p style="margin-left:8px;">
						A solution to make Fast Debugger (a.k.a ruby-debug-ide) work with NetBeans IDE 6.9.1 and 7.0 on Windows 7 and Vista.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6423">JSF 2.0, JPA 2.0 and Bean Validation on WebLogic Server</a></h2>
						<p style="margin-left:8px;">
						Using NetBeans IDE 7.0 to develop a simple JSF 2.0 and JPA 2.0  application deployed on WebLogic Server 10.3.4.</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/2011-05-16.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>