
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 504</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 # 504 - Sep 13, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6758">NetBeans @ JavaOne 2011</a></h2>
						<p style="margin-left:8px;">
						NetBeans is going to be strongly represented at JavaOne 2011, with technical sessions, BOFs, and hands on labs. Here's an overview of the many NetBeans-oriented topics you'll find when you get to San Francisco this year!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6757">Report on NetCAT Introductory Chat</a></h2>
						<p style="margin-left:8px;">
						Dhawal Saiya reports on the recently held kick off meeting for the NetBeans IDE 7.1 NetCAT program, which is the NetBeans beta testing program. Read it and find out what happened!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6756">Plugin: Antlr Editor Support</a></h2>
						<p style="margin-left:8px;">
						Nikolay Krasilnkov reports that his NetBeans plugin for Antlr files has been updated to support NetBeans IDE 7.0 and 7.0.1. Syntax coloring and other cool features are all there to help you as you work on Antlr files in NetBeans IDE.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6753">Tip: NetBeans Java Code Completion Box</a></h2>
						<p style="margin-left:8px;">
						In the Java editor, the code completion box probably offers more functionality than you're aware of. Read this blog entry to find out about some of the cool code snippets that can be generated right from the code completion box.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6754">Twitter: NetBeans PHP Rocks</a></h2>
						<p style="margin-left:8px;">
						@msafi: "If I were a PHP IDE maker and then I stumbled on NetBeans, I'd shut down and go make something else with my life... NetBeans is AWESOME!"</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6755">nbusers: Memory Usage in NetBeans IDE 7.0.1</a></h2>
						<p style="margin-left:8px;">
						NetBeans user Mark Barnes writes: "Since installing NB 7.0.1 (from 6.9) I have seen MUCH better memory usage when looking at the Memory Meter." Read on for details.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6752">Upcoming NetBeans Training in San Francisco</a></h2>
						<p style="margin-left:8px;">
						Eppleton and Marakana are partnering to bring you the latest NetBeans training in the US. Set to be held right after JavaOne, you're warmly invited to attend and bring others with you!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6750">NetBeans Training, Chennai, India</a></h2>
						<p style="margin-left:8px;">
						JUG Chennai in India hosted a NetBeans training. The participants were in India, while the trainer was in Amsterdam... and they were connected via Skype for two interesting days, learning about the NetBeans APIs.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6751">NetBeans Training, Groningen, Netherlands</a></h2>
						<p style="margin-left:8px;">
						A NetBeans Platform Certified Training has been held at the Hanze University Groningen - Applied Sciences, in the Netherlands. Read all about it and about the farm management application being developed there.</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-09-13.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>