
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 382</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 # 382 - Mar 10, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3370">New Brazilian Portuguese Version of NetBeans 6.5 Plugins Now Available!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Localization team is pleased to release the Brazilian Portuguese version of the Auto Update Center plugins for NetBeans 6.5. The localized plugins are: UML, BlueJ Project Support, JBuilder Project Importer, JMX, JConsole, Axis2 Support, Interactive UI Gestures Collector and Developer Collaboration. You can get the localized AUC modules in two ways:<br><ul>
<li><a href="https://netbeans.org/downloads/index.html">Download</a> and install the NetBeans IDE 6.5 ML. Go to the Help menu, select <i>Check for Updates</i>, and install the updated modules.
<li>If you already have the NetBeans IDE installed, launch the IDE, go to the Help menu, select <i>Check for Updates</i>, and install the updated modules. The localized plugins can also be found under <i>Tools -> Plugins -> Updates/Available Plugins</i>.</ul>
Learn more about the NetBeans 6.5 Update Center Localization Project <a href="http://wiki.netbeans.org/NB65L10nUc">here</a>, and get the complete status of the NetBeans 6.5 Update Center Modules <a href="http://wiki.netbeans.org/NB65StableModulesUC">here</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3371">Introducing the New NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team is pleased to announce the members of the 16th cycle of the Governance Board.<br><br>
<b>Fabrizio Giudici</b> and <b>Tom Wheeler</b> received the most votes to become the community elected members of the new season. The Sun Microsystems appointee and third member of the Board is <b>James Branam</b>.
<br><br>
Please join us in congratulating Fabrizio, Tom and James, and in extending our thanks to all of our <a href="https://netbeans.org/community/articles/election_profiles.html">accomplished nominees</a> for taking part in this election and for their continued support of the NetBeans project!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3372">Creating a Graphical Client for Twitter</a></h2>
						<p style="margin-left:8px;">
						Using the NetBeans IDE, create a simple, graphical, REST-based client that displays public Twitter messages and lets you view and update your Twitter status. The application uses Swing and the NetBeans IDE's support for Twitter's SaaS operations.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3375">Top 10 NetBeans APIs (Part 8)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2611&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;'/>
						The NetBeans API screencasts return! Part 8 begins with a recap of the previous parts and then follows with a demo that creates a scenario in which the Visual Library API will be needed.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3374">Enhancing a Structured Document Using jQuery</a></h2>
						<p style="margin-left:8px;">
						A tutorial for enhancing the usability and appearance of structured documents using the jQuery JavaScript library in the NetBeans IDE. jQuery is a light-weight JavaScript library that allows programmers to easily and quickly add enhancements to the appearance and behaviors of their web pages.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3373">Using Profiling Points in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						An introduction to profiling an application using the NetBeans IDE. The NetBeans profiling tool enables you to monitor thread states, CPU performance, and memory usage of your Java application from within the IDE, and imposes relatively low overhead.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3376">What You Can Build In 5 Minutes with Java EE 6</a></h2>
						<p style="margin-left:8px;">
						Find out what Java EE expert Adam Bien built in eight steps and in less than five minutes at a recent developer conference, using NetBeans 6.7 Milestone 2 and GlassFish v3 EA.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3377">Create a Maven Project Site in NetBeans</a></h2>
						<p style="margin-left:8px;">
						A quick entry from NetBeans user Mr. Haki about creating a simple Maven project site using the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3378">Selenium Plugin for PHP in NetBeans</a></h2>
						<p style="margin-left:8px;">
						Recent news from the NetBeans PHP team blog. Selenium support is now available for PHP projects. Check out this <a href="http://wiki.netbeans.org/SeleniumPluginPHP">wiki</a> for more details.</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-10.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>