
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 591</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 # 591 - Jun 10, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8415">Register for Free Webinar on Java EE 7</a></h2>
						<p style="margin-left:8px;">
						Developer productivity and application portability play a huge role in the success or failure of your business. Already the world’s #1 development platform, Java is now better than ever with the release of Java EE 7. On Wednesday June 12, Join Oracle and participants from throughout the Java community to learn how Java EE 7 can help you.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8420">Plugin: Display NetBeans Module Dependencies</a></h2>
						<p style="margin-left:8px;">
						In order to understand module relations in an application based on the NetBeans Platform, it is a lot easier to use a graph. This module generates a UML-like component diagram showing the dependencies of NetBeans modules.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8412">Multiple Methods for Monitoring and Managing GlassFish 3</a></h2>
						<p style="margin-left:8px;">
						GlassFish 3 supports multiple methods of monitoring and management. In this article, Dustin Marx looks briefly at the approaches GlassFish provides for administration, monitoring, and management.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8413">Hack OpenJDK with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Vladimir Voskresensky reports that the OpenJDK repository since recently contains a NetBeans project for all C/C++ parts of the OpenJDK, including Hotspot. He shows how to get started and use NetBeans IDE C/C++ tools to hack OpenJDK.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8414">Perl on NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Beta 2 of Sudeep Hazra's Perl IDE on top of NetBeans IDE is available. Read the list of features and code in the free and open source Perl IDE today!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8416">Tweet of the Week: @javapapo</a></h2>
						<p style="margin-left:8px;">
						"I am tired of Eclipse and its never ending bug parade, waiting for this for that. Moving to NetBeans IDE 7.3!"</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8411">NetBeans Community in Croatia, Serbia, Slovenia</a></h2>
						<p style="margin-left:8px;">
						Network satellite management, geolocation services, OpenMQ administration, and neural network management all have tools on the NetBeans Platform, created in Croatia, Slovenia, and Serbia, as this report explains.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8418">Screencast: Adam Bien and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Adam Bien is seen in this screencast hacking live in NetBeans IDE at the JDD conference in Krakow, Poland.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8417">The Ultimate NetBeans Platform Resource</a></h2>
						<p style="margin-left:8px;">
						Hermien Pellissier, in South Africa, reports "I have found that the NetBeans source code is well structured and easy to follow. So even on your very first adventure, you can gain much wisdom!" Join her in her explorations in the NetBeans source code.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8419">Code to the Beat of NetBeans IDE!</a></h2>
						<p style="margin-left:8px;">
						Emilian Bold shares a video showing a NetBeans module that plays an MP3 and syncs in the IDE to the beat.</p>
					</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="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/2013-06-10.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>