
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 415</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 # 415 - Nov 12, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4395">Welcome to the New NetBeans.org!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Team is pleased to announce that the migration of NetBeans.org to the Kenai infrastructure has been completed! By now, all registered NetBeans.org users should have received email messages containing their new login and temporary password, and instructions for accessing the new site. Registered users can now access all of the site's services (Wiki, Issuezilla, Source Code Management, Mailing Lists, etc.) with a single sign-on!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4363">NetBeans DVD: Free Shipping Promotion</a></h2>
						<p style="margin-left:8px;">
						The NetBeans team is running a special DVD promotion for international users with low bandwidths. The NetBeans Starter Kit DVD contains NetBeans IDE 6.7.1, the latest JavaFX SDK, and documentation. We will send out NetBeans DVDs for free until we run out, so order now!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4396">Community Language Downloads Available for NetBeans 6.8 Beta</a></h2>
						<p style="margin-left:8px;">
						What's your native language? There's a good chance that the NetBeans IDE speaks it! In addition to the full localization of NetBeans IDE 6.8 Beta into the Sun-supported languages (English, Japanese, Brazilian-Portuguese and Simplified Chinese), select modules of the release are available in some community-translated languages.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4398">NetBeans at the International PHP Conference 2009</a></h2>
						<p style="margin-left:8px;">
						Learn about PHP support and new features in NetBeans IDE 6.8 at the International PHP Conference in Germany! NetBeans PHP engineer Petr Pisl will host a session about how the IDE speeds up development of PHP web applications, and more. Meet the NetBeans team, ask questions and get free gifts!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4361">NetBeans 6.8: A Few of Your Favorite Things</a></h2>
						<p style="margin-left:8px;">
						What are a few of your favorite things about the upcoming NetBeans IDE 6.8?  DZone has rounded up NetBeans developers and users to tell us what they like about the new beta version and how they're using the new features.  The comments reveal the diversity of uses and features in the new NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4366">New Feature on Kenai.com: Deleting Test Projects</a></h2>
						<p style="margin-left:8px;">
						Did you start a few "test" projects to try out Kenai.com, and are now ready to start meaningful projects? Use the new feature on Kenai.com that lets you delete test or silent projects. And remember, by deleting inactive projects, you help keep the collection of projects hosted at Kenai.com useful to the larger Kenai community.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4364">Test the New Cube°n Google Code Connector</a></h2>
						<p style="margin-left:8px;">
						Cube°n integrates tasks and issue tracking systems into NetBeans. Download the latest cubeon-dev version and try the new Cube°n Google Code connector. It allows you to create and update issues both offline and online; supports queries with auto completion hints; and comes with a Task editor and context support. Test it and send feedback to the project owner.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4367">Amazing NetBeans 6.8 Beta Features</a></h2>
						<p style="margin-left:8px;">
						Adam Bien writes about cool new features he spotted while testing the NetBeans IDE 6.8 Beta. For example, the IDE generates unit tests for EJB 3.1 with embeddable container code, and you don't have to look-up the JNDI-name. If you want to learn more, join the lively discussion on his blog.</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/2009-11-12.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>