
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 351</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 {padding-top:50px;text-align:center; 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;text-align:center;}
#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;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>


<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 351 - Jul 21, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2315">Help Test the Eclipse Project Importer for NetBeans 6.5 Milestone 1</a></h2>
						<p style="margin-left:8px;">
						Due to many requests, the Eclipse Project Importer has been improved and is now part of the standard distribution in NetBeans IDE 6.5 Milestone 1. If you work in mixed-IDE teams and have colleagues using Eclipse, we encourage you to try to import Eclipse projects and provide feedback about the experience by:
<ul>
<a href="https://netbeans.org/community/issues.html">Filing an issue</a>; select component 'ide' and subcomponent 'eclipse project import'. Or<br>
Writing to the <a href="https://netbeans.org/community/lists/top.html#top">nbusers alias</a> with "Eclipse Project Importer" in the subject line.</ul></p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2312">Ibon Urrutia - Building Mobile Apps with TagsMe, No Java Required</a></h2>
						<p style="margin-left:8px;">
						TagsME is an application development platform for portable devices. TagsMe's GUI editor, built on the NetBeans Platform by Java developer and NetBeans Dream Team member Ibon Urrutia, requires no knowledge of Java to get started with creating mobile apps.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2313">Building the NetBeans Docs Community</a></h2>
						<p style="margin-left:8px;">
						In this article, NetBeans Community Docs Manager James Branam writes about the start of the Community Docs program, its members and recent accomplishments, and what to expect in the future.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2307">Shapes, Binding and Animation in JavaFX and NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1488&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						JavaFX makes working with graphics and animation super easy. And thanks to the new NetBeans plugin you can build rich graphics interactively. In this quick demo by Josh Marinacci, learn the basics of creating shapes, binding to variables, and simple rollover animations.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2308">What's Your Sign? - Introduction to the JavaServer Faces Framework</a></h2>
						<p style="margin-left:8px;">
						This tutorial, the first in a series, demonstrates the fundamentals of using the JavaServer Faces (JSF) framework to code web applications in the NetBeans IDE. You create a web application called jAstrologer that takes a user's name and birthday and returns information such as the user's zodiac sign, birthstone, and horoscope.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2310">Creating & Consuming RESTful Web Service jMaki Components</a></h2>
						<p style="margin-left:8px;">
						You can reuse RESTful client stubs in multiple web applications by wrapping the stub in jMaki components, also called a jMaki widget. This tutorial shows you how to create and consume jMaki components built from RESTful Web services projects in NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2309">Installing & Configuring Ruby Support in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Learn to download, install and configure the Ruby support for the NetBeans 6.1 IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2314">Ten Great Features in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Community member Zach Elko showcases his list of ten helpful and cool features in the NetBeans IDE, and illustrates with superb visuals from a C++ project.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2316">Groovy in NetBeans - Inplace Rename</a></h2>
						<p style="margin-left:8px;">
						Martin Adamek's blog is a good stop for updates about Groovy support in NetBeans IDE 6.5. In this blog entry (and a few more to come) he gives a summary of interesting features available in the IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2317">Good idea: Java and Groovy with NetBeans 6.5 Milestone 1</a></h2>
						<p style="margin-left:8px;">
						This blog describes the benefits of using the NetBeans IDE to mix Groovy and Java, a completely intuitive process with no worries about build scripts and library management.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2311">NetBeans as an IDE for Developing MySQL</a></h2>
						<p style="margin-left:8px;">
						Kaj Arno, MySQL's community Veep, posts about the technical advantages of using the NetBeans IDE to learn and code MySQL.</p>
					</div>
	<div class="edited">
	This 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 class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-07-21.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>