
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 557</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 # 557 - Oct 03, 2012
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7774">NetBeans IDE 7.3 Beta Now Available for Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7141&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans IDE 7.3 Beta introduces new HTML5 support for developing rich web and mobile applications, with a page inspector and CSS style editor, completely revamped JavaScript editor, new JavaScript debugger, and more. Additional highlights include continued improvements to the IDE's support for PHP, Groovy, Java EE, JavaFX and C/C++.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7779">Video: JavaOne 2012 Technical Keynote</a></h2>
						<p style="margin-left:8px;">
						Watch the JavaOne 2012 Technical Keynote for an overview of how Java technology is evolving to meet the needs of developers and the next generation of enterprise computing. Highlights include the NetBeans HTML5 Project Easel demo.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7776">NetBeans & Project Easel at Silicon Valley Code Camp (Oct. 6-7, 2012)</a></h2>
						<p style="margin-left:8px;">
						Discover how NetBean IDE's new HTML5 support allows a developer to create and manage client side HTML5/CSS3/JavaScript applications. Get details on working with the JavaScript library manager; code completion for HTML5, JavaScript, and jQuery; CSS styling of dynamically generated content, browser integration for fine tuning CSS, and JavaScript debugging.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7773">Video:Getting Started with HTML5 Applications in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						An introduction to support for developing HTML5 applications in NetBeans IDE. The screencast shows how to use wizards in the IDE to create an HTML5 project and how to use the Chrome browser with the NetBeans extension to help preview project layout on various screen sizes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7772">Video: Support for IMP-NG Profile in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates the support for the Information Module Profile - Next Generation profile (JSR 228) when developing small embedded JavaME applications in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7775">Authenticating and Authorizing Users in Java EE 6 Web Applications Running on WebLogic Server 12c</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7130&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 secure a Java EE 6 Web Application with form-based authentication and role-based authorization. It shows how to create a login form with JavaServer Faces as the client to collect user and password data and how to authorize certain roles that access a Servlet. It also shows how to add users to the WebLogic Server 12c and map them to the Web Application roles that will be used in the authentication and authorization processes.</p><br style="clear:both;"/>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7777">3 Nods for NetBeans at Duke's Choice Awards 2012</a></h2>
						<p style="margin-left:8px;">
						Three NetBeans-based projects are among the 2012 Duke's Choice Awards winners. The Agrosense project, NATO's MICE project, and the United Nations High Commissioner for Refugees project received honors at the JavaOne 2012 conference.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7778">Highlights from NetBeans Day at JavaOne 2012!</a></h2>
						<p style="margin-left:8px;">
						The return of NetBeans Community Day to JavaOne was a hit! Geertjan provides a rundown of the day's highlights.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7780">JavaOne Discount:</a></h2>
						<p style="margin-left:8px;">
						For a limited time, Java EE 6 developer and author David Heffelfinger is offering a "JavaOne special" on orders of his comprehensive guide to Java EE 6 development with NetBeans IDE. Enter the code "GFAS8NB" and receive a discount on print copies of his book.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=7757">Nominations Open for the NetBeans Governance Board</a></h2>
						<p style="margin-left:8px;">
						Only a few days left to submit nominees for the 20th term of the NetBeans Governance Board. You can even nominate yourself!
<br><br>
The <b>deadline for nominations is Monday, October 8</b>, at <a href="http://www.timeanddate.com/worldclock/fixedtime.html?msg=NetBeans+Governance+20th+Term+Nomination+Deadline&iso=20121008T2355&p1=1033">midnight in the last time zone</a>.</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-10-03.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>