
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 553</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 # 553 - Sep 03, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7691">ESPN.com Lead Architect @ NetBeans Day 2012</a></h2>
						<p style="margin-left:8px;">
						The latest speaker to be added to the agenda for NetBeans Day 2012, to be held in San Francisco on Sunday 30 September, is Sean Comerford, Director of the ESPN.com Architecture and Platforms team. Join us and learn how NetBeans IDE is used to develop ESPN.com!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7693">Plugin: javscazGChat</a></h2>
						<p style="margin-left:8px;">
						The Chat Client for Gmail, by Aristides Villarreal Bravo, has recently been updated for usage in NetBeans IDE 7.2.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7687">Hermien Pellissier: New NetBeans Dream Team Member</a></h2>
						<p style="margin-left:8px;">
						Congratulations to Hermien Pellissier, the newest <a href="http://wiki.netbeans.org/NetBeansDreamTeam">NetBeans Dream Team</a> member! Her blog, full of tips about NetBeans IDE and the NetBeans Platform, most recently with information for Maven developers, is highly recommended.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7685">#netbeans irc on FreeNode</a></h2>
						<p style="margin-left:8px;">
						Did you know there's a dedicated irc channel where NetBeans users discuss topics of interest and share tips and tricks? Join the channel today and share your own user experiences of NetBeans IDE and the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7692">Tweet of the Week: @cagataycivici</a></h2>
						<p style="margin-left:8px;">
						"Don't miss NetBeans Day at J1, I'll show how to create an app with an elegant PrimeFaces UI in 15 mins with NetBeans & Java EE."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7696">Dustin Marx on Community Session @ JavaOne</a></h2>
						<p style="margin-left:8px;">
						Dustin Marx, who blogs at <a href="http://marxsoftware.blogspot.nl/">http://marxsoftware.blogspot.nl</a>, blogs about his presence at the upcoming NetBeans Day at JavaOne!</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7694">NetBeans Platform Course in San Francisco</a></h2>
						<p style="margin-left:8px;">
						From 5 to 7 October, Eppleton will be hosting a NetBeans Platform training course in San Francisco, directly after JavaOne. Come learn how to make robust and pluggable software systems!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7695">Tinkerforge/NetBeans Integration Course in Germany</a></h2>
						<p style="margin-left:8px;">
						Want to learn how to connect external devices to NetBeans IDE (and other NetBeans Platform applications)? Join the <a href="http://www.tinkerforge.com/">Tinkerforge</a> integration course to be held in Nordhorn/Lingen in Germany.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7689">How to Use NetBeans on Mac OSX</a></h2>
						<p style="margin-left:8px;">
						An article full of tips and tricks and information to be aware of when you're using NetBeans IDE 7.2 on Mac OSX!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7690">How to Switch Off Dependency Scanning</a></h2>
						<p style="margin-left:8px;">
						When the dependency switch is disabled, NetBeans IDE does not scan for dependencies or update the error badges when you change a file.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7686">YouTube: WorldWind Development on Terramenta</a></h2>
						<p style="margin-left:8px;">
						When developing on Java WorldWind, a lot needs to be done to get started before you can actually begin coding. Terramenta is a comprehensive application framework on the NetBeans Platform to help you get started with Java WorldWind. Watch the related YouTube videos that have very recently been released!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7688">YouTube: App Inspector in JavaFX</a></h2>
						<p style="margin-left:8px;">
						Anton Epple, a NetBeans Dream Team member, introduces you to a new idea he's been working on: an application troubleshooter written in JavaFX for NetBeans IDE. Very cool animations, check it out!</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/2012-09-03.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>