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

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 297 - Jun 25, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1240">IDE Shootout at JUG Cologne - July 3</a></h2>
						<p style="margin-left:8px;">
						Come watch four IDEs--NetBeans, Oracle, Eclipse and JetBrains--battle it out July 3 at JUG Cologne in Germany. Only one IDE will be left standing. Which will it be?! <b>NetBeans Evangelist <a href="http://blogs.sun.com/roumen/">Roumen Strobl</a> will be representing NetBeans. Good luck to NetBeans!</b> Registration is free, but seating is LIMITED. <a href="https://www.xing.com/app/events?op=detail;id=124526;from=home">Reserve</a> your spot now.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1233">Dream Team Profile: Edgar Silva</a></h2>
						<p style="margin-left:8px;">
						Here's a puzzler: Can Jiu-Jitsu (a martial art form, if you don't know...) make you a better developer? Find out in our latest Dream Team interview with Edgar Silva from Brazil.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1237">NetBeans Podcast Episode 30</a></h2>
						<p style="margin-left:8px;">
						Listen in as Roumen and Gregg talk about tutorials, cool GlassFish documents, upcoming events, and more. Plus, a "NetBeans Puzzler" winner and his cool prize.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1234">Putting Flickr on Rails</a></h2>
						<p style="margin-left:8px;">
						Check out the NetBeans 6.0 Ruby support in action! With this tutorial, create a Ruby on Rails application that searches the Flickr database and displays the results in a web browser.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1231">Resolving Java ME Device Fragmentation Issues</a></h2>
						<p style="margin-left:8px;">
						The write once, run anywhere axiom that has driven the popularity of the Java programming language does not apply very well to the world of Java Micro Edition (Java ME). Device capabilities such as screen size, color depth and memory vary considerably. Throw in the choice of profiles, configurations and J2ME APIs and you have what we call device fragmentation. This tutorial shows how to use the IDE's built-in capabilities to resolve Java ME MIDP device fragmentation problems.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1239">NetBeans Google Toolbar Module Tutorial</a></h2>
						<p style="margin-left:8px;">
						This two-part tutorial demonstrates how to create a module that adds a Google Search toolbar to the IDE.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1230">Extending the NetBeans API Wizards</a></h2>
						<p style="margin-left:8px;">
						Are you developing an application on top of the NetBeans Platform? Or, maybe you're creating plugins to extend NetBeans IDE with new functionality? In either case, you probably use one or more of the NetBeans API wizards, such as the New Action wizard or the New File Type wizard. But what do you do when these wizards do not create all the code you need? Maybe you should think about customizing these wizards to suit your own needs in your own environment. Geertjan gives you some pointers in a new series of blog entries.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1236">Divas Talk About Page Fragments</a></h2>
						<p style="margin-left:8px;">
						In their latest blog entry, the Divas explain how page fragments work and give a few code samples for common tasks.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1238">Screencast #Web2: jMaki on Rails for Dummies</a></h2>
						<p style="margin-left:8px;">
						This screencast from Arun Gupta shows how NetBeans 6.0 M9 can be used to add a Maki-wrapped Yahoo DataTable widget that pulls data from MySQL database using ActiveRecord in a Rails application.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1232">eWeek: USDA Keeps Up with the Flow (With NetBeans)</a></h2>
						<p style="margin-left:8px;">
						<b>Using NetBeans to solve real life issues!</b> Water is an integral part of our lives, yet someone has to make sure there's enough to go around. Read how USDA developers help to keep people hydrated (not to mention clean!) with the NetBeans Platform and development tools from <a href="https://netbeans.org/community/partners/list-strategic.html">NetBeans Strategic Partners</a> Intland and CollabNet.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1235">NetBeans Plug-in for Sun Grid Application Development</a></h2>
						<p style="margin-left:8px;">
						The <a href="http://sungridplugin.dev.java.net/">Sun Grid Compute Utility Module</a> for the NetBeans IDE lets you do a number of cool things: develop a Java application directly in NetBeans; manage resources, jobs, and "runs" on Sun Grid Compute Utility without leaving Netbeans; and more. Learn more about the plug-in and watch a demonstration that was given at JavaOne.</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-06-25.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>