
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 586</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 # 586 - May 07, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8319">Jelastic Announces Integration with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Jelastic Inc., the creators of a cloud hosting platform for Java and PHP applications, has announced the integration of the Jelastic platform with NetBeans IDE. Full instructions are provided for getting started with the Jelastic plugin in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8317">Emmet Plugin for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Emmet, the coding productivity tool for web applications, is now available on the Update Center for NetBeans IDE 7.2 and 7.3.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8318">Working with Java ME Embedded and Raspberry Pi - Series</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7706&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='48' width='48' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This two-part series includes a video that shows how to get started working with Raspberry Pi and a tutorial that describes how to get up and running Java with Raspberry Pi.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8312">UML Modeling in NetBeans with Visual Paradigm</a></h2>
						<p style="margin-left:8px;">
						This tutorial outlines four quick steps to UML modeling in NetBeans IDE using the Visual Paradigm for UML plugin (VP-UML).</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8315">Tech Tip: Easy Debugging with NetBeans and XDebug</a></h2>
						<p style="margin-left:8px;">
						A short primer on setting up Xdebug environment in NetBeans IDE.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8320">Duke's Choice Award for NetBeans Based Air Traffic Control System</a></h2>
						<p style="margin-left:8px;">
						VNIIRA in St. Petersburgm, Russia, recently won a Duke's Choice Award for their air traffic control system, consisting of dozens of NetBeans modules, that allows tracking of hundreds of flights using primary and secondary surveillance radars.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8316">Trip Report: JavaOne Russia</a></h2>
						<p style="margin-left:8px;">
						A report on NetBeans-related activities at the recently held JavaOne Russia in Moscow. Java EE, HTML5, and NetBeans Platform developers learned about the latest features in their favorite IDE, while networking with Oracle staff and software developers from all over Russia.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8314">Java 7 Code Coverage for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Jonathan Lermitage presents two new solutions for Java 7 code coverage in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8313">Everything on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Check out the ever-growing list of the diverse software tools and applications developed on the NetBeans Platform.</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/2013-05-07.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>