
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 576</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 # 576 - Feb 25, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8135">NetBeans IDE 7.3 Released</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7516&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans IDE 7.3 is out! The 7.3 release empowers developers to create and debug rich web and mobile applications using the latest HTML5, JavaScript, and CSS3 standards. Developers can expect a state of the art rich web and mobile development experience with a live web page inspector, Chrome integration, a CSS3 style editor, a completely revamped JavaScript editor based on the latest Nashorn JavaScript engine, a new JavaScript debugger, and more.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8134">NetBeans IDE Feature Pages Rewritten</a></h2>
						<p style="margin-left:8px;">
						The pages outlining the main features of NetBeans IDE have been rewritten over the past weeks! Java SE, Java EE, HTML5 and more: read all about the tools and utilities you can use to speed up development in NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8130">SDTimes: NetBeans IDE 7.3 expands JavaScript support</a></h2>
						<p style="margin-left:8px;">
						While NetBeans has always been the Java IDE, support for other languages has crept in over time. NetBeans IDE 7.3 has been released, bringing with it a host of new support for CSS3, HTML5 and JavaScript.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8131">InfoWorld: Oracle updates NetBeans IDE for HTML5</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 7.3 "allows developers to use the same IDE to compose in HTML5 that they would use for building back-end services that their Web and mobile applications would connect to," said Bill Pataky, Oracle vice president of product management of tools and frameworks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8132">jaxenter: NetBeans IDE 7.3 embraces web with arrival of HTML5 support</a></h2>
						<p style="margin-left:8px;">
						"The web development features introduced into the popular IDE represent the converging development world we now live in. It’s no longer possible to avoid the likes of HTML5 and JavaScript in application development, and Oracle’s decision to embrace them was inevitable, and should be greatly received."</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8133">Anahata Announces NetBeans 7.3 First Choice IDE</a></h2>
						<p style="margin-left:8px;">
						NetBeans is a great IDE for developing Java Applications with the latest standards of Java SE and Java EE. It has a vibrant open source community responding incredibly quick to issues we find and feature requests.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8136">Customized & Automated Search/Replace</a></h2>
						<p style="margin-left:8px;">
						Custom hints (a.k.a custom inspections or quick fixes in other IDEs) are available since NetBeans IDE 7.1. They match patterns in Java code and can provide transformations. This enables you to create small refactorings based on the AST, without coding. A typical usecase is the type-safe migration of API, instead of the error-prone plain text-based “search and replace” approach.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8137">JavaOne India 2013 CFP Open</a></h2>
						<p style="margin-left:8px;">
						JavaOne India returns 8–9 May, and is being held again this year at the Hyderabad International Convention Centre. As always, the two days will be packed full with more valuable content than you’ll have hours in the day for, from keynotes to technical sessions to hands-on labs and demos.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8138">Tweet of the Week: @Dayong_He</a></h2>
						<p style="margin-left:8px;">
						"@netbeans 7.3 start up speed has been improved a lot, it takes 6 seconds only on my laptop."</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="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-02-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>