
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 507</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 # 507 - Oct 04, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6807">NetBeans IDE 7.1 Beta Now Available for Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6129&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;'/>
						<b>NetBeans IDE 7.1 Beta</b> debuts with support for JavaFX 2.0. Using 7.1 Beta and the JavaFX 2.0 SDK, developers can experience the full compile/debug/profile development cycle for JavaFX applications.<br><br>NetBeans IDE 7.1 Beta also features support for CSS3; improvements to the Swing GUI Builder; a Visual Debugger for Swing and JavaFX UIs; integrated Git support; PHP, Java EE and Maven enhancements, and more.<br><br>
<b>The final release of NetBeans IDE 7.1 is planned for Fall 2011.</b> The Beta release is available in English, Brazilian Portuguese, Japanese, Russian, and Simplified Chinese.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6806">JavaFX 2.0 Now Available for Download</a></h2>
						<p style="margin-left:8px;">
						JavaFX 2.0 is a major update to the JavaFX platform and provides Java APIs for JavaFX, FXML, a new graphics pipeline for modern GPUs, and more than 50 easily customizable charts, forms, and layout components that can be easily integrated in existing Swing applications.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6813">SodBeans, NetBeans Module Suite, Wins Duke's Choice Award!</a></h2>
						<p style="margin-left:8px;">
						Congratulations to NetBeans Dreamteam member Andreas Stefik and his Southern Illinois University Edwardsville teammates for their recent Duke's Choice Award win at JavaOne 2011! <b>SodBeans</b>, their NetBeans-based module suite around accessibility for the blind in modern programming environments, was selected as an "Innovative Accessibility Solution" winner.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6812">All About NetBeans at the JavaOne 2011 Conference!</a></h2>
						<p style="margin-left:8px;">
						As JavaOne 2011 kicks off this week, visit NetBeans.org for all the information you need about NetBeans at the conference, including session details, schedule, and content, and audio casts from members of the NetBeans team participating in San Francisco</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6811">Setting Up NetBeans IDE With JavaFX 2.0</a></h2>
						<p style="margin-left:8px;">
						JavaFX provides a powerful Java-based UI platform capable of handling large-scale data-driven business applications. NetBeans IDE supports the creation of JavaFX 2.0 applications and the insertion of Swing-compliant JavaFX 2.0 components in Swing applications. Using this document, learn how to set up NetBeans IDE with JavaFX 2.0 SDK when you install the IDE and the SDK separately.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6810">Git User Guide for NetBeans IDE 7.1</a></h2>
						<p style="margin-left:8px;">
						Git support is now integrated into NetBeans IDE 7.1 Beta. Users can now perform versioning tasks directly from their projects within the IDE. This tutorial demonstrates how to perform basic versioning tasks in NetBeans IDE by guiding users through the standard workflow when using versioning software.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6809">Securing a Web Application in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This document takes you through the basics of adding security to a web application that is deployed to either the Oracle GlassFish Open Source Edition, Oracle WebLogic, or Apache Tomcat server.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6808">NetBeans Platform Certified Training, San Francisco (Oct. 10)</a></h2>
						<p style="margin-left:8px;">
						There's still more NetBeans learning to be had after JavaOne 2011 ends! The following week, join NetBeans trainers Toni Epple and Geertjan Wielenga in San Francisco for a deep dive into creating modular Swing applications with the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6805">Java SE 7 Fundamentals Course</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6108&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;'/>
						The Java SE 7 Fundamentals course was designed to enable students with little or no programming experience to begin to learn programming using the Java programming language. The course teaches the significance of object-oriented programming, the keywords and constructs of the Java programming language, and the steps required to create simple Java technology programs. Students taking this course can receive a solid basis in the Java programming language upon which to base continued work and training.<br><br>The course features the Java Platform, Standard Edition 7 (Java SE 7) platform, and uses the Java SE Development Kit 7 (JDK 7) product. See the Oracle Training page for complete details.</p><br style="clear:both;"/>
					</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/2011-10-04.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>