
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 565</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 # 565 - Nov 26, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7917">NetBeans at JavaOne Latin America 2012 (Dec 4-6)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7285&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='110' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The place to be in early December is Sao Paolo, Brazil, for JavaOne 2012 Latin America--and the NetBeans team is making the trip!<br><br>Drop-in on technical sessions and talks that show the latest features of the NetBeans IDE, including demos of HTML5, CSS3 and JavaScript support, Java EE and JavaFX support, and more. Registration is still open!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7843">Signup for JayDay 2012 Munich (Dec 3)</a></h2>
						<p style="margin-left:8px;">
						There's still time to sign up for JayDay Munich--a cool new conference for the Java Community in Munich and surrounding areas. Join a lineup of Java Rockstars and Champions, and Oracle ACEs for a full day of talks and workshops about all things Java.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7856">NetBeans at JDays Sweden 2012 (Dec 3)</a></h2>
						<p style="margin-left:8px;">
						Join Geertjan Wielenga, NetBeans product manager, in Gothenberg for a look at how NetBeans IDE makes Java EE development with Maven a simple and painless task!</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7919">Twig Improvements to NetBeans PHP Support</a></h2>
						<p style="margin-left:8px;">
						Two new Twig improvements have been added to the features lineup for NetBeans 7.3: Code templates and Interpolation coloring. Test them out and remember to leave the team feedback.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7920">Fast Start to JavaFX 2 and Scene Builder</a></h2>
						<p style="margin-left:8px;">
						Using the NetBeans IDE, Mark Heckler outlines a fast, easy and fun start to JavaFX and Scene Builder.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7915">Video: JavaFX and NetBeans Platform Integration</a></h2>
						<p style="margin-left:8px;">
						A single application demonstrates the benefits of integrating JavaFX and the NetBeans Platform.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7916">On Demand Training: Java SE 7 and JavaFX 2.0</a></h2>
						<p style="margin-left:8px;">
						Everything you wanted to know about Java including Java SE 7, Java FX 2.0 and the roadmap to Java SE 8. Discover how Java can help you reduce your project risk and build more advanced, more portable desktop clients.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7918">What is the definition of a JUG Leader?</a></h2>
						<p style="margin-left:8px;">
						"<i>A JUG Leader understands the power of communication, collaboration, and community.</i>" Greenville JUG leader John Yeary opines on the qualities and responsibilities of a good JUG leader.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7853">NetBeans Poll: Your Biggest Projects in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						What's the biggest project you've developed using NetBeans IDE? Let the NetBeans Team know via the latest community poll.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7921">Java Spotlight Podcast 109: Pete Muir on CDI 1.1</a></h2>
						<p style="margin-left:8px;">
						Roger Brinkley interviews CDI 1.1 specification lead Pete Muir.</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/2012-11-26.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>