
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 580</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 # 580 - Mar 25, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8217">JavaOne 2013 Call-for-Papers is Live!</a></h2>
						<p style="margin-left:8px;">
						Come talk about what you're doing with NetBeans at JavaOne 2013! The Call for Papers for JavaOne 2013 is now open. Attendees will want to hear the best ideas from Java experts... developers, visionaries, customers, and partners. Submit your proposals by April 12.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8212">Upcoming in NetBeans IDE: Network Monitor</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team is working on a network monitor that helps analyze REST related communication, WebSocket communication, and any problematic network requests. It will be available for Chrome with NetBeans integration and the Embedded WebKit Browser. Read all about it in the NetBeans WebClient blog!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8214">Plugin: Gradle Support</a></h2>
						<p style="margin-left:8px;">
						Attila Kelemen has been working hard on improving and extending Gradle support for NetBeans IDE. Try it out, from plugins.netbeans.org, or directly from his site.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8208">Lambdas and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Mohamed Sanaulla shows how early development builds of NetBeans IDE and Java 8 can be used to learn about lambda expressions.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8210">Scala and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						In this article, Simon Holywell shows you how to set up the JDK, NetBeans IDE, Scala, and the NetBeans Scala plugin. Before you know it, you'll have NetBeans up and running and be coding your first Scala application!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8215">Couchbase and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Developing the Couchbase Java Client library in NetBeans IDE can be done once you've set it up correctly in the IDE. This article shows you how via the Java Free Form project type.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8216">NetBeans Team Interview: Jiří Kovalský</a></h2>
						<p style="margin-left:8px;">
						Hermien Pellissier, NetBeans Governance Board Member, plans to introduce you to individual NetBeans team members via interviews with them. The first of these is NetBeans community manager Jiri Kovalsky!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8211">NetBeans Community Tweet: @svmohr</a></h2>
						<p style="margin-left:8px;">
						"Switched from Eclipse to NetBeans and won't look back, superior Maven support and Gradle support is also in the works."</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8209">YouTube: Bukkit Plugin Tutorial Using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Bukkit is a Minecraft Server mod. Follow this great new series of YouTube tutorials about programming for Bukkit in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8213">YouTube: Real Time Java on the NetBeans RCP</a></h2>
						<p style="margin-left:8px;">
						Watch a new YouTube movie showing how to integrate real time data, such as stock data or air traffic data, in a NetBeans Platform application.</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/2013-03-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>