
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 683</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 # 683 - Apr 07, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9916">History of NetBeans</a></h2>
						<p style="margin-left:8px;">
						Java-based NetBeans began life nearly 20 years ago as ‘Xelfi’ – a project at Charles University in Prague. Since then, it’s evolved into one of the most popular IDEs for developers in the JVM space. Read the whole article, including an interview with NetBeans founder Jaroslav Tulach.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9914">Improving the Performance of Java EE Applications</a></h2>
						<p style="margin-left:8px;">
						Learn tips for improving Java EE application performance in the latest Java Magazine article by Josh Juneau, a NetBeans Dream Team member, including insights into usage of the NetBeans Profiler.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9915">Codename One</a></h2>
						<p style="margin-left:8px;">
						Codename One is a complete open source platform allowing developers to build (visually or using a Swing-like API) native applications for Android, iPhone/iPad, Blackberry, and Windows Phone 7. It is free for commercial use and includes a GUI builder, simulator and everything you need in a single package.</p>
					</div>
				<h1>Books</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9913">JavaFX 8: Grundlagen und Fortgeschrittene Techniken</a></h2>
						<p style="margin-left:8px;">
						Anton Epple's brand new JavaFX book offers a quick introduction and comprehensive overview of the entire JavaFX API (in German). Step by step, it shows how to build a first application, how you present your own data model in the surface, and make editable and how to enrich the application with JavaFX features to get a modern and attractive user interface</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9912">Java EE 7 Development with NetBeans 8</a></h2>
						<p style="margin-left:8px;">
						In a of detail and with many screenshots and explanations, David R. Heffelfinger takes you through developing professional enterprise Java EE applications quickly and easily with NetBeans IDE.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9909">April 17: NetBeans Day Greece</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans enthusiasts at a free event in Athens. The event is full but you can sign on to the waiting list.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9910">May 29: NetBeans Day UK</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans enthusiasts at a free event at Greenwich University, London. 35 tickets remaining!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9911">June 22: NetBeans Day Brazil</a></h2>
						<p style="margin-left:8px;">
						Join NetBeans enthusiasts at a free event at the Oracle office in São Paulo, Brazil. The event has been announced yesterday, get a ticket today!</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-04-07.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>