
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 462</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 # 462 - Nov 16, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5764">Patch2 for NetBeans IDE 6.9 Now Available</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team has released a new patch, which is an update to NetBeans IDE 6.9.1. The patch includes bug fixes in modules for C/C++, IDE Platform, Java, Java Debugger, Java Web Applications, Maven, Mobility, OSGI, PHP, and RCP Platform.<br><br>
<b>To obtain the fixes, the NetBeans IDE must be installed and running. You can also download the fixes through the IDE's Plugin Manager.</b></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5760">JDK 7 Support in NetBeans IDE 7.0</a></h2>
						<p style="margin-left:8px;">
						Get an overview and images of JDK 7 support coming in NetBeans IDE 7.0.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5761">Plugin: Javeleon</a></h2>
						<p style="margin-left:8px;">
						Javeleon allows developers to dynamically and transparently update actively running Java code within NetBeans modules in a test-instance of an application under development.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5757">The NetBeans E-commerce Tutorial - Testing and Profiling</a></h2>
						<p style="margin-left:8px;">
						This tutorial unit of the NetBeans E-commerce Tutorial series demonstrates how to use JMeter and the NetBeans Profiler to examine the functionality and performance of applications.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5759">NetBeans IDE at OTN Developer Days Sydney (Nov 17) & Melbourne (Nov 19)</a></h2>
						<p style="margin-left:8px;">
						Oracle Technology Network (OTN) Developer Day is a free developer event specifically designed for the enterprise Java developers, to allow all attendees to learn how to enrich their development experience with the latest developments in the Java technology. Join NetBeans evangelist Ashwin Rao in <a href="http://www.oracle.com/go/?&Src=7009948&Act=42&pcode=APACFM10037745MPP037"><b>Sydney</b></a> and in <a href="http://www.oracle.com/go/?&Src=7009948&Act=41&pcode=APACFM10037745MPP036"><b>Melbourne</b></a> where he will demonstrate NetBeans IDE and support for JDK 7 and Java SE 7.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5763">Configure NetBeans For Android Development on Ubuntu</a></h2>
						<p style="margin-left:8px;">
						NetBeans user Tiklu documents his experience setting up his Android SDK in NetBeans IDE (7.0M2) on Ubuntu OS.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5762">Tech Tip: CVS Compression for NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						An oldie but useful tip from NetBeans dreamteam-er Michel Graciano's saved emails.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5756">Java Development with NetBeans IDE and Maven</a></h2>
						<p style="margin-left:8px;">
						This three-part blog series configures Maven for the NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5758">Mobile Internet Portal Development on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Amdocs ChangingWorlds is a telecommunications software company that creates software for large telecom companies worldwide to build mobile internet portals. Using the NetBeans Platform Amdocs has developed a template builder that allows its customers to customize and maintain their portals.</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/2010-11-16.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>