
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 331</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 # 331 - Mar 03, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1619">Register for NetBeans Day Sydney - March 6</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=729&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 NetBeans WorldTour leaves India and goes down under. Join us in Sydney, Australia! NetBeans Day is a great way for fans of NetBeans and new users to learn about updates to the IDE and how to fast-track their projects. Plus, mingle with the NetBeans team and get cool gifts. Registration for NetBeans Day is FREE, but the seats go fast!</p><br style="clear:both;"/>
					</div>
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1616">Roman Strobl Demoes NetBeans IDE & MySQL</a></h2>
						<p style="margin-left:8px;">
						MySQL, the popular open-source database, is now part of Sun's software portfolio. In this screencast, get a quick start to developing database driven applications with the NetBeans IDE using the MySQL database server.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1617">Build Mobile Games with NetBeans 6.0 & Java ME for the Swedish Game Awards!</a></h2>
						<p style="margin-left:8px;">
						Here's another opportunity to win money using the NetBeans IDE—if you're a Swedish student. The <a href="http://gameawards.se/">Swedish Game Awards</a> has introduced a special category for the use of Netbeans IDE 6.0 and Java ME. This extra prize is 10000 SEK! Swedish Game Awards is the largest game development competition for students in Sweden.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1613">Vinicius Senger: Softening Java's Learning Curve with the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						<a href="http://wiki.netbeans.org/wiki/view/NetBeansDreamTeam">NetBeans Dream Team</a> member Vinicius Senger is the founder of GlobalCode, the largest Java training company in Brazil, and the NetBeans IDE gets an A-plus from him as the ideal tool for teaching and learning Java. Find out why.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1618">Help Define my.netbeans.org & Get a NetBeans T-Shirt!</a></h2>
						<p style="margin-left:8px;">
						Are you a part of <a href="http://my.netbeans.org/">my.netbeans.org</a>, our new community networking site? Check it out and sign up to create your personal profile, add existing community members to your network, keep up to date with the latest news, and generate a cool widget to put on your web properties.
<br><Br>What's next? We want your help in defining the future of my.netbeans. What additional functionality and customizations would you like the site and widget to offer? When you have a suggestion just hit the feedback button. If we like your idea you get a t-shirt!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1614">Creating a Simple Web Application Using a MySQL Database</a></h2>
						<p style="margin-left:8px;">
						Learn to create a simple web application that connects to a MySQL database server with this tutorial that also covers some basic ideas and technologies in web development, such as JavaServer Pages™ (JSP) and more.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1612">Easy Web Site Creation in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This beginner tutorial shows how easy it is to create a web site with NetBeans's drag-and-drop features. It also shows how a new developer can gradually learn Java programming by adding JavaServer Pages (JSP), and creating other features or programs that may be added to a website.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1615">A SOAP Client for Open Calais</a></h2>
						<p style="margin-left:8px;">
						Amit Kumar Saha guides you through the process of creating a SOAP client for Open Calais. You write a simple, console-based Java SOAP client to access the Open Calais web service. The concepts presented in this tutorial are also useful when you write a SOAP client for any other web service.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1622">Getting Started Extending VisualVM (Parts 1 - 6)</a></h2>
						<p style="margin-left:8px;">
						<a href="http://visualvm.dev.java.net/">Visual VM</a> is an open-source monitoring and profiling tool built on the NetBeans Platform. Geertjan Wielenga has written six blog entries (and counting...) about extending Visual VM using the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1620">Woodstock Accordion Component</a></h2>
						<p style="margin-left:8px;">
						James Branam writes about new components to Woodstock in the NetBeans IDE. In this entry, he takes a look at the Accordion and Accordion Tab components. In a previous post, he covered the <a href="http://blogs.sun.com/branajam/entry/woodstock_bubble_help_component">Bubble Help component</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1621">Class Visualization Module for NetBeans</a></h2>
						<p style="margin-left:8px;">
						Tim Boudreau has created a module that uses NetBeans Visual Library and the Javac Tree API to create a graph of the contents of a Java file, showing dependencies between class members. The module is available on the NetBeans daily build update center, and Boudreau would like feedback.</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/2008-03-03.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>