
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 435</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/appl/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/appl/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 # 435 - Apr 14, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4962">Are You a Swing Developer In Norway?</a></h2>
						<p style="margin-left:8px;">
						Are you in Norway (or thereabouts)? Toni Epple and Geertjan Wielenga will be giving a NetBeans Platform Certified Training and related presentations in Oslo and Bergen in the next two weeks! They look forward to meeting developers (universities, institutions, companies, JUGs) interested in developing Swing applications on the NetBeans Platform. Contact Geertjan to get in touch.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4959">Great Indian Developer Summit 2010</a></h2>
						<p style="margin-left:8px;">
						If you attend the Great Indian Developer Summit next week in Bangalore to learn more about rich internet applications, cloud computing and Java, come to our booth (#9) where we demo NetBeans IDE and the new JavaFX Composer. Register now!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4966">NetBeans Platform Certified Training Kraków 2010</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga, Toni Epple, and Karol Harezlak meet up with the Polish Java User Group in Kraków next week for another round of NetBeans Platform training. If you are in the area, join us and learn how to develop state-of-the-art Swing Desktop applications!</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4960">DZone: New Cool Tools for OSGi Developers</a></h2>
						<p style="margin-left:8px;">
						The upcoming NetBeans IDE 6.9 brings new tools for OSGi developers, specifically for those who want to use Swing as their UI toolkit. The NetBeans Platform 6.9 understands what an OSGi bundle is and you'll be able to import OSGi bundles into your NetBeans Platform applications.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4961">JavaFX Database Programming with Java DB</a></h2>
						<p style="margin-left:8px;">
						Who said JDBC programming with Java was difficult? With JavaFX you can build media-rich applications with far less code than you would with Swing, yet you can still call into your existing Java codebase. This includes databases via JDBC as well, but there are some tricks you'll need to know, which we'll explore here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4963">Tech Tip: Automatic Import Statement Organizer</a></h2>
						<p style="margin-left:8px;">
						A student of the NetBeans Platform Certified Training created a new plugin that helps you reorganize import statements. It works in NetBeans IDE 6.7.1 or 6.8.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4964">Complete List of Macro Keywords for the NetBeans Java Editor</a></h2>
						<p style="margin-left:8px;">
						In NetBeans IDE's Java editor, you can create macros by clicking the "Start/Stop Macro Recording" button. You can also edit macros in the Options window, in the Editor>Macros tab. A special macro syntax is used to define these macros -- here's the complete list.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4965">Generate a NetBeans Platform Installer with NetBeans IDE 6.9</a></h2>
						<p style="margin-left:8px;">
						In the upcoming NetBeans IDE 6.9, you'll be able to use the IDE to generate installers of your NetBeans Platform applications.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4967">Tech Tip: Packaging Fun</a></h2>
						<p style="margin-left:8px;">
						When using NetBeans to create a JavaFX application, it creates JNLP files, a JavaFX JAR file, and a default HTML page to run in the browser. This is a great way to run standalone or in a browser, but how do you package the app when you want to deploy it to an application server like Glassfish? Matt Warman shares some advice.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<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/2010-04-14.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>