
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 370</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/appl2/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/appl2/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 # 370 - Dec 01, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2991">Get NetBeans IDE 6.5 ML from the Chinese NetBeans Portal</a></h2>
						<p style="margin-left:8px;">
						The Chinese NetBeans portal (zh-cn.netbeans.org) now offers NetBeans IDE 6.5 ML for download! Chinese users, and especially university students, can expect increased download speeds via our portal. <a href="http://zh-cn.netbeans.org/">Download the Chinese localization of the NetBeans IDE now</a>.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2989">Get Things Done with Thinking Rock (Built on the NetBeans Platform)</a></h2>
						<p style="margin-left:8px;">
						A two-person development team in Australia has created a software application that helps you to get things done. We spoke to the lead developer of ThinkingRock, Jeremy Moore, to learn about his team's experience using the NetBeans Platform.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2992">Importing Eclipse Projects into NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						NetBeans IDE 6.5 introduces an enhanced Import Eclipse Project wizard. This wizard enables you to use NetBeans to work on Java desktop and web application projects that were created in Eclipse and MyEclipse. Once you have the project imported, you can use either the NetBeans and Eclipse IDEs to modify the project, or both!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2985">Top Eight Non-Java Netbeans 6.5 Features</a></h2>
						<p style="margin-left:8px;">
						New to NetBeans? Dream Team member Adam Bien gives you an overview of his top 8 favorite NetBeans features–and he is not even counting the Java features!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2988">A Look Back at NetCAT 6.5</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team Member Varun Nischal participated in the NetBeans Community Acceptance (NetCAT) program for the very first time. Read his blog if you are interested in his experience of being among the first to try and review upcoming features.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2986">Working with JavaScript Toolkits in NetBeans IDE 6.5</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2201&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						This screencast demonstrates how to work with JavaScript toolkits in the IDE. The first part shows how to add a toolkit that is registered with the IDE to a project; the second part shows how to register a new toolkit with the IDE.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2990">Debugging Multithreaded Applications in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This document describes how to use the Debugging window in NetBeans IDE 6.5 to debug multithreaded applications. The tutorial also demonstrates how to use the IDE to detect deadlocks in an application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2987">PHP Support in NetBeans 6.5 (Part I & 2)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2200&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						In the first part of this new screencast series focused on NetBeans IDE 6.5 for PHP, you will learn about PHP project and run configurations. The <a href="https://channelsun.sun.com/category/playlist?id=81">second part</a> is about basic editor features.</p><br style="clear:both;"/>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<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>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-12-01.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>