
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 496</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 # 496 - Jul 18, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6602">News from the Governance Board</a></h2>
						<p style="margin-left:8px;">
						Tom, Sven, and John, the currently elected members of the NetBeans Governance Board, recently met and have posted the minutes of their meeting.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6605">NetBeans Poll: How Do You Solve IDE Problems?</a></h2>
						<p style="margin-left:8px;">
						Send a patch? Fix an issue? Throw your hands up in despair? The current NetBeans community poll asks how you respond to problems with NetBeans IDE. Please take a moment and take part in this poll!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6603">Plugin: PHP Smarty Templates</a></h2>
						<p style="margin-left:8px;">
						Syntax coloring and code completion for SMARTY commands are just two of the cool features provided by this new plugin for PHP developers. Have you tried it yet?</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6601">Swedish Tips for NetBeans IDE Users</a></h2>
						<p style="margin-left:8px;">
						From code templates to shortcuts, Nicklas Löf, a very experienced NetBeans user from Stockholm, Sweden, presents a very long list of tips & tricks for making you even more productive.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6597">NATO's Air Defence on NetBeans</a></h2>
						<p style="margin-left:8px;">
						NATO's command & control software is being updated to run on the NetBeans RCP, for deployment to 20 NATO countries. Read an article written by its lead developer and see some interesting NetBeans screenshots!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6600">Handy Overview of Java 7 Features</a></h2>
						<p style="margin-left:8px;">
						Loiane Groner provides a very nice write up on the new Java 7 features, together with how to get started with NetBeans IDE 7.0 and JDK 7.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6598">Synthetica Look and Feel</a></h2>
						<p style="margin-left:8px;">
						Want to try NetBeans IDE with a different look and feel? A new version of Wolfgang Zitzelsberger's Synthetica code has been released, including a NetBeans plugin. Take it for a spin?</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6599">NetBeans Day Munich 2011</a></h2>
						<p style="margin-left:8px;">
						Kirk Pepperdine, Jaroslav Tulach, Adam Bien, Petr Jiricka, and several other high profile speakers were at the recent NetBeans Day in Munich, Germany. Read about what happened here! And don't you want to host a NetBeans Day too?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6596">New NetBeans Serbian Project Community</a></h2>
						<p style="margin-left:8px;">
						Out of many NetBeans RCP training courses that have taken place in Belgrade, Serbia, a project team has been formed to focus on NetBeans projects such as Neuroph and NetBeans UML tools.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6604">New NetBeans Platform Training Newsletter</a></h2>
						<p style="margin-left:8px;">
						Periodically, students who have attended a NetBeans Platform training are sent a newsletter on the latest developments around student-related projects on the NetBeans Platform. The latest edition came out last week, take a look at what's going on around NetBeans Platform training courses.</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-07-18.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>