
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 423</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 # 423 - Jan 19, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4645">Beta-Test the New Java Card Plugin!</a></h2>
						<p style="margin-left:8px;">
						Java Card is a platform for developing Java programs that run on Smart Cards. The new Java Card plugins for NetBeans are now available in the <a href="http://bits.netbeans.org/download/trunk/nightly/latest/">development builds</a>, and we would love to get <a href="https://netbeans.org/bugzilla/enter_bug.cgi">feedback</a> from real users! Please help us beta test this new plugin and tell us what you think.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4646">DTrace GUI 1.1 Now Available for Download</a></h2>
						<p style="margin-left:8px;">
						A new version (1.1) of the DTrace GUI plugin is now available from the NetBeans 6.8 Update Center. The current release of the DTrace GUI has seven new Chime displays which can be used by PHP developers and users to debug and tune applications written in PHP. Go to <i>Tools > Plugins > Available Plugins > DTrace</i> to install the plugin.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4653">NetBeans Platform Fans Set New Record!</a></h2>
						<p style="margin-left:8px;">
						Geertjan and Toni returned to the Poznan JUG to offer a NetBeans Platform Certified Training last weekend: With 52 enthusiastic attendees, it was the biggest training so far. Luckily, organizer Adam Dudczak managed to find a larger venue--that's agile project management! If your school or JUG is <a href="http://blogs.sun.com/geertjan/entry/poznan_jug_netbeans_platform_certified">interested in Platform Training</a> too, contact us at users AT edu.netbeans.org!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4648">Getting Started with Google App Engine and NetBeans</a></h2>
						<p style="margin-left:8px;">
						Get started with Google App Engine development! Sign up for the Google App Engine and download the SDK, install the NetBeans plugin and service, and run the guestbook sample application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4650">Creating a Java EE 6 App with JSF 2, EJB 3.1, JPA, and NetBeans</a></h2>
						<p style="margin-left:8px;">
						There are many articles that discuss how to use the individual technologies of Java EE 6 (such as JSF 2, EJB 3.1, JPA) to develop an application. This article however brings all these technologies together in one extensive end-to-end demonstration.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4649">Developing Secure JavaFX Applications</a></h2>
						<p style="margin-left:8px;">
						This article provides insight on the basic Java and JavaFX concepts that you need to know when creating a secure JavaFX application, and how Java ME security works in general.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4647">Mobile Applications: Your First MIDlet</a></h2>
						<p style="margin-left:8px;">
						This blog gets you started with developing your first mobile application. You will learn what MIDlets are, how to use the NetBeans Visual Mobile Designer, and how to work with device configurations.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4651">Creating a JFileChooser With NetBeans</a></h2>
						<p style="margin-left:8px;">
						This tutorial demonstrates how to leverage the NetBeans GUI Builder for implementing a custom file chooser. As a setup, we will also create a small Java desktop application. Download the sample project and go through the tutorial to learn more!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4652">Tech Tip: Connecting to a HSQLDB Database</a></h2>
						<p style="margin-left:8px;">
						This quick tip shows how to configure the NetBeans IDE for work with your locally installed HSQLDB (Hyper Structured Query Language Database) using a JDBC driver.</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-01-19.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>