
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 317</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 # 317 - Nov 13, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1450">New NetBeans Days in Dubai & Cairo! (Nov. 19 & 21)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=549&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Two exciting opportunities for NetBeans fans in the Middle East: We're hosting software days in Dubai (Nov. 19) and Cairo (Nov. 21)! Learn what's coming in NetBeans 6.0, how to use NetBeans to develop rich internet applications, how to take advantage of new Swing tooling, what's new in mobility and more. This is a first for us, so please help to spread the word to your developer friends in the Middle East.
<br><br>Register for Dubai <a href="http://www.cpilive.net/nl/2007/uadf/index.aspx">here</a>, and stay tuned for more details on Cairo!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1452">Catch Up With NetBeans in South America!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=556&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='104' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Evangelists Tim Boudreau and Bruno Souza have been on a whirlwind tour of universities in South America, meeting with students, professors and local JUGs in Brazil, Uruguay, Argentina and Chile. Follow details of their adventures on Tim's blog, replete with photos of the local flavors. But there are only three more days left in the tour, so make sure to catch up with the guys in Brazil: Florianopolis (Nov. 14), Natal (Nov. 16) and Porto Alegre (Nov. 19).</p><br style="clear:both;"/>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1444">Optimize Apps With the NetBeans DTrace GUI Plug-in</a></h2>
						<p style="margin-left:8px;">
						DTrace is a powerful tracing tool built into Solaris that lets developers and administrators optimize applications for performance and troubleshoot the OS. The <a href="https://netbeans.org/kb/dtracegui_plugin/NetBeans_DTrace_GUI_Plugin.html">NetBeans DTrace GUI plug-in</a> runs DTrace scripts in the NetBeans 5.5/5.5.1/6.0 IDEs and Sun Studio 12 IDE. No knowledge of D language is required to use DTrace. Easily create and add new scripts to the DTrace GUI, and run D scripts packaged in the DTraceToolKit. <a href="http://developers.sun.com/solaris/articles/dtrace.html">Learn more</a> about what DTrace can do for you! <i>(Note: The current plug-in runs only on Solaris 10 and 11 systems.)</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1448">NetBeans Can Refactor C/C++ Code!</a></h2>
						<p style="margin-left:8px;">
						An experimental version of the C/C++ Refactoring module is now available for download from the NetBeans Plugin Portal. Watch a <a href="http://wiki.netbeans.org/wiki/attach/CndRefactoring/Refactoring.htm">demo</a> that shows the functions the module provides, such as instant rename of local variables in functions (Ctrl-R), global Rename (Ctrl-R) and Find Usages (Alt-F7). The team responsible for the module also wants your feedback. Let them know what you think. Send comments to <a href="mailto:Vladimir.Voskresensky@sun.com">Vladimir.Voskresensky@sun.com</a> or <a href="mailto:users@cnd.netbeans.org">users@cnd.netbeans.org</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1449">Updated: Visual Web Woodstock Component Theme Builder Plugin</a></h2>
						<p style="margin-left:8px;">
						Winston Prakash has updated the Visual Web Woodstock Component Theme Builder plugin for the Beta 2 release of NetBeans 6. The plugin allows Visual Web users to create custom themes to give their web apps a unique look. Check out Winston's blog for download link and installation instructions.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1443">Video: Creating a Weblog Using NetBeans 6.0 Ruby Support</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=542&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='68' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Tor Norbye uses the NetBeans 6.0 Ruby Support to create a weblog in this update to the classic Ruby Weblog screencast.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1451">Working With Ant in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Apache Ant is a popular Java-based build tool. With this tutorial, learn how to convert the Ant open-source project into a NetBeans project to develop, build, and test Ant within the Netbeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1445">Resolving NetBeans Web App Deployment Problem to Apache Tomcat</a></h2>
						<p style="margin-left:8px;">
						Tutorials and screencasts are not the only ways to participate in the <a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">Community Docs</a> program, shorter "Tips & Tricks" entries are equally welcome, like this one from <a href="http://blogs.sun.com/branajam/entry/nb_community_docs_spotlight_kok">Kok-Yan Lo</a>, a University of Surrey (Guildford) student and a two-year NetBeans user. Lo gives the steps to fixing errors encountered in NetBeans when deploying web applications to Apache Tomcat.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1446">Training Future NetBeans Certified Engineers</a></h2>
						<p style="margin-left:8px;">
						The first <a href="http://wiki.netbeans.org/wiki/view/NetBeansCertifiedEngineerCourse">NetBeans Certified Engineering Course</a> was held, in Linz, Austria on November 9th and 10th, and 40 students at the Institut für Systemsoftware were introduced to the main NetBeans APIs in the context of the NetBeans Platform. They will be certified NetBeans engineers once they submit modules, code fixes, or patches of an acceptable standard. Do you want to learn about the NetBeans Platform too? Let us know!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1442">Access the NetBeans Update Center Over the Web</a></h2>
						<p style="margin-left:8px;">
						Strict firewall rules can at times prevent access to the NetBeans Update Center (NetBeans 5.x) or Plugin Manager (NetBeans 6.0) directly from the IDE. Now, a "secret" URL link provides this access over the web! Get the skinny from Roman's blog entry.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1453">Screencast #Web10: CRUD Using jMaki & JPA</a></h2>
						<p style="margin-left:8px;">
						Using the NetBeans IDE, create a simple jMaki application that performs some of the  CRUD operations on a Data Table widget. Java Persistence API (JPA) connects to the database and the application is deployed on GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1447">Creating an Auto-Complete Entry Field With Woodstock</a></h2>
						<p style="margin-left:8px;">
						This entry from Dmitry Kushner shows how to use Woodstock components to add auto-complete functionality to a textField and listBox.</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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-11-13.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>