
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 411</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 # 411 - Oct 06, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4227">Webinar: Deploy Your Java Application Using MySQL Connector/MXJ (Oct. 7)</a></h2>
						<p style="margin-left:8px;">
						Learn how to use MySQL Connector/MXJ for automatic deployment of Java+MySQL applications on any platform in MySQL's latest webinar. Connector/MXJ is a Java utility package that makes the MySQL database appear to be a Java-based component.
<br><br>
<b>WHEN: Wednesday, October 07, 2009 @ 10:00am (US Pacific time)</b>
<br><br>
WHERE: Access the <a href="http://mysql.com/news-and-events/web-seminars/display-423.html">webinar</a> from the comfort of your desk.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4228">Learning EJB technology</a></h2>
						<p style="margin-left:8px;">
						NetBeans user Marco Marcellis has created a course site for students interested in learning EJB technology. The course provides several tasks that help users master the technology. In each task, a complete Java enterprise application is built.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4232">Beginning JNI with NetBeans IDE 6.7 and C/C++ Plugin on Linux</a></h2>
						<p style="margin-left:8px;">
						A tutorial describing how to compile and run JNI powered Java applications using the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4233">Introduction to the Google Web Toolkit Framework</a></h2>
						<p style="margin-left:8px;">
						A short guide to using the Google Web Toolkit in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4234">Using the C/C++ Tool Collection Descriptor</a></h2>
						<p style="margin-left:8px;">
						A short guide on how to create a new tool collection for C/C++ in NetBeans IDE 6.7.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4231">A Web Browser for the Blind (NetBeans Platform App)</a></h2>
						<p style="margin-left:8px;">
						An interview with Piotr Leszczyński, creator of a web browser that interprets web content into audio text for visually impaired users.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4229">OpenSolaris IPS and the NetBeans Python Editor</a></h2>
						<p style="margin-left:8px;">
						OpenSolaris' Image Packaging System (IPS) is written in Python. In this blog entry, Brian Leonard takes the new Python Editor in NetBeans 6.7 for a test drive against the IPS source code.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4230">Movie Management on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Many cool applications are built on the NetBeans Platform. In Geertjan's blog, he showcases an app that manages how information about current movies are displayed to customers in movie theaters around France. Tres cool!</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> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2009-10-06.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>