<!DOCTYPE html>
<html>

  <head>
	<meta charset="UTF-8">
	<title>Xtend - Release Notes</title>
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description"
		content="Xtend is a statically typed programming language sitting on top of Java.">
	<meta name="author" content="Sven Efftinge">
	<meta name="author" content="Miro Spoenemann">
	<!--  styles -->
	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
	<!--[if lt IE 9]>
	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->
	
	<!-- Le fav and touch icons -->
	
	<link rel="shortcut icon" href="/xtend/images/favicon.png">
	
	<link href="/xtend/css/bootstrap.css" rel="stylesheet" type='text/css'>
	<link href="/xtend/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
	<link href="/xtend/css/shield-responsive.css" rel="stylesheet" type='text/css'>
	<link href='/xtend/css/fonts.css' rel='stylesheet' type='text/css'>
	<link href="/xtend/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
	<link href="/xtend/css/prettify.css" type="text/css" rel="stylesheet"/>
	<link href="/xtend/css/style.css" rel="stylesheet" type='text/css'>
	
	<!--[if lt IE 9]>
	<link href="css/iebugs.css" rel="stylesheet" type='text/css'>
	<![endif]-->

	<!-- BEGIN Cookie Consent
	<link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.css" />
	<script src="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.js"></script>
	<script>
	window.addEventListener("load", function(){
	window.cookieconsent.initialise({
		"palette": {
		"popup": {
		  "background": "#000"
		},
		"button": {
		  "background": "#f1d600"
		}
		},
		"theme": "edgeless",
		"type": "opt-in",
		onInitialise: function (status) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		},
		onStatusChange: function(status, chosenBefore) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		}, 
		onRevokeChoice: function() {
		  var type = this.options.type;
		  if (type == 'opt-in') {
		    // TODO: disable cookies
		  }
		  if (type == 'opt-out') {
		    // TODO: enable cookies
		  }
		},
		"content": {
		"href": "http://www.eclipse.org/legal/privacy.php"
		}
	})});
	</script>
	END Cookie Consent -->
</head>


  <body>

    <!-- Navbar -->
  <div class="navbar navbar-fixed-top"
    style="border-bottom: 1px solid #000;">
    <div class="navbar-inner">
      <div class="container">
        <a class="btn btn-navbar" data-toggle="collapse"
          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
          class="icon-bar"></span> <span class="icon-bar"></span>
        </a> <a class="brand" href="/xtend/index.html"></a>
        <div class="nav-collapse collapse" style="height: 0px;">
          <ul class="nav">
            <li ><a href="/xtend/download.html">Download</a></li>
            <li ><a href="/xtend/documentation/index.html">Documentation</a></li>
            <li ><a href="/xtend/community.html">Community</a></li>
            <li ><a href="http://xtext.org">Xtext</a></li>
            <li ><a href="http://www.eclipse.org">Eclipse.org</a></li>
          </ul>
              <!--div class="btn-group pull-right">
                <div class="g-plusone" data-href="http://www.xtend-lang.org"></div>
              </div-->
        </div>
        <!--/.nav-collapse -->
      </div>
    </div>
  </div>
  <!-- Navbar End -->


    <div id="page">  
	<div class="inner">
		<div class="container">
			<br/>
				<div> 
					<h3>Table of Contents</h3>
					<ul>
						
							<li><p><a href="#/releasenotes/2020/12/01/version-2-24-0">Xtend 2.24.0 Release Notes &mdash; Dec 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/09/01/version-2-23-0">Xtend 2.23.0 Release Notes &mdash; Sep 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/06/02/version-2-22-0">Xtend 2.22.0 Release Notes &mdash; Jun 2, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/03/03/version-2-21-0">Xtend 2.21.0 Release Notes &mdash; Mar 3, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2019/12/03/version-2-20-0">Xtend 2.20.0 Release Notes &mdash; Dec 3, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2019/09/03/version-2-19-0">Xtend 2.19.0 Release Notes &mdash; Sep 3, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2019/06/04/version-2-18-0">Xtend 2.18.0 Release Notes &mdash; Jun 4, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2019/04/03/version-2-17-1">Xtend 2.17.1 Release Notes &mdash; Apr 3, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2019/03/05/version-2-17-0">Xtend 2.17.0 Release Notes &mdash; Mar 5, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2018/12/04/version-2-16-0">Xtend 2.16.0 Release Notes &mdash; Dec 4, 2018</a></p>
						
					</ul>
				</div>
				
				  <hr/>
				  <section id="/releasenotes/2020/12/01/version-2-24-0">
				  	<h1>Xtend 2.24.0 Release Notes<small>&nbsp;&nbsp;Dec 1, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.24.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="updates">Updates</h2>

<ul>
  <li>Xtend now uses ASM 9.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Emmanuel Chebbi (INRIA) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.24&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.24&amp;query_format=advanced&amp;status_whiteboard=v2.24&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/09/01/version-2-23-0">
				  	<h1>Xtend 2.23.0 Release Notes<small>&nbsp;&nbsp;Sep 1, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.23.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtext-xtend-eclipse-and-java-11">Xtext, Xtend, Eclipse, and Java 11</h2>

<p>The Eclipse Platform and Java Development Tools have decided to migrate to Java 11 with the new 2020-09 (4.17) release. Xtext and Xtend depend on these projects both for the integration into Eclipse as well as in the LSP and standalone mode. Xtext 2.23 still works with Java 8, but if you want to work with Xtext in Eclipse 2020-09 (4.17) you have to start your Tycho builds with Java 11 as well as launch your Runtime Eclipse Applications with Java 11.</p>

<p>We decided to follow suit to close a window of opportunity for hard to find bugs. Therefore, the version 2.24 of Xtext and Xtend which is due along with Eclipse 2020-12 will be the first release that depends on Java 11. Please feel encouraged to join the discussion in <a href="https://github.com/eclipse/xtext/issues/1804">https://github.com/eclipse/xtext/issues/1804</a> if you have any concerns, general comments or other suggestions.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="quickfix-improvements">Quickfix improvements</h3>

<p>A quick fix was added to create a local variable or value in addition to the option to create class members.</p>

<p><img src="/xtend/images/releasenotes/2_23_xtend-quickfix-before0.png" alt="Quick Fix: Add local var/val" height="50%" width="50%" /><br />
<img src="/xtend/images/releasenotes/2_23_xtend-quickfix-after0.png" alt="Quick Fix: Add local var/val" height="50%" width="50%" /></p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Lorenzo Addazi (Mälardalen University Sweden)</li>
  <li>Aaron R Miller <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Tamas Miklossy (itemis)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.23&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.23&amp;query_format=advanced&amp;status_whiteboard=v2.23&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/06/02/version-2-22-0">
				  	<h1>Xtend 2.22.0 Release Notes<small>&nbsp;&nbsp;Jun 2, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.22.0 is mainly a maintenance release with a small number of usability improvements.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext--xtend">Call to Action: Secure the future maintenance of Xtext &amp; Xtend</h2>

<p>As you might have recognized, the number of people contributing to Xtext &amp; Xtend on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext &amp; especially Xtend is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="documentation">Documentation</h2>

<p>The <a href="https://www.eclipse.org/xtend/community.html">Xtend community website</a> has been updated to list the recently published videos, presentations and blog posts around Xtend. The list is not yet complete, so feel free to contact us if you are also interested in listing your articles there.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Mathias Rieder (Bachmann)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.22&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.22&amp;query_format=advanced&amp;status_whiteboard=v2.22&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/03/03/version-2-21-0">
				  	<h1>Xtend 2.21.0 Release Notes<small>&nbsp;&nbsp;Mar 3, 2020</small></h1>
				    <br/>
				    <p>Xtend 2.21.0 is a maintenance release with some usability improvements.</p>

<h2 id="license-change">License Change</h2>

<p>In compliance with general requirements by the Eclipse Foundation the license for Xtext &amp; Xtend has been changed to <a href="https://www.eclipse.org/legal/epl-2.0/">EPL 2.0</a>.</p>

<h2 id="xtend-compiler">Xtend Compiler</h2>

<h3 id="unnecessary-modifiers">Unnecessary modifiers</h3>

<p>The Xtend compiler has been improved to avoid generating unnecessary modifiers. No modifier is produced in these contexts:</p>

<ul>
  <li><code>static</code> modifier for nested types within interfaces</li>
  <li><code>public</code> modifier for interface members</li>
  <li><code>abstract</code> modifier for operations within interfaces</li>
</ul>

<p>Example:</p>

<pre><code>interface FooItf {
  def void bar ()
  static class FooItfImpl implements FooItf {
    override void bar () {}
  }
}
</code></pre>

<p>Old compilation result:</p>

<pre><code>public interface FooItf {
  public static class FooItfImpl implements FooItf {
    @Override
    public void bar () {
    }
  }

  public abstract void bar();
}
</code></pre>

<p>New compilation result:</p>

<pre><code>public interface FooItf {
  class FooItfImpl implements FooItf {
    @Override
    void bar () {
    }
  }

  void bar();
}
</code></pre>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sven Efftinge (TypeFox)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.21+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.21+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.21&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.21&amp;query_format=advanced&amp;status_whiteboard=v2.21&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/12/03/version-2-20-0">
				  	<h1>Xtend 2.20.0 Release Notes<small>&nbsp;&nbsp;Dec 3, 2019</small></h1>
				    <br/>
				    <p>Xtend 2.20.0 is mainly a maintenance release with a small number of usability improvements</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="new-refactoring-import-static-method-and-import-static-extension-method">New Refactoring: Import Static Method and Import Static Extension Method</h3>

<p>Two refactoring commands have been added which can add as static or static <strong>extension</strong> import the selected static method call and update all the occurrences in the document. The refactoring commands can be triggered from the <code>Refactoring &gt; Import Static | Import Static Extension</code> context menu in the Xtend editor or using <code>M1+Shift+M</code> and <code>M1+Shift+Alt+M</code> key shortcuts. (<a href="https://github.com/eclipse/xtext-xtend/issues/751">#751</a>)</p>

<p><img src="/xtend/images/releasenotes/2_20_refactoring_import_static_method.gif" alt="Refactoring: Import Static Method" height="50%" width="50%" /></p>

<h3 id="improved-junit-test-case-recognitionexecution">Improved JUnit test case recognition/execution</h3>

<p>The Xtend IDE has been improved to recognize and execute all JUnit test cases (implemented in Xtend) event if the cursor is currently located before/after the test class definition.</p>

<h3 id="new-quick-fix-add-junit-4-or-5-to-the-classpath">New Quick Fix: Add JUnit 4 or 5 to the classpath</h3>

<p>A quick fix was added which adds the necessary libraries for JUnit 4 or 5 to the classpath. The quick fix will show on import errors starting with <code>org.junit.jupiter</code> (for JUnit 5) or <code>org.junit</code> (for JUnit 4). It works both for plug-in projects and regular Java projects. (<a href="https://github.com/eclipse/xtext-xtend/issues/919">#919</a></p>

<p><img src="/xtend/images/releasenotes/2_20_quickfix_add_junit4_classpath.gif" alt="Quick Fix: Add JUnit 4 to Classpath" height="50%" width="50%" /><br />
<img src="/xtend/images/releasenotes/2_20_quickfix_add_junit5_classpath.gif" alt="Quick Fix: Add JUnit 5 to Classpath" height="50%" width="50%" /></p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Vivien Jovet (TORO Limited)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.20+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.20+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.20&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.20&amp;query_format=advanced&amp;status_whiteboard=v2.20&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/09/03/version-2-19-0">
				  	<h1>Xtend 2.19.0 Release Notes<small>&nbsp;&nbsp;Sep 3, 2019</small></h1>
				    <br/>
				    <p>Xtend 2.19.0 is mainly a maintenance release.</p>

<h2 id="fixes">Fixes</h2>

<ul>
  <li>The <code>Delegate</code> Active Annotation now uses a stable order.</li>
  <li>Improved <code>@Override</code> annotations in generated code.</li>
  <li>Improved ambigous constructor calls.</li>
</ul>

<h2 id="upgrades">Upgrades</h2>

<p>Xtend now uses Guava 27.1.0. The new version will be picked up automatically if you make use of the Xtext BOM or consume Xtend from its P2 repository.</p>

<h2 id="infrastructure">Infrastructure</h2>

<p>Xtend is built now on the new Kubernetes based CBI infrastructure <a href="https://wiki.eclipse.org/CBI/Jenkins_Migration_FAQ">JIRO</a>.</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. 5 issues and 62 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.19+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.19+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.19&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.19&amp;query_format=advanced&amp;status_whiteboard=v2.19&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/06/04/version-2-18-0">
				  	<h1>Xtend 2.18.0 Release Notes<small>&nbsp;&nbsp;Jun 4, 2019</small></h1>
				    <br/>
				    <p>Xtend 2.18.0 provides new language features (Ternary Expressions and Try-With-Resources) and some smaller improvements.</p>

<h2 id="ternary-expressions">Ternary Expressions</h2>

<p>Xtend now allows to use the ternary operator. This enables to assign conditional values to variables in the shortest possible way, as already well known from Java.</p>

<pre><code>val v = condition ? “thenValue” : “elseValue”
</code></pre>

<p>If it is disapproved to use ternary expressions, it is possible to flag them with an error and convert them via quickfix into a traditional if-expression.</p>

<pre><code>val v = if(condition) “thenValue” else “elseValue”
</code></pre>

<h2 id="try-with-resources">Try With Resources</h2>

<p>Try statements are often used with resources, that have to be closed in the finally block. Xtend now supports the convenient try-with-resources expression. This closes the opened resources automatically at the end of the try block - without having to code that explicitly.</p>

<pre><code>def m() {
    val resource = new StringReader("This \n is a text!");
    try
        return resource.read
    finally
        resource?.close     
}
</code></pre>

<p>Becomes:</p>

<pre><code>def m() {
    try (val resource = new StringReader("This \n is a text!"))
        return resource.read
}
</code></pre>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="new-quickfix-rename-class">New Quickfix: Rename Class</h3>

<p>When an Xtend class name does not match the file name it is defined in then Xtend raises a warning. A new quickfix has been provided to rename the class according to the file name. (<a href="https://github.com/eclipse/xtext-xtend/issues/744">#744</a>)</p>

<p><img src="/xtend/images/releasenotes/2_18_Quickfix_RenameClass.gif" alt="Quickfix: Rename Class" height="50%" width="50%" /></p>

<h3 id="quickfix-remove-unused-member-improved">Quickfix “Remove Unused Member” Improved</h3>

<p>The quickfix “Remove member” for unused members was improved. Additionally to the member itself the quickfix will now also remove obsolete import statements and write accesses. (<a href="https://github.com/eclipse/xtext-xtend/issues/736">xtext-xtend</a>)</p>

<h3 id="xtend-elements-wizards-in-project-explorer--navigator-view">Xtend Elements Wizards in Project Explorer / Navigator View</h3>

<p>Context menu entries to trigger New Wizards for Xtend elements were only offered in the Package Explorer. These entries are now additionally offered in the context menu in the Project Explorer and Navigator views. (<a href="https://github.com/eclipse/xtext-xtend/issues/699">xtext-xtend#699</a>)</p>

<h2 id="maven-integration">Maven Integration</h2>

<p>When the goal <code>xtend-install-debug-info</code> is executed on empty source directories, a warning is raised by default:</p>

<pre><code>[WARNING] Directory &lt;SOURCE_DIR&gt; is empty. Can't process.
</code></pre>

<p>This warning can now be suppressed by configure the new parameter <code>showEmptyDirWarning</code> to <code>false</code>. (<a href="https://github.com/eclipse/xtext-xtend/issues/787">xtext#787</a>)</p>

<h2 id="xtend-compiler">Xtend Compiler</h2>

<p>The Xtend batch compiler lookup order preferred classes in jars on the classpath before local classes that are on the source path. The order has been changed so that local classes are now first on the search path. (<a href="https://github.com/eclipse/xtext-xtend/issues/750">#750</a>)</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Sebastian Zarnekow (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Holger Schill (itemis)</li>
  <li>Eva Poell (itemis)</li>
  <li>Lorenzo Addazi <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Niko Stotz (Altran) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Max Leuthäuser (itemis) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Vivien Jovet (TORO Limited) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than 20 issues and almost 60 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.18+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.18+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.18&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.18&amp;query_format=advanced&amp;status_whiteboard=v2.18&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/04/03/version-2-17-1">
				  	<h1>Xtend 2.17.1 Release Notes<small>&nbsp;&nbsp;Apr 3, 2019</small></h1>
				    <br/>
				    <p>This is a hotfix release. Here is the list of fixed issues:</p>

<ul>
  <li>There was a <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=545343">bug</a> in the Xtext Builder that leads to non Xtext projects being built by Xtext.</li>
  <li>The <a href="https://github.com/eclipse/xtext-core/issues/1059">LSP4J</a> version in Xtext 2.17.0 did not match the one in Eclipse 2019-03. Upgraded to LSP4J 0.7.0.</li>
  <li>The <a href="https://github.com/eclipse/xtext-xtend/issues/750">Xtend Batch Compiler</a> preferred classes found on the classpath over local classes.</li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/03/05/version-2-17-0">
				  	<h1>Xtend 2.17.0 Release Notes<small>&nbsp;&nbsp;Mar 5, 2019</small></h1>
				    <br/>
				    <p>This release focuses on the compatibility with Java 11 &amp; Eclipse 2019-03, stability, performance and technical debt reduction.</p>

<h2 id="java-11">Java 11</h2>

<p>Xtend is now fully compliant with Java 11. Java 11 can be chosen as runtime VM and as target version for the compiler.</p>

<h2 id="xtend-maven-plugin">xtend-maven-plugin</h2>

<h3 id="bom-managed-dependencies">BOM Managed Dependencies</h3>

<p>One major pain point with past releases was that the xtend-maven-plugin used ranged dependencies. This lead sometimes to <a href="https://github.com/eclipse/xtext/issues/1231">problems with the plugin execution</a>, which had to be worked around by clients by explicit dependency management.</p>

<p>Solving this problem was one of the main motivations behind the <a href="https://www.eclipse.org/Xtext/releasenotes.html#/releasenotes/2019/03/05/version-2-17-0">introduction of the new Maven BOM</a>. With this BOM all external dependencies of Xtext and its Maven plugins are managed in compatible versions without room for interpretation of dependency version ranges.</p>

<h3 id="upgrade-to-maven-3-api">Upgrade to Maven 3 API</h3>

<p>The <code>xtext-maven-plugin</code> has been refactored to use the latest Maven 3 API. The most significant internal change is that all doclet based configurations have been changed to use Maven 3 annotation API.</p>

<h3 id="faster-startup">Faster Startup</h3>

<p>The plugin was using version ranges for some of its dependencies, especially Google Guava. Resolving the metadata of these ranged dependencies lead to a short time delay on execution of the plugin. All used dependency versions have been pinned to a single version, which speeds up the plugin execution.</p>

<h3 id="resolve-usage-of-deprecated-api">Resolve Usage of Deprecated API</h3>

<p>The plugin has been refactored to resolve all usages of deprecated API from Eclipse Platform and m2e bundles. (<a href="https://github.com/eclipse/xtext-xtend/issues/647">to issue</a>)</p>

<h2 id="quickfixes">Quickfixes</h2>

<h3 id="quickfix-for-unused-private-member">Quickfix for ‘unused private member’</h3>

<p>The <em>unused private member</em> issue can now be resolved by a quickfix. The quickfix is capable to resolve multiple selected issues at once when selected from the <em>Problems</em> view. (<a href="https://github.com/eclipse/xtext-xtend/issues/671">details</a>)</p>

<p><img src="/xtend/images/releasenotes/2_17_Xtend-quickfix-remove-unused-member.gif" alt="Quickfix for 'unused private member'" height="50%" width="50%" /></p>

<h3 id="quickfix-to-add-the-abstract-modifier">Quickfix to Add the Abstract Modifier</h3>

<p>If a class is named something like ‘AbstractFoo’ but is not declared abstract. A warning is raised and can be resolved via quickfix insertion of the abstract modifier. (<a href="https://github.com/eclipse/xtext-xtend/issues/719">details</a>)</p>

<p><img src="/xtend/images/releasenotes/2_17_Xtend-quickfix-add-abstract-modifier-bc-classname.gif" alt="Quickfix to add the abstract modifier" height="50%" width="50%" /></p>

<h2 id="static-member-favorites">Static Member Favorites</h2>

<p>Annoyed by typing <code>org.junit.Assert.assertEquals</code> to use static methods? Wouldn’t it be cool having all your favorite static methods at hand and let the language do the import automatically? In JDT this feature is known as Static Member Favorites and it comes with a preference page, where you can configure which class’s methods should be visible. Besides wildcard imports you could make a single method visible - it’s up to you.</p>

<p><img src="/xtend/images/releasenotes/2_17_Xtend-static-favorites_1.gif" alt="Use favorites for static import" height="50%" width="50%" /></p>

<p>We thought it’s a good idea to reuse the already defined JDT preferences in Xtend. Since this release Xtend supports Static Member Favorites like Java does - but a bit more.</p>

<p><img src="/xtend/images/releasenotes/2_17_Xtend-static-favorites_2.png" alt="Invoke content assist static import" height="50%" width="50%" /></p>

<p>In Xtend we have <em>extension methods</em>. Here the first parameter becomes the implicit receiver. The visible static methods are analysed to fit as an extension method and then gets imported like that.</p>

<p><img src="/xtend/images/releasenotes/2_17_Xtend-static-favorites_3.png" alt="Invoke content assist static import" height="50%" width="50%" /></p>

<h2 id="deprecations">Deprecations</h2>

<h3 id="deprecation-of-android-archetype">Deprecation of Android Archetype</h3>

<p>The Maven archetype <code>org.eclipse.xtend.maven.android.archetype</code> has been deprecated with this version and is no longer published.</p>

<h3 id="deprecation-of-gwt-related-artifacts">Deprecation of GWT related artifacts</h3>

<p>The bundles <code>org.eclipse.xtend.lib.gwt</code> and <code>org.eclipse.xtext.xbase.lib.gwt</code> are now deprecated. They are subject for removal in one of the next releases.</p>

<h2 id="credits">Credits</h2>

<p>The Xtend Language project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Holger Schill (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Sebastian Zarnekow (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Prajwal Gowda (itemis) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Eva Poell (itemis) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Stéphane Galland</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than 18 issues and almost 50 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?q=is%3Aissue+milestone%3ARelease_2.17+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?q=is%3Apr+milestone%3ARelease_2.17+is%3Aclosed+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.17&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.17&amp;query_format=advanced&amp;status_whiteboard=v2.17&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2018/12/04/version-2-16-0">
				  	<h1>Xtend 2.16.0 Release Notes<small>&nbsp;&nbsp;Dec 4, 2018</small></h1>
				    <br/>
				    <p>This release focuses on stability, performance and the compatibility with Eclipse 2018-12.</p>

<h2 id="hover-and-hyperlink-on-links-in-javadoc-comments">Hover and Hyperlink on links in Javadoc comments</h2>

<p>Inside Xtend source files, hovering over a link inside a Javadoc will now display the Javadoc comments in a hover pop-up. F3 is also supported on these links.</p>

<p><img src="/xtend/images/releasenotes/2_16_hover_javadoc_link.png" alt="Hover Example" /></p>

<h2 id="triple-equals-quickfix-is-now-a-multifix">Triple-equals quickfix is now a multifix</h2>

<p>Warnings of the type <code>The operator '!=' should be replaced by '!==' when null is one of the arguments.</code> could only be fixed one by one. The quickfix has been extended to allow fixing multiple issues at once.</p>

<h2 id="deprecation-of-gwt">Deprecation of GWT</h2>

<p>We will no longer maintain the GWT versions of Xbase and Xtend Lib. The corresponding jars will be no longer published with future versions of Xtext (likely from 2.17 on).</p>

<h2 id="outlook-for-217">Outlook for 2.17</h2>

<p>Java 11 Support, a Maven BOM and a new MWE version are planned for 2.17.</p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than 90 issues and almost 300 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.16+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.16+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.16&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.16&amp;query_format=advanced&amp;status_whiteboard=v2.16&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
			
		</div>
  	</div>
</div>
    
    <footer class="site-footer">
  <div id="extra">
    <div class="container inner-footer">
      <div class="row">
        <div class="span6">
          <h3 class="footer-links-header">Quick Links</h3>
          <ul class="footer-links clearfix">
            <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
            <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
            <li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
            <li><a href="http://www.eclipse.org/legal/">Legal</a></li>
          </ul>
          <ul class="footer-links clearfix">
            <li><a href="http://www.eclipse.org">Eclipse Home</a></li>
            <li><a href="http://marketplace.eclipse.org/">Market Place</a></li>
            <li><a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
            <li><a href="https://www.eclipse.org/forums/index.php/f/27/">Xtext Forum</a></li>
          </ul>
        </div>
        <div class="span6">
            <!-- Social Media Links -->
            <h3 class="footer-links-header"">Social Media</h3>
            <ul class="footer-links clearfix">
              <li>
                <a href="https://twitter.com/xtendlang"><img src="/xtend/images/Twitter-bird-darkgray.png" class="img-responsive" style="margin-right: 5px;height: 1em;" alt="Twitter icon">@xtendlang on Twitter</a>
              </li>
            </ul>
          </div>

      </div>
    </div>
  </div>
  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
  <a href="http://dryicons.com/">Icons by http://dryicons.com</a>
  <!-- Le javascript
      ================================================== -->
  <!-- Placed at the end of the document so the pages load faster -->
  <script src="/xtend/js/jquery-1.7.1.min.js" type="text/javascript"></script>
  <script src="/xtend/js/bootstrap.min.js" type="text/javascript"></script>
  
  <!-- include pretty-print files -->
  <script src="/xtend/js/prettify.js" type="text/javascript" ></script>
  <script src="/xtend/js/lang-xtend.js" type="text/javascript"></script>
  
  <!-- Include the plug-in -->
  <script src="/xtend/js/jquery.prettyPhoto.js" type="text/javascript"></script>
  <script src="/xtend/js/jquery.easing.1.3.js" type="text/javascript"></script>
  <script src="/xtend/js/custom.js" type="text/javascript"></script>
  <!--script src="https://apis.google.com/js/platform.js" async defer></script-->
  <!--script type="text/javascript">
    var _gaq = _gaq || [];  
      _gaq.push([ '_setAccount', 'UA-2429174-4' ]);
    _gaq.push([ '_trackPageview' ]);
    (function() {
      var ga = document.createElement('script');
      ga.type = 'text/javascript';
      ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
          : 'http://www')
          + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0];
      s.parentNode.insertBefore(ga, s);
    })();
  </script-->
</footer>

  </body>

</html>
