
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 461</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 # 461 - Nov 08, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5726">NetBeans IDE 7.0 Testers Wanted - Register for NetCAT 7.0!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=4989&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Do you enjoy playing with software, hunting for defects? If you are an experienced NetBeans IDE user and you have a few hours per week from November through February, you can join other community volunteers in the NetCAT 7.0 program. Get your NetBeans bug(s) fixed and make friends along the way. Register for NetCAT 7.0!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5718">Plugin: PHP Nette Framework</a></h2>
						<p style="margin-left:8px;">
						Ondrej Brejla's PHP Nette Framework plugin provides support for the Nette Framework, a powerful PHP framework for rapid and easy creation of high quality and innovative web applications. The plugin provides built-in support for the "Latte" template language with syntax highlighting and code completion.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5720">NetBeans Platform at Oracle Technology Network Developer Day Vienna, Nov. 11</a></h2>
						<p style="margin-left:8px;">
						Get an introduction to the NetBeans Platform at Oracle's Developer Day in Vienna, Austria on November 11. There will be a session to explore concepts behind the NetBeans Platform and a hands-on lab to get experience creating modular Swing applications on the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5724">NetBeans Platform Lab at Devoxx 2010, Nov. 15</a></h2>
						<p style="margin-left:8px;">
						Join Geertjan Wielenga and Anton Epple for a NetBeans Platform hands-on lab at Devoxx 2010. The lab will provide a comprehensive overview of the NetBeans Platform, how it works, and how to get started using it.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5723">NetBeans Maven: Better Than M2Eclipse?</a></h2>
						<p style="margin-left:8px;">
						Gunther Popp introduces himself to Maven 3 support in NetBeans IDE 7.0 M2 and discovers a lot of powerful features.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5725">What's New in PHP Support in NetBeans IDE 7.0 Milestone 2?</a></h2>
						<p style="margin-left:8px;">
						A blog review of enhancements and new features in PHP support in the second milestone build of NetBeans IDE 7.0.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5721">Setup NetBeans For Developing Google Android Apps</a></h2>
						<p style="margin-left:8px;">
						A quick-start article on developing Google Android applications, using integrated development environments such as the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5722">NetBeans, Drupal Plugin, and Drupal Setup</a></h2>
						<p style="margin-left:8px;">
						An overview of how to locate and install the Drupal NetBeans plugin, and then set up existing Drupal projects in the NetBeans IDE.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5719">The Java Spotlight Podcast Series</a></h2>
						<p style="margin-left:8px;">
						Hosted by Oracle evangelists Roger Brinkley and Terrence Barr, the Java Spotlight Podcast is a new weekly show with indepth interviews, new, and insights for and from Java developers. Recent guests include Mark Reinhold, Chief Architect of Oracle's Java Platform Group.</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/2010-11-08.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>