
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 542</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 # 542 - Jun 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=7474">Code Coverage for Maven Integrated in NetBeans IDE 7.2</a></h2>
						<p style="margin-left:8px;">
						JaCoCo, the Java Code Coverage library, is now supported natively in NetBeans IDE 7.2.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7475">NetBeans IDE 7.2 Introduces TestNG</a></h2>
						<p style="margin-left:8px;">
						Blogger Dustin Marx demonstrates how NetBeans IDE 7.2 helps developers new to TestNG get started with the test framework that is an alternative to JUnit.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7476">LightFish: The Enterprise Side of JavaFX</a></h2>
						<p style="margin-left:8px;">
						Learn to use LightView to convert REST services into a bindable set of properties.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7469">Part 3 of the RESTful Web Services Using NetBeans 7 Tutorial Series</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6812&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;'/>
						Developing an Ajax Client for RESTful Web Services in NetBeans 7: Part 3 is the third installment of the RESTful Web Services Using NetBeans 7 Tutorial Series. This tutorial demonstrates using an Ajax-based HTML page as the client to consume RESTful Web service in NetBeans 7. It provides an overview of two approaches to render AJAX response either in XML or JSON format.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7471">Video: How to Rewrite the Tabs in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Learn to change the appearance of the tabs in the NetBeans IDE. See the <a href="https://blogs.oracle.com/geertjan/entry/youtube_how_to_rewrite_the">related blog entry</a> for additional links.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7472">Video: Why Not Private Visibility For Injected Fields</a></h2>
						<p style="margin-left:8px;">
						This screencast explains why package private visibility of injected fields does not break the encapsulation of Java EE applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7470">New JavaMail and Java EE Environmental Variables tutorials</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6811&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;'/>
						Sending an Email using the JavaMail API <https://apex.oracle.com/pls/apex/f?p=44785:24:1316134537148901::NO::P24_CONTENT_ID,P24_PREV_PAGE:6316,1> covers sending email from a Java EE application using the JavaMail API. 	
Using Java EE Environmental Variables <https://apex.oracle.com/pls/apex/f?p=44785:24:1316134537148901::NO::P24_CONTENT_ID,P24_PREV_PAGE:6317,1> shows you how to avoid hard-coding variable values within your application that may frequently need to be modified.</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7473">Tech Tip: Build and Sign Android APK Using JDK 7 with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Tonny Kohar shares an easy tip for building and signing Android APK with JDK7 and NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7477">Writing an Atlassian Bamboo Plugin</a></h2>
						<p style="margin-left:8px;">
						A new Atlassian Bamboo plugin is on its way, courtesy of Adam Myatt.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<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-06-18.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>