
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 594</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 # 594 - Jul 01, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8466">Video: Preview of NetBeans UML Plugin</a></h2>
						<p style="margin-left:8px;">
						Led by Zoran Sevarac, the Open Source software team at the University of Belgrade is developing a NetBeans UML plugin. This screencast shows a preview of features available in the plugin.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8447">Plugin: NBAndroid</a></h2>
						<p style="margin-left:8px;">
						NBAndroid provides support for the Android application development cycle. Its functionality covers a variety of aspects of Android development directly in NetBeans IDE.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8468">Using WebSocket for Real-Time Communication in Java Platform, Enterpise Edition 7</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7861&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='79' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This tutorial and video series shows you how to create an application that uses the WebSocket API for real-time communication between a client and a server.</p><br style="clear:both;"/>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8467">Newly Published: jMonkeyEngine 3.0 Beginner's Guide</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7862&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='110' width='89' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Aspiring game developers can learn to build modern 3D games with Java in this new primer on 3D programming, packed with best practices, tips and tricks, and example code.</p><br style="clear:both;"/>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8465">Java EE 7 Support in NetBeans 7.3.1</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE provides full support for Java EE 7, with tools, templates, and samples for building EE 7 applications. Arun Gupta outlines what's new in the latest NetBeans update release.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8450">Features for the NetBeans Platform using JavaFX and CSS!</a></h2>
						<p style="margin-left:8px;">
						This article demonstrates several tricks to visually enhance a NetBeans Platform app with JavaFX controls embedded.  It builds upon previous tutorials that demonstrate complete replacements for the default NetBeans Swing components using JavaFX.  Code examples feature NetBeans Platform, JavaFX and CSS.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8449">Released: Open Source Nautical Navigation Software on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						NaVisu is an open source nautical navigation software created on the NetBeans Platform. You can read your nautical charts, connect to a GPS, and display many beautiful JavaFX widgets on the top of the application.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8463">NetBeans Community Tweets: @TheTechGuyTT</a></h2>
						<p style="margin-left:8px;">
						"@netbeans You guys have the best IDE out there. Thanks to your GUI builder I was able to finish my project for Programming. #amazing"</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8464">NetBeans Community Tweets: @dipetr</a></h2>
						<p style="margin-left:8px;">
						"@netbeans improved very much in the last versions.Very user friendly and with many features. Well done guys!!"</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-07-01.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>