
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 613</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 # 613 - Nov 11, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8779">From Database to RESTful Web Service to HTML5 in 5 Minutes</a></h2>
						<p style="margin-left:8px;">
						A new article on JAXenter.com lets you click your way to an awesome HTML5 application with a Java EE 7 back-end. Integrate the best of both worlds, Java EE 7 and HTML5.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8775">Plugin: GWT4NB</a></h2>
						<p style="margin-left:8px;">
						The GWT4NB project aims to enable developers to take advantage of both the superior support for creating Web Applications built into NetBeans IDE and the power of Google Web Toolkit. And the 7.4 version of the plugin is available!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8781">Apache Cordova for NetBeans IDE on Fedora</a></h2>
						<p style="margin-left:8px;">
						Constantin Drabo from Burkina Faso describes getting started with Cordova in NetBeans IDE 7.4.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8773">JavaScript Rapid Application Development on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Platypus Platform is a new software platform for quickly building cross-platform JavaScript client-server applications. Platypus Platform supports HTML5 or desktop Java client and any Java EE compatible server to run business applications made completely in JavaScript.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8772">Favorite New NetBeans IDE 7.4 Features?</a></h2>
						<p style="margin-left:8px;">
						With the release of NetBeans IDE 7.4, handy HTML5 development tools (such as a JavaScript debugger and Chrome "live editing" features) introduced in NetBeans IDE 7.3 have been extended to Java EE and PHP applications, while there is brand new support for mobile web development on the Android and iOS platforms, together with deep integration for developers using the Cordova/PhoneGap framework. What are your favorite features? Share them here!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8778">NetBeans at DevFest Istanbul</a></h2>
						<p style="margin-left:8px;">
						Mark Stephens was lucky enough to be part of DevFest Turkey recently. He shares his experiences of talking about NetBeans and GlassFish with a great photo of the large audience in attendance.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8774">NetBeans Community Tweets: @glen_a_smith</a></h2>
						<p style="margin-left:8px;">
						<i>Dear @netbeans team, what you guys have done with the Two-way Live Chrome Integration in 7.4 is just amazing! Great timesaving stuff!</i></p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8780">Installing NetBeans IDE onto Ubuntu</a></h2>
						<p style="margin-left:8px;">
						An excellent new video on getting started with Ubuntu and NetBeans IDE 7.4</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8777">Video: Introduction to Java ME 8</a></h2>
						<p style="margin-left:8px;">
						This webcast features a quick introduction to Java ME 8, a modern, flexible, and robust software platform for intelligent devices and the Internet of Things.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8776">Video: Five Simple Ways to Extend NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Get started integrating your technology into NetBeans IDE today! It is much easier than you might think...</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8771">Video: CoffeeScript Rocks in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						CoffeeScript is a handy preprocessor for JavaScript, as shown in this quick demo, using the CoffeeScript plugin for NetBeans IDE.</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="http://www.netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="http://www.netbeans.org/community/news/newsletter/index.html">English</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="http://www.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="http://www.netbeans.org/community/news/newsletter/2013-11-11.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>