
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 499</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 # 499 - Aug 09, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6663">How Satisfied Are You With NetBeans 7?</a></h2>
						<p style="margin-left:8px;">
						With each NetBeans release, we strive to deliver an IDE that gives you the best coding experience available. Your survey responses will let us know if we are on target, and also alert us to features or enhancements to consider for future releases. Please take a moment to answer the questions in the survey! It should only take about 3-5 minutes to complete.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6668">Plugin: JFormDesigner</a></h2>
						<p style="margin-left:8px;">
						JFormDesigner is a professional GUI designer for Java Swing user interfaces. It has outstanding support for JGoodies FormLayout, GroupLayout, TableLayout. and GridBagLayout, making it easy to create professional looking forms.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6659">Governance Board: Discussion About Community Contributions to NetBeans</a></h2>
						<p style="margin-left:8px;">
						Governance board member Tom Wheeler kicks off a discussion on what it will take for more code contributions to be made to the NetBeans project: "If you have contributed to NetBeans, what motivated you to do so?  If you haven't, what stopped you?  If you're active in other open source projects, what specific things could we learn from them?" Join the discussion!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6664">Dream Team: Book Review of "Java: The Good Parts"</a></h2>
						<p style="margin-left:8px;">
						"The unnamed package is a form of namespace limbo where code written by confused, obstinate, or lazy programmers is placed until they evolve to a higher life form." NetBeans Dream Team member John Yeary has written a very interesting review with some great quotations from an in depth book about Java. Read it here!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6661">AgroSense Farm Manager</a></h2>
						<p style="margin-left:8px;">
						From the northern parts of the Netherlands comes yet another release of AgroSense, the modular farm management system. You too can join this open source project!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6662">New Editor History Tab</a></h2>
						<p style="margin-left:8px;">
						All NetBeans editors will have their own editor tabs in the next release of NetBeans IDE. Read all about the related ideas & plans here.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6666">August 2011: Goettingen</a></h2>
						<p style="margin-left:8px;">
						At the end of August, you're invited to attend a NetBeans training as part of Source Talk Tage in Goettingen, Germany.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6665">September 2011: Munich</a></h2>
						<p style="margin-left:8px;">
						Eppleton provides yet another one of its popular NetBeans training courses in Munich during September.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6667">October 2011: San Francisco</a></h2>
						<p style="margin-left:8px;">
						Marakana & Eppleton are teaming up to provide a great NetBeans Platform training course right after JavaOne. Last year it was great -- this year it will be even better!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6660">Karel Language Programming on NetBeans</a></h2>
						<p style="margin-left:8px;">
						If ANTLR and JavaCC are your bread and butter, it's time to discover how NetBeans integrates with these meta programming languages. Karel, a fairly simple language, is a good place to start!</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-08-09.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>