
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 588</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 # 588 - May 21, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8362">Develop Mobile Web Applications On Your Android Device in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						There's an exciting new feature coming to NetBeans IDE 7.4: Support for JavaScript debugging and visual CSS editing on Android devices. But no need to wait till GA release, you can test out the feature now, using the NetBeans 7.4 nightly builds.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8361">Nette Framework with Latte Templates in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						The upcoming NetBeans IDE 7.4 release will have support for Nette Framework, a popular framework for PHP web development. Visit the NetBeans PHP team blog to learn about new features coming to PHP support in NetBeans IDE.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8357">Register for Java EE 7 Launch Webcast (June 12)</a></h2>
						<p style="margin-left:8px;">
						Register for a LIVE webcast introducing Java EE 7! The Java EE 7 platform JSR has been approved; join the count down to begin developing with the many new Java EE features.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8359">Register for Java Virtual Developer Day (June 19 & 25)</a></h2>
						<p style="margin-left:8px;">
						Go virtual and join Oracle’s latest Virtual Developer Day. Kick back and check out informative tutorials (that you can repeat at your own pace) to improve your Java programming expertise and engage in live chat sessions with the preeminent Java experts.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8356">JavaFX Accordion Slide Out Menu for the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Sean Phillips outlines the steps for using JavaFX to build a slide out menu for a NetBeans Platform application.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8355">Real World Java EE - Devoxx 2012 Session Replay Available</a></h2>
						<p style="margin-left:8px;">
						No slides, just demos. Adam Bien's "Real World Java EE" session at Devoxx 2012 is now available for replay on Parleys.com.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8360">Live Band Music Manager on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Chord Maestro is an application built on the NetBeans Platform. It displays chord charts on a computer, television, or confidence monitor, and eliminates the need for music sheets and music stands.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8358">Plugin: Git Branch in Status Bar</a></h2>
						<p style="margin-left:8px;">
						An experimental plugin that shows the current Git branch in the NetBeans IDE status bar.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8353">NetBeans Community Tweets: @YellDavid</a></h2>
						<p style="margin-left:8px;">
						The [history] button in @netbeans is just epic. The fact it integrates Git history as well as local history is phenomenal.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8354">NetBeans Community Tweets: @CodeGuzzler</a></h2>
						<p style="margin-left:8px;">
						Thank you @netbeans for the best #Gradle integration I have seen so far.</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-21.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>