
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 568</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 # 568 - Dec 18, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7986">Interested in Lambdas and JDK8?</a></h2>
						<p style="margin-left:8px;">
						A preliminary NetBeans build supporting JDK8 Lambdas is available. Many features, including code completion, code highlighting, go to declaration, have been updated to know about lambda expressions and method references.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7983">Plugin: Max 5 Plugin for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Max is a programming environment which is fully aimed at providing multimedia solutions. Find out about the NetBeans IDE 7.2 plugin that provides support for Max!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7980">NetBeans IDE 7.3: Null Dereferencing Hints</a></h2>
						<p style="margin-left:8px;">
						Null checks -- when should you include them in your code? Do you know? From NetBeans IDE 7.3 onwards, NetBeans knows and will be able to help you.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7981">NetBeans IDE 7.3: Improved "Go To" Declaration</a></h2>
						<p style="margin-left:8px;">
						Michael Müller reports on a great performance boost for JSF developers, which he proposed and has recently been implemented.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7979">NetBeans IDE 7.3: Class Element Reordering</a></h2>
						<p style="margin-left:8px;">
						When you're cleaning up your code, you'll be able to use NetBeans IDE 7.3 to set ordering rules and to apply them across scopes of interest, such as files, packages, applications, or multiple applications at the same time!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7985">JavaFX: Designing for Multiple Screen Resolutions</a></h2>
						<p style="margin-left:8px;">
						JavaFX contains a wide range of features that help you support multiple screen resolutions. Designing for a very high resolution, and then using JavaFX's on-the-fly image scaling, ensures all your customers get a perfect end-user experience. Read more here!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7982">NetBeans Community at JavaOne 2012</a></h2>
						<p style="margin-left:8px;">
						Gerrick Bivins and Toni Epple report on their experiences as NetBeans community members at JavaOne 2012. Were you there too? Why not blog about the highlights of JavaOne for you?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7984">Book Review: 20 API Paradoxes</a></h2>
						<p style="margin-left:8px;">
						"Paradoxes you probably haven't thought of before!" Read a new Amazon review of Jaroslav Tulach's new book on API design.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7976">Video: Get Started with JRebel in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Learn how to install and configure JRebel in NetBeans IDE to handle dynamic class reloading and speed up your development time significantly.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7977">Video: Generate an HTML5 Application from JavaEE</a></h2>
						<p style="margin-left:8px;">
						In this YouTube movie, you are shown how to use the IDE to generate JAX-RS web services and then how to generate an HTML5 application from those services.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7978">Video: Spanish Java Programming with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						In this series of Spanish-language YouTube tutorials, you learn Java step by step via NetBeans IDE</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/2012-12-18.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>