
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 280</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 {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 280 - Feb 26, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1056">NetBeans 6.0 Milestone 7 Available</a></h2>
						<p style="margin-left:8px;">
						Milestone 7 of NetBeans 6.0 is now available for <a href="http://wiki.netbeans.org/wiki/view/MilestoneDownloads">download</a>. M7 comes up with many new features and improvements: Java Web Start support for J2SE Projects, Expression stepping in Debugger, JBoss 5 support, Profiler Improvements, Local History and Subversion, and more. Read the milestone report for details.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1056">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1059">UML Beta 3 Now Available for Download</a></h2>
						<p style="margin-left:8px;">
						You sent us feedback and we listened! The UML Beta 3 is now available for download from the NetBeans 5.5 Beta Update Center. This Beta 3 release contains all the fixes to defects reported by our user community since the Beta 2 release in January. We encourage you to install this latest version and let us know what you think using the UML user survey.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1059">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1064">NetBeans Governance Board Elections</a></h2>
						<p style="margin-left:8px;">
						At this time we are asking you to submit your nominations for the community members you wish to be considered for the NetBeans Governance Board. The deadline for nominations is Wednesday, March 7th, midnight in the last time zone.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1064">Read more&nbsp;...</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1060">NetBeans Day Hyderabad: Standing Room Only</a></h2>
						<p style="margin-left:8px;">
						Want to know what happens at a typical NetBeans Day? Get the details from Geertjan who attended Sun Tech Days in Hyderabad, India, and did some presentations.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1060">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1058">Using NetBeans to Help Track Drunk Drivers</a></h2>
						<p style="margin-left:8px;">
						Smart Start is a company that makes ignition interlock devices that prevent intoxicated drivers from driving. CPB Inc is a software consulting and design firm. Find out how the two used NetBeans to manage the business of "separating drinking from driving".
						<a href="http://services.netbeans.org/newsletter/story.php?id=1058">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1055">What is "Project Schliemann"?</a></h2>
						<p style="margin-left:8px;">
						Hint: Scripting language, NetBeans 6.0. Get the details from Sandip Chitale's latest blog entry.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1055">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1063">What is the NetBeans Enterprise Pack Really All About?</a></h2>
						<p style="margin-left:8px;">
						With the 5.5 release the NetBeans Enterprise Pack provides visual editors for XML schemas, WSDL files, and BPEL scripts.  But where do those BPEL scripts get deployed?  And for what purpose?  To get some answers, check out Gregg Sporar's blog entry: Understanding JBI and Open ESB.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1063">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1062">Web Service Development Using WSIT Plug-in, NetBeans & GlassFish</a></h2>
						<p style="margin-left:8px;">
						Part three of Arun Gupta's Web Service Screencast Series shows how a reliable and inter-operable Web Service can be developed and invoked using the NetBeans IDE and WSIT plug-in. Also, get a sneak preview of other upcoming screen casts.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1062">Read more&nbsp;...</a></p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1052">NetBeans Day, Kuala Lumpur — March 6, 2007</a></h2>
						<p style="margin-left:8px;">
						NetBeans Day Hyderabad just wrapped up. And did you read about the <a href="http://blogs.sun.com/geertjan/date/20070223">Standing Room Only</a> crowd? If you missed all the NetBeans fun in India you can make up for it in Malaysia.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1052">Read more&nbsp;...</a></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1053">Learning Java - One Week of SL-275</a></h2>
						<p style="margin-left:8px;">
						You ask questions on forums, learn from code samples and APIs, and you are comfortable with the features your language of choice has to offer. So why take a formal programming course at all? Intrepid reporter Ruth Kusterer attended SL-275, a Java training class offered by Sun Microsystems, to find out what she might be missing going at it alone.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1053">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1061">Creating a XML Multiview for a XML File</a></h2>
						<p style="margin-left:8px;">
						Want to learn how the XML Multiview API and Visual Library API work together? Vadiraj, based in Bangalore, India, is part of a team that has extensively used both APIs. Here he begins a series discussing how to use them together.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1061">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1054">Struts Basic</a></h2>
						<p style="margin-left:8px;">
						In this hands-on lab from Sang Shin, you will learn the fundamental concept, architecture, and features of Struts 1.1 by building and deploying simple Struts applications, following a step-by-step guide using NetBeans.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1054">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1057">Visual Web Pack: Building a Tree from Database Data</a></h2>
						<p style="margin-left:8px;">
						This tutorial teaches you how to dynamically build a tree structure from data in a database.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1057">Read more&nbsp;...</a></p>
					</div>
	<div class="edited">
	This week's 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-02-26.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>