
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 589</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 # 589 - May 27, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8373">Register for Free Webinar on Java EE 7</a></h2>
						<p style="margin-left:8px;">
						The "Introducing Java EE 7" webinar is a free online event where you can connect with Java users from all over the world as you learn about the power and capabilities of Java EE 7. It will be broadcast on Wednesday, June 12, 2013 and Thursday, June 13, 2013.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8374">Join NetCAT for NetBeans IDE 7.4</a></h2>
						<p style="margin-left:8px;">
						For the upcoming NetBeans IDE 7.4, the start of the NetBeans Community Acceptance Testing program (NetCAT) has been announced. Get involved with the program, develop on the bleeding edge, and report on your experiences directly to the NetBeans team.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8375">PCWorld.com: Office Suite on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Anthony Goubard, a freelance Java developer, took 30 days to build and launch a basic open source office suite on the NetBeans Platform. Many YouTube movies, screencasts, and information about this project is available. Join in today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8376">Jelastic.com: Integration with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						The Jelastic team reports on why they created a Jelastic plugin for NetBeans IDE. With the new Jelastic plugin, you can work with your development, test and production deployments without leaving your favorite IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8377">JAXenter.com: NetBeans IDE 7.3 and HTML5 support</a></h2>
						<p style="margin-left:8px;">
						More and more enterprise applications are moving to the HTML5 platform and NetBeans IDE wants to help ease that transition. Read a recently published article on JAXenter.com about the new HTML5 features in NetBeans IDE.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8382">30 May 2013: Joeffice Launch Party in Amsterdam</a></h2>
						<p style="margin-left:8px;">
						There has been quite a lot of press coverage on the launch of Joeffice, the NetBeans Platform based open source office suite, including in Slashdot, PC World, webwereld.nl, IT wire, SF gate, and Le monde informatique. Come to the launch party and find out what all the buzz is about.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8379">3 June - 5 June 2013: Java Croatia Conference</a></h2>
						<p style="margin-left:8px;">
						The HrOUG (Croatian Oracle User Group) and HUJAK (Croatian Java User Association) continue the tradition of organizing the International Java Conference in Croatia. Great speakers and content. If you're in Croatia, be sure to join in!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8378">1 July 2013: JayDay Munich</a></h2>
						<p style="margin-left:8px;">
						Adam Bien, Gerrit Grunwald, Simon Ritter, and many more rock star speakers will be in Munich, Germany, on 1 July 2013 at JayDay! Register today!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8380">Tweet of the Week: @muellermi</a></h2>
						<p style="margin-left:8px;">
						"Get involved with @NetBeans. Join the NetCAT program!"</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8381">YouTube: Installing Tomcat 7 in NetBeans 7.3 IDE</a></h2>
						<p style="margin-left:8px;">
						YouTube has many movies on using NetBeans IDE with popular technologies and framework. Want to see how to register and use Tomcat 7 with NetBeans IDE 7.3? Here's how to get started.</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-05-27.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>