
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 422</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 # 422 - Jan 12, 2010
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4619">VisualVM 1.2.2 Available for Download</a></h2>
						<p style="margin-left:8px;">
						VisualVM 1.2.2 has been released and is available for <a href="http://visualvm.dev.java.net/download.html">download</a>. The new version upgrades the underlying framework to the NetBeans Platform 6.8 and delivers several performance improvements and bug fixes.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4617">Grow Your Code with the NetBeans IDE 6.8 and Kenai.com!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3885&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The NetBeans 6.8 IDE comes with improved collaboration integration with Kenai.com, Sun's onramp for the connected developer experience of tomorrow. Learn how to easily host code/projects and engage with distributed teams directly from the NetBeans IDE. <a href="http://kenai.com/projects/help/pages/KenaiOverview">Learn more about Kenai.com</a>.</p><br style="clear:both;"/>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4614">Free Java EE 6 Online Codecamp (Jan. 12-19)</a></h2>
						<p style="margin-left:8px;">
						Sign up for Sang Shin's free one-week Java EE 6 online codecamp where participants get to write lots and lots of code and in the process learn about key Java EE 6 technologies. A panel of expert advisors will also be available throughout the week to answer technical questions and provide guidance.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4618">Video: Java EE 6 and GlassFish v3 Deep Dive with Arun Gupta</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3884&column=image&table=story&type=image/gif&db=services&db_type=pear&id_col=story_id'
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Sun Evangelist Arun Gupta highlights some of the new and cool features provided by Java EE 6 technologies. See how the NetBeans IDE allows you to create a simple web application, enable JSF and create Facelets.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4616">Easy Animated Transitions in JavaFX</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3881&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='51' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The JavaFX SDK offers some useful features that enable developers to create complex animated and transformational effects. Learn how to apply classes from the javafx.animation.transition package to build fade, translate, rotate, scale, and path transitions.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4622">Developing High Transaction Web Apps with Java, MySQL & NetBeans</a></h2>
						<p style="margin-left:8px;">
						This blog tutorial uses the NetBeans IDE, Java and MySQL to develop a web application that can handle simultaneous requests from clients and keep them secure from each other.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4623">Five Features That Make NetBeans 6.8 My IDE of Choice</a></h2>
						<p style="margin-left:8px;">
						Java champion and Java EE expert Adam Bien lists five reasons why he continues to be a fan of the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4615">Modular Scuba Diving Application on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Rafal Maslana is an avid diver and a NetBeans Platform developer. Read about his open-source dive planning application built on the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4620">Zend Framework Support on Its Way</a></h2>
						<p style="margin-left:8px;">
						A cool announcement from the NetBeans PHP team: Early support for the Zend framework is available for testing. Try it out and give the team feedback.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4621">Webstarting a NetBeans Platform Application</a></h2>
						<p style="margin-left:8px;">
						You might know that you can deploy a web-startable (JNLP) NetBeans Platform application to a web server, but what if the server doesn't support WAR-files? Developer Florian Brunner found a solution and shared his Ant script and some tips.</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/2010-01-12.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>