
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 601</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 # 601 - Aug 19, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8580">Take the NetBeans IDE 7.3 Satisfaction Survey!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team nees your feedback about your experience using NetBeans IDE 7.3 or its update release, NetBeans IDE 7.3.1. Are you getting the best coding experience when using NetBeans IDE 7.3 or NetBeans IDE 7.3.1? Are there features or enhancements the NetBeans team should consider in future releases? Let us know!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8579">Plugin: NetBeans CSV Editor</a></h2>
						<p style="margin-left:8px;">
						The NetBeans CSV Editor plugin provides a handy graphical editor for CSV files.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8582">Java EE 7 Technical Kit</a></h2>
						<p style="margin-left:8px;">
						The Java EE 7 Technical Kit is a bundle of in-depth material that brings developers quickly up to speed on the many new and updated features available in the platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8583">10 Steps to Happiness with Scala and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A step by step procedure for install Scala support in NetBeans IDE 7.3.1. The article also shows how to open the examples from the Scala distribution into NetBeans IDE. A <a href="https://blogs.oracle.com/geertjan/entry/lift_scala_maven_and_netbeans">follow up article</a> shows how to work with the Lift framework in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8584">ExtJs, JSON-P, and Java Web with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						In a previous article, Constantin Drabo demonstrated how to build an ExtJs application. In the latest article in the series, he shows the content of a small patient management application using ExtJs as client-side framework and Java web with Spring framework on the server-side.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8585">Updates for Benno Markiewicz Plugins</a></h2>
						<p style="margin-left:8px;">
						Benno Markiewicz reports on having updated his plugin "Close All Documents From This Project"/"Close All Documents From Other Projects", as well as his plugin to open the tracked GIT branch in the WebUI of the repository hoster you cloned from.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8586">Video Tip: Enable or Disable Line Numbers in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A quick tip showing how to work with line numbers in the IDE.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8581">Java Platform, Enterprise Edition 7: Validating a Method with Bean Validation 1.1</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7983&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 covers how to use method and return value validations, which are new features in Bean Validation 1.1 of Java Platform, Enterprise Edition 7 (Java EE 7). It also covers how Contexts and Dependency Injection (CDI) is supported by the Bean Validation components, such as ConstraintValidator.</p><br style="clear:both;"/>
					</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="http://www.netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="http://www.netbeans.org/community/news/newsletter/index.html">English</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="http://www.netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="http://www.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="http://www.netbeans.org/community/news/newsletter/2013-08-19.html">www.netbeans.org</a>,
				<a href="http://www.netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>