
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 676</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 # 676 - Feb 17, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9808">Subscribe to the NetBeans YouTube Channel!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans YouTube channel is a library of short screencasts organized in categories focused on the Java platform, the HTML5 platform, and more, with new content available every week. Subscribe to the channel and receive notifications whenever new items are published.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9809">New: RedmineNB</a></h2>
						<p style="margin-left:8px;">
						Support for Redmine issue tracker and project management. Redmine version 2.2.0+ is recommended for best compatibility.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9803">Trip Report: NetBeans Day Netherlands</a></h2>
						<p style="margin-left:8px;">
						If you missed NetBeans Day Netherlands yesterday, here's what happened -- and there are many more opportunities to get involved in this very diverse community, as described in the trip report.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9804">NetBeans Theme Builder</a></h2>
						<p style="margin-left:8px;">
						Quickly and easily design new themes for NetBeans, using Sven Spruijt's handy on-line tool. Once the design is done, press Download, then use the Options window in NetBeans to import the ZIP file.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9807">Manoj Kumar: "Hello World in NetBeans IDE"</a></h2>
						<p style="margin-left:8px;">
						A great way to get involved in the NetBeans community is to make small YouTube screencasts to highlight cool features in NetBeans! Meet Manoj Kumar, who has started a new YouTube channel to introduce you to programming in Java with NetBeans IDE. In this first screencast, he quickly introduces you to a 'hello world' scenario in Java. It takes less than three minutes</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9806">Lisa Spitzl: "Neo4J with NetBeans IDE"</a></h2>
						<p style="margin-left:8px;">
						Learn about graph databases in a simple example! Watch an excellent new video by Lisa Spitzl, a student at HTL Leonding in Austria, on how Maven, Neo4J (neo4j.com) and NetBeans can be used together to visualize Java data structures</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9810">March 16: NetBeans Day Germany</a></h2>
						<p style="margin-left:8px;">
						After the recently held <a href="https://blogs.oracle.com/geertjan/entry/trip_report_netbeans_day_germany">NetBeans Day Germany</a>, the feeling was that another one should be organized soon. And within a few weeks, all the seats are almost full. Sign up for this free event in Munich today!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9805">Recent File & Recent Edit</a></h2>
						<p style="margin-left:8px;">
						When working with many projects and files in NetBeans, it is useful to be able to open the most recently closed document and to jump the cursor to the place where the last change took place. Do you know how to do these things and which keyboard shortcuts are applicable? Spend 4 minutes learning about this!</p>
					</div>
	<div class="edited">
	NetBeans Weekly Newsletter is brought to you by the NetBeans Team.<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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2015-02-17.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>