
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 381</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/appl2/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/appl2/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 # 381 - Mar 02, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3344">NetBeans 6.7 Milestone 2 Now Available for Download!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Team is pleased to announce Milestone 2 of the NetBeans IDE 6.7. The release includes improvements and enhancements to several features: Maven and C/C++ support, the Profiler, SVG components and more.
<br><br>
With this release, the IDE now gives users the option of activating only functionality they want to use. An enhanced self-diagnostic tool lets users review performance issues, or send a report to the NetBeans team for analysis. The MAC OS X look-and-feel has also been given a cool update. Find out more about what's <a href="http://wiki.netbeans.org/NewAndNoteworthyMilestone2NB67">new and noteworthy in the release</a>, and give us your <a href="https://netbeans.org/community/lists/top.html">feedback</a>!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3343">Last Call to Vote for the NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						Today is the final day to vote in the NetBeans Governance Board Elections. Again, here are the fine nominees who want your votes:
<ul><li>Toni Epple
<li>Ryan de Laplante
<li>Fabrizio Giudici
<li>Tonny Kohar
<li>Kristian Rink
<li>Tom Wheeler
</ul>
Read their <a href="https://netbeans.org/community/articles/election_profiles.html">profiles</a> to learn more about them, and <a href="https://netbeans.org/community/articles/nbelections.html">vote for up to three candidates</a> that you would like to see on the Board! Voting ends <b>Monday, March 2, at midnight in the last time zone</b>. The results and the new board will be announced March 9.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3346">Not Your Average Java Developer's Quiz</a></h2>
						<p style="margin-left:8px;">
						The latest Sun Developer Network (SDN) Java quiz surveys past interviews with leading Java developers to find questions that might challenge, inform, entertain, amuse, and provoke you. The questions aspire to reflect both the intellectual curiosity and spirit of fun to be found in the Java community!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3345">The Big PHP IDE Test: Why Use One & Which To Choose</a></h2>
						<p style="margin-left:8px;">
						Smashing Magazine's Alexander Makarov compared several PHP IDEs in this article, and the NetBeans IDE scored high marks for its editing tools, code completion, and responsiveness, among other features.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3341">Create Mobile Games with the NetBeans IDE</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2537&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This screencast will show you how to create a Java ME game using the NetBeans Mobile Game Builder. It focuses on how to use the game designer to create the visual components of a game such as sprites and tiled layers.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3342">Screencast: JavaFX in 15 Minutes or Less</a></h2>
						<p style="margin-left:8px;">
						Join Sun Microsystems technical writer Robert Eckstein as he teaches the fundamentals of the JavaFX programming language in fifteen minutes--or less.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3349">Using Hibernate in a Java Swing Application</a></h2>
						<p style="margin-left:8px;">
						Use the NetBeans IDE to create and deploy a Java Swing application that displays data from a database. The application uses the Hibernate framework as the persistence layer to retrieve POJOs (plain old Java objects) from a relational database.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3347">OQL Support in the HeapWalker</a></h2>
						<p style="margin-left:8px;">
						NetBeans 6.7 Milestone 2 comes with enhanced OQL support in the HeapWalker. The NetBeans Profiler team blog includes a link to a simple demo highlighting OQL integration.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3348">NetBeans 6.7 - Testing The Ergonomics IDE</a></h2>
						<p style="margin-left:8px;">
						Pro NetBeans author Adam Myatt experiments with a brand new feature in the NetBeans 6.7 Milestone 2 release--the option of selecting only the functionality that you need when the IDE loads.</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/2009-03-02.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>