
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 279</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;text-align:center;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 279 - Feb 20, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1051">NetBeans Software Day at the 2007 JavaOne Conference</a></h2>
						<p style="margin-left:8px;">
						Early details are now available. NetBeans Software Day 2007 will take place on Monday, May 7, at the Moscone Center in San Francisco. Learn from the experts what's happening with the NetBeans IDE and Platform at the fourth annual NetBeans Software Day!
						<a href="http://services.netbeans.org/newsletter/story.php?id=1051">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1045">Enterprise Pack NetCAT 5.5.1 Participants Wanted!</a></h2>
						<p style="margin-left:8px;">
						Get on board for our upcoming NetBeans Enterprise Pack 5.5.1 community acceptance testing (NetCAT) Beta program. This 5-week program is scheduled to begin on February 26, 2007.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1045">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1039">NetBeans Vi Editor Module</a></h2>
						<p style="margin-left:8px;">
						The waiting is over. You can now use the new vi plug-in for NetBeans to edit your sources. This feature has been requested many times by people all over the world, so it's great that it is now available.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1039">Read more&nbsp;...</a></p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1038">NetBeans WorldTour</a></h2>
						<p style="margin-left:8px;">
						The next stop on the NetBeans WorldTour is Hyderabad, India. The following two stops will be in Kuala Lumpur, Malaysia and then on to London, UK.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1038">Read more&nbsp;...</a></p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1048">Plugging in to the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						A book on the NetBeans Platform, entitled Rich Client Programming: Plugging in to the NetBeans Platform, is nearing completion and due to be published in early May. Get more information on the book and download a draft chapter.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1048">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1046">NetBeans AspectJ Module Update</a></h2>
						<p style="margin-left:8px;">
						Ramon Ramos has updated the NetBeans AspectJ Module to the latest
AspectJ Version 1.5.3. Get the module from his update center as
described in his blog.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1046">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1049">Screencast WS#2: Invoking a Web Service using NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This screencast by Arun Gupta shows the various ways by which NetBeans IDE can invoke a Web service endpoint. The first part showed only the default way to invoke the endpoint, but this screen cast shows two additional ways.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1049">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1050">Module Info Task Module</a></h2>
						<p style="margin-left:8px;">
						The Module Info Task modules installs an action <strong>Tools:Generate Module Info,</strong> which generates an html document with information about installed modules. The module also defines an Ant task, <code>moduleinfotask</code>, which, when run inside NetBeans (say inside the build.xml of your module or suite project), will generate an html document with information about all the modules. The <strong>Tools:Generate Module Info</strong> and the Ant task share the same code to generate the html document. 

<p>Ant task usage:
<pre>    <code>&lt;moduleinfotask htmlOutputFile=&quot;path/moduleinfo.html&quot;/&gt;</code>            </pre>

Helpful for cross referencing module information and dependencies and generating a report at the end of the build.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1050">Read more&nbsp;...</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1040">Connecting a GUI to a Java DB Database with NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This tutorial guides you through the process of connecting the GUI of an application called ContactEditor to a Java DB database. In the process you will add data aware JDBC components to the GUI that will enable the program to interact with an employee database.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1040">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1041">Working with the Java DB (Derby) Database in NetBeans 5.5</a></h2>
						<p style="margin-left:8px;">
						This document demonstrates how to quickly set up a connection to Sun's Java DB  (which is based on the Apache Derby  database) in NetBeans. Once a connection is made, you can easily begin working with the database in the NetBeans IDE, allowing you to create tables, populate them with data, run SQL queries, and more.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1041">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1042">Visual Web Pack. Hibernate Tutorial</a></h2>
						<p style="margin-left:8px;">
						This tutorial shows you how to use the Hibernate framework in a NetBeans Visual Web Pack project. It also shows how to wrap back end data with Option arrays and ObjectListDataProvider objects for binding to JavaServer Faces components.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1042">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1044">Meet a NetBeans Module Writer: Toni Epple</a></h2>
						<p style="margin-left:8px;">
						Based in Munich, Germany, Toni Epple is busily involved in creating an advanced visual designer for reports in NetBeans IDE. In this brand new interview, you meet Toni, you find out about this project, and you receive an invitation to join this project by contributing code. He also presents a cool Flash demo of current status:
						<a href="http://services.netbeans.org/newsletter/story.php?id=1044">Read more&nbsp;...</a></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1043">Results of the 2007 Prediction Poll</a></h2>
						<p style="margin-left:8px;">
						A month ago, we announced a poll: Six NetBeans experts, six opinions about what could happen for NetBeans or Java in 2007. The results are in and Yarda Tulach's prediction: "Linux community adopts Java" received the most votes.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1043">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1047">NetBeans Podcast Episode #24</a></h2>
						<p style="margin-left:8px;">
						Roumen interviewed Geertjan Wielenga for the 24th episode of NetBeans podcast. The topic of the interview was NetBeans Platform - what are it's advantages, how to get started, links to useful resources, etc.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1047">Read more&nbsp;...</a></p>
					</div>
	<div class="edited">
	This week's issue was brought to you by: Robert Demmer<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-02-20.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>