
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 581</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 # 581 - Apr 02, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8233">NetBeans IDE 7.3 Patch 1 Now Available</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Team has released a patch for NetBeans IDE 7.3 with numerous fixes that enhance stability and performance. 
<br><br>
To obtain the fixes, <b>NetBeans IDE 7.3 must be installed and running</b>. An update notification will appear in the IDE. Click the notification to install the updates. Alternatively, you can also download the fixes through the NetBeans IDE Plugin Manager.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8236">NetBeans Poll: Have You Tried HTML5 Support in NetBeans IDE 7.3?</a></h2>
						<p style="margin-left:8px;">
						<a href="https://netbeans.org/features/html5/index.html">HTML5 support</a> is brand new in NetBeans IDE 7.3. In the latest NetBeans Community Poll we want to know how users are taking to the new feature.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8229">Debugging and Testing JavaScript in HTML5 Applications Using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A tutorial demonstrating support for debugging and testing JavaScript using JS Test Driver in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8228">C/C++ Remote Development Modes in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A short guide to using C/C++ remote development in NetBeans IDE and in Oracle Solaris Studio IDE.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8230">Java EE and JavaFX Workshops with Adam Bien (April - July 2013)</a></h2>
						<p style="margin-left:8px;">
						Java expert Adam Bien will be delivering a host of sessions, workshops and talks about Java EE and JavaFX from April through July. His events are very popular; check out his calendar, and sign up for a date or several.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8234">NetBeans Team Interview: Marián Mirilovič</a></h2>
						<p style="margin-left:8px;">
						Leading the busiest team in the NetBeans organization! An interview with Marián Mirilovič, Quality Engineering Manager.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8231">Eight Years Of Blogging on NetBeans</a></h2>
						<p style="margin-left:8px;">
						What is it like to blog for eight years about the same product? NetBeans evangelist and product manager Geertjan Wielenga looks back on the start of his popular blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8237">New Issue of Java Magazine - Java Is Community</a></h2>
						<p style="margin-left:8px;">
						The latest issue of Java Magazine is all about the Java community worldwide, featuring interviews with Java leaders and tips for keeping Java active and relevant in your corner of the globe.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8232">Malkovich Moment: Gradle, Gradle, Gradle</a></h2>
						<p style="margin-left:8px;">
						What happens when you open Gradle, which is built on Gradle, using the NetBeans Gradle plugin?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8235">Which Works Better for You: NetBeans IDE or Chrome Developer Tools?</a></h2>
						<p style="margin-left:8px;">
						Is the JavaScript Debugger in NetBeans IDE  better than the one in Chrome Developer Tools (CDT)? How do they compare feature by feature? Why should I use the debugger in NetBeans and not the one in CDT? NetBeans engineer David Konecny explores these questions in the new NetBeans Web Client blog.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Jan Pirek<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-04-02.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>