
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 517</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 # 517 - Dec 13, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6992">NetBeans Community Greenlights NetBeans IDE 7.1</a></h2>
						<p style="margin-left:8px;">
						The results of the NetBeans IDE 7.1 Community Acceptance Survey are out! A majority of the respondents found 7.1 release ready. Read on for the survey details.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6988">NetBeans PDF to JavaFX Plugin Released</a></h2>
						<p style="margin-left:8px;">
						With the PDF Viewer Plugin for NetBeans, you can display and convert PDF files to JavaFX. This is the first release; give the module a try and provide feedback to the JPedal team.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6987">Rapid Drupal Development with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A new version of the NetBeans Drupal Development Tool module is now available, and integrated with Drush.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6990">NetBeans IDE on Facebook</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team has set up a new Facebook page. Go ahead and "Like" us to get daily news, tech tips, insightful and topical articles about NetBeans and your development needs.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6989">Spring to Java EE Migration Using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						CTO and ardent Java EE fan David Heffelfinger demonstrates how easy it is to develop the data layer of an application using Java EE, JPA, and the NetBeans IDE instead of the Spring Framework.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6991">Quickstart WebLogic 12c with NetBeans 7.1</a></h2>
						<p style="margin-left:8px;">
						A quickstart guide to the new WebLogic release, running the Java EE 6 Pet Catalog sample in NetBeans IDE 7.1 with MySQL.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6993">Creating Web Application with NetBeans IDE Using JSF</a></h2>
						<p style="margin-left:8px;">
						An how-to on creating a web application using the JSF 2.0 framework and NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6984">SSNNotify: Replacing Amazon Services Order Notifier with NetBeans</a></h2>
						<p style="margin-left:8px;">
						SSNNotify is a free, replacement application for the discontinued Amazon Services Order Notifier (ASON) which allowed Amazon merchants to manage their online orders. Find out how the team behind SSNNotify chose the NetBeans Platform to launch this new app.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6985">JavaFX Wows JavaOne Latin America</a></h2>
						<p style="margin-left:8px;">
						The audience at the recently concluded JavaOne Latin America was a-buzz about JavaFX. Geertjan Wielenga shares some of the highlights in his blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6986">Why should I use NetBeans for PHP development?</a></h2>
						<p style="margin-left:8px;">
						Short and sweet. Two key reasons why you should be using NetBeans for PHP development--if you don't already.</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/2011-12-13.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>