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

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 304 - Aug 13, 2007
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1312">Register for NetBeans Day Boston - September 11</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=395&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The first stop on the <a href="https://netbeans.org/community/articles/worldtour/index.html">NetBeans worldTour 2007-2008</a> is Boston! Attend NetBeans Day Boston and discover the latest in developer tools, and how NetBeans can boost your productivity regardless of what type of Java technology  development you do or what language you work in. Meet other NetBeans users and experts, and see demos of the next generation of NetBeans software. Learn <b><a href="http://wiki.netbeans.org/wiki/view/NetBeansWorldTour2008">more</a></b> about what to expect on NetBeans Day, and remember: <b><a href="https://www21.cplan.com/pls/pg_sun/reg_sun_std_entry.reg_185X001">Registration</a></b> is free!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1309">NetBeans at Javagruppen (Denmark) - August 20 & 23</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans evangelist Roman Strobl in <a href="http://www.javagruppen.dk/meeting/meetings/67.article">Aarhus</a> (August 20) and <a href="http://www.javagruppen.dk/meeting/meetings/68.article">Copenhagen</a> (August 23), Denmark, for an introduction to the NetBeans IDE. Discover the newest features within the NetBeans IDE for desktop, web and mobile development, and watch demos that highlight these features in action.</p>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1310">Developer Edition of NetBeans OpenGL-Pack Released</a></h2>
						<p style="margin-left:8px;">
						A developer release of the <a href="http://netbeans-opengl-pack.dev.java.net/">OpenGL-Pack for the Netbeans 6.0 IDE</a> is now available for download. Features include: OpenGL Shading Language Compiler/Linker integration and syntax highlighting, Compile and Link arbitrary shaders, and more. Check out <a href="http://www.adam-bien.com/roller/page/abien?entry=3d_for_netbeans_6_0">Adam Bien's blog entry</a> for additional information about the release.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1303">NetBeans Platform: Extending JFugue Music NotePad</a></h2>
						<p style="margin-left:8px;">
						When Michal Fapso, a student at the Faculty of Information Technology in the Czech Republic, needed a project to work on for his term paper on Graphical User Interfaces in Java, he found the open source JFugue Music NotePad and extended it with very powerful editing features. He received full marks, and contributed his code back to the project. And in the process, he learned about the NetBeans Platform. Read all about it in Geertjan's blog.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1302">NetBeans Podcast Episode #33</a></h2>
						<p style="margin-left:8px;">
						Tune in to hear Roman and Gregg talk about everything from the status of NetBeans 6.0 to bugs in the JDK.  There is also discussion of Ruby, freeform projects, project Jarvis, and more!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1306">Using Java Persistence API Within a Visual Web Application</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=389&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='64' width='109' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Learn how to combine a visual web application in the NetBeans 6.0 IDE with the Java Persistence API. This article shows you how to simultaneously use the Java Persistence API and visual web components to retrieve database records and display and modify the data.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1311">Integrating & Using SQE Plug-in for NetBeans IDE 6.0</a></h2>
						<p style="margin-left:8px;">
						A tutorial contribution to <a href="http://grizzly.dev.java.net/">Project Grizzly</a> from Antek Baran: Learn how to setup and use NetBeans IDE 6.0 with the SQE plug-in.  The SQE plug-in contains the popular static analysis tools: FindBugs, PMD and CheckStyle along with Dependency Finder.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1305">The Divas Write About jMaki 0.9.7</a></h2>
						<p style="margin-left:8px;">
						Release Candidate 2 (0.9.7) of the jMaki framework was released on August 10. The Tutorial Divas have posted two blog entries that show how to use the new data model in RC2 to dynamically load data from a database, use the JSON API to format it into the data model format and load it into a jMaki widget that uses that particular data model. In their <a href="http://blogs.sun.com/divas/entry/using_the_spry_accordion_in">first blog entry</a>, they use the Spry Accordion widget in a Visual Web application. In their <a href="http://blogs.sun.com/divas/entry/jmaki_9_7_using_the">second entry</a>, they show how simple it is to swap in the Yahoo Tabbed View widget.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1307">Creating "Pretty" URLs with NetBeans and Visual Web Pack</a></h2>
						<p style="margin-left:8px;">
						Ever noticed those ugly URLs that JavaServer Faces produces when you navigate around a JavaServer Faces web application?  Check out David Botterill's blog entry in which he writes about turning those ugly URLs into pretty ones.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1308">Double Feature: Two Screencasts from Arun Gupta</a></h2>
						<p style="margin-left:8px;">
						<b><a href="http://blogs.sun.com/arungupta/entry/screencast_web5_creating_mashups_with">Screencast #Web5: Creating Mashups with jMaki - Mashing up the Maps</a></b> shows how jMaki allows you to embed and interact with map widgets in your application using NetBeans IDE. In <b><a href="http://blogs.sun.com/arungupta/entry/screencast_web6_first_jruby_app">Screencast #Web6: First JRuby app in GlassFish</a></b>, see how a JRuby application can be developed using NetBeans IDE and deployed on GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1304">Perspectives in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Shakthi Anuradha has created a plugin module for NetBeans IDE 6.0 that provides a perspectives feature. It allows you to easily save and restore window positions in the IDE.  His blog entry includes a link to a Flash demo that shows it in action.</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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at <a href="https://netbeans.org/community/news/newsletter/2007-08-13.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>