
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 593</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 # 593 - Jun 25, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8442">Nominate Projects for a 2013 Duke's Choice Award</a></h2>
						<p style="margin-left:8px;">
						The Duke's Choice Award is the "Oscar Award" of the Java ecosystem. The award is open to all members of the Java community and nominations are accepted by anyone for any compelling use of Java technology. Nominate a project, including your own, today, by 22 July 2013!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8444">JDK 8 is Feature Complete</a></h2>
						<p style="margin-left:8px;">
						Mark Reinhold reports: "All planned features have been implemented and integrated into the master forest, together with unit tests." Try out the feature complete JDK 8 today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8441">Released: Quorum 2.0</a></h2>
						<p style="margin-left:8px;">
						Quorum is a general purpose, object-oriented, programming language. Designed in formal empirical studies with human subjects, Quorum has been iteratively refined to make it easy to understand and use.
major software release of our tools, Quorum 2.0 and Sodbeans 4.0, this last week. More can be found on our new website for the project:</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8440">NetBeans Community Tweets: @thefuzzinator</a></h2>
						<p style="margin-left:8px;">
						"Started a project today in @netbeans using @java ee 7 and websockets. So far EE 7 seems to rock."</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8445">Scratching the Surface with JavaFX at JayDay Munich (July 1, 2013)</a></h2>
						<p style="margin-left:8px;">
						One of the very interesting and useful platforms for JavaFX is touch enabled devices such as Windows 8 tablets. A session on this topic at JayDay/Munich on 1 July 2013 will demonstrate a variety of JavaFX applications running on a Surface Windows 8 Pro, pointing out capabilities in JavaFX designed to leverage touch capabilities.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8448">LibreOffice Integration Framework on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Squibbly is a new framework for Java desktop applications that need to integrate with LibreOffice, or more generally, need office features as part of a Java desktop solution that could include, for example, JavaFX components.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8443">Java EE 7 and NetBeans IDE 7.3.1 in 10 minutes</a></h2>
						<p style="margin-left:8px;">
						Lucas Jellema from Amis in the Netherlands gets you started, very quickly, shows all the links and info you need to work with the freshly released NetBeans IDE 7.3.1 and Java EE 7.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8446">Video: Enterprise Application with MySQL NetBeans 7.3</a></h2>
						<p style="margin-left:8px;">
						In under ten minutes, Nguyen Thanh Tai shows how to do enterprise development with MySQL in NetBeans IDE 7.3.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8451">JSF 2.2 and HTML5  Placeholders</a></h2>
						<p style="margin-left:8px;">
						Adam Bien highlights how Java EE 7 enables the definition of any arbitrary attributes, which are not going to be processed by the JSF runtime and directly passed to the browser.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8452">Another NetBeans Source Adventure</a></h2>
						<p style="margin-left:8px;">
						Hermien Pellissier from South Africa reports on her latest deep dives into the NetBeans sources, this time related to debugging.</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-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>