
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 475</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 # 475 - Feb 21, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6125">NetBeans IDE 7.0 Beta 2 Available for Download, with Git Preview</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5423&column=image&table=story&type=image/gif&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.0 Beta 2 provides improved quality and performance with bug fixes, as well as a preview of Git support! To obtain the Git plugin: <a href="http://download.netbeans.org/netbeans/7.0/beta2/"><b>Download Beta 2</b></a>; In the IDE, go to <i>Tools --> Plugins --> Available Plugins</i>.<br><br>
NetBeans IDE 7.0 Beta 2 is available in English, Brazilian Portuguese, Japanese, Russian, and Simplified Chinese, as well as in several community-translated languages. Visit the <a href="http://wiki.netbeans.org/NewAndNoteworthyNB70">7.0 New and Noteworthy page</a> for additional information and development updates. <b>The final release of NetBeans IDE 7.0 is planned for April 2011</b>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6118">Tom Enebo and Ruby Community Take Over NetBeans Ruby Support</a></h2>
						<p style="margin-left:8px;">
						Ruby developer Thomas Enebo and other experts in the Ruby/JRuby community (Yoko Harada, Charles Nutter, Nick Sieger, Erno Mononen) are taking the lead to continue development of Ruby support in the NetBeans IDE. Find out why this effort is important, and how to join them!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6123">NetBeans Plugin - CUDA Plugin</a></h2>
						<p style="margin-left:8px;">
						This module provides NetBeans IDE 6.9.1 with a toolchain for the NVIDIA CUDA compiler (nvcc) under Linux.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6124">NetBeans Podcast #54: SodBeans & Intuitive Computer Programming</a></h2>
						<p style="margin-left:8px;">
						Get the latest NetBeans Community news; take a guess at the puzzler; learn a new API design tip; and listen to Computer Science professor Andreas Stefik discuss how his research is making computer programming easier for blind developers, and more intuitive for all.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6121">Git User Guide in NetBeans IDE 7.0</a></h2>
						<p style="margin-left:8px;">
						The NetBeans IDE 7.0 Beta 2 provides support for the Git version control client. This tutorial gives an overview of Git Features in the IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6122">Video: Generating PHP Documentation With NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This screencast shows how to generate PHP documentation using PHPDocumentor in the NetBeans IDE. The video includes details of installing PHPDocumentor with PEAR and configuring PHPDocumentor, NetBeans IDE and your php.ini file.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6126">Video: WebLogic Server - Java EE 6 Web Profile</a></h2>
						<p style="margin-left:8px;">
						A short demonstration of a development build of WebLogic Server showing Java EE 6 Web Profile support with Servlet 3.0 and CDI examples, driven from NetBeans 7.0.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6119">Interview: Tom Enebo, from the NetBeans Ruby Project</a></h2>
						<p style="margin-left:8px;">
						Thomas Enebo, co-lead of the JRuby project, recently stepped forward to lead community management of Ruby support in the NetBeans IDE. Learn more about Enebo's interest in NetBeans' Ruby support, the group's current development objectives and roadmap.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6120">Build a Web-startable NetBeans RCP App on Mac OS X</a></h2>
						<p style="margin-left:8px;">
						Petr Dvorak shows how to build JNLP (web-startable) applications on the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6127">Tech Tip: Useful JSF 2 / CDI Table Generation Wizard in NetBeans</a></h2>
						<p style="margin-left:8px;">
						NetBeans 6.9.1 comes with a nice and clean JSF 2 table generation wizard. Adam Bien demonstrates.</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/2011-02-21.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>