
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 278</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 {text-align:center; padding-top:50px; 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;}
#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 {border-top:1px solid silver; margin-top:15px;padding-top:3px;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 278 - Feb 12, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1036">CORRECTION: NetBeans Day, Hyderabad — February 23, 2007</a></h2>
						<p style="margin-left:8px;">
						In previous editions, we published an incorrect date for NetBeans Day, Hyderabad. The right date is February 23, 2007. We apologize for any confusion this may have caused.

Next stop on the NetBeans WorldTour is Hyderabad, India! Mingle with NetBeans experts and enthusiasts. Watch cool demos of available and upcoming features. Pick up a few IDE tips & tricks. Get the latest on NetBeans, and more. The best part? The WorldTour is FREE. Space is limited so reserve your spot today.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1036">Read more&nbsp;...</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1035">"Why I Want to Move to the NetBeans Platform"</a></h2>
						<p style="margin-left:8px;">
						We like "Switch" stories and here's a good one from Geertjan's blog. An email query from a software architect for a telecommunications company in London turns into an impromptu interview about why he plans to move his company's Swing app to the NetBeans Platform.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1035">Read more&nbsp;...</a></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1032">VWP: Setting Up Page Navigation</a></h2>
						<p style="margin-left:8px;">
						This tutorial provides steps on setting up page navigation in NetBeans 5.5 Visual Web Pack. You also learn an alternative and more advanced method of dynamic page navigation, which allows the page navigation to occur as soon as a selection is made from the Drop Down List.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1032">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1034">VWP: Coordinated Drop-Down Lists</a></h2>
						<p style="margin-left:8px;">
						The Tutorial Divas show how easy it is to synchronize coordinated drop-down lists in a Visual Web Pack page.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1034">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1033">Uncovering Memory Leaks Using NetBeans Profiler</a></h2>
						<p style="margin-left:8px;">
						A two-part tutorial on using the NetBeans Profiler to locate memory leaks in a Java application.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1033">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1037">Generate a NetBeans Module for Your Library or JavaBeans in One Ant Task</a></h2>
						<p style="margin-left:8px;">
						Wouldn't it be nice if you could get more Swing components for the component palette, to use in your programs?  Tim Boudreau has created a tool - an Ant task - that allows any project that produces AWT or Swing components to generate a NetBeans module with the components, their source code and the Javadoc, which you can simply drop into NetBeans and use.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1037">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1028">Building Use-Case Diagrams with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Do you want to create a Use Case diagram with NetBeans? Charles Ditzel provides links to a two-part tutorial that shows you how.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1028">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1029">A Simple System FileSystem Browser with a Twist</a></h2>
						<p style="margin-left:8px;">
						Sandip Chitale has created a module that displays the System FileSystem (resulting from combining all the layer files of installed modules) in a window. There are other System FileSystem Browser modules out there but Sandip's has a twist.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1029">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1030">Glassfish v1, v2 and Beyond</a></h2>
						<p style="margin-left:8px;">
						What is the difference between Glassfish v1 and v2? Why will Glassfish v3 be revolutionary? How does Glassfish v2 work with NetBeans 5.5.1? Find out in Roman Strobl's blog.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1030">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1031">Web Services Development Using NetBeans IDE & GlassFish</a></h2>
						<p style="margin-left:8px;">
						A series of screen casts from Arun Gupta that show how the NetBeans IDE provides first-class interoperable web services development experience using WSIT in GlassFish v2. The first episode shows how a simple Web service can be developed, deployed and invoked using JAX-WS in GlassFish.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1031">Read more&nbsp;...</a></p>
					</div><div class="align-center">If you do not want to recieve this newsletter, you can <a href="https://netbeans.org/community/lists/top.html">unsubscribe here<a></div>
	<div class="edited">
	This week's issue was brought to you by: Tinuola Awopetu
	</div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-02-12.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>