
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 386</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/appl2/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/appl2/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 # 386 - Apr 06, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3515">NetBeans 6.7 Milestone 3 Now Available for Download!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team is pleased to announce the availability of NetBeans IDE 6.7 Milestone 3 (M3). Highlights of the release include integrations with <a href="http://kenai.com/">Project Kenai</a>, GlassFish, and Hudson; and enhancements to Maven, PHP, Platform, Profiler, C/C++ and more. Learn more about what's <a href="http://wiki.netbeans.org/NewAndNoteWorthy">new and noteworthy</a> in this release, and give us your <a href="https://netbeans.org/community/lists/top.html">feedback</a>!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3516">Help Us Improve NetBeans - Take the NetBeans User Survey</a></h2>
						<p style="margin-left:8px;">
						We want to learn more about you and what you do with NetBeans! Take our new NetBeans User Survey and give us your perspective on NetBeans: what works and what doesn't; how you use NetBeans and how NetBeans can better serve you in the future. Your feedback is very valuable to us and will help us to continue to deliver a top-quality NetBeans IDE!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3518">Flaunt Your NetBeans Platform Application!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Platform screenshots page has grown significantly as more developers see the value in promoting their applications on the page. Have you built a cool application using the NetBeans Platform and would like to include a screenshot in our showcase? Write to "news at platform dot netbeans dot org" with details about your application.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3522">New Community Docs Contribution Coordinator: Kristian Rink</a></h2>
						<p style="margin-left:8px;">
						Kristian Rink is the new Contribution Coordinator for the NetBeans Community Docs program. A native of Germany, Kristian has been an active participant in the program and an evangelist. He takes over the coordinator reins from Varun Nischal. <i>The NetBeans team thanks Varun for his stellar work managing the program. And we welcome Kristian into his new role!</i></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3514">Debugging C/C++ Projects</a></h2>
						<p style="margin-left:8px;">
						A short tutorial that demonstrates how you debug C/C++ projects in the NetBeans IDE. The gdb integration allows you to set breakpoints and watches, inspect the call stack, local variables, threads, and registers, and view assembly instructions in the Disassembler window.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3517">On-Demand Webinar: MySQL, NetBeans and Java RESTful Web Services</a></h2>
						<p style="margin-left:8px;">
						This on-demand webinar demonstrates how to leverage the latest version of the NetBeans IDE to develop RESTful Web Services and clients deployed on GlassFish with MySQL. The talk provides an overview of the design process for a sample RESTful Pet Catalog service using JAX-RS, then shows how to build two sample clients for the Pet Catalog service, one using the Dojo AJAX framework and the other using JavaFX.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3519">How do NetBeans Wizards Work?</a></h2>
						<p style="margin-left:8px;">
						Consistent dialog layouts is one of the promises of the NetBeans Platform. One way this is done is through the Wizard API, which helps your applications have a standard appearance. This new tutorial describes how the API is used.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3521">A Student Thesis on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Many student developers report that the NetBeans Platform is an interesting topic for their college theses. In this NetBeans Zone interview, German student Fionn Ziegler gives the details of his thesis relating to modular development for distributed tendering platforms and the many benefits of this approach.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3520">Installing Grails Plugins in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Developer MrHaki outlines the steps for downloading and installing a Grails plugin in the NetBeans IDE.</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/2009-04-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>