diff --git a/noteworthy/blank.css b/noteworthy/blank.css
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/noteworthy/blank.css
diff --git a/noteworthy/cdt.adoc b/noteworthy/cdt.adoc
index 4504560..14c7604 100644
--- a/noteworthy/cdt.adoc
+++ b/noteworthy/cdt.adoc
@@ -14,7 +14,8 @@
 [[cdt]]
 == C/C++
 
-pass:[C/C++] support is provided by the {cdtPackageUrl}[Eclipse IDE for pass:[C/C++] Developers].
+Eclipse Neon includes many improvements in stability and some new 
+functionality for C/C++ developers.
 
 === General
 
diff --git a/noteworthy/images/Pdt-ExceptionBP.png b/noteworthy/images/Pdt-ExceptionBP.png
new file mode 100644
index 0000000..8094833
--- /dev/null
+++ b/noteworthy/images/Pdt-ExceptionBP.png
Binary files differ
diff --git a/noteworthy/images/Pdt37_ca2.png b/noteworthy/images/Pdt37_ca2.png
new file mode 100644
index 0000000..b6a3df9
--- /dev/null
+++ b/noteworthy/images/Pdt37_ca2.png
Binary files differ
diff --git a/noteworthy/images/Pdt40_class_instanceof.png b/noteworthy/images/Pdt40_class_instanceof.png
new file mode 100644
index 0000000..189c48a
--- /dev/null
+++ b/noteworthy/images/Pdt40_class_instanceof.png
Binary files differ
diff --git a/noteworthy/images/json_editor.png b/noteworthy/images/json_editor.png
new file mode 100644
index 0000000..db0632a
--- /dev/null
+++ b/noteworthy/images/json_editor.png
Binary files differ
diff --git a/noteworthy/images/v8_debugger.png b/noteworthy/images/v8_debugger.png
new file mode 100644
index 0000000..ca3866d
--- /dev/null
+++ b/noteworthy/images/v8_debugger.png
Binary files differ
diff --git a/noteworthy/index.php b/noteworthy/index.php
index 026de90..84184ac 100644
--- a/noteworthy/index.php
+++ b/noteworthy/index.php
@@ -18,7 +18,7 @@
 $Nav = new Nav();
 include($App->getProjectCommon());
 
-//$App->AddExtraHtmlHeader('<link rel="stylesheet" href="noteworthy.css">');
+$App->AddExtraHtmlHeader('<link rel="stylesheet" href="noteworthy.css">');
 
 $pageTitle ="Eclipse Neon New and Noteworthy";
 $pageAuthor = "Wayne Beaton";
diff --git a/noteworthy/js.adoc b/noteworthy/js.adoc
new file mode 100644
index 0000000..f67f29a
--- /dev/null
+++ b/noteworthy/js.adoc
@@ -0,0 +1,54 @@
+//////////////////////////////////////////
+* Copyright (c) 2016 Eclipse Foundation and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*    Wayne Beaton (Eclipse Foundation)- initial API and implementation
+//////////////////////////////////////////
+
+[[js]]
+== JavaScript and JSON
+
+=== JavaScript Development
+
+==== New EcmaScript 2015 Parser
+
+Significant new work has been invested in the JavaScript development tools, 
+starting with a new parser with EcmaScript 2015 (ES6) support. With this, 
+the Eclipse IDE recognizes and support ES6 language constructs and provides 
+better validation accuracy compared to the earlier parser. 
+
+==== Libraries and Tools
+
+Both Bower and npm are supported with creation wizards and launch shortcuts 
+for executing update and install commands. Grunt and gulp build systems are 
+accessible from within the _Project Explorer_ view and can be executed via 
+launch shortcuts.
+ 
+`Node.js` runtimes are now directly supported (`Eclipse Preferences > JavaScript > Runtimes`) 
+including a new launch configuration type can be used to run and debug 
+`Node.js` applications. `Node.js` applications can be debugged directly 
+from the editor via the Chromium V8 debugger, with full support for breakpoints 
+and inspecting JavaScript variable values in the _Variables_ view (and when 
+you hover over an in-scope variable). 
+
+image::images/v8_debugger.png[]
+
+=== JSON Development
+
+==== JSON Editor
+
+The new `JSON` editor provides support to edit some well-known `JSON` file 
+types including package.json, bower.json, .bowerrc, and .jshintrc. This support 
+includes the following features:
+
+* Syntax Coloring which can be customized with preferences;
+* An Outline Tree view;
+* Text hover on JSON Objects/Array keys and values;
+* Text folding on JSON Objects and Arrays; and
+* Editor extensions for custom hyperlinks, json schema validation, and hover help
+
+image::images/json_editor.png[]
diff --git a/noteworthy/makefile b/noteworthy/makefile
index 4fc3da0..4f8835e 100644
--- a/noteworthy/makefile
+++ b/noteworthy/makefile
@@ -2,4 +2,4 @@
 .PHONY : all
 
 ./noteworthy.html : *.adoc images/*
-	asciidoctor -a stylesheet=noteworthy.css -b html5 -d article -o noteworthy.html noteworthy.adoc
\ No newline at end of file
+	asciidoctor -a stylesheet=blank.css -b html5 -d article -o noteworthy.html noteworthy.adoc
\ No newline at end of file
diff --git a/noteworthy/modeling.adoc b/noteworthy/modeling.adoc
index f1726cc..9b8402b 100644
--- a/noteworthy/modeling.adoc
+++ b/noteworthy/modeling.adoc
@@ -15,6 +15,8 @@
 
 === Code Generation
 
+==== Builds
+
 http://www.eclipse.org/acceleo[Acceleo] introduced a new mechanism to launch code generators as part of a Maven build which is way easier and more robust by integrating with Tycho.
 
 image::images/acceleo-launcher.png[]
@@ -44,17 +46,19 @@
 
 === Model Comparison
 
+==== Visual Comparison and Merge
+
 The Neon release brings experimental support for comparing diagrams of http://www.eclipse.org/sirius[Sirius] based modelers.
 
 image::images/compare-sirius-family.png[]
 
-  
 With a right-click on a model element or resource in the viewer, a new context menu now offers you to merge all _non-conflicting_ differences that are _contained_ in the selected model element or resource with one click.
+
 With local models (both writable):
 
 image::images/compare-local.png[]
 
-With a read-only side (for example when using EGit):
+With a read-only side (for example when comparing against a previous version in Git):
 
 image::images/compare-readonly.png[]
 
@@ -64,13 +68,17 @@
 
 === Custom Graphical Editors
 
+==== Rich Property Views
+
 With the new version of http://www.eclipse.org/sirius[Sirius] you can now define rich property views alongside the diagram definition without having to write a line of code.
-This capability is introduced as an experimental feature for Neon and will be extended in the next months based on the user community feedback.
+
+This capability is introduced as an experimental feature for Eclipse Neon and will be extended in the next months based on the user community feedback.
 
 image::images/sirius-properties.png[]
 
+==== Image Rendering
 
-Packs of SVG shapes can now be contributed through a plugin to be reused in other modelers:
+Packs of SVG shapes can now be contributed through a plug-in to be reused in other modelers:
 
 image::images/svg-stencils.png[]
 
@@ -94,7 +102,9 @@
 
 image::images/bordernodeposition.png[]
 
-The "Link with editor" button has been improved and is now bidirectional.
+==== More
+
+The _Link with editor_ support has been improved and is now bidirectional.
 
 image::images/bidi-link.gif[]
 
@@ -110,4 +120,3 @@
 A new mechanism is introduced to externalize the messages in a `.odesign` model.
 
 image::images/i18n.png[]
-
diff --git a/noteworthy/noteworthy.adoc b/noteworthy/noteworthy.adoc
index 42e9fe6..7fbd5d7 100644
--- a/noteworthy/noteworthy.adoc
+++ b/noteworthy/noteworthy.adoc
@@ -29,6 +29,8 @@
 
 include::pdt.adoc[]
 
+include::js.adoc[]
+
 include::modeling.adoc[]
 
 [[sources]]
diff --git a/noteworthy/noteworthy.html b/noteworthy/noteworthy.html
index f8c82cf..eebb195 100644
--- a/noteworthy/noteworthy.html
+++ b/noteworthy/noteworthy.html
@@ -1,747 +1,76 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<meta name="generator" content="AsciiDoc 8.6.9">
+<meta charset="UTF-8">
+<!--[if IE]><meta http-equiv="X-UA-Compatible" content="IE=edge"><![endif]-->
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<meta name="generator" content="Asciidoctor 1.5.2">
 <title>Eclipse Neon New and Noteworthy</title>
-<style type="text/css">
-/* Shared CSS for AsciiDoc xhtml11 and html5 backends */
-
-/* Default font. */
-body {
-  font-family: Georgia,serif;
-}
-
-/* Title font. */
-h1, h2, h3, h4, h5, h6,
-div.title, caption.title,
-thead, p.table.header,
-#toctitle,
-#author, #revnumber, #revdate, #revremark,
-#footer {
-  font-family: Arial,Helvetica,sans-serif;
-}
-
-body {
-  margin: 1em 5% 1em 5%;
-}
-
-a {
-  color: blue;
-  text-decoration: underline;
-}
-a:visited {
-  color: fuchsia;
-}
-
-em {
-  font-style: italic;
-  color: navy;
-}
-
-strong {
-  font-weight: bold;
-  color: #083194;
-}
-
-h1, h2, h3, h4, h5, h6 {
-  color: #527bbd;
-  margin-top: 1.2em;
-  margin-bottom: 0.5em;
-  line-height: 1.3;
-}
-
-h1, h2, h3 {
-  border-bottom: 2px solid silver;
-}
-h2 {
-  padding-top: 0.5em;
-}
-h3 {
-  float: left;
-}
-h3 + * {
-  clear: left;
-}
-h5 {
-  font-size: 1.0em;
-}
-
-div.sectionbody {
-  margin-left: 0;
-}
-
-hr {
-  border: 1px solid silver;
-}
-
-p {
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-
-ul, ol, li > p {
-  margin-top: 0;
-}
-ul > li     { color: #aaa; }
-ul > li > * { color: black; }
-
-.monospaced, code, pre {
-  font-family: "Courier New", Courier, monospace;
-  font-size: inherit;
-  color: navy;
-  padding: 0;
-  margin: 0;
-}
-pre {
-  white-space: pre-wrap;
-}
-
-#author {
-  color: #527bbd;
-  font-weight: bold;
-  font-size: 1.1em;
-}
-#email {
-}
-#revnumber, #revdate, #revremark {
-}
-
-#footer {
-  font-size: small;
-  border-top: 2px solid silver;
-  padding-top: 0.5em;
-  margin-top: 4.0em;
-}
-#footer-text {
-  float: left;
-  padding-bottom: 0.5em;
-}
-#footer-badges {
-  float: right;
-  padding-bottom: 0.5em;
-}
-
-#preamble {
-  margin-top: 1.5em;
-  margin-bottom: 1.5em;
-}
-div.imageblock, div.exampleblock, div.verseblock,
-div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
-div.admonitionblock {
-  margin-top: 1.0em;
-  margin-bottom: 1.5em;
-}
-div.admonitionblock {
-  margin-top: 2.0em;
-  margin-bottom: 2.0em;
-  margin-right: 10%;
-  color: #606060;
-}
-
-div.content { /* Block element content. */
-  padding: 0;
-}
-
-/* Block element titles. */
-div.title, caption.title {
-  color: #527bbd;
-  font-weight: bold;
-  text-align: left;
-  margin-top: 1.0em;
-  margin-bottom: 0.5em;
-}
-div.title + * {
-  margin-top: 0;
-}
-
-td div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content div.title:first-child {
-  margin-top: 0.0em;
-}
-div.content + div.title {
-  margin-top: 0.0em;
-}
-
-div.sidebarblock > div.content {
-  background: #ffffee;
-  border: 1px solid #dddddd;
-  border-left: 4px solid #f0f0f0;
-  padding: 0.5em;
-}
-
-div.listingblock > div.content {
-  border: 1px solid #dddddd;
-  border-left: 5px solid #f0f0f0;
-  background: #f8f8f8;
-  padding: 0.5em;
-}
-
-div.quoteblock, div.verseblock {
-  padding-left: 1.0em;
-  margin-left: 1.0em;
-  margin-right: 10%;
-  border-left: 5px solid #f0f0f0;
-  color: #888;
-}
-
-div.quoteblock > div.attribution {
-  padding-top: 0.5em;
-  text-align: right;
-}
-
-div.verseblock > pre.content {
-  font-family: inherit;
-  font-size: inherit;
-}
-div.verseblock > div.attribution {
-  padding-top: 0.75em;
-  text-align: left;
-}
-/* DEPRECATED: Pre version 8.2.7 verse style literal block. */
-div.verseblock + div.attribution {
-  text-align: left;
-}
-
-div.admonitionblock .icon {
-  vertical-align: top;
-  font-size: 1.1em;
-  font-weight: bold;
-  text-decoration: underline;
-  color: #527bbd;
-  padding-right: 0.5em;
-}
-div.admonitionblock td.content {
-  padding-left: 0.5em;
-  border-left: 3px solid #dddddd;
-}
-
-div.exampleblock > div.content {
-  border-left: 3px solid #dddddd;
-  padding-left: 0.5em;
-}
-
-div.imageblock div.content { padding-left: 0; }
-span.image img { border-style: none; vertical-align: text-bottom; }
-a.image:visited { color: white; }
-
-dl {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-dt {
-  margin-top: 0.5em;
-  margin-bottom: 0;
-  font-style: normal;
-  color: navy;
-}
-dd > *:first-child {
-  margin-top: 0.1em;
-}
-
-ul, ol {
-    list-style-position: outside;
-}
-ol.arabic {
-  list-style-type: decimal;
-}
-ol.loweralpha {
-  list-style-type: lower-alpha;
-}
-ol.upperalpha {
-  list-style-type: upper-alpha;
-}
-ol.lowerroman {
-  list-style-type: lower-roman;
-}
-ol.upperroman {
-  list-style-type: upper-roman;
-}
-
-div.compact ul, div.compact ol,
-div.compact p, div.compact p,
-div.compact div, div.compact div {
-  margin-top: 0.1em;
-  margin-bottom: 0.1em;
-}
-
-tfoot {
-  font-weight: bold;
-}
-td > div.verse {
-  white-space: pre;
-}
-
-div.hdlist {
-  margin-top: 0.8em;
-  margin-bottom: 0.8em;
-}
-div.hdlist tr {
-  padding-bottom: 15px;
-}
-dt.hdlist1.strong, td.hdlist1.strong {
-  font-weight: bold;
-}
-td.hdlist1 {
-  vertical-align: top;
-  font-style: normal;
-  padding-right: 0.8em;
-  color: navy;
-}
-td.hdlist2 {
-  vertical-align: top;
-}
-div.hdlist.compact tr {
-  margin: 0;
-  padding-bottom: 0;
-}
-
-.comment {
-  background: yellow;
-}
-
-.footnote, .footnoteref {
-  font-size: 0.8em;
-}
-
-span.footnote, span.footnoteref {
-  vertical-align: super;
-}
-
-#footnotes {
-  margin: 20px 0 20px 0;
-  padding: 7px 0 0 0;
-}
-
-#footnotes div.footnote {
-  margin: 0 0 5px 0;
-}
-
-#footnotes hr {
-  border: none;
-  border-top: 1px solid silver;
-  height: 1px;
-  text-align: left;
-  margin-left: 0;
-  width: 20%;
-  min-width: 100px;
-}
-
-div.colist td {
-  padding-right: 0.5em;
-  padding-bottom: 0.3em;
-  vertical-align: top;
-}
-div.colist td img {
-  margin-top: 0.3em;
-}
-
-@media print {
-  #footer-badges { display: none; }
-}
-
-#toc {
-  margin-bottom: 2.5em;
-}
-
-#toctitle {
-  color: #527bbd;
-  font-size: 1.1em;
-  font-weight: bold;
-  margin-top: 1.0em;
-  margin-bottom: 0.1em;
-}
-
-div.toclevel0, div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 {
-  margin-top: 0;
-  margin-bottom: 0;
-}
-div.toclevel2 {
-  margin-left: 2em;
-  font-size: 0.9em;
-}
-div.toclevel3 {
-  margin-left: 4em;
-  font-size: 0.9em;
-}
-div.toclevel4 {
-  margin-left: 6em;
-  font-size: 0.9em;
-}
-
-span.aqua { color: aqua; }
-span.black { color: black; }
-span.blue { color: blue; }
-span.fuchsia { color: fuchsia; }
-span.gray { color: gray; }
-span.green { color: green; }
-span.lime { color: lime; }
-span.maroon { color: maroon; }
-span.navy { color: navy; }
-span.olive { color: olive; }
-span.purple { color: purple; }
-span.red { color: red; }
-span.silver { color: silver; }
-span.teal { color: teal; }
-span.white { color: white; }
-span.yellow { color: yellow; }
-
-span.aqua-background { background: aqua; }
-span.black-background { background: black; }
-span.blue-background { background: blue; }
-span.fuchsia-background { background: fuchsia; }
-span.gray-background { background: gray; }
-span.green-background { background: green; }
-span.lime-background { background: lime; }
-span.maroon-background { background: maroon; }
-span.navy-background { background: navy; }
-span.olive-background { background: olive; }
-span.purple-background { background: purple; }
-span.red-background { background: red; }
-span.silver-background { background: silver; }
-span.teal-background { background: teal; }
-span.white-background { background: white; }
-span.yellow-background { background: yellow; }
-
-span.big { font-size: 2em; }
-span.small { font-size: 0.6em; }
-
-span.underline { text-decoration: underline; }
-span.overline { text-decoration: overline; }
-span.line-through { text-decoration: line-through; }
-
-div.unbreakable { page-break-inside: avoid; }
-
-
-/*
- * xhtml11 specific
- *
- * */
-
-div.tableblock {
-  margin-top: 1.0em;
-  margin-bottom: 1.5em;
-}
-div.tableblock > table {
-  border: 3px solid #527bbd;
-}
-thead, p.table.header {
-  font-weight: bold;
-  color: #527bbd;
-}
-p.table {
-  margin-top: 0;
-}
-/* Because the table frame attribute is overriden by CSS in most browsers. */
-div.tableblock > table[frame="void"] {
-  border-style: none;
-}
-div.tableblock > table[frame="hsides"] {
-  border-left-style: none;
-  border-right-style: none;
-}
-div.tableblock > table[frame="vsides"] {
-  border-top-style: none;
-  border-bottom-style: none;
-}
-
-
-/*
- * html5 specific
- *
- * */
-
-table.tableblock {
-  margin-top: 1.0em;
-  margin-bottom: 1.5em;
-}
-thead, p.tableblock.header {
-  font-weight: bold;
-  color: #527bbd;
-}
-p.tableblock {
-  margin-top: 0;
-}
-table.tableblock {
-  border-width: 3px;
-  border-spacing: 0px;
-  border-style: solid;
-  border-color: #527bbd;
-  border-collapse: collapse;
-}
-th.tableblock, td.tableblock {
-  border-width: 1px;
-  padding: 4px;
-  border-style: solid;
-  border-color: #527bbd;
-}
-
-table.tableblock.frame-topbot {
-  border-left-style: hidden;
-  border-right-style: hidden;
-}
-table.tableblock.frame-sides {
-  border-top-style: hidden;
-  border-bottom-style: hidden;
-}
-table.tableblock.frame-none {
-  border-style: hidden;
-}
-
-th.tableblock.halign-left, td.tableblock.halign-left {
-  text-align: left;
-}
-th.tableblock.halign-center, td.tableblock.halign-center {
-  text-align: center;
-}
-th.tableblock.halign-right, td.tableblock.halign-right {
-  text-align: right;
-}
-
-th.tableblock.valign-top, td.tableblock.valign-top {
-  vertical-align: top;
-}
-th.tableblock.valign-middle, td.tableblock.valign-middle {
-  vertical-align: middle;
-}
-th.tableblock.valign-bottom, td.tableblock.valign-bottom {
-  vertical-align: bottom;
-}
-
-
-/*
- * manpage specific
- *
- * */
-
-body.manpage h1 {
-  padding-top: 0.5em;
-  padding-bottom: 0.5em;
-  border-top: 2px solid silver;
-  border-bottom: 2px solid silver;
-}
-body.manpage h2 {
-  border-style: none;
-}
-body.manpage div.sectionbody {
-  margin-left: 3em;
-}
-
-@media print {
-  body.manpage div#toc { display: none; }
-}
-
+<style>
 
 </style>
-<script type="text/javascript">
-/*<![CDATA[*/
-var asciidoc = {  // Namespace.
-
-/////////////////////////////////////////////////////////////////////
-// Table Of Contents generator
-/////////////////////////////////////////////////////////////////////
-
-/* Author: Mihai Bazon, September 2002
- * http://students.infoiasi.ro/~mishoo
- *
- * Table Of Content generator
- * Version: 0.4
- *
- * Feel free to use this script under the terms of the GNU General Public
- * License, as long as you do not remove or alter this notice.
- */
-
- /* modified by Troy D. Hanson, September 2006. License: GPL */
- /* modified by Stuart Rackham, 2006, 2009. License: GPL */
-
-// toclevels = 1..4.
-toc: function (toclevels) {
-
-  function getText(el) {
-    var text = "";
-    for (var i = el.firstChild; i != null; i = i.nextSibling) {
-      if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
-        text += i.data;
-      else if (i.firstChild != null)
-        text += getText(i);
-    }
-    return text;
-  }
-
-  function TocEntry(el, text, toclevel) {
-    this.element = el;
-    this.text = text;
-    this.toclevel = toclevel;
-  }
-
-  function tocEntries(el, toclevels) {
-    var result = new Array;
-    var re = new RegExp('[hH]([1-'+(toclevels+1)+'])');
-    // Function that scans the DOM tree for header elements (the DOM2
-    // nodeIterator API would be a better technique but not supported by all
-    // browsers).
-    var iterate = function (el) {
-      for (var i = el.firstChild; i != null; i = i.nextSibling) {
-        if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
-          var mo = re.exec(i.tagName);
-          if (mo && (i.getAttribute("class") || i.getAttribute("className")) != "float") {
-            result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
-          }
-          iterate(i);
-        }
-      }
-    }
-    iterate(el);
-    return result;
-  }
-
-  var toc = document.getElementById("toc");
-  if (!toc) {
-    return;
-  }
-
-  // Delete existing TOC entries in case we're reloading the TOC.
-  var tocEntriesToRemove = [];
-  var i;
-  for (i = 0; i < toc.childNodes.length; i++) {
-    var entry = toc.childNodes[i];
-    if (entry.nodeName.toLowerCase() == 'div'
-     && entry.getAttribute("class")
-     && entry.getAttribute("class").match(/^toclevel/))
-      tocEntriesToRemove.push(entry);
-  }
-  for (i = 0; i < tocEntriesToRemove.length; i++) {
-    toc.removeChild(tocEntriesToRemove[i]);
-  }
-
-  // Rebuild TOC entries.
-  var entries = tocEntries(document.getElementById("content"), toclevels);
-  for (var i = 0; i < entries.length; ++i) {
-    var entry = entries[i];
-    if (entry.element.id == "")
-      entry.element.id = "_toc_" + i;
-    var a = document.createElement("a");
-    a.href = "#" + entry.element.id;
-    a.appendChild(document.createTextNode(entry.text));
-    var div = document.createElement("div");
-    div.appendChild(a);
-    div.className = "toclevel" + entry.toclevel;
-    toc.appendChild(div);
-  }
-  if (entries.length == 0)
-    toc.parentNode.removeChild(toc);
-},
-
-
-/////////////////////////////////////////////////////////////////////
-// Footnotes generator
-/////////////////////////////////////////////////////////////////////
-
-/* Based on footnote generation code from:
- * http://www.brandspankingnew.net/archive/2005/07/format_footnote.html
- */
-
-footnotes: function () {
-  // Delete existing footnote entries in case we're reloading the footnodes.
-  var i;
-  var noteholder = document.getElementById("footnotes");
-  if (!noteholder) {
-    return;
-  }
-  var entriesToRemove = [];
-  for (i = 0; i < noteholder.childNodes.length; i++) {
-    var entry = noteholder.childNodes[i];
-    if (entry.nodeName.toLowerCase() == 'div' && entry.getAttribute("class") == "footnote")
-      entriesToRemove.push(entry);
-  }
-  for (i = 0; i < entriesToRemove.length; i++) {
-    noteholder.removeChild(entriesToRemove[i]);
-  }
-
-  // Rebuild footnote entries.
-  var cont = document.getElementById("content");
-  var spans = cont.getElementsByTagName("span");
-  var refs = {};
-  var n = 0;
-  for (i=0; i<spans.length; i++) {
-    if (spans[i].className == "footnote") {
-      n++;
-      var note = spans[i].getAttribute("data-note");
-      if (!note) {
-        // Use [\s\S] in place of . so multi-line matches work.
-        // Because JavaScript has no s (dotall) regex flag.
-        note = spans[i].innerHTML.match(/\s*\[([\s\S]*)]\s*/)[1];
-        spans[i].innerHTML =
-          "[<a id='_footnoteref_" + n + "' href='#_footnote_" + n +
-          "' title='View footnote' class='footnote'>" + n + "</a>]";
-        spans[i].setAttribute("data-note", note);
-      }
-      noteholder.innerHTML +=
-        "<div class='footnote' id='_footnote_" + n + "'>" +
-        "<a href='#_footnoteref_" + n + "' title='Return to text'>" +
-        n + "</a>. " + note + "</div>";
-      var id =spans[i].getAttribute("id");
-      if (id != null) refs["#"+id] = n;
-    }
-  }
-  if (n == 0)
-    noteholder.parentNode.removeChild(noteholder);
-  else {
-    // Process footnoterefs.
-    for (i=0; i<spans.length; i++) {
-      if (spans[i].className == "footnoteref") {
-        var href = spans[i].getElementsByTagName("a")[0].getAttribute("href");
-        href = href.match(/#.*/)[0];  // Because IE return full URL.
-        n = refs[href];
-        spans[i].innerHTML =
-          "[<a href='#_footnote_" + n +
-          "' title='View footnote' class='footnote'>" + n + "</a>]";
-      }
-    }
-  }
-},
-
-install: function(toclevels) {
-  var timerId;
-
-  function reinstall() {
-    asciidoc.footnotes();
-    if (toclevels) {
-      asciidoc.toc(toclevels);
-    }
-  }
-
-  function reinstallAndRemoveTimer() {
-    clearInterval(timerId);
-    reinstall();
-  }
-
-  timerId = setInterval(reinstall, 500);
-  if (document.addEventListener)
-    document.addEventListener("DOMContentLoaded", reinstallAndRemoveTimer, false);
-  else
-    window.onload = reinstallAndRemoveTimer;
-}
-
-}
-asciidoc.install(2);
-/*]]>*/
-</script>
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.2.0/css/font-awesome.min.css">
 </head>
 <body class="article">
 <div id="header">
 <h1>Eclipse Neon New and Noteworthy</h1>
-<div id="toc">
-  <div id="toctitle">Table of Contents</div>
-  <noscript><p><b>JavaScript must be enabled in your browser to display the table of contents.</b></p></noscript>
+<div id="toc" class="toc">
+<div id="toctitle">Table of Contents</div>
+<ul class="sectlevel1">
+<li><a href="#platform">Platform</a>
+<ul class="sectlevel2">
+<li><a href="#_general">General</a></li>
+<li><a href="#_look_and_feel">Look and Feel</a></li>
+<li><a href="#_other_changes_and_improvements">Other Changes and Improvements</a></li>
+</ul>
+</li>
+<li><a href="#java">Java&#8482;</a>
+<ul class="sectlevel2">
+<li><a href="#_java_9">Java 9</a></li>
+<li><a href="#_java_editor">Java Editor</a></li>
+<li><a href="#_java_views_wizards_and_other_ui">Java Views, Wizards, and Other UI</a></li>
+<li><a href="#_debug">Debug</a></li>
+<li><a href="#_null_analysis">Null Analysis</a></li>
+</ul>
+</li>
+<li><a href="#cdt">C/C++</a>
+<ul class="sectlevel2">
+<li><a href="#_general_2">General</a></li>
+<li><a href="#_debug_2">Debug</a></li>
+<li><a href="#_other_change_and_improvements">Other Change and Improvements</a></li>
+</ul>
+</li>
+<li><a href="#pdt">PHP</a>
+<ul class="sectlevel2">
+<li><a href="#_php_language">PHP Language</a></li>
+<li><a href="#_editors">Editors</a></li>
+<li><a href="#pdt-debugging">PHP Debugging</a></li>
+</ul>
+</li>
+<li><a href="#js">JavaScript and JSON</a>
+<ul class="sectlevel2">
+<li><a href="#_javascript_development">JavaScript Development</a></li>
+<li><a href="#_json_development">JSON Development</a></li>
+</ul>
+</li>
+<li><a href="#modeling">Modeling</a>
+<ul class="sectlevel2">
+<li><a href="#_code_generation">Code Generation</a></li>
+<li><a href="#_model_editors">Model Editors</a></li>
+<li><a href="#_model_comparison">Model Comparison</a></li>
+<li><a href="#_custom_graphical_editors">Custom Graphical Editors</a></li>
+</ul>
+</li>
+<li><a href="#sources">Sources</a></li>
+</ul>
 </div>
 </div>
 <div id="content">
 <div id="preamble">
 <div class="sectionbody">
-<div class="paragraph"><p>Here are some of the noteworthy features in the Eclipse Neon Simultaneous Release.</p></div>
+<div class="paragraph">
+<p>Here are some of the noteworthy features in the Eclipse Neon Simultaneous Release.</p>
+</div>
 </div>
 </div>
 <div class="sect1">
@@ -750,50 +79,59 @@
 <div class="sect2">
 <h3 id="_general">General</h3>
 <div class="sect3">
-<h4 id="_improved_interactive_performance_and_reduced_memory_consumption">Improved interactive performance and reduced memory consumption</h4>
-<div class="paragraph"><p>This and earlier milestones contain a multitude of fixes to enhance interactive and startup performance of the Eclipse IDE, and to reduce overall memory consumption.</p></div>
-<div class="paragraph"><p>TBD: insert some benchmarks</p></div>
-</div>
-<div class="sect3">
 <h4 id="_import_projects">Import Projects</h4>
-<div class="paragraph"><p>A new <strong>Import Projects</strong> wizard is available via the <span class="monospaced">File &gt; Open Projects...</span>
-menu and via the general <span class="monospaced">Import...</span> command under <span class="monospaced">General &gt; Projects</span> from Folder
-or Archive.</p></div>
-<div class="paragraph"><p>Compared to other ways to import or create projects, this wizard aims at being
+<div class="paragraph">
+<p>A new <strong>Import Projects</strong> wizard is available via the <code>File &gt; Open Projects&#8230;&#8203;</code>
+menu and via the general <code>Import&#8230;&#8203;</code> command under <code>General &gt; Projects</code> from Folder
+or Archive.</p>
+</div>
+<div class="paragraph">
+<p>Compared to other ways to import or create projects, this wizard aims at being
 a universal wizard that, from a source directory or archive, can detect and
-configure various kinds of projects.</p></div>
+configure various kinds of projects.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/import-projects.png" alt="images/import-projects.png">
+<img src="images/import-projects.png" alt="import projects">
 </div>
 </div>
-<div class="paragraph"><p>This wizard relies on an extensible set of strategies that look at the content
+<div class="paragraph">
+<p>This wizard relies on an extensible set of strategies that look at the content
 of the import source to detect file types, project layout patterns, or even
 look into some files in order to deduct which folders should be turned into
 projects and how those should be configured. Configuration usually involves
-setting up project natures and preferences.</p></div>
-<div class="paragraph"><p>The import strategies are contributed via the new extension point
-<span class="monospaced">org.eclipse.ui.ide.projectConfigurator</span>, so that other IDE components can contribute
-detection and configuration specific to the technology they&#8217;re supporting.</p></div>
+setting up project natures and preferences.</p>
+</div>
+<div class="paragraph">
+<p>The import strategies are contributed via the new extension point
+org.eclipse.ui.ide.projectConfigurator, so that other IDE components can contribute
+detection and configuration specific to the technology they&#8217;re supporting.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_search_in_binary_files">Search in binary files</h4>
-<div class="paragraph"><p>The <span class="monospaced">Search &gt; File&#8230;</span> dialog has a new option to search in binary files as well.</p></div>
+<div class="paragraph">
+<p>The Search &gt; File... dialog has a new option to search in binary files as well.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/search-binary-files.png" alt="images/search-binary-files.png">
+<img src="images/search-binary-files.png" alt="search binary files">
 </div>
 </div>
-<div class="paragraph"><p>By default, the option is disabled, and matches are only reported in files that
+<div class="paragraph">
+<p>By default, the option is disabled, and matches are only reported in files that
 have the <strong>Text</strong> content type, or in files that have no content type and don&#8217;t
-contain the null character (<span class="monospaced">\u0000</span>).</p></div>
+contain the null character (\u0000).</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_automatic_save_of_dirty_editors">Automatic Save of dirty editors</h4>
-<div class="paragraph"><p>Auto-save of dirty editors is now available in Eclipse. The autosave option is disabled by default. A new autosave preference page (Preferences &gt; General &gt; Editors &gt; Autosave) is available and allows to enable/disable the autosave and change the interval of autosave. The countdown is reset on keyboard activity, mouse click, or when a popup is displayed (e.g. content assist, preference page, &#8230;).</p></div>
+<div class="paragraph">
+<p>Auto-save of dirty editors is now available in Eclipse. The autosave option is disabled by default. A new autosave preference page (Preferences &gt; General &gt; Editors &gt; Autosave) is available and allows to enable/disable the autosave and change the interval of autosave. The countdown is reset on keyboard activity, mouse click, or when a popup is displayed (e.g. content assist, preference page, &#8230;&#8203;).</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/autosave-preference-page.png" alt="images/autosave-preference-page.png">
+<img src="images/autosave-preference-page.png" alt="autosave preference page">
 </div>
 </div>
 </div>
@@ -802,185 +140,233 @@
 <h3 id="_look_and_feel">Look and Feel</h3>
 <div class="sect3">
 <h4 id="_resolution_based_image_auto_scaling">Resolution-based image auto-scaling</h4>
-<div class="paragraph"><p>Images now automatically scale on high-DPI monitors on Windows and Linux,
+<div class="paragraph">
+<p>Images now automatically scale on high-DPI monitors on Windows and Linux,
 similar to the Mac&#8217;s Retina support on OS X. In the absence of high-resolution
 images, available images are automatically scaled proportionately to the
-resolution of the monitor.</p></div>
+resolution of the monitor.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/swt-high-dpi.png" alt="images/swt-high-dpi.png">
+<img src="images/swt-high-dpi.png" alt="swt high dpi">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_preference_setting_to_disable_css_based_theming">Preference setting to disable CSS based theming</h4>
-<div class="paragraph"><p>You can disable the CSS-based styling of the Eclipse IDE via
-<span class="monospaced">Preferences &gt; General &gt; Appearance &gt; Enable theming</span>. This will prevent the Eclipse
+<div class="paragraph">
+<p>You can disable the CSS-based styling of the Eclipse IDE via
+Preferences &gt; General &gt; Appearance &gt; Enable theming. This will prevent the Eclipse
 Workbench from rendering custom colors, shades, and borders, and may result in better
-performance.</p></div>
+performance.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/enable-disable-theming.png" alt="images/enable-disable-theming.png">
+<img src="images/enable-disable-theming.png" alt="enable disable theming">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_full_screen">Full Screen</h4>
-<div class="paragraph"><p>The Full Screen feature is now also available on Windows and Linux. You can toggle
-the mode via shortcut (<span class="monospaced">Alt+F11</span>) or menu (<span class="monospaced">Window &gt; Appearance &gt; Toggle Full Screen</span>).</p></div>
-<div class="paragraph"><p>When Full Screen is activated, you&#8217;ll see a dialog which tells you how to turn it off again.</p></div>
+<div class="paragraph">
+<p>The Full Screen feature is now also available on Windows and Linux. You can toggle
+the mode via shortcut (Alt+F11) or menu (Window &gt; Appearance &gt; Toggle Full Screen).</p>
+</div>
+<div class="paragraph">
+<p>When Full Screen is activated, you&#8217;ll see a dialog which tells you how to turn it off again.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_hide_the_window_toolbars">Hide the window toolbars</h4>
-<div class="paragraph"><p>You can use the Toggle Visibility of all Toolbars command (via Quick Access:
-<span class="monospaced">Ctrl+3</span> or <span class="monospaced">Command+3</span>) to hide all currently visible toolbars of the currently
+<div class="paragraph">
+<p>You can use the Toggle Visibility of all Toolbars command (via Quick Access:
+Ctrl+3 or Command+3) to hide all currently visible toolbars of the currently
 window. Selecting the command again, reveals these toolbars again. This allows
 the developer to maximize the space available for editors and views. If you
 minimize a stack after you selected this command, the minimized stack will be
 visible until you trigger the command to hide the toolbars again. This allows
-you to decide which minimized stacks are currently useful for you.</p></div>
-<div class="paragraph"><p>The following is a screenshot of the IDE with a maximized Java editor
-and several toolbars visible.</p></div>
+you to decide which minimized stacks are currently useful for you.</p>
+</div>
+<div class="paragraph">
+<p>The following is a screenshot of the IDE with a maximized Java editor
+and several toolbars visible.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/ide-with-toolbars.png" alt="images/ide-with-toolbars.png">
+<img src="images/ide-with-toolbars.png" alt="ide with toolbars">
 </div>
 </div>
-<div class="paragraph"><p>The next screenshot shows the same maximized editor but with hidden toolbars.</p></div>
+<div class="paragraph">
+<p>The next screenshot shows the same maximized editor but with hidden toolbars.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/ide-full-screen.png" alt="images/ide-full-screen.png">
+<img src="images/ide-full-screen.png" alt="ide full screen">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_word_wrap_in_text_editors">Word wrap in text editors</h4>
-<div class="paragraph"><p>A Toggle Word Wrap button has been added to the workbench toolbar.
-Shortcut: <span class="monospaced">Alt+Shift+Y</span>.</p></div>
+<div class="paragraph">
+<p>A Toggle Word Wrap button has been added to the workbench toolbar.
+Shortcut: Alt+Shift+Y.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/word-wrap.png" alt="images/word-wrap.png">
+<img src="images/word-wrap.png" alt="word wrap">
 </div>
 </div>
-<div class="paragraph"><p>By default, text editors are opened with word wrap disabled.</p></div>
+<div class="paragraph">
+<p>By default, text editors are opened with word wrap disabled.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_commands_and_shortcuts_to_zoom_in_text_editors">Commands and shortcuts to zoom in text editors</h4>
-<div class="paragraph"><p>In text editors, you can now use Zoom In (<span class="monospaced">Ctrl++</span> or <span class="monospaced">Ctrl+=</span>)
-and Zoom Out (<span class="monospaced">Ctrl+-</span>) commands to increase and decrease the font size.</p></div>
-<div class="paragraph"><p>Like a change in the <span class="monospaced">General &gt; Appearance &gt; Colors and Fonts</span> preference page,
+<div class="paragraph">
+<p>In text editors, you can now use Zoom In (Ctrl++ or Ctrl+=)
+and Zoom Out (Ctrl+-) commands to increase and decrease the font size.</p>
+</div>
+<div class="paragraph">
+<p>Like a change in the General &gt; Appearance &gt; Colors and Fonts preference page,
 the commands persistently change the font size in all editors of the same type.
 If the editor type&#8217;s font is configured to use a default font, then that
-default font will be zoomed.</p></div>
+default font will be zoomed.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_pinch_to_zoom_in_text_editors">Pinch to zoom in text editors</h4>
-<div class="paragraph"><p>To temporarily zoom the editor font in text editors, use a "pinch" gesture on a
-touchpad. Put two fingers on the touchpad and move them apart or together.</p></div>
-<div class="paragraph"><p>To reset the original font size, rotate two fingers by at least 45°, or close
-and reopen the editor (<span class="monospaced">Navigate &gt; Back</span>).</p></div>
-<div class="paragraph"><p>Those gestures only affect the current editor. Changes are neither propagated
-to other editors nor persisted.</p></div>
-<div class="admonitionblock">
-<table><tr>
+<div class="paragraph">
+<p>To temporarily zoom the editor font in text editors, use a "pinch" gesture on a
+touchpad. Put two fingers on the touchpad and move them apart or together.</p>
+</div>
+<div class="paragraph">
+<p>To reset the original font size, rotate two fingers by at least 45°, or close
+and reopen the editor (Navigate &gt; Back).</p>
+</div>
+<div class="paragraph">
+<p>Those gestures only affect the current editor. Changes are neither propagated
+to other editors nor persisted.</p>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
 <td class="icon">
-<img src="./images/icons/note.png" alt="Note">
+<i class="fa icon-note" title="Note"></i>
 </td>
-<td class="content">SWT currently only supports these gestures on OS X and on Windows systems
+<td class="content">
+SWT currently only supports these gestures on OS X and on Windows systems
 that use the native multi-touch support. Touchpads that emulate mouse move/scroll
-events don&#8217;t support gestures. Gesture support on GTK is not implemented yet.</td>
-</tr></table>
+events don&#8217;t support gestures. Gesture support on GTK is not implemented yet.
+</td>
+</tr>
+</table>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_directly_start_previously_selected_workspaces_in_the_launcher">Directly start previously selected workspaces in the launcher</h4>
-<div class="paragraph"><p>The workspace selection dialog now allows you to start a previously selected
+<div class="paragraph">
+<p>The workspace selection dialog now allows you to start a previously selected
 workspace directly via a link. The path to the workspace is shortened. The full
-path is available if you hover over the link.</p></div>
+path is available if you hover over the link.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/recent-workspace-launcher.png" alt="images/recent-workspace-launcher.png">
+<img src="images/recent-workspace-launcher.png" alt="recent workspace launcher">
 </div>
 </div>
-<div class="paragraph"><p>You can remove existing entries via the context menu.</p></div>
+<div class="paragraph">
+<p>You can remove existing entries via the context menu.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_selecting_the_text_editor_for_unassociated_file_types">Selecting the text editor for unassociated file types</h4>
-<div class="paragraph"><p>On the <span class="monospaced">Preferences &gt; General &gt; Editors &gt; File Association</span> page, you can now
+<div class="paragraph">
+<p>On the Preferences &gt; General &gt; Editors &gt; File Association page, you can now
 define an editor selection strategy for unassociated file types. Three strategies
-are provided out-of-the-box:</p></div>
-<div class="ulist"><ul>
-<li>
-<p>
-<em>Search Marketplace</em> (default) will use the Eclipse Marketplace Client to
-search the <a href="http://marketplace.eclipse.org">Eclipse Marketplace</a> for plug-ins that
-support the file type;
-</p>
-</li>
-<li>
-<p>
-<em>System Editor; if none: Text Editor</em> will open the system editor
-associated with the file, if available. If no system editor is associated with
-the given file, fall back to the Eclipse Text Editor;
-</p>
-</li>
-<li>
-<p>
-<em>Text Editor</em> will always open Eclipse&#8217;s Text Editor on unassociated file types;
-and
-</p>
-</li>
-<li>
-<p>
-<em>Ask via pop-up</em> will open the same dialog as using <span class="monospaced">Open With &gt; Other&#8230;</span> on a
-file and let you choose which editor to use (inside or outside the IDE).
-</p>
-</li>
-</ul></div>
-<div class="admonitionblock">
-<table><tr>
-<td class="icon">
-<img src="./images/icons/note.png" alt="Note">
-</td>
-<td class="content">It&#8217;s possible to assign an editor for an <em>unassociated</em>
-file type either via this same preference page, or via the <span class="monospaced">Open With &gt; Other&#8230;</span>
-context-menu on the file.</td>
-</tr></table>
+are provided out-of-the-box:</p>
 </div>
-<div class="paragraph"><p>The implementation comes with a new extension-point <span class="monospaced">org.eclipse.ui.ide.unknownEditorStrategy</span>
-that allows external contributions of additional strategies.</p></div>
+<div class="ulist">
+<ul>
+<li>
+<p><em>Search Marketplace</em> (default) will use the Eclipse Marketplace Client to
+search the <a href="http://marketplace.eclipse.org">Eclipse Marketplace</a> for plug-ins that
+support the file type;</p>
+</li>
+<li>
+<p><em>System Editor; if none: Text Editor</em> will open the system editor
+associated with the file, if available. If no system editor is associated with
+the given file, fall back to the Eclipse Text Editor;</p>
+</li>
+<li>
+<p><em>Text Editor</em> will always open Eclipse&#8217;s Text Editor on unassociated file types;
+and</p>
+</li>
+<li>
+<p><em>Ask via pop-up</em> will open the same dialog as using Open With &gt; Other... on a
+file and let you choose which editor to use (inside or outside the IDE).</p>
+</li>
+</ul>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-note" title="Note"></i>
+</td>
+<td class="content">
+It&#8217;s possible to assign an editor for an <em>unassociated</em>
+file type either via this same preference page, or via the Open With &gt; Other...
+context-menu on the file.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>The implementation comes with a new extension-point org.eclipse.ui.ide.unknownEditorStrategy
+that allows external contributions of additional strategies.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_quick_access_improvements">Quick Access improvements</h4>
-<div class="paragraph"><p>Quick Access (<span class="monospaced">Ctrl+3</span>) is a small text field in the toolbar. You can use it to
-trigger any command in the Eclipse Workbench.</p></div>
+<div class="paragraph">
+<p>Quick Access (Ctrl+3) is a small text field in the toolbar. You can use it to
+trigger any command in the Eclipse Workbench.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/eclipse-quick-access-improved-search.png" alt="images/eclipse-quick-access-improved-search.png">
+<img src="images/eclipse-quick-access-improved-search.png" alt="eclipse quick access improved search">
 </div>
 </div>
-<div class="paragraph"><p>You can now restrict the search to Views, Commands, etc. by typing the category name
+<div class="paragraph">
+<p>You can now restrict the search to Views, Commands, etc. by typing the category name
 followed by a colon. For example, to filter the list of all the views, start typing
-"Views: " in the search-box.</p></div>
-<div class="paragraph"><p>A few usability bugs have been fixed: The tooltip shows the keyboard shortcut, the
+"Views: " in the search-box.</p>
+</div>
+<div class="paragraph">
+<p>A few usability bugs have been fixed: The tooltip shows the keyboard shortcut, the
 number of search results per category is independent of the size of the proposals
 window, and the list with previous choices already opens when you click the field
-with the mouse.</p></div>
+with the mouse.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_new_welcome_screen">New Welcome Screen</h4>
-<div class="paragraph"><p>The Welcome/Intro introduces a new <em>Solstice</em> theme that provides a new modern
-appearance and enhanced functionality.</p></div>
+<div class="paragraph">
+<p>The Welcome/Intro introduces a new <em>Solstice</em> theme that provides a new modern
+appearance and enhanced functionality.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/eclipse-welcome-solstice.png" alt="images/eclipse-welcome-solstice.png">
+<img src="images/eclipse-welcome-solstice.png" alt="eclipse welcome solstice">
 </div>
 </div>
-<div class="paragraph"><p>In Eclipse 3.x, the <em>Go to Workbench</em> button on the Welcome page would minimize
-the Welcome page to the window status bar. This behavior has been restored.</p></div>
+<div class="paragraph">
+<p>In Eclipse 3.x, the <em>Go to Workbench</em> button on the Welcome page would minimize
+the Welcome page to the window status bar. This behavior has been restored.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/eclipse-welcome-launchbar.png" alt="images/eclipse-welcome-launchbar.png">
+<img src="images/eclipse-welcome-launchbar.png" alt="eclipse welcome launchbar">
 </div>
 </div>
 </div>
@@ -989,21 +375,35 @@
 <h3 id="_other_changes_and_improvements">Other Changes and Improvements</h3>
 <div class="sect3">
 <h4 id="_more">More</h4>
-<div class="paragraph"><p>The look of the toolbar in the MacOS default theme was adjusted to align with
-other MacOS applications.</p></div>
-<div class="paragraph"><p>To save space in the toolbar, the perspective switcher has been changed to show
+<div class="paragraph">
+<p>The look of the toolbar in the MacOS default theme was adjusted to align with
+other MacOS applications.</p>
+</div>
+<div class="paragraph">
+<p>To save space in the toolbar, the perspective switcher has been changed to show
 only the icons of perspectives by default. You can show the text again via the
-context menu.</p></div>
-<div class="paragraph"><p>The <em>date</em> variable, supported in editor and code templates, now allows you to
-specify which format to use when inserting the current date (or time).</p></div>
-<div class="paragraph"><p>The <em>word_selection</em> and <em>line_selection</em> variables, supported in editor and
+context menu.</p>
+</div>
+<div class="paragraph">
+<p>The 'date' variable, supported in editor and code templates, now allows you to
+specify which format to use when inserting the current date (or time).</p>
+</div>
+<div class="paragraph">
+<p>The 'word_selection' and 'line_selection' variables, supported in editor and
 code templates, now allow you to specify a default value to use if the current
-text selection is empty.</p></div>
-<div class="paragraph"><p>The workspace name is now shown at the beginning of the window title by default.
-The initial name is the name of the workspace directory.</p></div>
-<div class="paragraph"><p>When you export your preference settings via <span class="monospaced">File &gt; Export... &gt; Preferences</span>,
-the preferences are now sorted alphabetically in the resulting file.</p></div>
-<div class="paragraph"><p>Eclipse has been updated to include improved support for the Wayland display manager.</p></div>
+text selection is empty.</p>
+</div>
+<div class="paragraph">
+<p>The workspace name is now shown at the beginning of the window title by default.
+The initial name is the name of the workspace directory.</p>
+</div>
+<div class="paragraph">
+<p>When you export your preference settings via <code>File &gt; Export&#8230;&#8203; &gt; Preferences</code>,
+the preferences are now sorted alphabetically in the resulting file.</p>
+</div>
+<div class="paragraph">
+<p>Eclipse has been updated to include improved support for the Wayland display manager.</p>
+</div>
 </div>
 </div>
 </div>
@@ -1011,128 +411,161 @@
 <div class="sect1">
 <h2 id="java">Java&#8482;</h2>
 <div class="sectionbody">
-<div class="paragraph"><p>Eclipse Neon includes numerous bug fixes and improvements in the Java 8
-support, along with a lot of other useful features.</p></div>
+<div class="paragraph">
+<p>Eclipse Neon includes numerous bug fixes and improvements in the Java 8
+support, along with a lot of other useful features.</p>
+</div>
 <div class="sect2">
 <h3 id="_java_9">Java 9</h3>
 <div class="sect3">
 <h4 id="_launching_on_java_9">Launching on Java 9</h4>
-<div class="paragraph"><p>Launching Eclipse with recent Java 9 previews fails with <span class="monospaced">NoClassDefFoundErrors</span> for
-<span class="monospaced">javax/annotation/PostConstruct</span> and similar types.</p></div>
-<div class="paragraph"><p>The workaround is to add the VM arguments</p></div>
+<div class="paragraph">
+<p>Launching Eclipse with recent Java 9 previews fails with <code>NoClassDefFoundErrors</code> for
+<code>javax/annotation/PostConstruct</code> and similar types.</p>
+</div>
+<div class="paragraph">
+<p>The workaround is to add the VM arguments</p>
+</div>
 <div class="literalblock">
-<div class="content monospaced">
+<div class="content">
 <pre>-addmods java.se.ee</pre>
-</div></div>
-<div class="paragraph"><p>either on the command line after <span class="monospaced">-vmargs</span>, or at the end of the eclipse.ini file on
-two separate lines.</p></div>
+</div>
+</div>
+<div class="paragraph">
+<p>either on the command line after <code>-vmargs</code>, or at the end of the eclipse.ini file on
+two separate lines.</p>
+</div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_java_editor">Java Editor</h3>
 <div class="sect3">
 <h4 id="_ifnotnull_ifnull_templates">ifNotNull/ifNull templates</h4>
-<div class="paragraph"><p>The Java editor now offers default templates for creating "== null" and "!= null" checks.</p></div>
+<div class="paragraph">
+<p>The Java editor now offers default templates for creating "== null" and "!= null" checks.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/if-null-template.png" alt="images/if-null-template.png">
+<img src="images/if-null-template.png" alt="if null template">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_new_info_severity_level">New Info severity level</h4>
-<div class="paragraph"><p>You can now specify <em>Info</em> as a severity level for the problems detected by the Eclipse
-Java compiler.</p></div>
+<div class="paragraph">
+<p>You can now specify <em>Info</em> as a severity level for the problems detected by the Eclipse
+Java compiler.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/info-severity.png" alt="images/info-severity.png">
+<img src="images/info-severity.png" alt="info severity">
 </div>
 </div>
-<div class="paragraph"><p>A new decorator has been added to indicate information severity problems detected by the
-Eclipse Java Compiler.</p></div>
+<div class="paragraph">
+<p>A new decorator has been added to indicate information severity problems detected by the
+Eclipse Java Compiler.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/info-problem-decorator.png" alt="images/info-problem-decorator.png">
+<img src="images/info-problem-decorator.png" alt="info problem decorator">
 </div>
 </div>
-<div class="paragraph"><p>You can now configure the severity of a compiler problem by invoking the new <em>Quick Fix</em>
-(<span class="monospaced">Ctrl+1</span>) which opens the <span class="monospaced">Java &gt; Compiler &gt; Errors/Warnings</span> preference page and
-highlights the configurable problem.</p></div>
+<div class="paragraph">
+<p>You can now configure the severity of a compiler problem by invoking the new <em>Quick Fix</em>
+(<code>Ctrl+1</code>) which opens the <code>Java &gt; Compiler &gt; Errors/Warnings</code> preference page and
+highlights the configurable problem.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/configure-problem-severity.png" alt="images/configure-problem-severity.png">
+<img src="images/configure-problem-severity.png" alt="configure problem severity">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_substring_code_completion">Substring code completion</h4>
-<div class="paragraph"><p>Content Assist now supports substring patterns. Enter any part of the desired proposal&#8217;s
-text, and Content Assist will find it! For example, completing on <span class="monospaced">selection</span> proposes
-all results containing <span class="monospaced">selection</span> as a substring.</p></div>
+<div class="paragraph">
+<p>Content Assist now supports substring patterns. Enter any part of the desired proposal&#8217;s
+text, and Content Assist will find it! For example, completing on <code>selection</code> proposes
+all results containing <code>selection</code> as a substring.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/substring-code-completion.png" alt="images/substring-code-completion.png">
+<img src="images/substring-code-completion.png" alt="substring code completion">
 </div>
 </div>
-<div class="paragraph"><p>This feature can be disabled using the <span class="monospaced">Show substring matches</span> option on the
-<span class="monospaced">Java &gt; Editor &gt; Content Assist</span> preference page.</p></div>
+<div class="paragraph">
+<p>This feature can be disabled using the <code>Show substring matches</code> option on the
+<code>Java &gt; Editor &gt; Content Assist</code> preference page.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_clean_up_to_remove_redundant_type_arguments">Clean Up to remove redundant type arguments</h4>
-<div class="paragraph"><p>A new option to remove redundant type arguments has been added under the
-<em>Unnecessary Code</em> group of the Clean Up profile.</p></div>
+<div class="paragraph">
+<p>A new option to remove redundant type arguments has been added under the
+<em>Unnecessary Code</em> group of the Clean Up profile.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/remove-redundant-type-arguments.png" alt="images/remove-redundant-type-arguments.png">
+<img src="images/remove-redundant-type-arguments.png" alt="remove redundant type arguments">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_new_options_in_code_formatter">New options in code formatter</h4>
-<div class="paragraph"><p>In the new <em>Parentheses</em> tab, you can order the formatter to keep
+<div class="paragraph">
+<p>In the new <em>Parentheses</em> tab, you can order the formatter to keep
 parentheses of various Java elements on separate lines, i.e. put a
 line break after the opening parenthesis and before the closing
 parenthesis. This can be done always, only when parentheses are
 not empty, or when their content is wrapped. There&#8217;s also an option
 to preserve existing positions, if you want to manually manage parentheses
-positions on a case-by-case basis.</p></div>
+positions on a case-by-case basis.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/formatter-parentheses.png" alt="images/formatter-parentheses.png">
+<img src="images/formatter-parentheses.png" alt="formatter parentheses">
 </div>
 </div>
-<div class="paragraph"><p>In the <em>Line Wrapping</em> tab, you can set the wrapping policy for parameterized
+<div class="paragraph">
+<p>In the <em>Line Wrapping</em> tab, you can set the wrapping policy for parameterized
 types, you can decide to wrap before or after operators in assignments and
 conditional expressions, and you can control the wrapping policy of
-<span class="monospaced">'for' loop headers</span>.</p></div>
+<code>'for' loop headers</code>.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/formatter-wrap-for.png" alt="images/formatter-wrap-for.png">
+<img src="images/formatter-wrap-for.png" alt="formatter wrap for">
 </div>
 </div>
-<div class="paragraph"><p>The <em>Align fields in columns</em> feature in the <em>Indentation</em> section can now
+<div class="paragraph">
+<p>The <em>Align fields in columns</em> feature in the <em>Indentation</em> section can now
 be configured to <em>recognize groups separated by empty lines</em> and align them
-independently.</p></div>
+independently.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/formatter-align-groups.png" alt="images/formatter-align-groups.png">
+<img src="images/formatter-align-groups.png" alt="formatter align groups">
 </div>
 </div>
-<div class="paragraph"><p>In the <em>New lines</em> section, you can control if new lines should be added
-after annotations on <span class="monospaced">enum</span> constants.</p></div>
+<div class="paragraph">
+<p>In the <em>New lines</em> section, you can control if new lines should be added
+after annotations on <code>enum</code> constants.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/formatter-enum-constants.png" alt="images/formatter-enum-constants.png">
+<img src="images/formatter-enum-constants.png" alt="formatter enum constants">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_create_new_fields_from_method_parameters">Create new fields from method parameters</h4>
-<div class="paragraph"><p>You can now assign all parameters of a method or constructor to new fields
-at once using the new <em>Quick Assist</em> (<span class="monospaced">Ctrl+1</span>):</p></div>
+<div class="paragraph">
+<p>You can now assign all parameters of a method or constructor to new fields
+at once using the new <em>Quick Assist</em> (<code>Ctrl+1</code>):</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/assign-all-params-to-new-fields.png" alt="images/assign-all-params-to-new-fields.png">
+<img src="images/assign-all-params-to-new-fields.png" alt="assign all params to new fields">
 </div>
 </div>
 </div>
@@ -1141,185 +574,235 @@
 <h3 id="_java_views_wizards_and_other_ui">Java Views, Wizards, and Other UI</h3>
 <div class="sect3">
 <h4 id="_project_explorer_improvements">Project Explorer Improvements</h4>
-<div class="paragraph"><p>The <em>Project Explorer</em> view now groups referenced libraries in a new container node.</p></div>
+<div class="paragraph">
+<p>The <em>Project Explorer</em> view now groups referenced libraries in a new container node.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/show-referenced-libraries-node-project-explorer.png" alt="images/show-referenced-libraries-node-project-explorer.png">
+<img src="images/show-referenced-libraries-node-project-explorer.png" alt="show referenced libraries node project explorer">
 </div>
 </div>
-<div class="paragraph"><p>You can now hide empty library containers in the <em>Project Explorer</em> view by selecting
-the new filter in its <em>Customize View&#8230;</em> dialog.</p></div>
+<div class="paragraph">
+<p>You can now hide empty library containers in the <em>Project Explorer</em> view by selecting
+the new filter in its <em>Customize View&#8230;&#8203;</em> dialog.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/hide-empty-library-containers-project-explorer.png" alt="images/hide-empty-library-containers-project-explorer.png">
+<img src="images/hide-empty-library-containers-project-explorer.png" alt="hide empty library containers project explorer">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_add_meta_annotations_while_creating_a_new_java_annotation_type">Add meta-annotations while creating a new Java annotation type</h4>
-<div class="paragraph"><p>You can now choose to add <span class="monospaced">@Retention</span>, <span class="monospaced">@Target</span> and <span class="monospaced">@Documented</span> meta-annotations
-along with their applicable values while creating a new Java annotation type.</p></div>
+<div class="paragraph">
+<p>You can now choose to add <code>@Retention</code>, <code>@Target</code> and <code>@Documented</code> meta-annotations
+along with their applicable values while creating a new Java annotation type.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/add-meta-annotations.png" alt="images/add-meta-annotations.png">
+<img src="images/add-meta-annotations.png" alt="add meta annotations">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_search_on_multi_selections">Search on multi-selections</h4>
-<div class="paragraph"><p>You can now select multiple elements in views like <em>Package Explorer</em> and
+<div class="paragraph">
+<p>You can now select multiple elements in views like <em>Package Explorer</em> and
 <em>Outline</em> and then search for <em>References</em>, <em>Declarations</em>, <em>Implementors</em>,
-and <em>Read/Write Access</em> (where applicable):</p></div>
+and <em>Read/Write Access</em> (where applicable):</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/search-on-multi-selections.png" alt="images/search-on-multi-selections.png">
+<img src="images/search-on-multi-selections.png" alt="search on multi selections">
 </div>
 </div>
-<div class="paragraph"><p>You can even select results in the <em>Search</em> view and start a new search for those
+<div class="paragraph">
+<p>You can even select results in the <em>Search</em> view and start a new search for those
 elements. To follow method call chains, you&#8217;d probably use <em>Open Call Hierarchy</em>,
-though.</p></div>
+though.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_junit_support">JUnit Support</h4>
-<div class="paragraph"><p>Assertions are now enabled by default for new JUnit launch configurations. You can
-disable this on the <span class="monospaced">Preferences &gt; Java &gt; JUnit</span> page.</p></div>
+<div class="paragraph">
+<p>Assertions are now enabled by default for new JUnit launch configurations. You can
+disable this on the <code>Preferences &gt; Java &gt; JUnit</code> page.</p>
+</div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_debug">Debug</h3>
 <div class="sect3">
 <h4 id="_installing_breakpoints_from_unrelated_projects">Installing breakpoints from unrelated projects</h4>
-<div class="paragraph"><p>Multiple versions of the same Java type can be available in a workspace, and
+<div class="paragraph">
+<p>Multiple versions of the same Java type can be available in a workspace, and
 each version can have breakpoints configured at different source locations. When
 debugging, JDT tries to determine the "right" set of breakpoints to install in
-the target VM. This analysis now uses Java project dependencies by default.</p></div>
-<div class="paragraph"><p>To always install all enabled breakpoints, you can disable the new option
-<span class="monospaced">Preferences &gt; Java &gt; Debug &gt; Do not install breakpoints from unrelated projects</span>.</p></div>
+the target VM. This analysis now uses Java project dependencies by default.</p>
+</div>
+<div class="paragraph">
+<p>To always install all enabled breakpoints, you can disable the new option
+<code>Preferences &gt; Java &gt; Debug &gt; Do not install breakpoints from unrelated projects</code>.</p>
+</div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_null_analysis">Null Analysis</h3>
 <div class="sect3">
 <h4 id="_multiple_sets_of_null_annotations">Multiple sets of null annotations</h4>
-<div class="paragraph"><p>You can now configure annotation-based null analysis to use multiple sets of
+<div class="paragraph">
+<p>You can now configure annotation-based null analysis to use multiple sets of
 annotation types. This is relevant if your project uses 3rd party libraries
 that already use null annotations in their API, where the annotations used in
-a library may be different from those used in the current project.</p></div>
-<div class="paragraph"><p>Please open the dialog for configuring null annotation types from the project
-properties at <span class="monospaced">Java Compiler &gt; Errors/Warnings &gt; Null analysis</span>:</p></div>
+a library may be different from those used in the current project.</p>
+</div>
+<div class="paragraph">
+<p>Please open the dialog for configuring null annotation types from the project
+properties at <code>Java Compiler &gt; Errors/Warnings &gt; Null analysis</code>:</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/prefs-errors-warnings.png" alt="images/prefs-errors-warnings.png">
+<img src="images/prefs-errors-warnings.png" alt="prefs errors warnings">
 </div>
 </div>
-<div class="paragraph"><p>In the dialog that opens, only one primary set of annotations is supported;
+<div class="paragraph">
+<p>In the dialog that opens, only one primary set of annotations is supported;
 these are the annotations which JDT actively uses in <em>Quick Fixes</em>, error
-messages etc. These annotations must be present on the project&#8217;s build path.</p></div>
-<div class="paragraph"><p>You can now add an arbitrary number of secondary <span class="monospaced">null</span> annotation types, to
+messages etc. These annotations must be present on the project&#8217;s build path.</p>
+</div>
+<div class="paragraph">
+<p>You can now add an arbitrary number of secondary <code>null</code> annotation types, to
 be evaluated when reading class files external to the project. Within the
 configuration dialog, Content Assist is offered based on accessible annotation
 types, but for secondary annotation types unresolved names will be tolerated.
 This avoids the need to bloat the build path with transitive compile-time
-dependencies.</p></div>
+dependencies.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/annotation-selection.png" alt="images/annotation-selection.png">
+<img src="images/annotation-selection.png" alt="annotation selection">
 </div>
 </div>
 </div>
 <div class="sect3">
-<h4 id="_improved_span_class_monospaced_null_span_analysis_with_generics">Improved <span class="monospaced">null</span> analysis with generics</h4>
-<div class="paragraph"><p>The interplay of <span class="monospaced">null</span> annotations and generics has been improved in several
-regards.</p></div>
-<div class="paragraph"><p>The basic concepts had already been documented in the online help, but not
-all that was documented was actually checked by <span class="monospaced">null</span> analysis. With
+<h4 id="_improved_code_null_code_analysis_with_generics">Improved <code>null</code> analysis with generics</h4>
+<div class="paragraph">
+<p>The interplay of <code>null</code> annotations and generics has been improved in several
+regards.</p>
+</div>
+<div class="paragraph">
+<p>The basic concepts had already been documented in the online help, but not
+all that was documented was actually checked by <code>null</code> analysis. With
 the changes outlined below, null analysis based on type annotations is even
-more capable than previous versions.</p></div>
-<div class="paragraph"><p>(1) The first batch of contributed improvements implements what we call
+more capable than previous versions.</p>
+</div>
+<div class="paragraph">
+<p>(1) The first batch of contributed improvements implements what we call
 <em>pessimistic analysis for free type variables</em>, which affects implementors
-of generic types.</p></div>
+of generic types.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/pessimistic-analysis.png" alt="images/pessimistic-analysis.png">
+<img src="images/pessimistic-analysis.png" alt="pessimistic analysis">
 </div>
 </div>
-<div class="paragraph"><p>In order to allow clients to instantiate such a generic class with either
-a <span class="monospaced">@NonNull</span> or a <span class="monospaced">@Nullable</span> type as substitution for the "free type variable"
-<span class="monospaced">&lt;T&gt;</span>, the implementation of that class must account for the worst in both
-directions:</p></div>
-<div class="ulist"><ul>
+<div class="paragraph">
+<p>In order to allow clients to instantiate such a generic class with either
+a <code>@NonNull</code> or a <code>@Nullable</code> type as substitution for the "free type variable"
+<code>&lt;T&gt;</code>, the implementation of that class must account for the worst in both
+directions:</p>
+</div>
+<div class="ulist">
+<ul>
 <li>
-<p>
-To anticipate a <span class="monospaced">@NonNull</span> type, each field typed to a free type variable
-must be initialized with a non-<span class="monospaced">null</span> value, and passing <span class="monospaced">null</span> where <span class="monospaced">T</span> is
-expected is illegal; and
-</p>
+<p>To anticipate a <code>@NonNull</code> type, each field typed to a free type variable
+must be initialized with a non-<code>null</code> value, and passing <code>null</code> where <code>T</code> is
+expected is illegal; and</p>
 </li>
 <li>
-<p>
-To anticipate a <span class="monospaced">@Nullable</span> type, each dereference must be preceded by a <span class="monospaced">null</span> check.
-</p>
+<p>To anticipate a <code>@Nullable</code> type, each dereference must be preceded by a <code>null</code> check.</p>
 </li>
-</ul></div>
-<div class="paragraph"><p>At the bottom of each problem hover, you will find a link to the corresponding
+</ul>
+</div>
+<div class="paragraph">
+<p>At the bottom of each problem hover, you will find a link to the corresponding
 configuration option, should you like to change the severity of this diagnostic.
 Note that configurability is mainly given for smooth migration from previous
 JDT version; conceptually, problems detected by pessimistic analysis should be
 treated as errors, because they invalidate the null-guarantees given by a generic
-type.</p></div>
+type.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/configure-pessimistic-analysis.png" alt="images/configure-pessimistic-analysis.png">
+<img src="images/configure-pessimistic-analysis.png" alt="configure pessimistic analysis">
 </div>
 </div>
-<div class="paragraph"><p>(2) The second improvement concerns consumption of generic types from a library,
+<div class="paragraph">
+<p>(2) The second improvement concerns consumption of generic types from a library,
 more specifically: invocations of library methods whose return type is given by
-a free type variable.</p></div>
-<div class="paragraph"><p>If the library type is instantiated with a <span class="monospaced">@NonNull</span> type as the type argument,
-we generally want to interpret the mentioned return type as non-<span class="monospaced">null</span>, too.
-This is problematic only for some "legacy" methods, which may return <span class="monospaced">null</span>
-without declaring so. The most prominent example is <span class="monospaced">java.util.Map.get(K)</span>.</p></div>
-<div class="paragraph"><p>The analysis cannot see whether absence of a null annotation for such a return
+a free type variable.</p>
+</div>
+<div class="paragraph">
+<p>If the library type is instantiated with a <code>@NonNull</code> type as the type argument,
+we generally want to interpret the mentioned return type as non-<code>null</code>, too.
+This is problematic only for some "legacy" methods, which may return <code>null</code>
+without declaring so. The most prominent example is <code>java.util.Map.get(K)</code>.</p>
+</div>
+<div class="paragraph">
+<p>The analysis cannot see whether absence of a null annotation for such a return
 type is intentional (in the above sense of "free type variables"), or an omission
 that should be fixed. For that reason a new warning has been implemented to alert
-about this situation.</p></div>
+about this situation.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/unsafe-nonnull-interpretation.png" alt="images/unsafe-nonnull-interpretation.png">
+<img src="images/unsafe-nonnull-interpretation.png" alt="unsafe nonnull interpretation">
 </div>
 </div>
-<div class="paragraph"><p>In the above example, both fields list and map provide <span class="monospaced">@NonNull</span> <span class="monospaced">String</span> as a type
-argument, hence the return types of both <em>get</em> methods are interpreted as non-<span class="monospaced">null</span>.
-For <span class="monospaced">List</span> this is desired, for <span class="monospaced">Map</span> it is a bug.</p></div>
-<div class="paragraph"><p>The dilemma can be resolved by adding a (possibly empty) external annotation file
-(<span class="monospaced">.eea</span>) to each affected library class. By using an empty annotation file, the user
+<div class="paragraph">
+<p>In the above example, both fields list and map provide <code>@NonNull</code> <code>String</code> as a type
+argument, hence the return types of both <em>get</em> methods are interpreted as non-<code>null</code>.
+For <code>List</code> this is desired, for <code>Map</code> it is a bug.</p>
+</div>
+<div class="paragraph">
+<p>The dilemma can be resolved by adding a (possibly empty) external annotation file
+(<code>.eea</code>) to each affected library class. By using an empty annotation file, the user
 signals that all types in this class should be interpreted verbatim (like in the
-<span class="monospaced">List</span> case - use with care). In the other case, the missing <span class="monospaced">@Nullable</span> annotation
-should be added as an external annotation (like in the <span class="monospaced">Map</span> case).</p></div>
-<div class="paragraph"><p>In a project that is not yet configured to use external annotations for the
+<code>List</code> case - use with care). In the other case, the missing <code>@Nullable</code> annotation
+should be added as an external annotation (like in the <code>Map</code> case).</p>
+</div>
+<div class="paragraph">
+<p>In a project that is not yet configured to use external annotations for the
 library in question, the warning is demoted to level "information". Generally, the
 severity of this problem is configured using the option right below the one mentioned
-above, titled <span class="monospaced">Unsafe '@NonNull'</span> interpretation of free type variable from library.</p></div>
-<div class="paragraph"><p>(3) Finally, a small utility class, <span class="monospaced">org.eclipse.jdt.annotation.Checks</span>, has been
-included in the bundle <span class="monospaced">org.eclipse.jdt.annotation_2.1.0</span> containing helper methods
-for typical idioms for improving and documenting <span class="monospaced">null</span> safety.</p></div>
+above, titled <code>Unsafe '@NonNull'</code> interpretation of free type variable from library.</p>
+</div>
+<div class="paragraph">
+<p>(3) Finally, a small utility class, <code>org.eclipse.jdt.annotation.Checks</code>, has been
+included in the bundle <code>org.eclipse.jdt.annotation_2.1.0</code> containing helper methods
+for typical idioms for improving and documenting <code>null</code> safety.</p>
+</div>
 </div>
 <div class="sect3">
-<h4 id="_quick_fix_to_add_span_class_monospaced_nonnull_span_to_local_variable">Quick Fix to add <span class="monospaced">@NonNull</span> to local variable</h4>
-<div class="paragraph"><p>When a "potential null pointer access" problem is raised against a local variable,
-the reason is not always obvious. Perhaps <span class="monospaced">null</span> is assigned somewhere deep inside
-a complex control flow. If annotation-based <span class="monospaced">null</span> analysis is enabled, a new
-<em>Quick Fix</em> is offered (<span class="monospaced">Ctrl+1</span>), that adds a <span class="monospaced">@NonNull</span> annotation to the local
-variable.</p></div>
+<h4 id="_quick_fix_to_add_code_nonnull_code_to_local_variable">Quick Fix to add <code>@NonNull</code> to local variable</h4>
+<div class="paragraph">
+<p>When a "potential null pointer access" problem is raised against a local variable,
+the reason is not always obvious. Perhaps <code>null</code> is assigned somewhere deep inside
+a complex control flow. If annotation-based <code>null</code> analysis is enabled, a new
+<em>Quick Fix</em> is offered (<code>Ctrl+1</code>), that adds a <code>@NonNull</code> annotation to the local
+variable.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/add-nonnull1.png" alt="images/add-nonnull1.png">
+<img src="images/add-nonnull1.png" alt="add nonnull1">
 </div>
 </div>
-<div class="paragraph"><p>While this may not produce correct code, it tells the compiler your intention to
-not allow <span class="monospaced">null</span> in this variable, and subsequently the compiler will answer with more
+<div class="paragraph">
+<p>While this may not produce correct code, it tells the compiler your intention to
+not allow <code>null</code> in this variable, and subsequently the compiler will answer with more
 helpful warnings or errors pointing to the root problem. In the given example,
-it will alert you of subtleties about using unconstrained type variables.</p></div>
+it will alert you of subtleties about using unconstrained type variables.</p>
+</div>
 </div>
 </div>
 </div>
@@ -1327,116 +810,174 @@
 <div class="sect1">
 <h2 id="cdt">C/C++</h2>
 <div class="sectionbody">
-<div class="paragraph"><p>C/C++ support is provided by the <a href="https://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/marsr">Eclipse IDE for C/C++</a> Developers.</p></div>
+<div class="paragraph">
+<p>Eclipse Neon includes many improvements in stability and some new
+functionality for C/C++ developers.</p>
+</div>
 <div class="sect2">
 <h3 id="_general_2">General</h3>
 <div class="sect3">
 <h4 id="_import_projects_2">Import Projects</h4>
-<div class="paragraph"><p>When code completion is invoked in a function call expression, appropriate
-substitutions are suggested for each of the function parameters.</p></div>
+<div class="paragraph">
+<p>When code completion is invoked in a function call expression, appropriate
+substitutions are suggested for each of the function parameters.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Function_call.png" alt="images/Function_call.png">
+<img src="images/Function_call.png" alt="Function call">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_create_new_class_quick_fix">Create New Class - Quick Fix</h4>
-<div class="paragraph"><p>In C<span class="monospaced"> files if "Type not found" error is detected, there is a new <strong>Quick Fix</strong>
-now to create a class based on that type, which opens the <strong>New C</span> Class Wizard</strong>.
+<div class="paragraph">
+<p>In C files if "Type not found" error is detected, there is a new *Quick Fix*
+now to create a class based on that type, which opens the *New C Class Wizard*.
 Note: to enable quick user must enable "Type cannot be resolved" problem in
-"Code Analysis" settings</p></div>
+"Code Analysis" settings</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/CPPnewClass.png" alt="images/CPPnewClass.png">
+<img src="images/CPPnewClass.png" alt="CPPnewClass">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_format_edited_lines_save_action">Format Edited Lines Save Action</h4>
-<div class="paragraph"><p>It is now possible to format either the whole file or only the edited lines when a source or a
-header file is saved.</p></div>
+<div class="paragraph">
+<p>It is now possible to format either the whole file or only the edited lines when a source or a
+header file is saved.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Save_Actions.png" alt="images/Save_Actions.png">
+<img src="images/Save_Actions.png" alt="Save Actions">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_suppressions_in_code">Suppressions in code</h4>
-<div class="paragraph"><p>It is now possible to suppress code analysis errors/warnings by adding comments in the code.</p></div>
+<div class="paragraph">
+<p>It is now possible to suppress code analysis errors/warnings by adding comments in the code.</p>
+</div>
 <div class="literalblock">
-<div class="content monospaced">
+<div class="content">
 <pre>x = x; // @suppress("assignment in condition") because I know better</pre>
-</div></div>
-<div class="paragraph"><p>The comment is actually configurable using problem parameters (@suppress(&lt;title&gt;) is default).</p></div>
+</div>
+</div>
+<div class="paragraph">
+<p>The comment is actually configurable using problem parameters (@suppress(&lt;title&gt;) is default).</p>
+</div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_debug_2">Debug</h3>
 <div class="sect3">
 <h4 id="_gdbserver_options">Gdbserver options</h4>
-<div class="paragraph"><p>For automatic remote debugging sessions, CDT now supports specifying extra options
+<div class="paragraph">
+<p>For automatic remote debugging sessions, CDT now supports specifying extra options
 that will be passed to gdbserver when starting it. This way, users could activate
-debug messages (<span class="monospaced">--debug</span>), benefit of wrapper option (<span class="monospaced">--wrapper</span>) that gdbserver
-supports or use the other available command-line options of gdbserver.</p></div>
+debug messages (<code>--debug</code>), benefit of wrapper option (<code>--wrapper</code>) that gdbserver
+supports or use the other available command-line options of gdbserver.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Gdbserver-settings-tab.PNG" alt="images/Gdbserver-settings-tab.PNG">
+<img src="images/Gdbserver-settings-tab.PNG" alt="Gdbserver settings tab">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_os_resources_view_improvements">OS Resources View Improvements</h4>
-<div class="paragraph"><p>The <em>OS Resources</em> view displays different information about the resources of the operating
+<div class="paragraph">
+<p>The <em>OS Resources</em> view displays different information about the resources of the operating
 system, such as list of all processes running on the target or files opened by processes
-on target.</p></div>
-<div class="paragraph"><p>Now it is possible to attach to processes associated with selected resources directly
-from <em>OS Resources</em> view without resorting to "Connect to a process" button from Debug View.</p></div>
+on target.</p>
+</div>
+<div class="paragraph">
+<p>Now it is possible to attach to processes associated with selected resources directly
+from <em>OS Resources</em> view without resorting to "Connect to a process" button from Debug View.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/OS_Resources_Attach.JPG" alt="images/OS_Resources_Attach.JPG">
+<img src="images/OS_Resources_Attach.JPG" alt="OS Resources Attach">
 </div>
 </div>
-<div class="paragraph"><p>This feature requires non-stop mode support to be activated.</p></div>
-<div class="paragraph"><p>OS Resources View lists a lot of text information. Now it is possible to copy selected lines
-to the clipboard to save for later comparison.</p></div>
+<div class="paragraph">
+<p>This feature requires non-stop mode support to be activated.</p>
+</div>
+<div class="paragraph">
+<p>OS Resources View lists a lot of text information. Now it is possible to copy selected lines
+to the clipboard to save for later comparison.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="_debug_ux">Debug UX</h4>
-<div class="paragraph"><p>In an effort to reduce clutter, the Connect button was removed from the Debug toolbar. The action is still available from the Debug view context-menu as shown below. Furthermore, connecting to a process can now be done using the OS Resources view as described in this section.</p></div>
+<div class="paragraph">
+<p>In an effort to reduce clutter, the Connect button was removed from the Debug toolbar. The action is still available from the Debug view context-menu as shown below. Furthermore, connecting to a process can now be done using the OS Resources view as described in this section.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/CDT_Removed_Connect_Button.png" alt="images/CDT_Removed_Connect_Button.png">
+<img src="images/CDT_Removed_Connect_Button.png" alt="CDT Removed Connect Button">
 </div>
 </div>
-<div class="paragraph"><p>To streamline the UI, the "New&#8230;" button of the Connect dialogue which was used to create a new process has been removed. This action is available instead from the Debug view context-menu as shown below.</p></div>
+<div class="paragraph">
+<p>To streamline the UI, the "New&#8230;&#8203;" button of the Connect dialogue which was used to create a new process has been removed. This action is available instead from the Debug view context-menu as shown below.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/CDT_RemoveNewButton.png" alt="images/CDT_RemoveNewButton.png">
+<img src="images/CDT_RemoveNewButton.png" alt="CDT RemoveNewButton">
 </div>
 </div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_other_change_and_improvements">Other Change and Improvements</h3>
-<div class="paragraph"><p>The <em>Makefile Editor</em> now provides a single key <span class="monospaced">Ctrl+/</span> to toggle comments rather than
-have <span class="monospaced">Ctrl+/</span> to comment and <span class="monospaced">Ctrl+\</span> to uncomment. This is consistent with CDT and Java editors.</p></div>
+<div class="paragraph">
+<p>The <em>Makefile Editor</em> now provides a single key <code>Ctrl+/</code> to toggle comments rather than
+have <code>Ctrl+/</code> to comment and <code>Ctrl+\</code> to uncomment. This is consistent with CDT and Java editors.</p>
+</div>
 </div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="pdt">PHP</h2>
 <div class="sectionbody">
-<div class="paragraph"><p>We fixed / closed over 100 bugs in this release!</p></div>
-<div class="paragraph"><p>Better error messages for unsupported PHP versions (especially for
-legacy versions)</p></div>
+<div class="paragraph">
+<p>The Eclipse Neon release includes significant improvements in
+stability (including fixes for more than 100 bugs) and a lot of new
+functionality for PHP developers.</p>
+</div>
 <div class="sect2">
-<h3 id="pdt-general">General</h3>
-<div class="paragraph"><p>Final support for PHP 7 scalar type declarations</p></div>
+<h3 id="_php_language">PHP Language</h3>
+<div class="paragraph">
+<p>Eclipse Neon provides better error messages for unsupported PHP
+versions (especially for legacy versions).</p>
+</div>
+<div class="sect3">
+<h4 id="pdt-php7">PHP 7</h4>
+<div class="paragraph">
+<p>PHP 7 is the default version for new workspaces.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_scalar.png" alt="images/Pdt40_scalar.png">
+<img src="images/Pdt37_php7.jpg" alt="Pdt37 php7">
+</div>
+</div>
+<div class="paragraph">
+<p>Final support for PHP 7 scalar type declarations.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="images/Pdt40_scalar.png" alt="Pdt40 scalar">
+</div>
+</div>
+<div class="paragraph">
+<p>The syntax highlighter now fully supports PHP 7 context sensitive
+keywords.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="images/Pdt40_context_sensitive.png" alt="Pdt40 context sensitive">
+</div>
 </div>
 </div>
 </div>
@@ -1444,254 +985,329 @@
 <h3 id="_editors">Editors</h3>
 <div class="sect3">
 <h4 id="_code_assist">Code Assist</h4>
-<div class="paragraph"><p>The PHP validator identifies non abstract methods without body.</p></div>
+<div class="paragraph">
+<p>The PHP validator identifies non abstract methods without body.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_no_body.png" alt="images/Pdt40_no_body.png">
+<img src="images/Pdt40_no_body.png" alt="Pdt40 no body">
 </div>
 </div>
-<div class="paragraph"><p>Inappropriate use of multiple access modifiers (eg. <span class="monospaced">public</span> <span class="monospaced">private</span>
-functions)</p></div>
+<div class="paragraph">
+<p>Inappropriate use of multiple access modifiers (eg. <code>public</code> <code>private</code>
+functions)</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_multiple_access_modifiers.png" alt="images/Pdt40_multiple_access_modifiers.png">
+<img src="images/Pdt40_multiple_access_modifiers.png" alt="Pdt40 multiple access modifiers">
 </div>
 </div>
-<div class="paragraph"><p>The validator no longer analyzes PHP comments (except in <em>PHPDoc</em> comments).</p></div>
+<div class="paragraph">
+<p>The validator no longer analyzes PHP comments (except in <em>PHPDoc</em> comments).</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_use.png" alt="images/Pdt40_use.png">
+<img src="images/Pdt40_use.png" alt="Pdt40 use">
 </div>
 </div>
-<div class="paragraph"><p>The PHP indexer is significantly faster than in previous versions.
-The UI remains responsive when indexing is in progress.</p></div>
-<div class="paragraph"><p>Better task tags (e.g. <span class="monospaced">@todo</span>) detection</p></div>
+<div class="paragraph">
+<p>Improved Code Assist for <code>@param</code>, <code>@return</code>, and <code>@throws</code> tags
+inside <em>PHPDoc</em></p>
+</div>
+<div class="paragraph">
+<p><span class="image"><img src="images/Pdt37_ca1.png" alt="Pdt37_ca1"></span> <span class="image"><img src="images/Pdt37_ca2.png" alt="Pdt37_ca2"></span></p>
+</div>
+<div class="paragraph">
+<p>The PHP indexer is significantly faster than in previous versions.
+The UI remains responsive when indexing is in progress.</p>
+</div>
+<div class="paragraph">
+<p>Better task tags (e.g. <code>@todo</code>) detection</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_task_tags.png" alt="images/Pdt40_task_tags.png">
+<img src="images/Pdt40_task_tags.png" alt="Pdt40 task tags">
 </div>
 </div>
-<div class="paragraph"><p>Methods and functions are visible as <span class="monospaced">void</span> only if they do not have
-<span class="monospaced">return</span> and <span class="monospaced">yield</span> statements. The otherwise have the declared
-return type or <span class="monospaced">mixed</span>.</p></div>
+<div class="paragraph">
+<p>Methods and functions are visible as <code>void</code> only if they do not have
+<code>return</code> and <code>yield</code> statements. The otherwise have the declared
+return type or <code>mixed</code>.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_return_types.png" alt="images/Pdt40_return_types.png">
+<img src="images/Pdt40_return_types.png" alt="Pdt40 return types">
 </div>
 </div>
-<div class="paragraph"><p>Simple types (<span class="monospaced">int</span>, <span class="monospaced">bool</span>, <span class="monospaced">string</span>, &#8230;) are included in the
-suggestions for for PHP &gt;= 7 function return types.</p></div>
+<div class="paragraph">
+<p>Simple types (<code>int</code>, <code>bool</code>, <code>string</code>, &#8230;&#8203;) are included in the
+suggestions for for PHP &gt;= 7 function return types.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_return_sugestion.png" alt="images/Pdt40_return_sugestion.png">
+<img src="images/Pdt40_return_sugestion.png" alt="Pdt40 return sugestion">
+</div>
+</div>
+<div class="sect4">
+<h5 id="_more_code_assist">More Code Assist</h5>
+<div class="ulist">
+<ul>
+<li>
+<p>Improved Code Assist for unfinished class and method bodies;</p>
+</li>
+<li>
+<p>Improved support around <code>@inheritdoc</code> (coloring and code assist).</p>
+</li>
+</ul>
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_highlighting">Highlighting</h4>
-<div class="paragraph"><p>Improved support around <span class="monospaced">@inheritdoc</span> (coloring and code assist).</p></div>
-<div class="paragraph"><p>More semantic highlighters are enabled by default, including class,
-deprecation, and constants.</p></div>
+<div class="paragraph">
+<p>More semantic highlighters are enabled by default, including class,
+deprecation, and constants.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_default_highlighters.png" alt="images/Pdt40_default_highlighters.png">
+<img src="images/Pdt40_default_highlighters.png" alt="Pdt40 default highlighters">
 </div>
 </div>
-<div class="paragraph"><p>Improved highlighting for <span class="monospaced">array</span> type.</p></div>
+<div class="paragraph">
+<p>Improved highlighting for <code>array</code> type.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_array_highlight.png" alt="images/Pdt40_array_highlight.png">
+<img src="images/Pdt40_array_highlight.png" alt="Pdt40 array highlight">
 </div>
 </div>
-<div class="paragraph"><p>Added support for <span class="monospaced">instanceof</span> and <span class="monospaced">insteadof</span> in class semantic
-highlighter.</p></div>
+<div class="paragraph">
+<p>Added support for <code>instanceof</code> and <code>insteadof</code> in class semantic
+highlighter.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_class_instanceof.png" alt="images/Pdt40_class_instanceof.png">
+<img src="images/Pdt40_class_instanceof.png" alt="Pdt40 class instanceof">
 </div>
 </div>
-<div class="paragraph"><p>Assign to local quick assist (<span class="monospaced">ctrl/cmd + 2 + L</span>)</p></div>
+<div class="paragraph">
+<p>Assign to local quick assist (<code>ctrl/cmd + 2 + L</code>)</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_assign_to_local.png" alt="images/Pdt40_assign_to_local.png">
+<img src="images/Pdt40_assign_to_local.png" alt="Pdt40 assign to local">
 </div>
 </div>
-<div class="paragraph"><p>The syntax highlighter now fully supports PHP 7 context sensitive
-keywords.</p></div>
+<div class="paragraph">
+<p>Function / method return types are available in Content Assist
+proposals</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_context_sensitive.png" alt="images/Pdt40_context_sensitive.png">
+<img src="images/Pdt40_ca_return_types.png" alt="Pdt40 ca return types">
 </div>
 </div>
-<div class="paragraph"><p>Function / method return types are available in Content Assist
-proposals</p></div>
+<div class="paragraph">
+<p>Content Assist now supports colored labels</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_ca_return_types.png" alt="images/Pdt40_ca_return_types.png">
-</div>
-</div>
-<div class="paragraph"><p>Content Assist now supports colored labels</p></div>
-<div class="imageblock">
-<div class="content">
-<img src="images/Pdt40_colored_labels.png" alt="images/Pdt40_colored_labels.png">
+<img src="images/Pdt40_colored_labels.png" alt="Pdt40 colored labels">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_php_editor_commands">PHP Editor Commands</h4>
-<div class="paragraph"><p>Buttons have been added to the editor toolbar to enable/disable <em>Word wrap</em>,
-<em>Block selection</em>, and <em>Show white space characters</em>.</p></div>
+<div class="paragraph">
+<p>Buttons have been added to the editor toolbar to enable/disable <em>Word wrap</em>,
+<em>Block selection</em>, and <em>Show white space characters</em>.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_editor_actions.png" alt="images/Pdt40_editor_actions.png">
+<img src="images/Pdt40_editor_actions.png" alt="Pdt40 editor actions">
 </div>
 </div>
-<div class="paragraph"><p>??? Quick Source and Quick Refactor menu entries have been added.</p></div>
-<div class="imageblock">
-<div class="content">
-<img src="images/Pdt40_quick_menu.png" alt="images/Pdt40_quick_menu.png">
-</div>
-</div>
-<div class="paragraph"><p>Quick Outline saves size and location</p></div>
-<div class="paragraph"><p>Improved code folding -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=443379">bug 443379</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=486018">bug 486018</a></p></div>
 </div>
 <div class="sect3">
 <h4 id="_more_php_editor_improvemvents">More PHP Editor Improvemvents</h4>
-<div class="ulist"><ul>
+<div class="ulist">
+<ul>
 <li>
-<p>
-Improved code assist performance for files with many assignments;
-</p>
+<p>Improved code assist performance for files with many assignments;</p>
 </li>
 <li>
-<p>
-General performance improvements for <em>PHPDoc</em> generation
-</p>
+<p>General performance improvements for <em>PHPDoc</em> generation</p>
 </li>
 <li>
-<p>
-Smart parenthesis works correctly inside closures
-</p>
+<p>Smart parenthesis works correctly inside closures</p>
 </li>
 <li>
-<p>
-<span class="monospaced">abstract</span> keyword is no longer proposed inside method body
-</p>
+<p><code>abstract</code> keyword is no longer proposed inside method body</p>
 </li>
 <li>
-<p>
-Deprecated highlighting is shown even if class in same namespace
-</p>
+<p>Deprecated highlighting is shown even if class in same namespace</p>
 </li>
 <li>
-<p>
-Content assist and hover tooltips shows function / method return types
-</p>
+<p>Content assist and hover tooltips shows function / method return types</p>
 </li>
 <li>
-<p>
-Improved deprecation highlighter support for inherited members
-</p>
+<p>Improved deprecation highlighter support for inherited members</p>
 </li>
-</ul></div>
+</ul>
 </div>
 </div>
-<div class="sect2">
-<h3 id="pdt-debugging">Debugging</h3>
-<div class="paragraph"><p>OSX support improvements
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=488630">bug 488630</a></p></div>
-<div class="paragraph"><p>Improvements in debugger variables support
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=487966">bug 487966</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=490697">bug 490697</a></p></div>
-<div class="paragraph"><p>No longer display outdated values
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=477241">bug 477241</a></p></div>
-<div class="paragraph"><p>Fix ignored breakpoints
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=489646">bug 489646</a></p></div>
-<div class="paragraph"><p>Added support for class statics inside namespace
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=492992">bug 492992</a></p></div>
-<div class="paragraph"><p>Remove PDT "Parameter Stack" view
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=492010">bug 492010</a></p></div>
-<div class="paragraph"><p>Breakpoints works with linked resources -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=240553">bug 240553</a></p></div>
-<div class="paragraph"><p>Fix xdebug debugging via SSH tunnel -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=478402">bug 478402</a></p></div>
-<div class="paragraph"><p>Support for PHP exception breakpoints -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=483694">bug 483694</a></p></div>
 <div class="sect3">
-<h4 id="_zend_debugger">Zend Debugger</h4>
-<div class="paragraph"><p>Fix variables fetching with static context in PHP 7
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=493839">bug 493839</a></p></div>
-<div class="paragraph"><p>Fix <em>Display debug information</em> saving
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=493154">bug 493154</a></p></div>
+<h4 id="_ide_integration">IDE Integration</h4>
+<div class="paragraph">
+<p>Integration with the <em>Project Explorer</em> view has been improved,
+including dedicated support for PHP Project elements and specific actions,
+and support for traits when the "group by namespace" option is selected.</p>
+</div>
+<div class="paragraph">
+<p>PHP Language Libraries have PHP Version badge</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="images/Pdt40_php_version_badge.png" alt="Pdt40 php version badge">
+</div>
+</div>
+<div class="paragraph">
+<p>"Add PHP support&#8230;&#8203;" no longer visible in PHP-enabled projects (i.e. when
+it is unnecessary).</p>
+</div>
+<div class="paragraph">
+<p>PHP <em>Quick Fixes</em> are available in <em>Problems View</em>.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="images/Pdt37_quickfix.png" alt="Pdt37 quickfix">
+</div>
+</div>
 </div>
 </div>
 <div class="sect2">
-<h3 id="pdt-other">Other</h3>
-<div class="paragraph"><p>"Short method return types" are enabled by default in all PDT views
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=469503">bug 469503</a></p></div>
-<div class="paragraph"><p>Better integration with eclipse Project Explorer. Support for PHP
-Project elements and specific actions.
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=480376">bug 480376</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=480374">bug 480374</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=494124">bug 494124</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=494124">bug 494124</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=494253">bug 494253</a></p></div>
-<div class="paragraph"><p>Support for traits in PHP Project Explorer when "group by namespace"
-is active <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=488685">bug
-488685</a></p></div>
-<div class="paragraph"><p>PHP Language Library have PHP Version badge
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=494137">bug 494137</a><br></p></div>
+<h3 id="pdt-debugging">PHP Debugging</h3>
+<div class="paragraph">
+<p>Eclipse Neon includes numerous bug fixes and improvements in the PHP
+Debugging.</p>
+</div>
+<div class="sect3">
+<h4 id="_exception_breakpoints">Exception Breakpoints</h4>
+<div class="paragraph">
+<p>Support for PHP exception breakpoints</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt40_php_version_badge.png" alt="images/Pdt40_php_version_badge.png">
+<img src="images/Pdt-ExceptionBP.png" alt="Pdt ExceptionBP">
 </div>
 </div>
-<div class="paragraph"><p>"Add PHP support&#8230;" no longer visible in PHP-enabled projects</p></div>
-<div class="paragraph"><p>Fixed regression during updating PHP file outline with PHP &lt; 5.3</p></div>
+</div>
+<div class="sect3">
+<h4 id="_more_debugging">More Debugging</h4>
+<div class="ulist">
+<ul>
+<li>
+<p>OSX support improvements</p>
+</li>
+<li>
+<p>Improvements in debugger variables support</p>
+</li>
+<li>
+<p>No longer display outdated values</p>
+</li>
+<li>
+<p>Fix ignored breakpoints</p>
+</li>
+<li>
+<p>Added support for class statics inside namespace</p>
+</li>
+<li>
+<p>Remove PDT "Parameter Stack" view (the <em>Variables</em> view renders this outdated <em>Parameter Stack</em> view as redundant and useless).\</p>
+</li>
+<li>
+<p>Breakpoints work with linked resources</p>
+</li>
+<li>
+<p>Xdebug debugging via SSH tunnel</p>
+</li>
+</ul>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
+<h2 id="js">JavaScript and JSON</h2>
+<div class="sectionbody">
+<div class="sect2">
+<h3 id="_javascript_development">JavaScript Development</h3>
+<div class="sect3">
+<h4 id="_new_ecmascript_2015_parser">New EcmaScript 2015 Parser</h4>
+<div class="paragraph">
+<p>Significant new work has been invested in the JavaScript development tools,
+starting with a new parser with EcmaScript 2015 (ES6) support. With this,
+the Eclipse IDE recognizes and support ES6 language constructs and provides
+better validation accuracy compared to the earlier parser.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_libraries_and_tools">Libraries and Tools</h4>
+<div class="paragraph">
+<p>Both Bower and npm are supported with creation wizards and launch shortcuts
+for executing update and install commands. Grunt and gulp build systems are
+accessible from within the <em>Project Explorer</em> view and can be executed via
+launch shortcuts.</p>
+</div>
+<div class="paragraph">
+<p><code>Node.js</code> runtimes are now directly supported (<code>Eclipse Preferences &gt; JavaScript &gt; Runtimes</code>)
+including a new launch configuration type can be used to run and debug
+<code>Node.js</code> applications. <code>Node.js</code> applications can be debugged directly
+from the editor via the Chromium V8 debugger, with full support for breakpoints
+and inspecting JavaScript variable values in the <em>Variables</em> view (and when
+you hover over an in-scope variable).</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="images/v8_debugger.png" alt="v8 debugger">
+</div>
+</div>
+</div>
 </div>
 <div class="sect2">
-<h3 id="general">General</h3>
-<div class="paragraph"><p>PHP 7 is default version for new workspaces</p></div>
-<div class="imageblock">
-<div class="content">
-<img src="images/Pdt37_php7.jpg" alt="pdt37_php7.jpg">
+<h3 id="_json_development">JSON Development</h3>
+<div class="sect3">
+<h4 id="_json_editor">JSON Editor</h4>
+<div class="paragraph">
+<p>The new <code>JSON</code> editor provides support to edit some well-known <code>JSON</code> file
+types including package.json, bower.json, .bowerrc, and .jshintrc. This support
+includes the following features:</p>
 </div>
-</div>
-<div class="paragraph"><p>Restored Call Hierarchy feature</p></div>
-<div class="imageblock">
-<div class="content">
-<img src="images/Pdt37_ca1.png" alt="images/Pdt37_ca1.png">
-</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Syntax Coloring which can be customized with preferences;</p>
+</li>
+<li>
+<p>An Outline Tree view;</p>
+</li>
+<li>
+<p>Text hover on JSON Objects/Array keys and values;</p>
+</li>
+<li>
+<p>Text folding on JSON Objects and Arrays; and</p>
+</li>
+<li>
+<p>Editor extensions for custom hyperlinks, json schema validation, and hover help</p>
+</li>
+</ul>
 </div>
 <div class="imageblock">
 <div class="content">
-<img src="images/Pdt37_ca2.png" alt="images/Pdt37_ca2.png">
+<img src="images/json_editor.png" alt="json editor">
 </div>
 </div>
-<div class="paragraph"><p>Improved Code Assist for unfinished class and method bodies.</p></div>
-<div class="paragraph"><p>Usage validator is case insensitive.</p></div>
-<div class="paragraph"><p>Improved external files support -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=479073">bug 479073</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=332741">bug 332741</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=484763">bug 484763</a>
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=479139">bug 479139</a></p></div>
-<div class="paragraph"><p>PHP quick fixes are available in Problems View -</p></div>
-<div class="imageblock">
-<div class="content">
-<img src="images/Pdt37_quickfix.png" alt="images/Pdt37_quickfix.png">
 </div>
 </div>
-<div class="paragraph"><p>Task list was added to PHP perspective -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=462644">bug 462644</a></p></div>
-<div class="paragraph"><p>Improved Save As dialog for Untitled PHP File -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=479235">bug 479235</a></p></div>
-<div class="paragraph"><p>PHP Explorer refresh operation no longer block eclipse interface -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=318960">bug 318960</a></p></div>
-<div class="paragraph"><p>Support for OSX alternative PHP executables -
-<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=460926">bug 460926</a></p></div>
-</div>
 </div>
 </div>
 <div class="sect1">
@@ -1699,137 +1315,196 @@
 <div class="sectionbody">
 <div class="sect2">
 <h3 id="_code_generation">Code Generation</h3>
-<div class="paragraph"><p><a href="http://www.eclipse.org/acceleo">Acceleo</a> introduced a new mechanism to launch code generators as part of a Maven build which is way easier and more robust by integrating with Tycho.</p></div>
+<div class="sect3">
+<h4 id="_builds">Builds</h4>
+<div class="paragraph">
+<p><a href="http://www.eclipse.org/acceleo">Acceleo</a> introduced a new mechanism to launch code generators as part of a Maven build which is way easier and more robust by integrating with Tycho.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/acceleo-launcher.png" alt="images/acceleo-launcher.png">
+<img src="images/acceleo-launcher.png" alt="acceleo launcher">
 </div>
 </div>
-<div class="paragraph"><p>You will find several examples on <a href="https://github.com/cbrun/acceleo-launcher-examples/">this repository</a> ranging from an UML to <span class="monospaced">C</span> generation to the export of a Modeling project as a website.</p></div>
+<div class="paragraph">
+<p>You will find several examples in <a href="https://github.com/cbrun/acceleo-launcher-examples/">this repository</a> ranging from launchging an UML to <code>C</code> code generation to exporting a Modeling project as a website.</p>
+</div>
+</div>
 </div>
 <div class="sect2">
 <h3 id="_model_editors">Model Editors</h3>
 <div class="sect3">
 <h4 id="_amalgam">Amalgam</h4>
-<div class="paragraph"><p>The <a href="http://www.eclipse.org/modeling/amalgam">Amalgam</a> project brings a new view to navigate and explore models. Ecore models are supported right away but the view can be extended to support your domain specific models.</p></div>
+<div class="paragraph">
+<p>The <a href="http://www.eclipse.org/modeling/amalgam">Amalgam</a> project brings a new view to navigate and explore models. Ecore models are supported right away and the view can be extended to support your domain specific models.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/amalgam-explorer.png" alt="images/amalgam-explorer.png">
+<img src="images/amalgam-explorer.png" alt="amalgam explorer">
 </div>
 </div>
 </div>
 <div class="sect3">
 <h4 id="_ecoretools">EcoreTools</h4>
-<div class="paragraph"><p>When using the Ecore graphical modeler references might now be displayed directly within the class shapes if it&#8217;s target is not in the diagram.</p></div>
+<div class="paragraph">
+<p>When using the Ecore graphical modeler references might now be displayed directly within the class shapes if it&#8217;s target is not in the diagram.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/ecoretools-refnodes.png" alt="images/ecoretools-refnodes.png">
+<img src="images/ecoretools-refnodes.png" alt="ecoretools refnodes">
 </div>
 </div>
-<div class="paragraph"><p>Inherited references will also be displayed if the super types are not part of the diagram.</p></div>
+<div class="paragraph">
+<p>Inherited references will also be displayed if the super types are not in the diagram.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/ecoretools-inheritedcontent.png" alt="images/ecoretools-inheritedcontent.png">
+<img src="images/ecoretools-inheritedcontent.png" alt="ecoretools inheritedcontent">
 </div>
 </div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_model_comparison">Model Comparison</h3>
-<div class="paragraph"><p>The Neon release brings experimental support for comparing diagrams of <a href="http://www.eclipse.org/sirius">Sirius</a> based modelers</p></div>
+<div class="sect3">
+<h4 id="_visual_comparison_and_merge">Visual Comparison and Merge</h4>
+<div class="paragraph">
+<p>The Neon release brings experimental support for comparing diagrams of <a href="http://www.eclipse.org/sirius">Sirius</a> based modelers.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/compare-sirius-family.png" alt="images/compare-sirius-family.png">
+<img src="images/compare-sirius-family.png" alt="compare sirius family">
 </div>
 </div>
-<div class="paragraph"><p>With a right-click on a model element or resource in the viewer, a new context menu now offers you to merge all <em>non-conflicting</em> differences that are <em>contained</em> in the selected model element or resource with one click.
-With local models (both writable)</p></div>
+<div class="paragraph">
+<p>With a right-click on a model element or resource in the viewer, a new context menu now offers you to merge all <em>non-conflicting</em> differences that are <em>contained</em> in the selected model element or resource with one click.</p>
+</div>
+<div class="paragraph">
+<p>With local models (both writable):</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/compare-local.png" alt="images/compare-local.png">
+<img src="images/compare-local.png" alt="compare local">
 </div>
 </div>
-<div class="paragraph"><p>With a read-only side (for example when comparing with EGit)</p></div>
+<div class="paragraph">
+<p>With a read-only side (for example when comparing against a previous version in Git):</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/compare-readonly.png" alt="images/compare-readonly.png">
+<img src="images/compare-readonly.png" alt="compare readonly">
 </div>
 </div>
-<div class="paragraph"><p>Each button now has a specific tooltip for each case depending on the selected element. It will display the best information depending on the context: which object will be affected by the merge action, and which side will be modified (or not) by the action.</p></div>
+<div class="paragraph">
+<p>Each button now has a specific tooltip for each case depending on the selected element. It will display the best information depending on the context: which object will be affected by the merge action, and which side will be modified (or not) by the action.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/compare-context-tooltips.png" alt="images/compare-context-tooltips.png">
+<img src="images/compare-context-tooltips.png" alt="compare context tooltips">
+</div>
 </div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_custom_graphical_editors">Custom Graphical Editors</h3>
-<div class="paragraph"><p>With the new version of <a href="http://www.eclipse.org/sirius">Sirius</a> you can now define rich property views alongside the diagram definition without having to write a line of code.
-This capability is introduced as an experimental feature for Neon and will be extended in the next months based on the user community feedback.</p></div>
+<div class="sect3">
+<h4 id="_rich_property_views">Rich Property Views</h4>
+<div class="paragraph">
+<p>With the new version of <a href="http://www.eclipse.org/sirius">Sirius</a> you can now define rich property views alongside the diagram definition without having to write a line of code.</p>
+</div>
+<div class="paragraph">
+<p>This capability is introduced as an experimental feature for Eclipse Neon and will be extended in the next months based on the user community feedback.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/sirius-properties.png" alt="images/sirius-properties.png">
+<img src="images/sirius-properties.png" alt="sirius properties">
 </div>
 </div>
-<div class="paragraph"><p>Packs of SVG shapes can now be contributed through a plugin to be reused in other modelers:</p></div>
+</div>
+<div class="sect3">
+<h4 id="_image_rendering">Image Rendering</h4>
+<div class="paragraph">
+<p>Packs of SVG shapes can now be contributed through a plug-in to be reused in other modelers:</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/svg-stencils.png" alt="images/svg-stencils.png">
+<img src="images/svg-stencils.png" alt="svg stencils">
 </div>
 </div>
 <div class="imageblock">
 <div class="content">
-<img src="images/svg-stencils-pick.gif" alt="images/svg-stencils-pick.gif">
+<img src="images/svg-stencils-pick.gif" alt="svg stencils pick">
 </div>
 </div>
-<div class="paragraph"><p>SVG rendering has been improved and is now pixel-perfect <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=442268">whatever the zoom level</a>.</p></div>
-<div class="paragraph"><p>Before:</p></div>
+<div class="paragraph">
+<p>SVG rendering has been improved and is now pixel-perfect <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=442268">whatever the zoom level</a>.</p>
+</div>
+<div class="paragraph">
+<p>Before:</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/svg-render-before.png" alt="images/svg-render-before.png">
+<img src="images/svg-render-before.png" alt="svg render before">
 </div>
 </div>
-<div class="paragraph"><p>With Sirius 4.0:</p></div>
+<div class="paragraph">
+<p>With Sirius 4.0:</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/svg-render-after.png" alt="images/svg-render-after.png">
+<img src="images/svg-render-after.png" alt="svg render after">
 </div>
 </div>
-<div class="paragraph"><p>It is now possible to define dash edge styles for both the nodes and the containers (like it was already possible for edges).</p></div>
+<div class="paragraph">
+<p>It is now possible to define dash edge styles for both the nodes and the containers (like it was already possible for edges).</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/sirius-border-styles.png" alt="images/sirius-border-styles.png">
+<img src="images/sirius-border-styles.png" alt="sirius border styles">
 </div>
 </div>
-<div class="paragraph"><p>And the border node position relative to its parent can now be constrained on a specific side (NORTH, EAST, WEST or SOUTH).</p></div>
+<div class="paragraph">
+<p>And the border node position relative to its parent can now be constrained on a specific side (NORTH, EAST, WEST or SOUTH).</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/bordernodeposition.png" alt="images/bordernodeposition.png">
+<img src="images/bordernodeposition.png" alt="bordernodeposition">
 </div>
 </div>
-<div class="paragraph"><p>The "Link with editor" button has been immproved and is now bidirectional.</p></div>
+</div>
+<div class="sect3">
+<h4 id="_more_2">More</h4>
+<div class="paragraph">
+<p>The <em>Link with editor</em> support has been improved and is now bidirectional.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/bidi-link.gif" alt="images/bidi-link.gif">
+<img src="images/bidi-link.gif" alt="bidi link">
 </div>
 </div>
-<div class="paragraph"><p>You now have the possibility to configure which elements to automatically select after a tool execution, using this it is possible to streamline the user experience
-by making sure that it is always possible to directly type right after the application of the tool.</p></div>
+<div class="paragraph">
+<p>You now have the possibility to configure which elements to automatically select after a tool execution, using this it is possible to streamline the user experience
+by making sure that it is always possible to directly type right after the application of the tool.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/elements-to-select.png" alt="images/elements-to-select.png">
+<img src="images/elements-to-select.png" alt="elements to select">
 </div>
 </div>
-<div class="paragraph"><p>The labels which are attached to an edge are now staying closer to it during a user modification.</p></div>
+<div class="paragraph">
+<p>The labels which are attached to an edge are now staying closer to it during a user modification.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/edge-stability.gif" alt="images/edge-stability.gif">
+<img src="images/edge-stability.gif" alt="edge stability">
 </div>
 </div>
-<div class="paragraph"><p>A new mechanism is introduced to externalize the messages in a <span class="monospaced">.odesign</span> model.</p></div>
+<div class="paragraph">
+<p>A new mechanism is introduced to externalize the messages in a <code>.odesign</code> model.</p>
+</div>
 <div class="imageblock">
 <div class="content">
-<img src="images/i18n.png" alt="images/i18n.png">
+<img src="images/i18n.png" alt="i18n">
+</div>
 </div>
 </div>
 </div>
@@ -1838,67 +1513,50 @@
 <div class="sect1">
 <h2 id="sources">Sources</h2>
 <div class="sectionbody">
-<div class="paragraph"><p>Content for this document were harvested from multiple sources, including:</p></div>
-<div class="ulist"><ul>
+<div class="paragraph">
+<p>Content for this document were harvested from multiple sources, including:</p>
+</div>
+<div class="ulist">
+<ul>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M1/">Eclipse Project Neon (4.6) M1 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M1/">Eclipse Project Neon (4.6) M1 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M2/">Eclipse Project Neon (4.6) M2 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M2/">Eclipse Project Neon (4.6) M2 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M3/">Eclipse Project Neon (4.6) M3 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M3/">Eclipse Project Neon (4.6) M3 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M4/">Eclipse Project Neon (4.6) M4 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M4/">Eclipse Project Neon (4.6) M4 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M5/">Eclipse Project Neon (4.6) M5 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M5/">Eclipse Project Neon (4.6) M5 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M6/">Eclipse Project Neon (4.6) M6 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M6/">Eclipse Project Neon (4.6) M6 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://www.eclipse.org/eclipse/news/4.6/M7/">Eclipse Project Neon (4.6) M7 - New and Noteworthy</a>
-</p>
+<p><a href="https://www.eclipse.org/eclipse/news/4.6/M7/">Eclipse Project Neon (4.6) M7 - New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://wiki.eclipse.org/CDT/User/NewIn90">Eclipse C/C++ Development Tools 9.0 New and Noteworthy</a>
-</p>
+<p><a href="https://wiki.eclipse.org/CDT/User/NewIn90">Eclipse C/C++ Development Tools 9.0 New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://wiki.eclipse.org/PDT/NewIn37">Eclipse PHP Development Tools 3.7 New and Noteworthy</a>
-</p>
+<p><a href="https://wiki.eclipse.org/PDT/NewIn37">Eclipse PHP Development Tools 3.7 New and Noteworthy</a></p>
 </li>
 <li>
-<p>
-<a href="https://wiki.eclipse.org/PDT/NewIn40">Eclipse PHP Development Tools 4.0 New and Noteworthy</a>
-</p>
+<p><a href="https://wiki.eclipse.org/PDT/NewIn40">Eclipse PHP Development Tools 4.0 New and Noteworthy</a></p>
 </li>
-</ul></div>
+</ul>
 </div>
 </div>
 </div>
-<div id="footnotes"><hr></div>
+</div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2016-06-15 09:09:39 CEST
+Last updated 2016-06-21 17:11:05 -04:00
 </div>
 </div>
 </body>
-</html>
+</html>
\ No newline at end of file
diff --git a/noteworthy/other.adoc b/noteworthy/other.adoc
deleted file mode 100644
index 5d6c98f..0000000
--- a/noteworthy/other.adoc
+++ /dev/null
@@ -1,25 +0,0 @@
-//////////////////////////////////////////
-* Copyright (c) 2015, 2016 Eclipse Foundation and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*    Wayne Beaton (Eclipse Foundation)- initial API and implementation
-//////////////////////////////////////////
-
-:cdtPackageUrl: https://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/marsr
-
-[[other]]
-Stuff
-~~~~~
-
-There's other stuff. TBD
-
-A title for some stuff
-^^^^^^^^^^^^^^^^^^^^^^
-
-Description of some stuff
-
-image::images/Some_Image.png[]
\ No newline at end of file
diff --git a/noteworthy/pdt.adoc b/noteworthy/pdt.adoc
index 4d5abd8..e4c3b54 100644
--- a/noteworthy/pdt.adoc
+++ b/noteworthy/pdt.adoc
@@ -1,18 +1,31 @@
 [[pdt]]
 == PHP
 
-We fixed / closed over 100 bugs in this release!
+The Eclipse Neon release includes significant improvements in
+stability (including fixes for more than 100 bugs) and a lot of new
+functionality for PHP developers.
 
-Better error messages for unsupported PHP versions (especially for
-legacy versions)
+=== PHP Language
 
-[[pdt-general]]
-=== General
+Eclipse Neon provides better error messages for unsupported PHP 
+versions (especially for legacy versions).
 
-Final support for PHP 7 scalar type declarations
+[[pdt-php7]]
+==== PHP 7
+
+PHP 7 is the default version for new workspaces.
+
+image::images/Pdt37_php7.jpg[]
+
+Final support for PHP 7 scalar type declarations.
 
 image::images/Pdt40_scalar.png[]
 
+The syntax highlighter now fully supports PHP 7 context sensitive
+keywords.
+
+image::images/Pdt40_context_sensitive.png[]
+
 === Editors
 
 ==== Code Assist
@@ -30,6 +43,11 @@
 
 image::images/Pdt40_use.png[]
 
+Improved Code Assist for `@param`, `@return`, and `@throws` tags
+inside _PHPDoc_
+
+image:images/Pdt37_ca1.png[] image:images/Pdt37_ca2.png[]
+
 The PHP indexer is significantly faster than in previous versions. 
 The UI remains responsive when indexing is in progress.
 
@@ -48,9 +66,12 @@
 
 image::images/Pdt40_return_sugestion.png[]
 
-==== Highlighting
+===== More Code Assist
 
-Improved support around `@inheritdoc` (coloring and code assist).
+* Improved Code Assist for unfinished class and method bodies;
+* Improved support around `@inheritdoc` (coloring and code assist).
+
+==== Highlighting
 
 More semantic highlighters are enabled by default, including class, 
 deprecation, and constants.
@@ -70,11 +91,6 @@
 
 image::images/Pdt40_assign_to_local.png[]
 
-The syntax highlighter now fully supports PHP 7 context sensitive
-keywords.
-
-image::images/Pdt40_context_sensitive.png[]
-
 Function / method return types are available in Content Assist
 proposals
 
@@ -91,16 +107,6 @@
 
 image::images/Pdt40_editor_actions.png[]
 
-??? Quick Source and Quick Refactor menu entries have been added.
-
-image::images/Pdt40_quick_menu.png[]
-
-Quick Outline saves size and location
-
-Improved code folding -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=443379[bug 443379]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=486018[bug 486018]
-
 ==== More PHP Editor Improvemvents
 
 * Improved code assist performance for files with many assignments;
@@ -111,106 +117,42 @@
 * Content assist and hover tooltips shows function / method return types
 * Improved deprecation highlighter support for inherited members
 
-[[pdt-debugging]]
-=== Debugging
+==== IDE Integration
 
-OSX support improvements
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=488630[bug 488630]
+Integration with the _Project Explorer_ view has been improved, 
+including dedicated support for PHP Project elements and specific actions,
+and support for traits when the "group by namespace" option is selected.
 
-Improvements in debugger variables support
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=487966[bug 487966]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=490697[bug 490697]
-
-No longer display outdated values
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=477241[bug 477241]
-
-Fix ignored breakpoints
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=489646[bug 489646]
-
-Added support for class statics inside namespace
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=492992[bug 492992]
-
-Remove PDT "Parameter Stack" view
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=492010[bug 492010]
-
-Breakpoints works with linked resources -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=240553[bug 240553]
-
-Fix xdebug debugging via SSH tunnel -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=478402[bug 478402]
-
-Support for PHP exception breakpoints -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=483694[bug 483694]
-
-==== Zend Debugger
-Fix variables fetching with static context in PHP 7
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=493839[bug 493839]
-
-Fix 'Display debug information' saving
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=493154[bug 493154]
-
-[[pdt-other]]
-=== Other
-
-"Short method return types" are enabled by default in all PDT views
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=469503[bug 469503]
-
-Better integration with eclipse Project Explorer. Support for PHP
-Project elements and specific actions.
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=480376[bug 480376]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=480374[bug 480374]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=494124[bug 494124]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=494124[bug 494124]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=494253[bug 494253]
-
-Support for traits in PHP Project Explorer when "group by namespace"
-is active https://bugs.eclipse.org/bugs/show_bug.cgi?id=488685[bug
-488685]
-
-PHP Language Library have PHP Version badge
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=494137[bug 494137] +
+PHP Language Libraries have PHP Version badge
 
 image::images/Pdt40_php_version_badge.png[]
 
-"Add PHP support..." no longer visible in PHP-enabled projects
+"Add PHP support..." no longer visible in PHP-enabled projects (i.e. when
+it is unnecessary).
 
-Fixed regression during updating PHP file outline with PHP < 5.3
-
-[[general]]
-=== General
-
-PHP 7 is default version for new workspaces
-
-image::images/Pdt37_php7.jpg[pdt37_php7.jpg,title="fig:pdt37_php7.jpg"]
-
-Restored Call Hierarchy feature
-
-image::images/Pdt37_ca1.png[]
-
-image::images/Pdt37_ca2.png[]
-
-Improved Code Assist for unfinished class and method bodies.
-
-Usage validator is case insensitive.
-
-Improved external files support -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=479073[bug 479073]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=332741[bug 332741]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=484763[bug 484763]
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=479139[bug 479139]
-
-PHP quick fixes are available in Problems View -
+PHP _Quick Fixes_ are available in _Problems View_.
 
 image::images/Pdt37_quickfix.png[]
 
-Task list was added to PHP perspective -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=462644[bug 462644]
+[[pdt-debugging]]
+=== PHP Debugging
 
-Improved Save As dialog for Untitled PHP File -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=479235[bug 479235]
+Eclipse Neon includes numerous bug fixes and improvements in the PHP
+Debugging. 
 
-PHP Explorer refresh operation no longer block eclipse interface -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=318960[bug 318960]
+==== Exception Breakpoints 
 
-Support for OSX alternative PHP executables -
-https://bugs.eclipse.org/bugs/show_bug.cgi?id=460926[bug 460926]
\ No newline at end of file
+Support for PHP exception breakpoints
+
+image::images/Pdt-ExceptionBP.png[]
+
+==== More Debugging
+
+* OSX support improvements
+* Improvements in debugger variables support
+* No longer display outdated values
+* Fix ignored breakpoints
+* Added support for class statics inside namespace
+* Remove PDT "Parameter Stack" view (the _Variables_ view renders this outdated _Parameter Stack_ view as redundant and useless).\
+* Breakpoints work with linked resources
+* Xdebug debugging via SSH tunnel
\ No newline at end of file
diff --git a/noteworthy/platform.adoc b/noteworthy/platform.adoc
index 29609f0..ad3c513 100644
--- a/noteworthy/platform.adoc
+++ b/noteworthy/platform.adoc
@@ -14,12 +14,6 @@
 
 === General
 
-==== Improved interactive performance and reduced memory consumption
-
-This and earlier milestones contain a multitude of fixes to enhance interactive and startup performance of the Eclipse IDE, and to reduce overall memory consumption.
-
-TBD: insert some benchmarks
-
 ==== Import Projects
 
 A new *Import Projects* wizard is available via the `File > Open Projects...` 
