
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 644</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 # 644 - Jun 17, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9310">NetBeans vs. Eclipse</a></h2>
						<p style="margin-left:8px;">
						Speed, native testing support, FindBugs, and the clear user interface of NetBeans IDE are some of the reasons why Gualtiero Testa, from JUG Milano, prefers NetBeans over Eclipse. Read the article to find out the details!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9309">NetBeans Users: Our Favorite NetBeans Features</a></h2>
						<p style="margin-left:8px;">
						Learn about the NetBeans Action Items window, code templates, Android integration, and keyboard shortcuts from NetBeans users <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-moseskhazalwa">Moses Khazalwa</a> and <a href="http://netbeans.dzone.com/5-favorite-netbeans-features-jesusquinones">Jesus Garcia Quinones</a>. What are your favorite NetBeans features? Blog about them or send them to netbeans dot webmaster at gmail dot com.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9308">Latest NetBeans Education Column</a></h2>
						<p style="margin-left:8px;">
						Ken Fogel, NetBeans education columnist, continues teaching you about scanners and regular expressions. Are you also teaching with NetBeans? Write to netbeans dot webmaster at gmail dot com and let us know!</p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9307">IDRsolutions Announce NetBeans Blog</a></h2>
						<p style="margin-left:8px;">
						The IDRsolutions team, one of the <a href="https://netbeans.org/community/partners/">NetBeans Partners</a>, have announced a section of their blog will be dedicated to tips and tricks related to NetBeans IDE. Take a look at their info on profilers, web service integration in NetBeans, and more!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9304">An Interview with John Clingan, GlassFish Product Manager</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Adam Bien interviews John Clingan about the status of GlassFish. John is the Oracle product manage for Java EE and GlassFish Server at Oracle and Sun Microsystems before that.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9303">7 New Tools Java Developers Should Know</a></h2>
						<p style="margin-left:8px;">
						An excellent article that gives you a quick overview of some of the newest most innovative tools around, including JClarity tools and Elasticsearch.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9302">Avoid Clickjacking with Java EE</a></h2>
						<p style="margin-left:8px;">
						Clickjacking, also known as a "UI redress attack", means "hijacking" clicks meant for a page and routing them to another page, most likely owned by another application, domain, or both. Keystrokes can also be hijacked. NetBeans Dream Team member John Yeary explains everything involved in how Java EE can help avoid these situations.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9305">Video: Embedded Development with NetBeans & Raspberry Pi</a></h2>
						<p style="margin-left:8px;">
						PiDome is a home automation system built with NetBeans IDE and the Raspberry Pi. John Sirach, the founder of the project, takes you through all the components of the project and shows how NetBeans IDE helped the team develop the project.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9306">Video: Java, Java EE Q&A with Adam Bien</a></h2>
						<p style="margin-left:8px;">
						The latest answers to questions about Java EE, Java SE, and JavaFX with NetBeans by NetBeans Dream Team member Adam Bien.</p>
					</div>
	<div class="edited">
	NetBeans Weekly Newsletter is brought to you by the NetBeans Team.<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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2014-06-17.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>