
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 638</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 # 638 - May 05, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9191">NetBeans IDE 8.0 Patch 1 Now Available</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 8.0 Patch 1 is an update to NetBeans IDE 8.0 and contains fixes for <a href="https://netbeans.org/bugzilla/buglist.cgi?status_whiteboard=80patch1&status_whiteboard_type=allwordssubstr">189 issues</a>. Get it today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9197">Join Free Virtual Developer Day</a></h2>
						<p style="margin-left:8px;">
						Virtual Developer Day: Java 2014 - May 6th (Americas), May 14th (EMEA) and May 21st (APAC). Hear from experts in Java SE 8, Java EE 7 and Java Embedded. Watch tutorials including NetBeans from the experts to improve your expertise in Java, and ask questions during live chats.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9192">NetBeans Ruby and Rails Plugin</a></h2>
						<p style="margin-left:8px;">
						Tom Enebo and the JRuby community have released the NetBeans IDE 8 version of the NetBeans plugin for Ruby and Rails. Several bugs have also been fixed.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9193">5 Features You Will Love About NetBeans</a></h2>
						<p style="margin-left:8px;">
						Support for multiple projects, HTML5 integration with Java EE, Apache Cordova, and more -- read all about Steve Nellon's five favorite NetBeans features!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9199">NetBeans in Education</a></h2>
						<p style="margin-left:8px;">
						"I have had to reveal an ugly truth about being a programmer to my students," writes Ken Fogel. "The truth is that all the errors that occur in their code are their own fault." Continue to his regular column on NetBeans usage in the classroom.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9200">Vaadin and NetBeans Enable Business Applications</a></h2>
						<p style="margin-left:8px;">
						Alejandro Duarte writes that Vaadin and NetBeans prove to be an excellent choice for applications created in the financial, communication, and education sectors. Read the full interview for all the details!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9194">Video: How To Tackle Java EE</a></h2>
						<p style="margin-left:8px;">
						How to start with Java EE? How to organize your code? Let Adam Bien show you how to think about Java EE and how most efficiently to organize your work.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9196">Video: NetBeans PHP Training</a></h2>
						<p style="margin-left:8px;">
						Follow a great series of lessons on PHP development and NetBeans IDE.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9198">Book Review: NetBeans Platform for Beginners</a></h2>
						<p style="margin-left:8px;">
						Dustin Marx discussed the latest NetBeans Platform book at length and ends with the words: "NetBeans Platform for Beginners provides a comprehensive introduction to the NetBeans Platform."</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9195">How to Build a NetBeans Platform To-Do Application</a></h2>
						<p style="margin-left:8px;">
						John N. Kostaras shows step by step how to get started with the NetBeans Platform by building a useful application for maintaining tasks.</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-05-05.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>