
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 585</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 # 585 - Apr 29, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8303">HTML5 Development in Java EE and PHP Projects</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Web Client Team discusses, in their blog, new tools being developed for working with HTML5 in Java EE and PHP projects.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8302">Plugin: PHP WordPress Blog/CMS</a></h2>
						<p style="margin-left:8px;">
						Get started with WordPress in the IDE, via a New Wordpress Project wizard, themes, hyperlink navigation, code completion, and more!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8306">Getting More Out of the NetBeans Debugger</a></h2>
						<p style="margin-left:8px;">
						The NetBeans debugger is one the top features that Hermien Pellissier simply cannot live without! She reports on a new feature she discovered: "Variable Formatters".</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8307">JavaFX in the NetBeans Menubar and Toolbar</a></h2>
						<p style="margin-left:8px;">
						Replacing your NetBeans Platform GUI components with JavaFX got a lot simpler in the last few days, as more instructions have come out explaining how to do so, from <a href="http://netbeans.dzone.com/articles/how-integrate-javafx-netbeans">menubar</a> to <a href="http://netbeans.dzone.com/articles/how-integrate-javafx-netbeans-part2">toolbar</a> to <a href="http://netbeans.dzone.com/articles/how-integrate-javafx-netbeans-part3">wizard</a> and <a href="http://netbeans.dzone.com/articles/how-integrate-javafx-netbeans-part4">explorer view</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8308">Airport Management on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Read how the NetBeans Platform is enabling collaboration between airport management stakeholders, including airports, air traffic control, airlines, ground handlers, and authorities.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8304">1 July 2013: JayDay Munich</a></h2>
						<p style="margin-left:8px;">
						JayDay 2013 is coming! The organisers have thought a long time about how to can make JayDay even better. The solution -- more rockstar speakers, more topics, more choice through more tracks run in parallel… simply more JayDay!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8309">News on Java Certification</a></h2>
						<p style="margin-left:8px;">
						We regularly receive quite a few questions about certifications for Java. What’s available? What’s changed? Should I bother to get certified? Am I still certified? Do I need to take training to get certified?  I talked to Kate Jones of the Certification Team at Oracle University to get your questions answered.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8305">JayDay 2013: Bigger and More Java</a></h2>
						<p style="margin-left:8px;">
						Tinu interviews Toni Epple all about JayDay 2013, to be held in Munich on 1 July this year.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8311">NetBeans Podcast #64: HTML5 and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						In this podcast, we focus on HTML5 tools in NetBeans IDE 7.3. Podcast Guests: David Konecny, Tushar Joshi, Atul Palandurkar.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8310">Leveraging Third-Party Libraries to Create and Deploy Applications to Oracle Cloud</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7688&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;'/>
						In this tutorial, you create and deploy an application that leverages the open source PrimeFaces JavaServer Faces (JSF) component suite library. JSF was designed to allow developers to create new components while leveraging the JSF life cycle, managed beans, and expression language. As a result, simply by adding a third-party library to your project, you can create a completely different look and feel and add functionality beyond the core JSF libraries.The NetBeans integrated development environment (IDE) supports PrimeFaces out of the box. It is easy to create, deploy, and test applications that use the component suite directly with a local Oracle WebLogic Server instance and remotely with Oracle Cloud.</p><br style="clear:both;"/>
					</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-04-29.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>