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

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 275 - Jan 22, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1003">NetBeans Selects Dream Team Members</a></h2>
						<p style="margin-left:8px;">
						Congratulations to Adam Bien, Vincent Brabant, Aristides Villarreal Bravo, Wade Chandler, Fabrizio Giudici, Masoud Kalali, Jörg Plewe, Vinicius Senger, Edgar Silva, David Strupl, and Ibon Urrutia. They are the 11 charter members of the newly launched NetBeans Dream Team. The Dream Team is a community-driven group of highly skilled NetBeans users who have a proven record of enthusiasm for and participation in NetBeans events. Learn more about the Dream Team and what the new members plan to do in the coming weeks.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1003">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1001">New NetBeans Poll: Predictions for 2007</a></h2>
						<p style="margin-left:8px;">
						Six NetBeans experts. Six different opinions about what lies ahead for NetBeans and the Java industry 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 for the forecast you think is likeliest to happen!
						<a href="http://services.netbeans.org/newsletter/story.php?id=1001">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=996">NetBeans Podcast Episode #22</a></h2>
						<p style="margin-left:8px;">
						Episode #22 is all about one framework: Seam. Roumen is joined by Brian Leonard to discuss the advantages of using this framework, how it fits with the rest of Java EE, what kinds of problems it solves, if it's ready for commercial use and so forth.
						<a href="http://services.netbeans.org/newsletter/story.php?id=996">Read more&nbsp;...</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=999">Interview: Adam Myatt, author of "Pro NetBeans"</a></h2>
						<p style="margin-left:8px;">
						A new book about NetBeans 5.5 is set to hit the market in March; Geertjan Wielenga talks to the author, Adam Myatt, about his NetBeans background, his experience writing about the IDE, and opinions he formed in the process.
						<a href="http://services.netbeans.org/newsletter/story.php?id=999">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1000">NetBeans Nominated for 2007 Jolt Awards</a></h2>
						<p style="margin-left:8px;">
						Another sign that NetBeans is off to a fine start in 2007. The IDE and two of its packs—Mobility and Visual Web—have been nominated for four Jolt Awards!
						<a href="http://services.netbeans.org/newsletter/story.php?id=1000">Read more&nbsp;...</a></p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1002">Download NetBeans 6.0 Milestone 6</a></h2>
						<p style="margin-left:8px;">
						NetBeans 6.0 Milestone 6 is now available for download. New features added and tested in Milestone 6 include: UI Gestures Collector that logs users’ activities in IDE and Profiler added Memory Profiling Improvements. The Milestone 6 Report contains a complete overview of what's new.
						<a href="http://services.netbeans.org/newsletter/story.php?id=1002">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=997">Portlet Container and NetBeans Portlet Plugin</a></h2>
						<p style="margin-left:8px;">
						This Portlet Container open source project milestone 1 beta is now available as the part of Java Application Platform SDK Update 2 release.
						<a href="http://services.netbeans.org/newsletter/story.php?id=997">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=995">"NetBeans is ready for prime time…"</a></h2>
						<p style="margin-left:8px;">
						Respected XML/Java expert Elliotte Rusty Harold had some good things to say about NetBeans 5.5 in a recent blog entry. Is a switch looming?
						<a href="http://services.netbeans.org/newsletter/story.php?id=995">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=998">Watch Movies in NetBeans IDE!</a></h2>
						<p style="margin-left:8px;">
						Ain’t it cool just how much you can do with NetBeans?! Geertjan Wielenga shows some cool screenshots of movies being played inside NetBeans IDE. Based on the Java Media Framework (JMF), his movie player is also shown running on the NetBeans Platform.
						<a href="http://services.netbeans.org/newsletter/story.php?id=998">Read more&nbsp;...</a></p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=994">Using Databound Components to Access a Database</a></h2>
						<p style="margin-left:8px;">
						In this tutorial, you use the NetBeans Visual Web Pack 5.5 integrated development environment (IDE) to create and deploy a web application that displays master-detail data from a database that is bundled with the IDE. In the application, you select a person from a drop-down list, and the application displays a table that shows all the trip records for that person.
						<a href="http://services.netbeans.org/newsletter/story.php?id=994">Read more&nbsp;...</a></p>
					</div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also live at <a href="https://netbeans.org/community/news/newsletter/2007-01-22.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>
