
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 274</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 # 274 - Jan 15, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=991">Mobility Pack for CDC Developer Survey</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Mobility Pack for CDC 5.5 is coming soon and the Mobility Team has started work on enhancements for the next release. This brief survey—just 10 questions—is your chance to let them know how to make future CDC Pack releases even more useful to you.
						<a href="http://services.netbeans.org/newsletter/story.php?id=991">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=985">Java EE 5 Tools Bundle, Multi-language Released</a></h2>
						<p style="margin-left:8px;">
						This tools bundle, which includes NetBeans IDE 5.5 Multi-language with NetBeans Enterprise Pack 5.5 Multi-language, is now available localized into Japanese, Simplified Chinese, and Brazilian Portuguese.
						<a href="http://services.netbeans.org/newsletter/story.php?id=985">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=990">Brazilian Portuguese Needs Testers!</a></h2>
						<p style="margin-left:8px;">
						Thanks to great contribution by a number of developers in Brazil, we now have a Brazilian Portuguese version of NetBeans 5.5. But the work isn't finished yet. We need testers to make sure the IDE will be accepted by developers in Brazil. Download NetBeans 5.5 in Brazilian Portuguese, try it out and give us feedback! Participate in the testing contest and you could win an iPod.
						<a href="http://services.netbeans.org/newsletter/story.php?id=990">Read more&nbsp;...</a></p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=992">NetBeans Takes The Gold</a></h2>
						<p style="margin-left:8px;">
						Last season, NetBeans racked up an impressive collection of good reviews and awards. What will it take to maintain this momentum in 2007? NetBeans's Director of Evangelism Judith Lilienfeld talks about NetBeans's current success and what to expect in the coming year.
						<a href="http://services.netbeans.org/newsletter/story.php?id=992">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=983">Two New Books About NetBeans</a></h2>
						<p style="margin-left:8px;">
						SDN China has published two new books on Java and NetBeans. "Mastering NetBeans" and "Mastering Java ME". "Mastering NetBeans" is a detailed tutorial on the NetBeans IDE, with examples on how to develop various kind of applications with the IDE, while "Mastering Java ME" offers tutorials on Java ME technology, with examples on how to develop, debug and deploy various MIDlet functions with the NetBeans IDE and Mobility Pack.
						<a href="http://services.netbeans.org/newsletter/story.php?id=983">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=982">Tutorial: Introduction to the JSF Framework</a></h2>
						<p style="margin-left:8px;">
						This tutorial, the first in a series, takes you through the basics of using the JavaServer Faces framework to code web applications in NetBeans IDE. Over the series, you will create a web application called jAstrologer that takes a user's name and birthday and returns information like the user's zodiac sign, birthstone, and horoscope.
						<a href="http://services.netbeans.org/newsletter/story.php?id=982">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=989">Tutorial: Download NetBeans Learning Trails</a></h2>
						<p style="margin-left:8px;">
						Looking for more ways to use NetBeans? We now have a new selection of tutorials for the NetBeans IDE and the various add-on packs. Happy learning!
						<a href="http://services.netbeans.org/newsletter/story.php?id=989">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=984">Tutorial: Component Based Web Development in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This 20-minute tutorial takes you through the basics of creating reusable components and assembling them into a web application.
						<a href="http://services.netbeans.org/newsletter/story.php?id=984">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=986">Tutorials: Using jMaki in a Visual Web Application</a></h2>
						<p style="margin-left:8px;">
						From the Java Studio Creator Tutorial Divas: "jMaki beta is out and there is a wonderful NetBeans plugin that works with the NetBeans standard web application project. You can use this plugin with a Visual Web application...."
						<a href="http://services.netbeans.org/newsletter/story.php?id=986">Read more&nbsp;...</a></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=987">Declaration and Javadoc module for NetBeans 6.0</a></h2>
						<p style="margin-left:8px;">
						From  Sandip Chitale: "This module displays the declaration and javadoc of the element under caret in Java editor, in the Declaration and Javadoc windows respectively. Use Window:Declartion and Window:Javadoc menuitems to show the Declaration and Javadoc windows respectively." This blog entry also explains how the module works.
						<a href="http://services.netbeans.org/newsletter/story.php?id=987">Read more&nbsp;...</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=988">Cool Tip: CSS Editor in NetBeans 5.5</a></h2>
						<p style="margin-left:8px;">
						Blogger Edgar Silva unearths a "hidden feature"—the CSS editor—in NetBeans 5.5 and includes a useful demo.
						<a href="http://services.netbeans.org/newsletter/story.php?id=988">Read more&nbsp;...</a></p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=993">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=993">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-15.html">www.netbeans.org</a>
		</div>
	</div>

</body>
</html>
