
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 471</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 # 471 - Jan 24, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6051">NetBeans Plugin: SCSS ("Sassy CSS") Support</a></h2>
						<p style="margin-left:8px;">
						SCSS is one of two syntaxes available for Sass, which is an extension of CSS that adds power and elegance to the basic language. Learn more about Sass <a href="http://sass-lang.com">here</a>. This NetBeans community-contributed plugin adds support for editing SCSS files.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6056">APIGen Plugin: PHP Project API Generator</a></h2>
						<p style="margin-left:8px;">
						The APIGen NetBeans plugin integrates API documentation generator APIGen into the NetBeans IDE and allows you to generate API documentation for PHP projects.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6050">NetBeans Community Poll: Next Version Control in NetBeans?</a></h2>
						<p style="margin-left:8px;">
						Serena Dimension, SourceSafe, Bazaar, Perforce? What version control would you want to see in NetBeans IDE? Tell us in the latest NetBeans Community Poll!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6057">Revived: NetBeans Platform Romanian Localization</a></h2>
						<p style="margin-left:8px;">
						Romanian localization for the NetBeans Platform is back on track with new translator Stan Ioan Eugen. With 93% localization completed on the NetBeans Platform 7.0, join Eugen to get the project to 100%!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6052">Webinar Replay - Java EE 6 with NetBeans and GlassFish</a></h2>
						<p style="margin-left:8px;">
						Did you miss the live Jan. 20th JavaEE 6, NetBeans, GlassFish webinar with Oracle evangelist Arun Gupta? The entire session is now available on-demand.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6053">Videos: NetBeans Platform Service Architecture</a></h2>
						<p style="margin-left:8px;">
						These video replays feature Toni Epple delivering a NetBeans Platform training course to JUG Poznan. The videos give you a good overview of what happens in our popular training courses.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6054">Adding Sub-projects to Project Types</a></h2>
						<p style="margin-left:8px;">
						Learn how to easily visualize modular architectures in tree hierarchies in Java Swing.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=5982">NetBeans, JDK 7 and Java EE 6 at JFokus, Sweden (Feb. 14-16)</a></h2>
						<p style="margin-left:8px;">
						Join Oracle evangelists Arun Gupta, Alexis Moussine-Pouchkine, Roger Brinkley and Tomas Nilsson at JFokus 2011 in Stockholm, Sweden to learn about the latest features in Java EE, GlassFish and JDK 7, how the NetBeans IDE in tandem with these technologies helps developers be more productive, and more.<br><br>
<b>Oracle Sessions at JFokus</b>:<br>
The Java EE 6 Programming Model Explained<br>
Java EE 6 Toolshow<br>
Running your Java EE applications in the clouds<br>
Learning Nuts & Bolts of Java EE 6 in a Code Intensive Tutorial<br>
JDK7 Update<br>
It's All About ME (Mobile and Embedded)</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6055">KLISS, Legislative Software on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Built on the NetBeans Platform, KLISS (Kansas Legislative Information Systems) is legislative software created by Propylon, a firm that specializes in legislative and regulatory information processing and content management.</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/2011-01-24.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>