
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 277</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 # 277 - Feb 05, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1027">NetBeans Day, Hyderabad — February 21, 2007</a></h2>
						<p style="margin-left:8px;">
						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=1027">Read more&nbsp;...</a></p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1024">Java Mobile Application Video Contest</a></h2>
						<p style="margin-left:8px;">
						Create a short (1-3 minute) video to tell everyone in your own words about a new mobile application or service that was created using the Java ME Platform or open source phoneME project. Whether you created it or not, you can tell others what it does, how it works, why you think it's cool, how it was built or anything else about it. Get creative. Do something unexpected. Win cool prizes. Contest deadline is April 27, 2007.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1024">Read more&nbsp;...</a></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1022">Video: Bruno and Roman Discuss NetBeans at JavaPolis</a></h2>
						<p style="margin-left:8px;">
						NetBeans Community Manager Bruno Souza and Evangelist Roman Strobl chat at Javapolis about NetBeans 5.5 and Java SE 6, the NetBeans community, what's coming up in NetBeans 6.0 and other important issues for NetBeans.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1022">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1021">NetBeans Poll: Predictions for 2007</a></h2>
						<p style="margin-left:8px;">
						It's your last chance to decide which of the six opinions from our NetBeans experts is likeliest to happen in 2007. Will Linux users open up to Java or will NetBeans's scripting support bring it some new fans? Read the predictions and vote. Or cast a vote for your own prediction!
						<a href="http://services.netbeans.org/newsletter/story.php?id=1021">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1025">NetBeans Podcast Episode #23</a></h2>
						<p style="margin-left:8px;">
						Not even an ice storm and two hurricanes could keep the 23rd episode of NetBeans podcast from coming together. Gregg and Roman discuss Project Plethora, NetBeans Mobility Pack for CDC 5.5 release, NetBeans 6.0 and more.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1025">Read more&nbsp;...</a></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1018">Java EE Application Client on Top of the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how easy is to create an application client on top of the NetBeans Platform.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1018">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1026">Generating Reports and PDFs From a Web Application</a></h2>
						<p style="margin-left:8px;">
						Do you want to display a report in your web application, or output the data in a PDF or spreadsheet format? JasperReports is a reporting tool that outputs reports in HTML, PDF, XLS, CSV, and XML formats. This tutorial shows how to use the open source JasperReport framework from a web project that you build using the NetBeans Visual Web Pack.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1026">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1017">99-Second Demos About NetBeans Enterprise Pack 5.5</a></h2>
						<p style="margin-left:8px;">
						A cool concept from Sherry Barkodar: short flash tutorials that summarize all you need to know about NetBeans Enterprise Pack 5.5.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1017">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1019">Automating Test Coverage Reports with NetBeans and Cobertura</a></h2>
						<p style="margin-left:8px;">
						From Dream Team member Fabrizio Giudici: "Whether you're an agilist or not, you should be aware that automated testing is one of the key factors for the success of your projects. While test runners such as JUnit are widely known, there are other powerful tools that can help: those that produce reports about your test coverage."
						<a href="http://services.netbeans.org/newsletter/story.php?id=1019">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1023">Creating and Invoking a Web Service Using GlassFish in 3 IDEs</a></h2>
						<p style="margin-left:8px;">
						A three-part series from Arun Gupta that compares how Web Services can be built, deployed and invoked using GlassFish in NetBeans, IntelliJ and Eclipse IDEs.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1023">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1020">Creating a New Components Palette for Java Server Faces Dev in NetBeans 5.5</a></h2>
						<p style="margin-left:8px;">
						Another Dream Team entry. Edgar Silva shares tips and tricks for those looking to create an application using Java Server Faces in NetBeans.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1020">Read more&nbsp;...</a></p>
					</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-05.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>