
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 356</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 # 356 - Aug 25, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2523">Ask the Experts Transcript: JavaFX Preview</a></h2>
						<p style="margin-left:8px;">
						What does the 'tween' keyword do? Why did the JavaFX language designers favor multiple inheritance over interfaces? Can you mix Swing and graphics components in JavaFX? Read the answers to these and a wide variety of other questions in the transcript of the recently-held Ask the Experts session on the JavaFX Preview.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2524">Community Docs Program Reaches Milestone: 200 (and counting!)</a></h2>
						<p style="margin-left:8px;">
						The Community Docs program has attracted more than 80 NetBeans enthusiasts to provide over 200 tutorials, screencasts, and other learning materials, written by the community for the community. Hear about the people behind it, and how it all started.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2525">Russian Java Instructor?</a></h2>
						<p style="margin-left:8px;">
						Are you a Russian Java instructor? Andrei Dmitriev has made available many slide presentations for anyone wishing to teach Java (and NetBeans) in Russian. Feel free to use them in the classroom with your own students!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2526">It Takes a Community to Write Good Software</a></h2>
						<p style="margin-left:8px;">
						The Dream Team, quality testing, plugin verificaton, mailing list moderation – How do NetBeans community members and the NetBeans engineers work together, and what's in it for you?</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2521">Jaroslav Tulach talks about Practical API Design</a></h2>
						<p style="margin-left:8px;">
						Lead API architect Jaroslav "Yarda" Tulach introduces his new book and shares  some insights relating to API design. Where can you learn more? You can get the first chapter, The Art of Building Modern Software, FREE from APress! Also, in every upcoming episode of the monthly NetBeans Podcast, Yarda will share another API design tip.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2522">Top 10 NetBeans Platform 6.5 Features</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielanga gives you an overview of the top 10 new features in the NetBeans 6.5 Platform. The Platform is the infrastructure that underpins NetBeans IDE, as well as many other similar large modular Swing applications, hence this blog entry isn’t applicable to NetBeans IDE only.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2527">Getting started with Prado in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						PRADO (PHP Rapid Application Development, Object-oriented) is a component-based and event-driven programming framework for developing Web applications in PHP 5. Read more about how Petr Pisl creates a Hello Word application based on the Prado framework in the NetBeans IDE.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2520">NetBeans IDE 6.5 Tech Tip: Compile on Save</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates the Compile on Save feature that has been introduced in NetBeans IDE 6.5. Save time by making incremental changes to your application and test-running those changes without rebuilding and redeploying the whole application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2528">Hello JavaServer Faces World with NetBeans and GlassFish</a></h2>
						<p style="margin-left:8px;">
						In his blog Arun Gupta shows how to create a simple Java Server Faces application using NetBeans IDE 6.1. It covers creating a JSF application, populating a JSF widget with a Managed Bean, using a Persistence Unit with JSF widgets, navigation rules between multiple pages, simple error validation messages, and injecting a bean into another class.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2529">Hibernate Demo for NetBeans IDE 6.1 and 6.5</a></h2>
						<p style="margin-left:8px;">
						Check out the NetBeans Hibernate support in this screencast. We go through creating POJOs, mapping the POJOs to the database using Hibernate mapping files, then displaying the data in a JSF web application created with Visual Web designer.</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>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2008-08-25.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>