
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 413</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 # 413 - Oct 20, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4299">Last Chance to Vote for NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Governance board is a three-member board whose main task it is to make sure that the NetBeans project is being run in a fair and open manner. <a href="https://netbeans.org/community/articles/election_profiles.html">Learn more about the nominees</a> and then <a href="https://netbeans.org/community/articles/nbelections.html">cast your votes</a>! The voting period runs through midnight, Wednesday, October 21 in the last time zone. The results and the new board will be announced Monday, October 26.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4295">OSUM Hosts Global NetBeans Demo Fest!</a></h2>
						<p style="margin-left:8px;">
						Are you a student or an educator? Join the Open Source University Meetup (OSUM) community and participate in the month-long NetBeans Demo Fest! Visit the OSUM site and find scheduled demo events. Gather your developer friends and watch (or show) cool demos of the NetBeans IDE in action. OSUM has prepared a series of webinars to introduce you to the IDE, and to train you on how to conduct a NetBeans demo if you would like to host a session.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4296">ALM Plugin with Support for Mercurial and Git</a></h2>
						<p style="margin-left:8px;">
						A group of open source enthusiasts and Intland Software continue to develop the NetBeans ALM (Application Lifecycle Management) plugin. This plugin integrates NetBeans with codeBeamer 5.4, Mercurial and Git. The team invites feedback from everyone, and encourages the NetBeans community members to join the project on JavaForge. The release is scheduled for January 31, 2010.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4298">NetBeans for PHP: Formatting and Indentation</a></h2>
						<p style="margin-left:8px;">
						Petr Pisl recently gave a presentation at the WebExpo 2009 in Prague. He spoke about developing web applications, and the audience showed a lot of interest in his PHP demos. After the session Petr collected all feedback in a newly created Issuezilla task. If you recall any issues (for example if the formatting or indentation in the PHP editor doesn't act as you'd expect) help us track them down by adding your code sample to the list.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4297">Working with Maven in NetBeans 6.7.1</a></h2>
						<p style="margin-left:8px;">
						In this article, we will look at the support for Maven in the latest NetBeans IDE 6.7.1. Maven is an excellent tool, much appreciated for its ability to help harmonize and standardize build practices within an organization. Learn more about creating and working with Maven projects, and managing the POM file and dependencies.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4300">Video: Carol McDonald demos RESTful Web Service</a></h2>
						<p style="margin-left:8px;">
						This Pet Store Catalog application exposes a catalog as a RESTful Web Service for remote client applications, and shows an Ajax client which gets and displays the Web Service responses in a dynamic Ajax table (Dojo grid). By Carol McDonald</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4301">Video: PHP Namespace Support in NetBeans IDE 6.8</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates code completion for PHP 5.3 namespaces in NetBeans IDE 6.8. It also shows the user how to change the options for PHP namespace code completion and other PHP editing features.</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/2009-10-20.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>