
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 480</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 # 480 - Mar 29, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6250">Vote for the 18th NetBeans Governance Board!</a></h2>
						<p style="margin-left:8px;">
						Who are the Governance Board nominees and how are they involved in the NetBeans Community? <a href="https://netbeans.org/community/articles/election_profiles.html">Read their profiles</a> and vote your choice! The voting period runs from <b>Monday, March 28 through Monday, April 11</b>. The results and the new board will be announced Tuesdday, April 12.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6249">NetBeans IDE 7.0 Release Candidate 1 Available</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5553&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans Team is pleased to announce the first release candidate build of NetBeans IDE 7.0. Download the build today and give us feedback on the <a href="https://netbeans.org/community/lists/top.html">NetBeans mailing lists & forums</a>, write us via <a href"https://netbeans.org/community/lists/top.html">Twitter</a>, or <a href="http://bit.ly/9xqZ1r">file a report</a>. The final release of NetBeans 7.0 is planned for April.</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6251">Getting Started with Java EE and Glassfish 3 Using NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5538&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='80' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Java EE Evangelist Arun Gupta demonstrates using Java EE and Glassfish with NetBeans in this 5-part video series.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6254">Getting Started with Google App Engine in NetBeans</a></h2>
						<p style="margin-left:8px;">
						John Yeary reports on a presentation about Google App Engine and shows how to get started.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6248">Getting Started with NetBeans RCP Swing Components</a></h2>
						<p style="margin-left:8px;">
						A technical article from Antonio Vieiro about NetBeans Platform basics (Nodes, ExplorerManager, UI Components) for NetBeans Platform newbies or Swing developers who are curious about the Platform or looking to migrate existing applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6255">Getting Started with Wicket in NetBeans</a></h2>
						<p style="margin-left:8px;">
						A new series of articles introducing Wicket in the context of NetBeans IDE.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6256">NetBeans Training in Boston</a></h2>
						<p style="margin-left:8px;">
						VisiTrend in Boston is hosting a NetBeans training, while an event about NetBeans was held at Boston's Microsoft center. Read all about it here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6252">NetBeans Training in Serbia</a></h2>
						<p style="margin-left:8px;">
						A short report and photo from Belgrade, Serbia, about the latest NetBeans training that took place there!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6253">NetBeans Training in Mexico</a></h2>
						<p style="margin-left:8px;">
						Recently a NetBeans training took place at a wheat and crop analysis center in Mexico, as reported here.</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/2011-03-29.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>