
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 675</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 # 675 - Feb 10, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9796">Accessing Web Sockets from Plain Java with JSR 356</a></h2>
						<p style="margin-left:8px;">
						Learn from Adam Bien, author, trainer, and NetBeans Dream Team member, as he shows how to access a Web Socket from JavaFX, Swing, or from test code. It is suprisingly easy with Java EE 7.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9795">New: Red Hat JBoss Forge Plugin for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Watch on YouTube as the JBoss Forge team demonstrates their new <a href="http://plugins.netbeans.org/plugin/57296/jboss-forge">NetBeans integration with JBoss Forge</a>, released this week.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9791">Released: "Java EE 7 Development with NetBeans 8"</a></h2>
						<p style="margin-left:8px;">
						David Heffelfinger's book on Java EE 7 together with NetBeans IDE has been released. It consists of 364 pages full of instructions and insights for anyone wanting to get a thorough basis for working with the Java EE platform, with NetBeans, the best IDE for Java EE. Buy it today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9793">Available: "JavaFX Rich Client Programming on the NetBeans Platform"</a></h2>
						<p style="margin-left:8px;">
						NetBeans Platform at your local bookstore? Gail Anderson, who with Paul Anderson co-authored "<a href="http://www.amazon.com/JavaFX-Client-Programming-NetBeans-Platform/dp/0321927710">JavaFX Rich Client Programming on the NetBeans Platform</a>" stopped by the local Barnes & Noble, where copies of their book are now available.</p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9794">Aspose</a></h2>
						<p style="margin-left:8px;">
						Watch a new YouTube movie in which the Aspose team demonstrates their new Aspose for Maven plugin for NetBeans IDE, enabling Java developers to work with various binary file formats by using Aspose Java APIs right in their Maven-based projects.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9792">Java SE 8: Using Threads in an HTTP Link Checker</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=9241&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;'/>
						This tutorial shows you how to use Java Platform, Standard Edition 8 (Java SE 8) and NetBeans 8 to create a link checker with the Thread class. For small applications, you add a thread defined by its Runnable interface or by the thread itself, as defined by a Thread object.</p><br style="clear:both;"/>
					</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/2015-02-10.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>