diff --git a/content/migrated_blog/a_couple_of_articles_on.markdown b/content/migrated_blog/a_couple_of_articles_on.markdown
new file mode 100644
index 0000000..dfe2ac1
--- /dev/null
+++ b/content/migrated_blog/a_couple_of_articles_on.markdown
@@ -0,0 +1,10 @@
+---
+layout: post
+title: A couple of articles on Isis at SDJournal (free access)
+date: '2013-02-13T17:56:49+00:00'
+permalink: a_couple_of_articles_on
+---
+<p>A couple of articles on Apache Isis have just been published by the Software Developers Journal, available for <a href="http://sdjournal.org/software-developers-journal-open-012013-2/">free download</a>.</p>
+  <p>The first article is a general introduction to Apache Isis, while the second looks in detail at Isis' RESTful APIs. &nbsp;Both were written by Dan Haywood, Isis' current PMC chair.</p>
+  <p>To download the journal, you do need to register, but it won't cost you anything other than your email address.</p>
+  <p><br /></p>
diff --git a/content/migrated_blog/ann-apache-isis-simpleapp-archetype.markdown b/content/migrated_blog/ann-apache-isis-simpleapp-archetype.markdown
new file mode 100644
index 0000000..6b650d8
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-simpleapp-archetype.markdown
@@ -0,0 +1,39 @@
+---
+layout: post
+title: "[ANN] Apache Isis simpleapp-archetype 1.13.2.1 Released"
+date: '2017-01-03T19:17:17+00:00'
+permalink: ann-apache-isis-simpleapp-archetype
+---
+<div>This release is for the simpleapp archetype only. &nbsp;It:</div> 
+  <div><br /></div> 
+  <div> 
+    <ul> 
+      <li>improves docker support - allowing docker images to be created easily</li> 
+      <li>reduces the amount of boilerplate (by backing out some of the mixins)</li> 
+      <li>fixes an issue with the fixture scripts</li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>For example, the webapp can be packaged as a Docker image using:</div> 
+  <div><br /></div> 
+  <div><font face="courier new, courier, monospace">&nbsp; &nbsp; mvn package -Dmavenmixin-docker \</font></div> 
+  <div><font face="courier new, courier, monospace">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;-Ddocker-plugin.imageName=mycompany/myapp</font></div> 
+  <div><br /></div> 
+  <div>and can then be run using:</div> 
+  <div><br /></div> 
+  <div><font face="courier new, courier, monospace">&nbsp; &nbsp; docker run -d -p8080:8080 mycompany/myapp</font></div> 
+  <div> </div> 
+  <p> </p> 
+  <p>See the README.adoc (generated by the archetype) for further details.</p> 
+  <div>Full release notes are available on the Apache Isis website at [1].</div> 
+  <div><br /></div> 
+  <div>You can access this release directly from the Maven central repo [2], or&nbsp;</div> 
+  <div>download the release and build it from source [3].</div> 
+  <div><br /></div> 
+  <div>Enjoy!</div> 
+  <div><br /></div> 
+  <div>--The Apache Isis team</div> 
+  <div><br /></div> 
+  <div>[1] http://isis.apache.org/release-notes.html#r1.13.2.1</div> 
+  <div>[2] http://search.maven.org</div> 
+  <div>[3] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann-apache-isis-version-1.markdown b/content/migrated_blog/ann-apache-isis-version-1.markdown
new file mode 100644
index 0000000..22c5351
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-1.markdown
@@ -0,0 +1,29 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.14.0 Released"
+date: '2017-02-19T15:56:13+00:00'
+permalink: ann-apache-isis-version-1
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis v1.14.0.</div>
+  <div><br /></div>
+  <div>The new features and improvements in this release include:</div>
+  <div>
+    <ul>
+      <li>the ability to invoke actions with collection parameters (rendered by the Wicket viewer as a multi-select drop-down).</li>
+      <li>a number of metamodel validations intended to make it apps already in production easier to refactor (including a new objectType attribute for @DomainService)</li>
+      <li>improvements to EmailService so easier to use in system test (non-prod) environments</li>
+      <li>a new TableColumnOrderService to allow column order of parented collections to be fine-tuned.</li>
+    </ul>
+  </div>
+  <div><br /></div>
+  <div>Full <a href="http://isis.apache.org/release-notes.html#r1.14.0" target="_blank">release notes</a> are available on the Apache Isis website. &nbsp;Please also read the <a href="http://isis.apache.org/migration-notes.html#_migration-notes_1.13.0-to-1.14.0" target="_blank">migration notes</a>.</div>
+  <div><br /></div>
+  <div>You can access this release directly from the <a href="http://search.maven.org" target="_blank">Maven central repo</a>, or download the release and <a href="http://isis.apache.org/downloads.html" target="_blank">build it from source</a>.</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>--The Apache Isis team</div>
+  <div><br /></div>
+  <div><br /></div>
+  <div><br /></div>
+  <div><br /></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-11.markdown b/content/migrated_blog/ann-apache-isis-version-11.markdown
new file mode 100644
index 0000000..1f9bfaa
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-11.markdown
@@ -0,0 +1,28 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.15.0 Released"
+date: '2017-08-14T19:57:19+00:00'
+permalink: ann-apache-isis-version-11
+---
+<div style="font-family: sans-serif; font-size: small;">The Apache Isis team is pleased to announce the release of Apache Isis v1.15.0.</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;"> 
+    <p>New features in this release include:</p> 
+    <p> </p> 
+    <ul> 
+      <li>inline prompts: the ability to edit a property or invoke an action (associated with a property) without requiring a modal dialog box.</li> 
+      <li>a &quot;hello world&quot; archetype</li> 
+      <li>upgrade of Apache Wicket from 6.x to 7.x.</li> 
+      <li>allow applications and integration tests to be bootstrapped with less boilerplate</li> 
+      <li>new metamodel validations for JAXB view models</li> 
+      <li>rename isis-viewer-wicket artifacts to isis-core-viewer-wicket (for consistency with other core modules)</li> 
+    </ul> 
+    <p> </p> 
+  </div> 
+  <p><span style="font-family: sans-serif; font-size: small;">Full <a href="http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.15.0">release notes</a> are available on the Apache Isis website, as are the&nbsp;</span><span style="font-family: sans-serif; font-size: small;"><a href="http://isis.apache.org/migration-notes/migration-notes.html#_migration-notes_1.14.0-to-1.15.0">migration notes</a>.</span></p> 
+  <div style="font-family: sans-serif; font-size: small;">You can access this release directly from the <a href="http://search.maven.org">Maven central repo</a>. &nbsp;Alternatively, or <a href="http://isis.apache.org/downloads.html">download</a> the release and build it from source.</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">Enjoy!</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">--The Apache Isis team</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-12.markdown b/content/migrated_blog/ann-apache-isis-version-12.markdown
new file mode 100644
index 0000000..395c96e
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-12.markdown
@@ -0,0 +1,31 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.15.1 Released"
+date: '2017-09-25T05:24:50+00:00'
+permalink: ann-apache-isis-version-12
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis v1.15.1.</div> 
+  <div><br /></div> 
+  <div>This is primarily a bug fix release. &nbsp;It includes an upgrade to Wicket 7.9.0 that fixes a major performance regression in the previous version of Wicket (that Isis 1.15.0 used). &nbsp;It also includes bug fix relating to the Wicket viewer's reference panel with choices, and some other small bug fixes.</div> 
+  <div><br /></div> 
+  <div>There are also a small number of new features:</div> 
+  <div> 
+    <ul> 
+      <li>a new Markup value type that allows the Wicket viewer to display arbitrary HTML</li> 
+      <li>a new &quot;layout&quot; URL for the Restful Objects viewer</li> 
+      <li>a new &quot;logout&quot; page for the Wicket viewer to support monitoring tools.</li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>Full release notes are available on the Apache Isis website at [1].</div> 
+  <div><br /></div> 
+  <div>You can access this release directly from the Maven central repo [2].</div> 
+  <div>Alternatively, download the release and build it from source [3].</div> 
+  <div><br /></div> 
+  <div>Enjoy!</div> 
+  <div><br /></div> 
+  <div>--The Apache Isis team</div> 
+  <div><br /></div> 
+  <div>[1] http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.15.1</div> 
+  <div>[2] http://search.maven.org</div> 
+  <div>[3] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann-apache-isis-version-13.markdown b/content/migrated_blog/ann-apache-isis-version-13.markdown
new file mode 100644
index 0000000..d424dfa
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-13.markdown
@@ -0,0 +1,28 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.16.0 Released"
+date: '2018-01-08T23:35:12+00:00'
+permalink: ann-apache-isis-version-13
+---
+<div style="font-family: sans-serif; font-size: small;">The Apache Isis team is pleased to announce the release of Apache Isis v1.16.0.</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">New features in this release include:</div> 
+  <div style="font-family: sans-serif; font-size: small;">* modules and simplified bootstrapping (of the application, integration tests and BDD specs)</div> 
+  <div style="font-family: sans-serif; font-size: small;">* improvements to fixture scripts</div> 
+  <div style="font-family: sans-serif; font-size: small;">* dynamic menu layouts (menubars.layout.xml)</div> 
+  <div style="font-family: sans-serif; font-size: small;">* support for explicitly-defined actions rather than implicit (ie use @Action, no need for @Programmatic)</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">Full release notes are available on the Apache Isis website at [1].</div> 
+  <div style="font-family: sans-serif; font-size: small;">Please also read the migration notes [2].</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">You can access this release directly from the Maven central repo [3].</div> 
+  <div style="font-family: sans-serif; font-size: small;">Alternatively, download the release and build it from source [4].</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">Enjoy!</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">--The Apache Isis team</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">[1] http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.16.0</div> 
+  <div style="font-family: sans-serif; font-size: small;">[2] http://isis.apache.org/migration-notes/migration-notes.html#_migration-notes_1.15.0-to-1.16.0</div> 
+  <div style="font-family: sans-serif; font-size: small;">[3] http://search.maven.org</div> 
+  <div style="font-family: sans-serif; font-size: small;">[4] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann-apache-isis-version-14.markdown b/content/migrated_blog/ann-apache-isis-version-14.markdown
new file mode 100644
index 0000000..c371b3f
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-14.markdown
@@ -0,0 +1,24 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.16.1 Released"
+date: '2018-02-22T23:00:46+00:00'
+permalink: ann-apache-isis-version-14
+---
+<div style="font-family: sans-serif; font-size: small;">The Apache Isis team is pleased to announce the release of Apache Isis v1.16.1.</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">This is primarily a bugfix release.&nbsp; Nevertheless there are a couple of new features:</div> 
+  <div style="font-family: sans-serif; font-size: small;">* checkboxes for parented collections.&nbsp; The selected rows are used as the defaults for any associated actions with collection parameters<br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">* infrastructure to enable replaying of commands from master to slave (for regression testing).&nbsp; This is used by the (non-ASF) command module.</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">Full release notes are available on the Apache Isis website at [1].</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">You can access this release directly from the Maven central repo [2].</div> 
+  <div style="font-family: sans-serif; font-size: small;">Alternatively, download the release and build it from source [3].</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">Enjoy!</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">--The Apache Isis team</div> 
+  <div style="font-family: sans-serif; font-size: small;"><br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">[1] http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.16.1</div> 
+  <div style="font-family: sans-serif; font-size: small;">[2] http://search.maven.org<br /></div> 
+  <div style="font-family: sans-serif; font-size: small;">[3] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann-apache-isis-version-15.markdown b/content/migrated_blog/ann-apache-isis-version-15.markdown
new file mode 100644
index 0000000..8a26353
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-15.markdown
@@ -0,0 +1,15 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.16.2 Released"
+date: '2018-03-06T07:38:27+00:00'
+permalink: ann-apache-isis-version-15
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis v1.16.2</p>
+  <p>This is primarily a maintenance fix release fixing one severe error in 1.16.1 relating to parented checkboxes.&nbsp; It does however introduce one new feature for the REST API (RO viewer) to support generic RO clients. There is also one notable performance improvement through the caching of JAXBContexts.</p>
+  <p>Full release notes are available on the Apache Isis website at [1].</p>
+  <p>You can access this release directly from the Maven central repo [2].&nbsp; Alternatively, download the release and build it from source [3].</p>
+  <p>Enjoy!</p>
+  <p>--The Apache Isis team</p>
+  <p>[1] http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.16.2</p>
+  <p>[2] http://search.maven.org</p>
+  <p>[3] http://isis.apache.org/downloads.html</p>
diff --git a/content/migrated_blog/ann-apache-isis-version-16.markdown b/content/migrated_blog/ann-apache-isis-version-16.markdown
new file mode 100644
index 0000000..345a033
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-16.markdown
@@ -0,0 +1,18 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.17.0 Released"
+date: '2019-01-06T18:01:44+00:00'
+permalink: ann-apache-isis-version-16
+---
+<div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px; direction: ltr;">The Apache Isis team is pleased to announce the release of Apache Isis 1.17.0.</div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px; direction: ltr;"><br /></div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px;">New features in this release include:</div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px;"> 
+    <ul> 
+      <li>the ability for dialog actions to be use a sidebar rather than a modal dialog&nbsp;</li> 
+      <li>the ability to export the metamodel as XML</li> 
+    </ul> 
+  </div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px;">Full release notes are available on the Apache Isis website [1].</div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px;">Please also read the migration notes [2].</div> 
+  <div class="m_1985096786079097871gmail-paragraph" style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small; box-sizing: border-box; margin: 0px; padding: 0px;"><br /></div><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">You can access this release directly from the Maven central repo [3].</span><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">Alternatively, download the release and build it from source [4].</span><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">Enjoy!</span><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">--The Apache Isis team</span><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">[1] </span><a href="http://isis.apache.org/release-notes/release-notes.html#_release-notes_1.17.0" target="_blank" data-saferedirecturl="https://www.google.com/url?q=http://isis.apache.org/release-notes/release-notes.html%23_release-notes_1.17.0&amp;source=gmail&amp;ust=1546883862446000&amp;usg=AFQjCNF80kfyHwkEQ6zyis95i7fEigW4_Q" style="color: #1155cc; font-family: Arial, Helvetica, sans-serif; font-size: small;">http://isis.apache.org/<wbr />release-notes/release-notes.<wbr />html#_release-notes_1.17.0</a><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">[2] </span><a href="http://isis.apache.org/migration-notes/migration-notes.html#_migration-notes_1.16.0-to-1.17.0" target="_blank" data-saferedirecturl="https://www.google.com/url?q=http://isis.apache.org/migration-notes/migration-notes.html%23_migration-notes_1.16.0-to-1.17.0&amp;source=gmail&amp;ust=1546883862446000&amp;usg=AFQjCNFIsgUNiKS9t-RxNUIBNA8oPLGiIA" style="color: #1155cc; font-family: Arial, Helvetica, sans-serif; font-size: small;">http://isis.apache.org/<wbr />migration-notes/migration-<wbr />notes.html#_migration-notes_1.<wbr />16.0-to-1.17.0</a><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">[3] </span><a href="http://search.maven.org/" target="_blank" data-saferedirecturl="https://www.google.com/url?q=http://search.maven.org&amp;source=gmail&amp;ust=1546883862446000&amp;usg=AFQjCNGXsoOZDOtlWqQGrNPvdtN-K0qLlQ" style="color: #1155cc; font-family: Arial, Helvetica, sans-serif; font-size: small;">http://search.maven.org</a><br style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;" /><span style="color: #222222; font-family: Arial, Helvetica, sans-serif; font-size: small;">[4] </span><a href="http://isis.apache.org/downloads.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=http://isis.apache.org/downloads.html&amp;source=gmail&amp;ust=1546883862446000&amp;usg=AFQjCNHcJoLevcKRV2MAfArpvGJgin5zfw" style="color: #1155cc; font-family: Arial, Helvetica, sans-serif; font-size: small;">http://isis.apache.org/<wbr />downloads.html</a>
diff --git a/content/migrated_blog/ann-apache-isis-version-17.markdown b/content/migrated_blog/ann-apache-isis-version-17.markdown
new file mode 100644
index 0000000..7d1c790
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-17.markdown
@@ -0,0 +1,25 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M2 Released"
+date: '2019-01-23T09:13:15+00:00'
+permalink: ann-apache-isis-version-17
+---
+<p>
+The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M2. </p> 
+  <p>This milestone introduces one new feature, namely support for a table tree view in the Wicket viewer. It also includes all the features as of Apache Isis 1.17.0. </p> 
+  <p>The long-term goal (for v2.0.0) is to allow the framework to be run on top of either SpringBoot or JEE MicroProfile, with either of those lower-level frameworks taking responsibility for configuration and injection. In this milestone, some significant initial work has been done in this area. Notably, the IsisConfiguration is now immutable once instantiated, and its creation with respect to the AppManifest has been figured out.</p> 
+  <p>Lots of work has also been done both in updating or removing dependencies, with google guava being notable as one dependency that has been removed.</p> 
+  <p>Full release notes are available on the Apache Isis website at [1]. </p> 
+  <p>You can access this release directly from the Maven central repo [2].
+Alternatively, download the release and build it from source [3].
+
+</p> 
+  <p>Enjoy!
+</p> 
+  <p>
+--The Apache Isis team
+
+</p> 
+  <p>[1] http://isis.apache.org/release-notes/release-notes.html#_release-notes_2.0.0-M2</p> 
+  <p>[2] http://search.maven.org</p> 
+  <p>[3] http://isis.apache.org/versions/2.0.0-M2/downloads.html</p>
diff --git a/content/migrated_blog/ann-apache-isis-version-2.markdown b/content/migrated_blog/ann-apache-isis-version-2.markdown
new file mode 100644
index 0000000..ef3ae49
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-2.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M3 Released"
+date: '2020-03-29T23:33:58+00:00'
+permalink: ann-apache-isis-version-2
+---
+<p>After a *lot* of development effort, the Apache Isis committers are delighted to announce the release of v2.0.0-M3 of the framework.<br><br>This is a major milestone release that "re-platforms" Apache Isis so that it now runs on top of Spring Boot 2.x. &nbsp;JDK8 is the minimum.&nbsp; Some highlights:</p><ul><li>A new convenience parent pom builds on top of Spring Boot’s similar parent pom, to make it easy to develop new apps, along with simplified "mavendeps" pom’s.</li><li>The Maven archetypes have been replaced with Starter Apps in github repos.</li><li>Configuration properties have been refactored, and can now be specified (with intellisense hints) using Spring’s application.properties or application.yml</li></ul><p>New features:<br></p><ul><li>a new @Property#projecting allows view model summaries to be returned as "projections" of underlying entities.</li><li>new layout() method (or UI event) allows a domain object to specify which layout file should be used to render it.</li><li>there is no longer any need to specify @ParameterLayout#named()</li><li>there is now a security integration with Keycloak</li></ul><p>There are also a number of new extensions:</p><ul><li>Flyway (integrating with Spring Boot’s support)</li><li>pdf.js (for Wicket viewer)</li><li>fullcalendar (for Wicket viewer)</li><li>excel download (for Wicket viewer)</li></ul><p>Other improvements include:</p><ul><li>Integration test support, and BDD (Cucumber) "spec" support have been refactored to run on Spring Boot with Junit 5.</li><li>New demo app to demonstrate new features.</li><li>New smoketest app to catch regressions</li></ul><p>Finally, the website has been updated to use Antora.</p><p>Full release notes are available on the Apache Isis website at [1].<br>You can access this release directly from the Maven central repo [2].<br>Alternatively, download the release and build it from source [3].<br></p><p>Enjoy!<br></p><p>--The Apache Isis team<br></p><p>[1] <a href="https://isis.apache.org/relnotes/2.0.0-M3/about.html" target="_blank">https://isis.apache.org/relnotes/2.0.0-M3/about.html</a><br>[2] <a href="http://search.maven.org" target="_blank">http://search.maven.org</a><br>[3] https://isis.apache.org/docs/2.0.0-M3/downloads/how-to.html<br><br></p><p><br></p>
diff --git a/content/migrated_blog/ann-apache-isis-version-21.markdown b/content/migrated_blog/ann-apache-isis-version-21.markdown
new file mode 100644
index 0000000..0c84e51
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-21.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M4 Released"
+date: '2020-10-17T13:11:27+00:00'
+permalink: ann-apache-isis-version-21
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M4.<br><br>Much of the emphasis in this release has been on stabilisation and regression testing.</p><div>That said, there are some new features in this release including:<div><br>* a new programming model for action parameter negotiation</div><div>* reworking/simplification&nbsp;of the command service, with two new extensions (command log and command replay)&nbsp;<br>* bringing in the kroviz&nbsp;client (incubating)</div><div>* updated demo app<br><br>Full release notes are available on the Apache Isis website at [1].<br><br>You can access this release directly from the Maven central repo [2].<br>Alternatively, download the release and build it from source [3].<br><br>Enjoy!<br><br>--The Apache Isis team<br><br>[1] http://isis.apache.org/relnotes/2.0.0-M4/about.html<br>[2] https://search.maven.org<br>[3] https://isis.apache.org/docs/2.0.0-M4/downloads/how-to.html</div></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-22.markdown b/content/migrated_blog/ann-apache-isis-version-22.markdown
new file mode 100644
index 0000000..7743906
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-22.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M5 Released"
+date: '2021-03-28T12:03:57+00:00'
+permalink: ann-apache-isis-version-22
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M5.<br><br>New features in this release include:<br><br>* JPA support&nbsp;(including Spring Data integration)</p><div>* Reworked JDO support to minimize differences between JPA and JDO integrations</div><div>* Use of Spring configuration properties (spring.datasource.url etc) for both JPA and JDO</div><div>* Updated demo apps (both JDO and JPA variants)</div><div>* Updated SecMan to work with logical types (rather than physical package names) and provided a JPA implementation</div><div>* Improved documentation (and documentation tooling)<br></div><div><br>Full release notes are available on the Apache Isis website at [1].<br><br>You can access this release directly from the Maven central repo [2].<br>Alternatively, download the release and build it from source [3].<br><br>Enjoy!</div><div><br></div><div>--The Apache Isis team<br><br>[1] http://isis.apache.org/relnotes/2.0.0-M5/about.html<br>[2] https://search.maven.org<br>[3] https://isis.apache.org/docs/2.0.0-M5/downloads/how-to.html<br></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-23.markdown b/content/migrated_blog/ann-apache-isis-version-23.markdown
new file mode 100644
index 0000000..b2680a6
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-23.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M6 Released"
+date: '2021-08-26T12:14:13+00:00'
+permalink: ann-apache-isis-version-23
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M6.</p><p>New features in this release include:<br></p><ul><li>full support for the CommandPublisher,ExecutionPublisher and EntityPropertyChangePublisher SPIs for both JPA and JDO.</li><li>support for Spring security</li><li>support for keycloak authentication (leveraging Spring security)</li><li>view models for serializable classes;</li><li>a library of architecture tests to detect possible programming issues with your domain apps</li><li>InteractionService added to the applib, allowing programmatic control of sessions</li><li>improvements to built-in and SecMan’s security (impersonation, surface UserMemento, decouple SecMan from Shiro)</li><li>new namedXxx() supporting method for dynamic names of properties and actions</li><li>new @MemberSupport annotation</li><li>removal of @MemberOrder annotation (now folded into the @XxxLayout annotations)</li><li>minimum version of Java was bumped to JDK11.<br></li></ul><p>Full release notes are available on the Apache Isis website [1].<br></p><p>You can access this release directly from the Maven central repo [2].<br></p><p>Alternatively, download the release and build it from source [3].</p><p><br></p><p>Enjoy!</p><p>--The Apache Isis team<br></p><p><br></p><p>[1] <a href="https://isis.apache.org/relnotes/2.0.0-M6/about.html" target="_blank">https://isis.apache.org/relnotes/2.0.0-M6/about.html</a></p><p>[2] <a href="https://search.maven.org" target="_blank">https://search.maven.org</a></p><p>[3] <a href="https://isis.apache.org/docs/2.0.0-M6/downloads/how-to.html" target="_blank">https://isis.apache.org/docs/2.0.0-M6/downloads/how-to.html</a></p><div><br></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-24.markdown b/content/migrated_blog/ann-apache-isis-version-24.markdown
new file mode 100644
index 0000000..9f99fd4
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-24.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M7 Released"
+date: '2022-02-28T23:48:14+00:00'
+permalink: ann-apache-isis-version-24
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M7.<br><br>New features in this release include:<br><br>* a new introspection policy meaning that members (and their supporting methods) can have non-public visibility.<br>* reworked treatment of value types (on the way towards supporting composite value type).<br>* support for UserLocale (language, number format, time format) as an attribute&nbsp;of the current user / user memento.<br>* Rationalization of the handling of logical type name for superclasses/supertypes.<br>* Update to DataNucleus 6.<br><br>Full release notes are available on the Apache Isis website at [1].<br><br>You can access this release directly from the Maven central repo [2].<br>Alternatively, download the release and build it from source [3].<br><br>Enjoy!<br><br>--The Apache Isis team<br><br>[1] https://isis.apache.org/relnotes/2.0.0-M7/about.html<br>[2] https://search.maven.org<br>[3] https://isis.apache.org/docs/2.0.0-M7/downloads/how-to.html<br></p><div></div>
diff --git a/content/migrated_blog/ann-apache-isis-version-25.markdown b/content/migrated_blog/ann-apache-isis-version-25.markdown
new file mode 100644
index 0000000..590bd26
--- /dev/null
+++ b/content/migrated_blog/ann-apache-isis-version-25.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 2.0.0-M8 Released"
+date: '2022-10-06T13:39:28+00:00'
+permalink: ann-apache-isis-version-25
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M8.<br></p><p>New features in this release include:<br></p><ul><li>Full support for audit trail, command log, execution log for JPA and JDO</li><li>New core extensions:<ul><li>SessionLog extension (ISIS-3062)</li><li>ExecutionOutbox extension, to support the outbox pattern (ISIS-3002)</li></ul></li><li>Big improvements for value types, including<ul><li>Support value types (simple ones at least) as a first-class citizen (ISIS-1695)</li><li>Support for persisting Temporal Types with Zone/Offset Information (ISIS-3105)</li><li>Add Vega and Vega-Lite Support (ISIS-3122)</li></ul></li><li>Wicket viewer UI improvements<ul><li>Improved client-side paging/filtering using datatables.net (ISIS-3197)</li><li>New extension to render PDF Blobs using pdf.js (ISIS-3040)</li><li>New extension to display events on calendar using fullcalendar.js (ISIS-3039 )</li></ul></li><li>New ENCAPSULATION_ENABLED introspection policy (eg ISIS-3190, ISIS-3188), which allows actions, collections and properties to have non-public visibility</li><li>New IdStringifier API/SPI interface (ISIS-3089), to allow pluggable management of identifiers in bookmarks/URLs etc</li><li>Support for Java Module System (module.info.java) (ISIS-3207)<br></li></ul><p><br></p><p>Full release notes are available on the Apache Isis website at [1].<br></p><p>You can access this release directly from the Maven central repo [2].&nbsp;<br></p><p>Alternatively, download the release and build it from source [3].</p><p><br></p><p>Enjoy!<br></p><p>--The Apache Isis team<br></p><p><br></p><p>[1] https://isis.apache.org/relnotes/2.0.0-M8/about.html</p><p>[2] https://search.maven.org</p><p>[3] https://isis.apache.org/docs/2.0.0-M8/downloads/how-to.html</p><div><br></div>
diff --git "a/content/migrated_blog/ann-new-committer-j\303\266rg-rade.markdown" "b/content/migrated_blog/ann-new-committer-j\303\266rg-rade.markdown"
new file mode 100644
index 0000000..8f7988b
--- /dev/null
+++ "b/content/migrated_blog/ann-new-committer-j\303\266rg-rade.markdown"
@@ -0,0 +1,7 @@
+---
+layout: post
+title: "[ANN]  New committer - Jörg Rade"
+date: '2020-03-29T23:31:07+00:00'
+permalink: ann-new-committer-jörg-rade
+---
+<p><span style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;">Hi folks,</span><br style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"></p><div style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"><br></div><div style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"><div>I'm delighted to announce that Jörg Rade has been voted in as a committer for Apache Isis, and also as a member of the Apache Isis PMC.&nbsp; The first gives Jörg the right to commit changes directly to Isis' codebase, the second gives him the right to be involved in future votes.</div><div><br></div><div>Jörg has been active in the community for more than five years, and has been actively been developing a new viewer for the framework, called "Kroviz" .&nbsp; This runs against the REST API provided by the Restful Objects viewer, and is implemented in Kotlin (running in the browser as KotlinJS).&nbsp; I'm delighted to say that Jörg will be donating this codebase to the framework and will continue to develop it within our new "incubator".</div><div><br></div><div>Jörg is also very visible on our new Slack channel (he's been sharing the status on Kroviz there for quite a while) so if you want to ping him and ask him questions about this new viewer, I'm sure he'd be very willing&nbsp;</div><div><br></div><div>I'm looking forward to continue working with Jörg in the future; another great addition to Isis' committers.</div><div><br></div><div>Dan Haywood</div><div>Apache Isis Committer, PMC</div></div>
diff --git a/content/migrated_blog/ann_apache_isis_1_0.markdown b/content/migrated_blog/ann_apache_isis_1_0.markdown
new file mode 100644
index 0000000..1817908
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_0.markdown
@@ -0,0 +1,32 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.0.0 (Core, 4 components, 1 archetype) Released"
+date: '2012-12-24T20:51:04+00:00'
+permalink: ann_apache_isis_1_0
+---
+<div>The Isis team is pleased to announce the release of Apache Isis Core 1.0.0, along with 4 components and 1 archetype</div>
+  <div><br /></div>
+  <div>- isis-core-1.0.0 &nbsp;(Isis core)</div>
+  <div>- isis-security-file-1.0.0 &nbsp;(file-based security)</div>
+  <div>- isis-objectstore-jdo-1.0.0 &nbsp;(JDO objectstore)</div>
+  <div>- isis-viewer-wicket-1.0.0 (Wicket viewer)</div>
+  <div>- isis-viewer-restfulobjects-1.0.0 &nbsp;(Restful Objects viewer)</div>
+  <div>- quickstart_wicket_restful_jdo-archetype-1.0.0 &nbsp;(Quickstart Archetype for Wicket viewer, Restful Objects viewer, JDO objectstore).</div>
+  <div><br /></div>
+  <div>This is the first release of Isis as an Apache top-level project. &nbsp;This release incorporates a restructuring so that the core is released independently of the main components.&nbsp;</div>
+  <div><br /></div>
+  <div>Full release notes are available at [1], [2], [3], [4], [5] on the Isis website.</div>
+  <div><br /></div>
+  <div>You can access this release directly from the Maven central repo [6], or download the release and build it from source [7].</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>-The Isis team</div>
+  <div><br /></div>
+  <div>[1] http://isis.apache.org/core/release-notes/isis-1.0.0.html</div>
+  <div>[2] http://isis.apache.org/components/security/file/release-notes/isis-security-file-1.0.0.html</div>
+  <div>[3] http://isis.apache.org/components/objectstores/jdo/release-notes/isis-objectstore-jdo-1.0.0.html</div>
+  <div>[4] http://isis.apache.org/components/viewers/restfulobjects/release-notes/isis-viewer-restfulobjects-1.0.0.html</div>
+  <div>[5] http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.0.0.html</div>
+  <div>[6] http://search.maven.org</div>
+  <div>[7] http://isis.apache.org/download.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_1_11.markdown b/content/migrated_blog/ann_apache_isis_1_11.markdown
new file mode 100644
index 0000000..9d3cdd6
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_11.markdown
@@ -0,0 +1,18 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.11.1 Released"
+date: '2016-01-17T15:04:08+00:00'
+permalink: ann_apache_isis_1_11
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">The Apache Isis team is pleased to announce the release of Apache Isis v1.11.1</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">This is a bug-fix release that re-releases v1.11.0 compiled to run under Java 7 (the previous release incorrectly used some Java 8 APIs).</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">The release also includes two minor updates to the simpleapp archetype: a minor fix to the JDOQL strings, and the reinstatement of .launch files for running the generated app within the Eclipse IDE.</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><span style="font-size: 12.8px;">You can access this release directly from the Maven central repo [1], or download the release and build it from source [2].</span></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">--The Apache Isis team<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><span style="font-size: 12.8px;">[1]</span><span style="font-size: 12.8px;"> </span><a href="http://search.maven.org/" target="_blank" style="font-size: 12.8px; color: #1155cc;">http://search.maven.org</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">[2] <a href="http://isis.apache.org/downloads.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />downloads.html</a></div>
diff --git a/content/migrated_blog/ann_apache_isis_1_12.markdown b/content/migrated_blog/ann_apache_isis_1_12.markdown
new file mode 100644
index 0000000..e81a7e3
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_12.markdown
@@ -0,0 +1,20 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.12.1 Released"
+date: '2016-04-12T07:35:44+00:00'
+permalink: ann_apache_isis_1_12
+---
+<p>The Apache Isis team is pleased to announce the release of Apache Isis v1.12.1 </p>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">This is a bug fix release for Apache Isis 1.12.0. &nbsp;The primary issue it addresses are spurious concurrency exceptions that can be thrown when editing an object. &nbsp;It also addresses a subtle issue where the new support in JAXB view models for auto-edit can cause some dirty objects not to be updated.</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Full release notes are available on the Apache Isis website at [1].<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">You can access this release directly from the Maven central repo [2], or download the release and build it from source [3].</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Enjoy!</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">--The Apache Isis team</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[1] http://isis.apache.org/release-notes.html#r1.12.1</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[2] http://search.maven.org<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[3] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_1_121.markdown b/content/migrated_blog/ann_apache_isis_1_121.markdown
new file mode 100644
index 0000000..f062d44
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_121.markdown
@@ -0,0 +1,21 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.12.2 Released"
+date: '2016-06-06T17:41:28+00:00'
+permalink: ann_apache_isis_1_121
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">The Apache Isis team is pleased to announce the release of Apache Isis v1.12.2</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">This is a bug fix release addressing ISIS-1396 (title links showing null after update) and ISIS-1132 (time rendered incorrectly on datepickers).</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">Full release notes are available on the Apache Isis website at [1].&nbsp; There are no migration notes.<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">You can access this release directly from the Maven central repo [2], or download the release and build it from source [3].</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">Thanks,</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">--The Apache Isis team<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">[1] <a href="http://isis.apache.org/release-notes.html#r1.12.2" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />release-notes.html#r1.12.2</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">[2] <a href="http://search.maven.org/" target="_blank" style="color: #1155cc;">http://search.maven.org</a><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 12.8px;">[3] <a href="http://isis.apache.org/downloads.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />downloads.html</a></div>
diff --git a/content/migrated_blog/ann_apache_isis_1_13.markdown b/content/migrated_blog/ann_apache_isis_1_13.markdown
new file mode 100644
index 0000000..88c4f0d
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_13.markdown
@@ -0,0 +1,29 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.13.0 Released"
+date: '2016-07-12T05:51:36+00:00'
+permalink: ann_apache_isis_1_13
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: small;">The Apache Isis team is pleased to announce the release of Apache Isis v1.13.0.</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">New features in this release include:</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">
+    <ul>
+      <li>reworked and improved commands, interactions and events</li>
+      <li>new domain services (InteractionContext, PublisherService, AuditerService, MetricsService, etc)</li>
+      <li>@Nullable support</li>
+      <li>initial support for Docker&nbsp;</li>
+    </ul>
+  </div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">
+    <p>Full release notes are available on the Apache Isis website at [1]. &nbsp;DO ALSO please read the migration notes [2].</p>
+    <p>You can access this release directly from the Maven central repo [3], or download the release and build it from source [4].</p>
+    <p>Enjoy!</p>
+  </div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">--The Apache Isis team</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[1] http://isis.apache.org/release-notes.html#r1.13.0</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[2] http://isis.apache.org/migration-notes.html#_migration-notes_1.12.x-to-1.13.0</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[3] http://search.maven.org</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[4] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_1_8.markdown b/content/migrated_blog/ann_apache_isis_1_8.markdown
new file mode 100644
index 0000000..c935fa9
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_1_8.markdown
@@ -0,0 +1,47 @@
+---
+layout: post
+title: "[ANN] Apache Isis 1.8.0"
+date: '2015-02-24T07:59:38+00:00'
+permalink: ann_apache_isis_1_8
+---
+<div>The Isis team is pleased to announce the release of:</div> 
+  <div> 
+    <ul> 
+      <li>Apache Isis Core version 1.8.0</li> 
+      <li>SimpleApp Archetype 1.8.0</li> 
+    </ul> 
+  </div> 
+  <div>New features in this release include:</div> 
+  <div> 
+    <ul> 
+      <li>a new theme-able look-n-feel for the Wicket viewer, using <a href="http://www.getbootstrap.com/" target="_blank">Twitter Bootstrap</a>&nbsp;and <a href="http://fortawesome.github.io/Font-Awesome/icons/" target="_blank">font awesome icons</a></li> 
+      <li>a new simplified set of annotations (@Property, @DomainObject, @CollectionLayout etc) to make features more discoverable; see <a href="http://isis.apache.org/intro/resources/cheat-sheet.html" target="_blank">cheat-sheet</a></li> 
+      <li>support to enable multi-tenancy (in particular in conjunction with <a href="https://github.com/isisaddons/isis-module-security" target="_blank">Isis addons security module</a>)</li> 
+      <li>new <a href="http://isis.apache.org/config/i18n-support.html" target="_blank">i18n support</a> using gettext .po files, honouring user locale</li> 
+      <li><a href="http://isis.apache.org/reference/services/user-registration-service.html" target="_blank">sign-up/self-registration</a> support (so that end-users can create own user accounts)</li> 
+      <li><a href="http://isis.apache.org/reference/services/email-service.html" target="_blank">EmailService</a> for sending HTML emails, optionally with attachments</li> 
+      <li>ability to validate individual parameters imperatively</li> 
+      <li>config property to flag use of deprecated annotations/method prefixes</li> 
+      <li>Maven plugin to validate domain object model with respect to Isis programming conventions</li> 
+      <li>improved support for Neo4J</li> 
+      <li>experimental support for more <a href="http://isis.apache.org/components/viewers/restfulobjects/suppressing-elements-of-the-representations.html" target="_blank">flexibility of generating Restful Objects representations</a></li> 
+    </ul> 
+  </div> 
+  <div>Full <a href="http://isis.apache.org/core/release-notes/isis-1.8.0.html" target="_blank">release notes</a> are available on the Isis website.</div> 
+  <div><br /></div> 
+  <div>Note that:</div> 
+  <div> 
+    <ul> 
+      <li>as of 1.8.0 the Wicket Viewer is bundled in with Core</li> 
+      <li>the ToDoApp archetype is no longer provided, however the <a href="https://github.com/isisaddons/isis-app-todoapp" target="_blank">example todoapp</a> is available from Isis addons (not ASF) to fork and adapt.</li> 
+      <li>this release drops support for JDK 1.6, standardizes on JDK 1.7</li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>You can access this release directly from the <a href="http://search.maven.org" target="_blank">Maven central repo</a>, or download the release and build it <a href="http://isis.apache.org/download.html" target="_blank">from source</a>.</div> 
+  <div><br /></div> 
+  <div>Enjoy!</div> 
+  <div><br /></div> 
+  <div>--The Apache Isis team</div> 
+  <div><br /></div> 
+  <div><br /></div>
diff --git a/content/migrated_blog/ann_apache_isis_core_1.markdown b/content/migrated_blog/ann_apache_isis_core_1.markdown
new file mode 100644
index 0000000..6088539
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_core_1.markdown
@@ -0,0 +1,34 @@
+---
+layout: post
+title: "[ANN] Apache Isis Core 1.1.0, Isis Shiro Security 1.1.0, Isis Wicket Viewer
+  1.1.0 and Quickstart (Wicket/Restful/JDO) Archetype 1.0.2 released"
+date: '2013-01-31T15:02:33+00:00'
+permalink: ann_apache_isis_core_1
+---
+<div>The Isis team is pleased to announce the release of Apache Isis Core 1.1.0, Isis Shiro Security 1.1.0, Isis Wicket Viewer 1.1.0 and Quickstart (Wicket/Restful/JDO) Archetype 1.0.2 released.</div>
+  <div><br /></div>
+  <div>New and notable features are:</div>
+  <div>
+    <ul>
+      <li>upload/download of files in the Wicket viewer</li>
+      <li>support for bulk actions in the Wicket viewer</li>
+      <li>improved extensibility of Wicket viewer (eg for gmap3 support)</li>
+      <li>support for LDAP authorization through a Shiro Realm implementation</li>
+    </ul>
+  </div>
+  <div><br /></div>
+  <div>Full release notes are available at [1], [2], [3], [4] on the Isis website.</div>
+  <div><br /></div>
+  <div>You can access this release directly from the Maven central repo [5],&nbsp;</div>
+  <div>or download the release and build it from source [6].</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>-The Isis team</div>
+  <div><br /></div>
+  <div>[1] http://isis.apache.org/core/release-notes/isis-1.1.0.html</div>
+  <div>[2] http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.1.0.html</div>
+  <div>[3] http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.1.0.html</div>
+  <div>[4] http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.0.2.html</div>
+  <div>[5] http://search.maven.org</div>
+  <div>[6] http://isis.apache.org/download.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_v1_9.markdown b/content/migrated_blog/ann_apache_isis_v1_9.markdown
new file mode 100644
index 0000000..790c455
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_v1_9.markdown
@@ -0,0 +1,26 @@
+---
+layout: post
+title: "[ANN] Apache Isis v1.9.0 Released"
+date: '2015-09-01T21:49:34+00:00'
+permalink: ann_apache_isis_v1_9
+---
+<div style="font-size: small; color: #222222; font-family: arial, sans-serif;">The Apache Isis team is pleased to announce the release of Apache Isis v1.9.0.</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">New release includes 18 new features, 50 improvements and 25 bug fixes. &nbsp;The new features include:</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">- upgrading dependency on DataNucleus to 4.1.x</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">- a new mechanism (&quot;AppManifest&quot;) for bootstrapping Isis</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">- a bunch of useful new domain services, including support for content negotiation service within the Restful Objects viewer<br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">Full release notes are available on the <a href="http://isis.apache.org/release-notes.html#r1.9.0">Apache Isis website</a>.</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">This release cycle has also included the reworkings of the Apache Isis website, now built using Asciidoctor and hosted as a git repository. &nbsp;There are also several new modules at the (non-ASF) <a href="http://isisaddons.org">Isis addons site</a>, to support polymorphic relationships, publishing via ActiveMQ, feature toggles, and fakedata for testing.<br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">You can access this release directly from the <a href="http://search.maven.org">Maven central repo</a>,</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">or download the release and build it <a href="http://isis.apache.org/downloads.html">from source</a>.</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">Enjoy!</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;">--The Apache Isis team</div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div style="font-size: small; color: #222222; font-family: arial, sans-serif;"><br /></div> 
+  <div><br /></div>
diff --git a/content/migrated_blog/ann_apache_isis_version_1.markdown b/content/migrated_blog/ann_apache_isis_version_1.markdown
new file mode 100644
index 0000000..12fcd26
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_1.markdown
@@ -0,0 +1,48 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.5.0 - decoupling using the event bus, fixture
+  scripts, better jrebel support"
+date: '2014-06-07T18:47:30+00:00'
+permalink: ann_apache_isis_version_1
+---
+<div style="color: #222222; font-family: arial, sans-serif;">The Isis team is pleased to announce the release of:</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Apache Isis Core version 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Wicket Viewer 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Restful Objects Viewer 2.3.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- JDO Object Store 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Shiro Security 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Simple Archetype 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Quickstart Archetype 1.5.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">New features and improvements in this release include:</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Additional EventBus service events, ability to programmatically trigger events, vetoing subscribers (ISIS-550, ISIS-786)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Integration testing improvements, most notably the new FixtureScript API and auto-injection of services into integration tests (ISIS-776, ISIS-782, ISIS-783)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Better handling of multiple realms in Shiro security (ISIS-746)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Better default column sizes for applib services (command, auditing, pubsub) (ISIS-744, ISIS-750)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Precommit phase to flush pending updates for applib services (ISIS-769)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Preparatory work for move to Java 7 (ISIS-569, ISIS-770, ISIS-772)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Improved support for JRebel in Maven and various IDEs (ISIS-756)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">Notable bug fixes include:</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Fixed blob/clob mapping in JDO Objectstore (ISIS-714)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- Fixed handling of mandatory boolean parameters in Wicket viewer (ISIS-431)</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">- RO not threadsafe when buiding metamodel (ISIS-777)<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">Full release notes are available at [1,2,3,4,5,6,7] on the Isis website.</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">You can access this release directly from the Maven central repo [8],&nbsp;</div>
+  <div style="color: #222222; font-family: arial, sans-serif;">or download the release and build it from source [9].</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">Enjoy!</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">-The Isis team</div>
+  <div style="color: #222222; font-family: arial, sans-serif;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[1] <a href="http://isis.apache.org/core/release-notes/isis-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/core/<wbr />release-notes/isis-1.5.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[2] <a href="http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/wicket/<wbr />release-notes/isis-viewer-<wbr />wicket-1.5.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[3] <a href="http://isis.apache.org/components/viewers/restfulobjects/release-notes/isis-viewer-restfulobjects-2.3.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/<wbr />restfulobjects/release-notes/<wbr />isis-viewer-restfulobjects-2.<wbr />3.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[4] <a href="http://isis.apache.org/components/objectstores/jdo/release-notes/isis-objectstore-jdo-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/objectstores/jdo/<wbr />release-notes/isis-<wbr />objectstore-jdo-1.5.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[5] <a href="http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/security/shiro/<wbr />release-notes/isis-security-<wbr />shiro-1.5.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[6] <a href="http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />quickstart_wrj-archetype-1.5.<wbr />0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[7] <a href="http://isis.apache.org/getting-started/release-notes/simple_wrj-archetype-1.5.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />simple_wrj-archetype-1.5.0.<wbr />html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[8] <a href="http://search.maven.org/" target="_blank" style="color: #1155cc;">http://search.maven.org</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif;">[9] <a href="http://isis.apache.org/download.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />download.html</a></div>
diff --git a/content/migrated_blog/ann_apache_isis_version_11.markdown b/content/migrated_blog/ann_apache_isis_version_11.markdown
new file mode 100644
index 0000000..b05e250
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_11.markdown
@@ -0,0 +1,90 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.6.0 Released"
+date: '2014-07-28T18:19:43+00:00'
+permalink: ann_apache_isis_version_11
+---
+<div style="color: #222222; font-family: arial; font-size: small;">The Isis team is pleased to announce the release of:</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Apache Isis Core version 1.6.0<br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Wicket Viewer 1.6.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* TodoApp Archetype 1.6.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* SimpleApp Archetype 1.6.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">Note that:</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Isis Core now incorporates the JDO Objectstore, Restful Objects Viewer and Shiro Security (all previously released as separate components).</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* TodoApp Archetype was previously the 'Quickstart (Wicket/Restful/JDO) archetype'</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* SimpleApp Archetype was previously the 'Simple (Wicket/Restful/JDO) archetype'</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><b>New and noteworthy</b></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><b><br /></b></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">New features in this release include:</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Extend (custom) EventBus vetoing logic so that can also encompass hide, disable, validate (ISIS-831)&nbsp;<br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"> 
+    <div>* @DomainService annotation to automatically discover and register domains (ISIS-493)</div> 
+    <div>* Wicket viewer: Add edit capability to view objects (ISIS-781)</div> 
+    <div>* Wicket viewer: Wizard-like form for Wicket viewer (ISIS-800, ISIS-810)</div> 
+    <div><br /></div> 
+    <div>Improvements include:</div> 
+    <div>* Move jdo, shiro and restful into core (ISIS-832)</div> 
+    <div>* Break out applib and JDO services into modules (ISIS-833)</div> 
+    <div>* Mock out individual domain services in integration tests (ISIS-813)</div> 
+    <div>* contributed properties and collections only for service actions with safe semantics (ISIS-801)</div> 
+    <div>* Wicket viewer: Internationalization of UI elements (edit, ok, cancel, logout, about) (ISIS-815)</div> 
+    <div><br /></div> 
+    <div>Notable bug fixes include:</div> 
+    <div>* lifecycle callbacks now all fire correctly (ISIS-796)</div> 
+    <div>* Restful objects decodes json request body while this is not (ISIS-797)</div> 
+    <div>* Isis 1.5 blob mapping broken for PostgreSQL (when set to null) (ISIS-812)</div> 
+    <div>* wrapSkipRules does not execute action due to being hidden (ISIS-818)</div> 
+    <div>* Precision gets lost when double values are use in BigDecimal attributes (ISIS-821)</div> 
+    <div>* In Wicket viewer, forms not flushing properties when annotated with JDO @NotPersistent. (ISIS-837)</div> 
+    <div><br /></div> 
+    <div> 
+      <div>Full release notes are available at [1,2,3,4] on the Isis website.</div> 
+      <div><br /></div> 
+      <div>You can access this release directly from the Maven central repo [5], download the release and build it from source [6], or start a new app using either of the archetypes [7,8].</div> 
+    </div> 
+    <div><br /></div> 
+    <div><br /></div> 
+    <div><b><a href="http://www.isisaddons.org/" target="_blank" style="color: #1155cc;">www.isisaddons.org</a></b></div> 
+    <div><br /></div> 
+    <div>Similar to the way in which Apache Wicket has an additional &quot;wicketstuff&quot; website [9], we have now set up a new companion website,&nbsp;<a href="http://www.isisaddons.org/" target="_blank" style="color: #1155cc;">www.isisaddons.org</a>&nbsp;[<wbr />10]. &nbsp;The intention is for this site to house various third-party extensions to Isis, such that they can either be used &quot;out-of-the-box&quot;, or be forked and extended as need be.</div> 
+    <div><br /></div> 
+    <div>Currently Isis add-ons fall into two categories:<br /></div> 
+  </div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* modules... these provide business functionality to be incorporated directly into your domain object model, usually as domain services, occasionally with supporting entities. &nbsp;Examples include mail merge, spreadsheets, tags/labels.</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* wicket extensions ... these extend the capability of the Wicket viewer, eg maps, calendars, charts.<br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">In the future we expect to add in &quot;metamodel&quot; category for customizations to Isis' metamodel, eg an extension to leverage various Java 8 reflection features which we don't want to roll into Isis core just yet.</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">The intention is for all modules in <a href="http://www.isisaddons.org/" target="_blank" style="color: #1155cc;">www.isisaddons.org</a> to follow a standard format, and include full unit and integration testing. &nbsp;Thus, if you want to fork and extend any given module, then there is a solid base to start from. &nbsp;Over time we hope that the &quot;modules&quot; in particular will provide a useful catalog to help bootstrap Isis development, and provide a way for the community to contribute back their own functionality as modules.</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">We are also considering moving some of Isis' own modules (ie those recently factored out, such as for auditing, command, publishing etc) into <a href="http://www.isisaddons.org/" target="_blank" style="color: #1155cc;">www.isisaddons.org</a>. &nbsp;Doing so will reduce the size of Isis itself while making it possible for these components to be more easily extended/adapted by the user community as need be. &nbsp;We will certainly take a *copy* of these modules in the first instance.</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><b>Migration from previous versions</b></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">Note that some Maven modules have been renamed, added or removed. &nbsp;While every effort has been made to minimize impact (in particular: no classes have been deleted or have changed their package), there are necessarily some changes that must be made to existing application pom.xml files.</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">For full details of migrating an existing Isis application to 1.6.0, please see [11].</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">Enjoy!</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">--The Isis team</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[1] <a href="http://isis.apache.org/core/release-notes/isis-1.6.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/core/<wbr />release-notes/isis-1.6.0.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[2] <a href="http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.6.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/wicket/<wbr />release-notes/isis-viewer-<wbr />wicket-1.6.0.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[3] <a href="http://isis.apache.org/getting-started/release-notes/todoapp-archetype-1.6.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />todoapp-archetype-1.6.0.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[4] <a href="http://isis.apache.org/getting-started/release-notes/simpleapp-archetype-1.6.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />simpleapp-archetype-1.6.0.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[5] <a href="http://search.maven.org/" target="_blank" style="color: #1155cc;">http://search.maven.org</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[6] <a href="http://isis.apache.org/download.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />download.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[7]&nbsp;<a href="http://isis.apache.org/intro/getting-started/simpleapp-archetype.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />intro/getting-started/<wbr />simpleapp-archetype.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[8]<a href="http://isis.apache.org/intro/getting-started/todoapp-archetype.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />intro/getting-started/todoapp-<wbr />archetype.html</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[9]&nbsp;<a href="http://wicketstuff.org/" target="_blank" style="color: #1155cc;">http://wicketstuff.org/</a><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[10] <a href="http://www.isisaddons.org/" target="_blank" style="color: #1155cc;">http://www.isisaddons.org/</a></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">[11]&nbsp;<a href="http://isis.apache.org/core/release-notes/migrating-to-1.6.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />core/release-notes/migrating-<wbr />to-1.6.0.html</a></div>
diff --git a/content/migrated_blog/ann_apache_isis_version_12.markdown b/content/migrated_blog/ann_apache_isis_version_12.markdown
new file mode 100644
index 0000000..d2cde6d
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_12.markdown
@@ -0,0 +1,46 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.7.0 Released"
+date: '2014-10-21T06:24:37+00:00'
+permalink: ann_apache_isis_version_12
+---
+<div style="color: #222222; font-family: arial; font-size: small;">The Isis team is pleased to announce the release of:</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">* Apache Isis Core version 1.7.0</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">* Wicket Viewer 1.7.0</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">* SimpleApp Archetype 1.7.0</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">* ToDoApp Archetype 1.7.0</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">New features in this release include:</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-809: @ViewModel annotation, no longer requiring explicit implementation of the IViewModel interface.</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-916: ability to override framework-provided services, such as MementoService or BookmarkService.</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-917: (beta): pluggable representations for the RO viewer</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">There are also some security fixes:</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-883: Bookmarkable action URLs can be submitted by a user without permissions to bring up action dialog (thereafter that user can invoke).</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-884: ErrorPage vulnerable to XSS attacks.</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- ISIS-895: HomePage should honour authorization rules.</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">Full release notes are available at [1,2,3,4] on the Isis website. &nbsp;</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">Isis modules that in 1.6.0 were released as part of Isis core have now moved to Isis addons [5]. Meanwhile the profilestore component (previously in core, but unused in the Wicket viewer) has been retired. &nbsp;Migration should be straightforward, see [6].</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">Significant updates in Isis add-ons:</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- isis-module-security module [7], for administering authentication and authorization</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">- all modules re-released against for 1.7.0.</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">You can access this release directly from the Maven central repo [8],&nbsp;</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">or download the release and build it from source [9].</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">Enjoy!</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">--The Isis team</div>
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[1] http://isis.apache.org/core/release-notes/isis-1.7.0.html</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[2] http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.7.0.html</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[3] http://isis.apache.org/archetypes/release-notes/todoapp-archetype-1.7.0.html</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[4] http://isis.apache.org/archetypes/release-notes/simpleapp-archetype-1.7.0.html</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[5] http://isis.apache.org/core/release-notes/migrating-to-1.7.0.html</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[6] https://github.com/isisaddons/isis-module-security</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[7] http://www.isisaddons.org</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[8] http://search.maven.org</div>
+  <div style="color: #222222; font-family: arial; font-size: small;">[9] http://isis.apache.org/download.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_version_13.markdown b/content/migrated_blog/ann_apache_isis_version_13.markdown
new file mode 100644
index 0000000..070ec8d
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_13.markdown
@@ -0,0 +1,30 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.10.0 Released"
+date: '2015-11-10T08:22:20+00:00'
+permalink: ann_apache_isis_version_13
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: small;">The Apache Isis team is pleased to announce the release of Apache Isis v1.10.0.</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">New features in this release include:</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">* ISIS-1213 - Support for @Mixin domain objects, as a specialized type of contributor</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">
+    <div>* ISIS-1210 - SPI service for handling exception stack traces</div>
+    <div>* ISIS-1205 - Support @Inject on List&lt;T&gt; or Collection&lt;T&gt;</div>
+    <div>* ISIS-1007 - Provide support for &quot;are you sure&quot; idiom using extended actionsemantics</div>
+    <div>* ISIS-1005 - Lifecycle events emitted, enabling eg services to pre-commit processing</div>
+    <div>* ISIS-867 - Domain service to automatically maintain lastUpdatedAt and lastUpdatedBy</div>
+  </div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Full release notes are available on the Apache Isis website at [1]. &nbsp;Please also read the migration notes [2]</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">You can access this release directly from the Maven central repo [3],</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">or download the release and build it from source [4].</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Enjoy!</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">--The Apache Isis team</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">
+    <p>[1] http://isis.apache.org/release-notes.html#r1.10.0<br />[2]&nbsp;http://isis.apache.org/migration-notes.html#_migration-notes_1.9.0-to-1.10.0<br />[3] http://search.maven.org<br />[4] http://isis.apache.org/downloads.html&nbsp;</p>
+  </div>
diff --git a/content/migrated_blog/ann_apache_isis_version_14.markdown b/content/migrated_blog/ann_apache_isis_version_14.markdown
new file mode 100644
index 0000000..a2c68c1
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_14.markdown
@@ -0,0 +1,183 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.11.0 Released"
+date: '2016-01-02T06:46:32+00:00'
+permalink: ann_apache_isis_version_14
+---
+<table class="iN" style="border-spacing: 0px; font-size: 15.6px; table-layout: fixed; width: 598.182px; vertical-align: top; border-collapse: collapse; color: #222222; font-family: arial, sans-serif;">
+    <tbody>
+      <tr>
+        <td class="GQ" style="font-family: arial, sans-serif; margin: 0px; width: 598.182px; padding: 0px 0px 2px;">
+          <div id=":o3" class="GP" style="margin: 0px -1px; overflow-y: hidden; padding: 0px 1px; position: relative; max-height: 624px; min-height: 436px;">
+            <div id=":oz" class="qz aXjCH" style="overflow: auto; position: relative; z-index: 0; max-height: 624px;">
+              <div id=":p3" class="et" style="border-color: transparent !important;">
+                <div id=":nb" class="aoX">
+                  <table cellpadding="0" class="cf An" id=":ym" style="width: 598.182px; table-layout: fixed;">
+                    <tbody>
+                      <tr>
+                        <td class="Ap" style="font-family: arial, sans-serif; margin: 0px; width: 594.545px; vertical-align: top;">
+                          <div id=":14x" class="Ar Au" style="padding: 7px 7px 9px; box-sizing: border-box; border-radius: 1px; transition: none; zoom: 1; border: 0px transparent !important; margin: 0px !important;">
+                            <div id=":13d" class="Am Al editable LW-avf" hidefocus="true" aria-label="Message Body" g_editable="true" role="textbox" tabindex="1" style="font-stretch: normal; font-size: small; width: 580.568px; overflow: visible; border: 0px; outline: none; direction: ltr; min-height: 378px; background-image: initial; background-attachment: initial; background-size: initial; background-origin: initial; background-clip: initial; background-position: initial; background-repeat: initial;">
+                              <div>The Apache Isis team is pleased to announce the release of Apache Isis v1.11.0.</div>
+                              <div><br /></div>
+                              <div>The main focus for this release is on the REST API and on view models using JAXB:<br /></div>
+                              <div>
+                                <div><br /></div>
+                                <div>* the Restful Objects viewer now supports simplified representations intended to make it easier to write custom Javascript (and other) clients that consume the REST API; these are obtained using the HTTP Accept header. There is also support for Swagger spec files so that the REST API can be more easily explored and tested. &nbsp;Separately, the x-ro-follow-links capability for RO spec representations is now supported.</div>
+                                <div><br /></div>
+                                <div>* JAXB-annotated classes are now recognised as view models; these also enable the contents collections to be part of the view model’s state (previously only view model properties were recognised). The new UrlEncodingService allows long URLs (for view models) to be converted into shorter URLs; this also allows the URL to optionally be encrypted.</div>
+                                <div><br /></div>
+                                <div>* The release also includes improved control for domain events (these can now be suppressed if required) , and a new category of UI events (so that titles, icons and CSS classes can be provided by event bus subscribers).</div>
+                              </div>
+                              <div><br /></div>
+                              <div>Full release notes are available on the <a href="http://isis.apache.org/release-notes.html#r1.11.0">Apache Isis website</a>. &nbsp;Please also read the <a href="http://isis.apache.org/migration-notes.html#_migration-notes_1.10.0-to-1.11.0">migration notes</a>.</div>
+                              <div><br /></div>
+                              <div>You can access this release directly from the <a href="http://search.maven.org">Maven central repo</a>, or <a href="http://isis.apache.org/downloads.html">download the release</a> and build it from source.</div>
+                              <div><br /></div>
+                              <div>Enjoy!</div>
+                              <div><br /></div>
+                              <div>--The Apache Isis team</div>
+                              <div><br /></div>
+                              <div><br /></div>
+                            </div>
+                          </div>
+                        </td>
+                      </tr>
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            </div>
+            <div id=":rt" class="GW" style="bottom: -1px; left: 0px; position: absolute; right: 0px;">
+              <div id=":13r" class="GL" style="padding: 0px 1px 1px;"></div>
+            </div>
+          </div>
+        </td>
+      </tr>
+      <tr>
+        <td class="HE" style="font-family: arial, sans-serif; margin: 0px; padding: 0px;">
+          <div id=":mm" class="aDg" style="position: relative; z-index: 0;">
+            <div id=":l3" class="aDj" style="border-width: 0px 1px 1px; margin: 0px; position: static;">
+              <div id=":mz" class="aC5" style="position: relative; z-index: 0;"></div>
+              <div id=":ml" class="aDl" style="position: relative; z-index: 0;">
+                <div id=":p6" class="xQMqOe"></div>
+                <div id=":ph" class="Ur" style="bottom: -4px; left: 0px; position: absolute;">
+                  <div class="aX" style="height: 44px; overflow: hidden; z-index: 10; position: relative; visibility: visible;">
+                    <div id=":1bz" class="aZ">
+                      <div class="J-Z" id=":1c0" role="toolbar" aria-label="Formatting options" style="border: 1px solid #cfcfcf; outline: 0px; padding: 4px 2px; position: relative; zoom: 1; box-shadow: rgba(0, 0, 0, 0.0980392) 0px 2px 2px -1px; display: inline-block; margin: 0px 6px; -webkit-user-select: none; background: #f5f5f5;">
+                        <div id=":12v" class="J-Z-axO J-Z-M-I aOz J-J5-Ji" command="+fontName" data-tooltip="Font ‪(Ctrl-Shift-5, Ctrl-Shift-6)‬" aria-label="Font ‪(Ctrl-Shift-5, Ctrl-Shift-6)‬" role="listbox" aria-activedescendant=":1cs" aria-expanded="false" aria-haspopup="true" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-M-I-Kv-H" style="position: relative; display: inline-block; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-M-I-J6-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="J-J5-Ji J-Z-M-I-Jm" id=":1cs" role="option" aria-setsize="0" aria-posinset="0" style="position: relative; display: inline-block; padding: 0px 0px 0px 4px; margin: 0px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; width: 60px; -webkit-user-select: none;">Sans Serif</div>
+                              <div class="J-J5-Ji J-Z-M-I-JG" style="position: relative; display: inline-block; float: right; margin: 7px 2px 0px 3px; padding: 0px; opacity: 0.8; vertical-align: middle; width: 7px; height: 11px; transform: none; filter: none; -webkit-user-select: none; background: url(&quot;//ssl.gstatic.com/ui/v1/disclosure/small-grey-disclosure-arrow-down.png&quot;) 50% 50% no-repeat;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div class="J-Z-axR J-J5-Ji" aria-disabled="true" role="separator" id=":1ct" style="position: relative; display: inline-block; border-left-width: 1px; border-left-style: solid; border-left-color: #cccccc; height: 17px; list-style: none; margin: 0px 2px; outline: none; overflow: hidden; padding: 0px; vertical-align: middle; width: 0px; -webkit-user-select: none;"></div>
+                        <div id=":12w" class="J-Z-M-I J-J5-Ji" command="+fontSize" data-tooltip="Size ‪(Ctrl-Shift--, Ctrl-Shift-+)‬" aria-label="Size ‪(Ctrl-Shift--, Ctrl-Shift-+)‬" role="button" aria-expanded="false" aria-haspopup="true" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-M-I-Kv-H" style="position: relative; display: inline-block; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-M-I-J6-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="J-J5-Ji J-Z-M-I-Jm" style="position: relative; display: inline-block; padding: 0px; margin: 0px; -webkit-user-select: none;">
+                                <div class="eY  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -84px 0px;"></div>
+                              </div>
+                              <div class="J-J5-Ji J-Z-M-I-JG" style="position: relative; display: inline-block; float: right; margin: 10px 2px 0px 3px; padding: 0px; opacity: 0.8; vertical-align: middle; width: 5px; height: 7px; -webkit-user-select: none; background: url(&quot;//ssl.gstatic.com/ui/v1/disclosure/small-grey-disclosure-arrow-down.png&quot;) 50% 50% no-repeat;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div class="J-Z-axR J-J5-Ji" aria-disabled="true" role="separator" id=":1cv" style="position: relative; display: inline-block; border-left-width: 1px; border-left-style: solid; border-left-color: #cccccc; height: 17px; list-style: none; margin: 0px 2px; outline: none; overflow: hidden; padding: 0px; vertical-align: middle; width: 0px; -webkit-user-select: none;"></div>
+                        <div id=":12x" class="J-Z-aEu-I J-Z-I J-J5-Ji" command="+bold" data-tooltip="Bold ‪(Ctrl-B)‬" aria-label="Bold ‪(Ctrl-B)‬" aria-pressed="false" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="eN  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: 0px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":12y" class="J-Z-aEu-I J-Z-I J-J5-Ji" command="+italic" data-tooltip="Italic ‪(Ctrl-I)‬" aria-label="Italic ‪(Ctrl-I)‬" aria-pressed="false" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="e3  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -21px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":12z" class="J-Z-aEu-I J-Z-I J-J5-Ji" command="+underline" data-tooltip="Underline ‪(Ctrl-U)‬" aria-label="Underline ‪(Ctrl-U)‬" aria-pressed="false" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="fu  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -42px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":15y" class="J-Z-M-I J-J5-Ji" command="+foreColor" data-tooltip="Text Colour" aria-label="Text Colour" role="button" aria-expanded="false" aria-haspopup="true" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-M-I-Kv-H" style="position: relative; display: inline-block; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-M-I-J6-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="J-J5-Ji J-Z-M-I-Jm" style="position: relative; display: inline-block; padding: 0px; margin: 0px; -webkit-user-select: none;">
+                                <div class="eS  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -105px 0px;"></div>
+                              </div>
+                              <div class="J-J5-Ji J-Z-M-I-JG" style="position: relative; display: inline-block; float: right; margin: 10px 2px 0px 3px; padding: 0px; opacity: 0.8; vertical-align: middle; width: 5px; height: 7px; -webkit-user-select: none; background: url(&quot;//ssl.gstatic.com/ui/v1/disclosure/small-grey-disclosure-arrow-down.png&quot;) 50% 50% no-repeat;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div class="J-Z-axR J-J5-Ji" aria-disabled="true" role="separator" id=":1d0" style="position: relative; display: inline-block; border-left-width: 1px; border-left-style: solid; border-left-color: #cccccc; height: 17px; list-style: none; margin: 0px 2px; outline: none; overflow: hidden; padding: 0px; vertical-align: middle; width: 0px; -webkit-user-select: none;"></div>
+                        <div id=":15x" class="J-Z-M-I J-J5-Ji" command="alignMenu" data-tooltip="Align" aria-label="Align" role="button" aria-expanded="false" aria-haspopup="true" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-M-I-Kv-H" style="position: relative; display: inline-block; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-M-I-J6-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="J-J5-Ji J-Z-M-I-Jm" style="position: relative; display: inline-block; padding: 0px; margin: 0px; -webkit-user-select: none;">
+                                <div class="aaA aaB e4" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -273px 0px;"></div>
+                              </div>
+                              <div class="J-J5-Ji J-Z-M-I-JG" style="position: relative; display: inline-block; float: right; margin: 10px 2px 0px 3px; padding: 0px; opacity: 0.8; vertical-align: middle; width: 5px; height: 7px; -webkit-user-select: none; background: url(&quot;//ssl.gstatic.com/ui/v1/disclosure/small-grey-disclosure-arrow-down.png&quot;) 50% 50% no-repeat;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":18n" class="J-Z-aEu-I J-Z-I J-J5-Ji" command="+insertOrderedList" data-tooltip="Numbered List ‪(Ctrl-Shift-7)‬" aria-label="Numbered List ‪(Ctrl-Shift-7)‬" aria-pressed="false" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="e6  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -168px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":18o" class="J-Z-aEu-I J-Z-I J-J5-Ji" command="+insertUnorderedList" data-tooltip="Bulleted List ‪(Ctrl-Shift-8)‬" aria-label="Bulleted List ‪(Ctrl-Shift-8)‬" aria-pressed="false" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="eO  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -189px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":18p" class="J-Z-I J-J5-Ji" command="+outdent" data-tooltip="Indent Less ‪(Ctrl-[)‬" aria-label="Indent Less ‪(Ctrl-[)‬" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="e8  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -210px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":18q" class="J-Z-I J-J5-Ji" command="+indent" data-tooltip="Indent More ‪(Ctrl-])‬" aria-label="Indent More ‪(Ctrl-])‬" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="e2  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -231px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div id=":xg" class="J-Z-I J-J5-Ji" command="+BLOCKQUOTE" data-tooltip="Quote ‪(Ctrl-Shift-9)‬" aria-label="Quote ‪(Ctrl-Shift-9)‬" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="fa  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -252px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                        <div class="J-Z-axR J-J5-Ji" aria-disabled="true" role="separator" id=":1d7" style="position: relative; display: inline-block; border-left-width: 1px; border-left-style: solid; border-left-color: #cccccc; height: 17px; list-style: none; margin: 0px 2px; outline: none; overflow: hidden; padding: 0px; vertical-align: middle; width: 0px; -webkit-user-select: none;"></div>
+                        <div id=":t6" class="J-Z-I J-J5-Ji" command="+removeFormat" data-tooltip="Remove Formatting ‪(Ctrl-\)‬" aria-label="Remove Formatting ‪(Ctrl-\)‬" role="button" style="position: relative; display: inline-block; border-radius: 2px; -webkit-user-select: none; border: 1px solid transparent; outline: none; padding: 0px; height: 24px; color: #444444; line-height: 24px; list-style: none; font-size: 11px; font-weight: bold; vertical-align: middle; cursor: default; background: 0px 50%;">
+                          <div class="J-J5-Ji J-Z-I-Kv-H" style="position: relative; display: inline-block; border: 0px; vertical-align: top; margin: 0px; padding: 0px; -webkit-user-select: none;">
+                            <div class="J-J5-Ji J-Z-I-J6-H" style="position: relative; display: inline-block; padding: 0px 2px; -webkit-user-select: none;">
+                              <div class="fb  aaA aaB" style="height: 21px; width: 21px; vertical-align: middle; opacity: 0.55; margin: 2px 0px; -webkit-user-select: none; background-image: url(&quot;//ssl.gstatic.com/ui/v1/icons/mail/html_editor.png&quot;); background-position: -336px 0px;"></div>
+                            </div>
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </td>
+      </tr>
+    </tbody>
+  </table>
diff --git a/content/migrated_blog/ann_apache_isis_version_15.markdown b/content/migrated_blog/ann_apache_isis_version_15.markdown
new file mode 100644
index 0000000..823fdc0
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_15.markdown
@@ -0,0 +1,29 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.12.0 Released"
+date: '2016-03-29T18:03:03+00:00'
+permalink: ann_apache_isis_version_15
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis v1.12.0.</div> 
+  <div><br /></div> 
+  <div>New features in this release include:</div> 
+  <div><br /></div> 
+  <div> 
+    <ul> 
+      <li>much enhanced support for custom layouts, using an optional separate XML layout file <font face="courier new, courier, monospace">Xxx.layout.xml</font>. &nbsp;This is similar in concept to the earlier support we have had for custom layouts through a <font face="courier new, courier, monospace">.layout.json</font> file, but introduces the ability to position object members anywhere using (<a href="getbootstrap.com">bootstrap3</a>) columns and rows. &nbsp;It also brings in support for tab groups, and allows object members to be included in the page more than once (eg a table view and also a calendar view).</li> 
+      <li>a change to the editing of objects: rather than an 'edit' button which toggles the entire page into edit mode, instead each property is edited individually.</li> 
+      <li>various new domain services. &nbsp;Some of these are in supoprt of the dynamic layouts functionality, others including new access into Apache Isis' metamodel. &nbsp;In addition, the <font face="courier new, courier, monospace">DomainObjectContainer</font> service has been deprecated, replaced by a number of fine-grained services such as <font face="courier new, courier, monospace">RepositoryService</font>&nbsp;and <font face="courier new, courier, monospace">MessageService</font>.</li> 
+      <li>a number of new mixins, to automatically surface in the UI an entity's id, version (if any) as properties, and actions to download the layout XML and other metadata actions. &nbsp;(These can always be hidden using either security or by writing a subscriber; see the <a href="http://isis.apache.org/migration-notes.html#_migration-notes_1.11.0-to-1.12.0">migration notes</a>).</li> 
+      <li>JAXB view models are now automatically editable by default.</li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div><a href="http://isis.apache.org/release-notes.html#r1.12.0">Full release notes</a> are available on the Apache Isis website.</div> 
+  <div><br /></div> 
+  <div>You can access this release directly from the <a href="http://search.maven.org">Maven central repo</a>, or <a href="http://isis.apache.org/downloads.html">download the release</a> and build it from source.</div> 
+  <div><br /></div> 
+  <div>Enjoy!</div> 
+  <div><br /></div> 
+  <div>--The Apache Isis team</div> 
+  <div><br /></div> 
+  <div><br /></div>
diff --git a/content/migrated_blog/ann_apache_isis_version_16.markdown b/content/migrated_blog/ann_apache_isis_version_16.markdown
new file mode 100644
index 0000000..6f30766
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_16.markdown
@@ -0,0 +1,26 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.13.1 Released"
+date: '2016-10-30T08:37:01+00:00'
+permalink: ann_apache_isis_version_16
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis v1.13.1</div>
+  <div><br /></div>
+  <div>This is primarily a bug fix release, with several new features/improvements, including:</div>
+  <div><br /></div>
+  <div>* ISIS-1510 - Improve support for docker containers by allowing isis configuration properties to be overridden using either system properties or an ISIS_OPT environment variable</div>
+  <div>* ISIS-1499 - Improve BookmarkService to be able to &quot;lookup&quot; domain services, so that can schedule background commands against a service.</div>
+  <div>* ISIS-1508 - The integration test framework should be more resilient to badly behaved tests that leave the transaction incomplete</div>
+  <div><br /></div>
+  <div>Full release notes are available on the Apache Isis website at [1].</div>
+  <div><br /></div>
+  <div>You can access this release directly from the Maven central repo [2], or download the release and build it from</div>
+  <div>source [3].</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>--The Apache Isis team</div>
+  <div><br /></div>
+  <div>[1] http://isis.apache.org/release-notes.html#r1.13.1</div>
+  <div>[2] http://search.maven.org</div>
+  <div>[3] http://isis.apache.org/downloads.html</div>
diff --git a/content/migrated_blog/ann_apache_isis_version_17.markdown b/content/migrated_blog/ann_apache_isis_version_17.markdown
new file mode 100644
index 0000000..8c0e380
--- /dev/null
+++ b/content/migrated_blog/ann_apache_isis_version_17.markdown
@@ -0,0 +1,30 @@
+---
+layout: post
+title: "[ANN] Apache Isis version 1.13.2 Released"
+date: '2016-12-14T09:21:56+00:00'
+permalink: ann_apache_isis_version_17
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis v1.13.2.</div>
+  <div><br /></div>
+  <div>
+    <p>This is a maintenance release with a number of minor improvements and bug fixes.</p>
+    <p>Of these the main improvement is that the simpleapp archetype has been substantially reworked to be more modular. &nbsp;This release also closes the ticket to provide a better DB migration story; this has been implemented by way of the (non-ASF) Isis addons' <a href="http://github.com/isisaddons/isis-module-flywaydb">flywaydb module</a>.</p>
+  </div>
+  <div>Other improvements in this release include:</div>
+  <div>
+    <ul>
+      <li>Prevent double click on buttons</li>
+      <li>Use 'readonly' rather than 'disabled' tag (to allow copying of text)</li>
+      <li>More flexibility with the @Mixin annotation</li>
+      <li>Improve SudoService</li>
+    </ul>
+  </div>
+  <div><a href="http://isis.apache.org/release-notes.html#r1.13.2">Full release notes</a> are available on the Apache Isis website.</div>
+  <div><br /></div>
+  <div>You can access this release directly from the <a href="http://search.maven.org">Maven central repo</a>, or download the release and <a href="http://isis.apache.org/downloads.html">build it from source</a>.</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>--The Apache Isis team</div>
+  <div><br /></div>
+  <div><br /></div>
diff --git a/content/migrated_blog/ann_isis_1_3_0.markdown b/content/migrated_blog/ann_isis_1_3_0.markdown
new file mode 100644
index 0000000..030c3b6
--- /dev/null
+++ b/content/migrated_blog/ann_isis_1_3_0.markdown
@@ -0,0 +1,86 @@
+---
+layout: post
+title: "[ANN] Isis 1.3.0 released - crammed full of goodies!"
+date: '2013-10-25T17:54:42+00:00'
+permalink: ann_isis_1_3_0
+---
+<div>The Isis team is pleased to announce the release of:</div> 
+  <div><br /></div> 
+  <div> 
+    <ul> 
+      <li><span style="font-size: 13px;">Apache Isis Core version 1.3.0</span></li> 
+      <li><span style="font-size: 13px;">Wicket Viewer 1.3.0</span></li> 
+      <li><span style="font-size: 13px;">Restful Objects Viewer 2.1.0</span></li> 
+      <li><span style="font-size: 13px;">JDO Object Store 1.3.0</span></li> 
+      <li><span style="font-size: 13px;">Shiro Security 1.3.0</span></li> 
+      <li><span style="font-size: 13px;">Quickstart Archetype 1.3.0</span></li> 
+      <li><span style="font-size: 13px;">Simple Archetype 1.3.0</span></li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>There are some major new features in this release; indeed this is probably the most significant release of Isis as a TLP. &nbsp;In core, the new features include:</div> 
+  <div> 
+    <ul> 
+      <li><span style="font-size: 13px;">contributed collections and properties</span></li> 
+      <li><span style="font-size: 13px;">view model support (across both Wicket and RO viewers)</span></li> 
+      <li><span style="font-size: 13px;">UI layouts defined in JSON files</span></li> 
+      <li><span style="font-size: 13px;">better integration and BDD testing support, including Cucumber-JVM integration</span></li> 
+      <li><span style="font-size: 13px;">domain services for handling application and user settings service</span></li> 
+      <li><span style="font-size: 13px;">domain service providing various developer utilities (eg downloading metamodel)</span></li> 
+      <li><span style="font-size: 13px;">domain service incorporating Guava's EventBus service);&nbsp;</span></li> 
+      <li><span style="font-size: 13px;">context-specific autoComplete</span></li> 
+      <li><span style="font-size: 13px;">conditional choices</span></li> 
+      <li><span style="font-size: 13px;">new annotations: @SortedBy; @CssClass; @PostsPropertyChangedEvent</span></li> 
+      <li><span style="font-size: 13px;">helpers for writing contract unit tests and for writing comparable entities</span></li> 
+      <li><span style="font-size: 13px;">optimistic locking improvements</span></li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>In the Wicket viewer, new features include:</div> 
+  <div> 
+    <ul> 
+      <li><span style="font-size: 13px;">default dashboard</span></li> 
+      <li><span style="font-size: 13px;">more sophisticated layouts, with multiple columns</span></li> 
+      <li><span style="font-size: 13px;">dynamic reloading of layouts</span></li> 
+      <li><span style="font-size: 13px;">sortable table columns</span></li> 
+      <li><span style="font-size: 13px;">BlobPanel displaying images</span></li> 
+      <li><span style="font-size: 13px;">bookmarkable actions</span></li> 
+      <li><span style="font-size: 13px;">upgrade to wicket 6.11.0</span></li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>In JDO objectstore, new features include:</div> 
+  <div> 
+    <ul> 
+      <li><span style="font-size: 13px;">better integration/validation between Isis and JDO metamodels</span></li> 
+      <li><span style="font-size: 13px;">upgrade to DataNucleus 3.2.7</span></li> 
+      <li><span style="font-size: 13px;">better Google App Engine compatibility</span></li> 
+      <li><span style="font-size: 13px;">expose JDO PersistenceManager via domain service for more sophisticated use cases</span></li> 
+    </ul> 
+  </div> 
+  <div><br /></div> 
+  <div>The Restful Objects viewer also had several bug fixes vis-a-vis the RO spec v1.0 (thanks to our GSOC students for highlighting these).</div> 
+  <p> </p> 
+  <div> 
+    <p>In addition to all that, there is a new &quot;simple&quot; archetype, making it easier to get started.</p> 
+    <p> </p> 
+  </div> 
+  <p> </p> 
+  <div>Full release notes are available at [1,2,3,4,5,6,7] on the Isis website.</div> 
+  <div><br /></div> 
+  <div>You can access this release directly from the Maven central repo [8],&nbsp;</div> 
+  <div>or download the release and build it from source [9].</div> 
+  <div><br /></div> 
+  <div>Enjoy!</div> 
+  <div><br /></div> 
+  <div>-The Isis team</div> 
+  <div><br /></div> 
+  <div>[1] http://isis.apache.org/core/release-notes/isis-1.3.0.html</div> 
+  <div>[2] http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.3.0.html</div> 
+  <div>[3] http://isis.apache.org/components/viewers/restfulobjects/release-notes/isis-viewer-restfulobjects-2.1.0.html</div> 
+  <div>[4] http://isis.apache.org/components/objectstores/jdo/release-notes/isis-objectstore-jdo-1.3.0.html</div> 
+  <div>[5] http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.3.0.html</div> 
+  <div>[6] http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.3.0.html</div> 
+  <div>[7] http://isis.apache.org/getting-started/release-notes/simple_wrj-archetype-1.3.0.html</div> 
+  <div>[8] http://search.maven.org</div> 
+  <div>[9] http://isis.apache.org/download.html</div>
diff --git a/content/migrated_blog/ann_isis_1_4_0.markdown b/content/migrated_blog/ann_isis_1_4_0.markdown
new file mode 100644
index 0000000..96a1205
--- /dev/null
+++ b/content/migrated_blog/ann_isis_1_4_0.markdown
@@ -0,0 +1,79 @@
+---
+layout: post
+title: "[ANN] Isis 1.4.0 released - yet more cool stuff!"
+date: '2014-03-14T19:00:43+00:00'
+permalink: ann_isis_1_4_0
+---
+<div style="color: #222222; font-family: arial; font-size: small;">The Isis team is pleased to announce the release of:</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Core 1.4.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* JDO Object Store 1.4.1</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Wicket Viewer 1.4.1</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Restful Objects Viewer 2.2.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Shiro Security 1.4.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* File Security 1.4.0</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Quickstart Archetype 1.4.1</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">* Simple Archetype 1.4.1</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;">There are many new features in this release!</div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial; font-size: small;"> 
+    <div>For Isis core and also the JDO objectstore, these include:</div> 
+    <div><br /></div> 
+    <div>- extensions to .layout.json files for additional facets/UI hints</div> 
+    <div>- @javax.validation.constraints.<wbr />Digits for length/scale of BigDecimal action parameters</div> 
+    <div>- better reporting of metamodel validation errors (including a new page in Wicket viewer)</div> 
+    <div>- improved support for bulk update</div> 
+    <div>- @javax.enterprise.context.<wbr />RequestScoped for request-scoped services</div> 
+    <div>- QueryResultsCache request-scoped domain service (for performance tuning)</div> 
+    <div>- new MementoService to support view models</div> 
+    <div>- new request-scoped @Bulk.InteractionontextService for standardized co-ordination between bulk action invocations</div> 
+    <div>- Scratchpad request-scoped domain service (for adhoc coordination between actions, eg bulk action invocations)</div> 
+    <div>- Command, CommandContext, BackgroundCommandService, for profiling and background task support</div> 
+    <div>- improvements to JDO implementations of auditing and publishing services, to integrate closely with the new Command/backgroundCommand services</div> 
+    <div>- improved support for running arbitrary Isis jobs via a scheduler</div> 
+    <div>- UUID and URI value type support</div> 
+    <div>- supporting methods (disableXxx, validateXxx) for contributed actions/associations now supported</div> 
+    <div>- services autowired prior to @PostConstruct, and Isis session present for service initialization</div> 
+    <div>- JRebel support (JRebel plugni itself is third-party, see Isis website for details)</div> 
+    <div><br /></div> 
+    <div><br /></div> 
+    <div>New features in the Wicket viewer include:</div> 
+    <div><br /></div> 
+    <div>- show action dialogs in a modal dialog, rather than new page</div> 
+    <div>- limit number of bookmarks, make less easier to accidentally trip, show/hide with keyboard shortcut</div> 
+    <div>- improved IE9 support, bundle CSS files</div> 
+    <div>- simplify URLs in Wicket viewer</div> 
+    <div>- actions returning URL open new browser window</div> 
+    <div>- UI sorting/ordering hints, pop-up to copy to clipboard</div> 
+    <div>- breadcrumb drop-down to easily revisit previous page</div> 
+    <div>- upper/lower case now switchable</div> 
+    <div>- standalone tables now rendered according to runtime type, not compile-time type</div> 
+    <div>- better tooltips over icon/titles</div> 
+    <div>- widget for java.sql.Timestamp</div> 
+    <div><br /></div> 
+    <div><br /></div> 
+    <div>Full release notes are available at [1,2,3,4,5,6,7,8,9,10,11] on the Isis website.</div> 
+    <div><br /></div> 
+    <div>You can access this release directly from the Maven central repo [12],&nbsp;</div> 
+    <div>or download the release and build it from source [13].</div> 
+    <div><br /></div> 
+    <div>Enjoy!</div> 
+    <div><br /></div> 
+    <div>-The Isis team</div> 
+    <div><br /></div> 
+    <div>[1] <a href="http://isis.apache.org/core/release-notes/isis-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/core/<wbr />release-notes/isis-1.4.0.html</a></div> 
+    <div>[2] <a href="http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/wicket/<wbr />release-notes/isis-viewer-<wbr />wicket-1.4.0.html</a></div> 
+    <div>[3] <a href="http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.4.1.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/wicket/<wbr />release-notes/isis-viewer-<wbr />wicket-1.4.1.html</a></div> 
+    <div>[4] <a href="http://isis.apache.org/components/viewers/restfulobjects/release-notes/isis-viewer-restfulobjects-2.2.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/<wbr />restfulobjects/release-notes/<wbr />isis-viewer-restfulobjects-2.<wbr />2.0.html</a></div> 
+    <div>[5] <a href="http://isis.apache.org/components/objectstores/jdo/release-notes/isis-objectstore-jdo-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/objectstores/jdo/<wbr />release-notes/isis-<wbr />objectstore-jdo-1.4.0.html</a></div> 
+    <div>[6] <a href="http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/security/shiro/<wbr />release-notes/isis-security-<wbr />shiro-1.4.0.html</a></div> 
+    <div>[7] <a href="http://isis.apache.org/components/security/file/release-notes/isis-security-file-1.40.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/security/file/<wbr />release-notes/isis-security-<wbr />file-1.40.html</a></div> 
+    <div>[8] <a href="http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />quickstart_wrj-archetype-1.4.<wbr />0.html</a></div> 
+    <div>[9] <a href="http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.4.1.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />quickstart_wrj-archetype-1.4.<wbr />1.html</a></div> 
+    <div>[10] <a href="http://isis.apache.org/getting-started/release-notes/simple_wrj-archetype-1.4.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />simple_wrj-archetype-1.4.0.<wbr />html</a></div> 
+    <div>[11] <a href="http://isis.apache.org/getting-started/release-notes/simple_wrj-archetype-1.4.1.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />simple_wrj-archetype-1.4.1.<wbr />html</a></div> 
+    <div>[12] <a href="http://search.maven.org/" target="_blank" style="color: #1155cc;">http://search.maven.org</a></div> 
+    <div>[13] <a href="http://isis.apache.org/download.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />download.html</a></div> 
+  </div>
diff --git a/content/migrated_blog/ann_isis_shiro_security_1.markdown b/content/migrated_blog/ann_isis_shiro_security_1.markdown
new file mode 100644
index 0000000..3f7a5be
--- /dev/null
+++ b/content/migrated_blog/ann_isis_shiro_security_1.markdown
@@ -0,0 +1,27 @@
+---
+layout: post
+title: "[ANN] Isis Shiro Security 1.0.0 and Quickstart (Wicket/Restful/JDO) archetype
+  1.0.1 released"
+date: '2013-01-10T18:50:04+00:00'
+permalink: ann_isis_shiro_security_1
+---
+<p>
+The Isis team is pleased to announce the release of Apache Isis Shiro Security 1.0.0, along with an update to the Quickstart (Wicket/Restful/JDO) archetype, v1.0.1. </p>
+  <p>The main new feature is the integration of Apache Shiro [1], to be used for authentication and authorization.   The quickstart archetype has been updated to integrate this new component [2].  Full release notes are available at [3] on the Isis website. </p>
+  <p>In addition, the quickstart archetype has been simplified so that both the Wicket viewer [4] and the Restful Objects viewer [5] are run within the same webapp.  There is also a new welcome page to help new users get started. </p>
+  <p>There is one known minor issue: the links on the welcome page to the wicket viewer and restful objects viewer are incorrect if run outside of the root context.</p>
+  <p>You can access this release directly from the Maven central repo [6], or download the release and build it from source [7].</p>
+  <p>
+
+Enjoy!</p>
+  <p>-The Isis team</p>
+  <p>[1]&nbsp;http://shiro.apache.org</p>
+  <p>[2] http://isis.apache.org/components/security/shiro/about.html
+</p>
+  <p>[3] http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.0.0.html
+</p>
+  <p>[4] http://isis.apache.org/components/viewers/wicket/about.html
+</p>
+  <p>[5] http://isis.apache.org/components/viewers/restfulobjects/about.html</p>
+  <p>[6] http://search.maven.org</p>
+  <p>[7] http://isis.apache.org/download.html</p>
diff --git a/content/migrated_blog/ann_isis_wicket_viewer_1.markdown b/content/migrated_blog/ann_isis_wicket_viewer_1.markdown
new file mode 100644
index 0000000..e1a5e11
--- /dev/null
+++ b/content/migrated_blog/ann_isis_wicket_viewer_1.markdown
@@ -0,0 +1,27 @@
+---
+layout: post
+title: "[ANN] Isis Wicket Viewer 1.3.1 released, with updated archetypes"
+date: '2013-11-14T08:01:09+00:00'
+permalink: ann_isis_wicket_viewer_1
+---
+<div>The Isis team is pleased to announce the release of:</div>
+  <div>- Wicket Viewer 1.3.1</div>
+  <div>- Simple Archetype 1.3.1</div>
+  <div>- Quickstart Archetype 1.3.1</div>
+  <div><br /></div>
+  <div>This is primarily a bug patch of Wicket viewer; the only changes to the</div>
+  <div>archetypes are to update the dependency on the Wicket viewer. &nbsp;Full release</div>
+  <div>are available at [1][2][3] on the Isis website.</div>
+  <div><br /></div>
+  <div>You can access this release directly from the Maven central repo [4],&nbsp;</div>
+  <div>or download the release and build it from source [5].</div>
+  <div><br /></div>
+  <div>Enjoy!</div>
+  <div><br /></div>
+  <div>-The Isis team</div>
+  <div><br /></div>
+  <div>[1] http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.3.1.html</div>
+  <div>[2] http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.3.1.html</div>
+  <div>[3] http://isis.apache.org/getting-started/release-notes/simple_wrj-archetype-1.3.1.html</div>
+  <div>[4] http://search.maven.org</div>
+  <div>[5] http://isis.apache.org/download.html</div>
diff --git a/content/migrated_blog/ann_release_of_apache_isis.markdown b/content/migrated_blog/ann_release_of_apache_isis.markdown
new file mode 100644
index 0000000..a68dffb
--- /dev/null
+++ b/content/migrated_blog/ann_release_of_apache_isis.markdown
@@ -0,0 +1,54 @@
+---
+layout: post
+title: "[ANN] Release of Apache Isis Core 1.2.0 and components"
+date: '2013-05-31T13:01:18+00:00'
+permalink: ann_release_of_apache_isis
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">The Isis team is pleased to announce the release of:</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- Apache Isis Core version 1.2.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- Wicket Viewer 1.2.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- Restful Objects Viewer 2.0.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- JDO Object Store 1.1.0</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- Shiro Security 1.1.1</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- File Security 1.0.1</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- Quickstart Archetype 1.0.3<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">There have been many new features and improvements in this release. &nbsp;Some highlights include:</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core publishing service</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core pluggable recognition of exception handling</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core 'injectXxx()' new prefix for injecting services</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core @RenderAsDayBefore annotation</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core Comparable methods automatically hidden</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core AuditingService (promoted up from JDO)</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- core BookmarkService enhancements</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- wicket viewer reworked bookmarks</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- wicket viewer about page</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">- wicket viewer abbreviated titles, suppression of redundant columns in tables<br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">
+    <div>- wicket viewer automatic summarizing of tables</div>
+    <div>- wicket viewer info messages, warnings and errors via growl-style popups</div>
+    <div>- restful objects compliant(ish) with RO spec v1.0<br /></div>
+    <div>- restful objects rendering engine used for publishing service implementation</div>
+    <div>- restful objects eager rendering of collections</div>
+    <div>- jdo objectstore JNDI lookup</div>
+    <div>- jdo objectstore eager registering of entities</div>
+  </div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">Full release notes are available at [1,2,3,4,5,6,7] on the Isis website.</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">You can access this release directly from the Maven central repo [8],&nbsp;</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">or download the release and build it from source [9].</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">Enjoy!</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">-The Isis team</div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;"><br /></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[1] <a href="http://isis.apache.org/core/release-notes/isis-1.2.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/core/<wbr />release-notes/isis-1.2.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[2]&nbsp;<a href="http://isis.apache.org/components/viewers/wicket/release-notes/isis-viewer-wicket-1.2.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/wicket/<wbr />release-notes/isis-viewer-<wbr />wicket-1.2.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[3]&nbsp;<a href="http://isis.apache.org/components/viewers/restfulobjects/release-notes/isis-viewer-restfulobjects-2.0.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/viewers/<wbr />restfulobjects/release-notes/<wbr />isis-viewer-restfulobjects-2.<wbr />0.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[4]&nbsp;<a href="http://isis.apache.org/components/objectstores/jdo/release-notes/isis-objectstore-jdo-1.1.0.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/objectstores/jdo/<wbr />release-notes/isis-<wbr />objectstore-jdo-1.1.0.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[5]&nbsp;<a href="http://isis.apache.org/components/security/shiro/release-notes/isis-security-shiro-1.1.1.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/security/shiro/<wbr />release-notes/isis-security-<wbr />shiro-1.1.1.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[6]&nbsp;<a href="http://isis.apache.org/components/security/file/release-notes/isis-security-file-1.0.1.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />components/security/file/<wbr />release-notes/isis-security-<wbr />file-1.0.1.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[7]&nbsp;<a href="http://isis.apache.org/getting-started/release-notes/quickstart_wrj-archetype-1.0.3.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />getting-started/release-notes/<wbr />quickstart_wrj-archetype-1.0.<wbr />3.html</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[8] <a href="http://search.maven.org/" target="_blank" style="color: #1155cc;">http://search.maven.org</a></div>
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: 13.333333969116211px;">[9] <a href="http://isis.apache.org/download.html" target="_blank" style="color: #1155cc;">http://isis.apache.org/<wbr />download.html</a></div>
diff --git a/content/migrated_blog/announce_new_committer_bilgin_ibryam.markdown b/content/migrated_blog/announce_new_committer_bilgin_ibryam.markdown
new file mode 100644
index 0000000..629dc5d
--- /dev/null
+++ b/content/migrated_blog/announce_new_committer_bilgin_ibryam.markdown
@@ -0,0 +1,30 @@
+---
+layout: post
+title: "[ANNOUNCE] New Committer - Bilgin Ibryam"
+date: '2016-11-09T12:27:51+00:00'
+permalink: announce_new_committer_bilgin_ibryam
+---
+<div style="color: #222222; font-family: arial, sans-serif; font-size: small;">I'm delighted to announce that Bilgin Ibryam has been voted in as a committer on Apache Isis, and also as a member of the Isis PMC. &nbsp;The first gives Bilgin the right to commit changes directly to the Apache Isis codebase, the second gives him the right to be involved in future votes.</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Bilgin is already a committer on both the Apache Camel [1,2,3] project and also for Apache Ofbiz [4, 5, 6]. &nbsp;He also recently wrote &quot;Camel Design Patterns&quot; book, via leanpub [7]. &nbsp;He works in London for RedHat [7]. &nbsp;</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Bilgin has been aware of Apache Isis for a long while; in fact it was he who introduced the predecessor - naked objects framework - to Jeroen, from whence the Estatio project (a major driver for the development of Apache Isis) was spawned.</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">More recently Bilgin has started contributing to the mailing list and started providing a number of pull requests [9]. &nbsp;He is also using Apache Isis for some internal projects within RedHat, which may help spread knowledge of the framework to a wider open-source community.</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">I'm looking forward to working with Bilgin in the future; another great addition to Isis' committers. &nbsp;So please join me in welcoming him to our happy band!</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Dan Haywood</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">Apache Isis PMC Chair</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;"><br /></div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[1] http://camel.apache.org/</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[2] https://github.com/apache/camel/graphs/contributors</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[3] http://camel.apache.org/team.html</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[4] http://ofbiz.apache.org/</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[5] https://github.com/apache/ofbiz/graphs/contributors</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[6] https://cwiki.apache.org/confluence/display/OFBADMIN/Apache+OFBiz+PMC+Members+and+Committers</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[7] https://leanpub.com/u/bibryam</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[8] http://developers.redhat.com/blog/author/bibryam/</div> 
+  <div style="color: #222222; font-family: arial, sans-serif; font-size: small;">[9] https://github.com/apache/isis/graphs/contributors</div> 
+  <div><br /></div>
diff --git a/content/migrated_blog/announce_new_committer_for_apache.markdown b/content/migrated_blog/announce_new_committer_for_apache.markdown
new file mode 100644
index 0000000..f0c10b9
--- /dev/null
+++ b/content/migrated_blog/announce_new_committer_for_apache.markdown
@@ -0,0 +1,20 @@
+---
+layout: post
+title: "[ANN] New committer for Apache Isis - Martin Grigorov"
+date: '2014-12-04T15:34:43+00:00'
+permalink: announce_new_committer_for_apache
+---
+<p>
+I'm delighted to announce that Martin Grigorov has been voted in as a committer on <a href="http://isis.apache.org/">Apache Isis</a>, and also as a member of the Isis PMC.  The first gives Martin the right to commit changes directly to Isis' codebase, the second gives him the right to be involved in future votes.
+
+</p> 
+  <p>Martin is already a <a href="https://github.com/apache/wicket/graphs/contributors">key committer</a> on the&nbsp;http://wicket.apache.org/&nbsp;project, as well as <a href="https://github.com/l0rdn1kk0n/wicket-bootstrap/graphs/contributors">actively contributing</a> to the companion <a href="https://github.com/l0rdn1kk0n/wicket-bootstrap">Wicket-bootstrap</a> project. &nbsp;If you're a subscriber to the <a href="http://isis.apache.org/support.html">Isis mailing lists</a>&nbsp;you also wouldn't have failed to have noticed his involvement in users and dev lists recently.</p> 
+  <p>Initially Martin got involved because Jeroen and I asked him to help <a href="https://issues.apache.org/jira/browse/ISIS-537">bootstrappify</a>&nbsp;the Wicket viewer.  Even though that piece of work is substantially complete, Martin continues to be actively involved, providing patches and working on other tickets, and from speaking with him I know he's keen to get involved with all aspects of Isis, not just the Wicket viewer.  For recent contributions, check out these <a href="https://github.com/apache/isis/graphs/contributors">github statistics</a> [6] and his <a href="https://issues.apache.org/jira/secure/ViewProfile.jspa?name=mgrigorov">activity stream</a> on JIRA.</p> 
+  <p>I'm looking forward to working with Martin in the future; another great addition to Isis' committers.  So please join me in welcoming him to our happy band!
+</p> 
+  <p>
+Dan Haywood</p> 
+  <p>Apache Isis PMC Chair
+
+</p> 
+  <p><br /></p>
diff --git a/content/migrated_blog/apache-causeway-version-2-0.markdown b/content/migrated_blog/apache-causeway-version-2-0.markdown
new file mode 100644
index 0000000..05e4657
--- /dev/null
+++ b/content/migrated_blog/apache-causeway-version-2-0.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: Apache Causeway version 2.0.0-RC1 Released
+date: '2023-03-26T14:36:22+00:00'
+permalink: apache-causeway-version-2-0
+---
+<p>T<span style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;">he Apache Causeway team is pleased to announce the release of Apache Causeway 2.0.0-RC1.</span></p><br style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"><span style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;">The main highlight is the change of name (to the new name 'causeway', from the old name 'isis'), which means that all Maven artifacts as well as package names have changed.&nbsp; The migration notes [1] explain how to update your code; if you need assistance then reach out through the mailing list [2] or our slack channel [3] because we can explain how to tackle change in stages.</span><div style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"><br><div>In addition, there are a small number of new features in this release, as well as numerous improvements and bug fixes.&nbsp; The new features include:<br><br>* a new PageRenderSubscriber SPI provides callbacks to track the time taken to render a page (CAUSEWAY-3373)</div><div>* a new service to generate HTML documentation based on the domain model (CAUSEWAY-3328)<br></div><div><div>* the simplification of the view model lifecycle by allowing injected dependencies to be specified as constructor parameters (CAUSEWAY-3293)<br></div><div>* a new BackgroundService that allows actions to be executed via a Quartz job (CAUSEWAY-3267)</div><div>* allowing SAFE semantics actions to be invoked with only VIEWING permission (CAUSEWAY-3358)</div><br>Full release notes are available on the Apache Causeway website at [4].<br><br>You can access this release directly from the Maven central repo [5].<br>Alternatively, download the release and build it from source [6].<br><br>Enjoy!<br><br>--The Apache Causeway team<br><br>[1]&nbsp;<a href="https://causeway.apache.org/relnotes/2.0.0-RC1/2023/2.0.0-RC1/mignotes.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://causeway.apache.org/relnotes/2.0.0-RC1/2023/2.0.0-RC1/mignotes.html&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw0XvSu8Ylp7dz7AeonzPYpX" style="color: rgb(17, 85, 204);">https://causeway.apache.<wbr>org/relnotes/2.0.0-RC1/2023/2.<wbr>0.0-RC1/mignotes.html</a></div><div>[2]&nbsp;<a href="https://causeway.apache.org/docs/2.0.0-RC1/support/mailing-list.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://causeway.apache.org/docs/2.0.0-RC1/support/mailing-list.html&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw3CLPDncqOJHph2XHvKGeVJ" style="color: rgb(17, 85, 204);">https://causeway.apache.<wbr>org/docs/2.0.0-RC1/support/<wbr>mailing-list.html</a></div><div>[3]&nbsp;<a href="https://causeway.apache.org/docs/2.0.0-RC1/support/slack-channel.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://causeway.apache.org/docs/2.0.0-RC1/support/slack-channel.html&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw05lwDvbMN1KDIX9uwfRV5z" style="color: rgb(17, 85, 204);">https://causeway.apache.<wbr>org/docs/2.0.0-RC1/support/<wbr>slack-channel.html</a></div><div>[4]&nbsp;<a href="https://causeway.apache.org/relnotes/2.0.0-RC1/about.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://causeway.apache.org/relnotes/2.0.0-RC1/about.html&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw196GLkfcTgyhkc106OJ3VS" style="color: rgb(17, 85, 204);">https://causeway.apache.org/<wbr>relnotes/2.0.0-RC1/about.html</a><br>[5]&nbsp;<a href="https://search.maven.org/" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://search.maven.org&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw385d99A1SYKByJh5CuRGSO" style="color: rgb(17, 85, 204);">https://search.maven.org</a><br>[6]&nbsp;<a href="https://causeway.apache.org/docs/2.0.0-RC1/downloads/how-to.html" target="_blank" data-saferedirecturl="https://www.google.com/url?q=https://causeway.apache.org/docs/2.0.0-RC1/downloads/how-to.html&amp;source=gmail&amp;ust=1679927583803000&amp;usg=AOvVaw3rDX4HZ74yaWWvh2pmWmI4" style="color: rgb(17, 85, 204);">https://causeway.apache.org/<wbr>docs/2.0.0-RC1/downloads/how-<wbr>to.html</a></div></div>
diff --git a/content/migrated_blog/apache-isis-version-2-0.markdown b/content/migrated_blog/apache-isis-version-2-0.markdown
new file mode 100644
index 0000000..5782761
--- /dev/null
+++ b/content/migrated_blog/apache-isis-version-2-0.markdown
@@ -0,0 +1,7 @@
+---
+layout: post
+title: Apache Isis version 2.0.0-M9 Released
+date: '2022-10-18T13:15:08+00:00'
+permalink: apache-isis-version-2-0
+---
+<div>The Apache Isis team is pleased to announce the release of Apache Isis 2.0.0-M9.<br><br>This is primarily a security release, to fix an XSS vulnerability (CVE-2022-42466).&nbsp; There are one or two other small improvements and bug fixes.</div><div><br></div><div>Full release notes are available on the Apache Isis website at [1].<br><br>You can access this release directly from the Maven central repo [2].<br>Alternatively, download the release and build it from source [3].<br><br>--The Apache Isis team<br><br>[1] https://isis.apache.org/relnotes/2.0.0-M9/about.html<br>[2] https://search.maven.org<br>[3] https://isis.apache.org/docs/2.0.0-M9/downloads/how-to.html<br></div><div><br style="color: rgb(34, 34, 34); font-family: Arial, Helvetica, sans-serif; font-size: small;"></div>
diff --git a/content/migrated_blog/apache_isis_0_2_0.markdown b/content/migrated_blog/apache_isis_0_2_0.markdown
new file mode 100644
index 0000000..8fbdf81
--- /dev/null
+++ b/content/migrated_blog/apache_isis_0_2_0.markdown
@@ -0,0 +1,25 @@
+---
+layout: post
+title: Apache Isis 0.2.0-incubating
+date: '2012-02-27T08:39:28+00:00'
+permalink: apache_isis_0_2_0
+---
+<p>Just a quick announcement that last week we put out our second release of <a href="http://incubator.apache.org/isis" title="Apache Isis (incubating)" target="_blank">Apache Isis</a> from the incubator, namely 0.2.0-incubating.
+
+</p>
+  <p>The main theme in this release is to try to simplify things a little, so that would-be users can more easily grok what Isis is about:
+</p>
+  <ul> 
+    <li>We've updated the website, hopefully explaining better what Isis is and what use cases it hits.</li> 
+    <li>we now have the <a href="http://mmyco.co.uk:8180/isis-onlinedemo" title="Isis online demo" target="_blank">online demo</a> linked directly from the website.</li> 
+    <li>the archetype has also been reworked; rather than have a module for each of the viewers, we've reduced the number of viewers (just HTML viewer and JSON viewer) and put them into a single webapp module.</li> 
+  </ul> 
+  <p>You can read full release notes <a href="http://incubator.apache.org/isis/release-notes-0.2.0-incubating.html" title="Isis 0.2.0-incubating" target="_blank">here</a>.
+
+</p>
+  <p>And, as for all Isis releases, the release can be found in the <a href="http://search.maven.org" target="_blank">Maven central repo</a>, you can use the Maven archetype to create a <a href="http://incubator.apache.org/isis/quick-start.html" target="_blank">quickstart app</a>, or you can <a href="http://incubator.apache.org/isis/downloads.html" target="_blank">download the release</a> and build it from source.
+
+</p>
+  <p>By the way, work is well under way on the next release, where the plan is to re-introduce the Scimpi viewer to the archetype, and also to bring in NoSQL (MongoDB) support.
+
+</p>
diff --git a/content/migrated_blog/google_open_source_blogpost_on.markdown b/content/migrated_blog/google_open_source_blogpost_on.markdown
new file mode 100644
index 0000000..d02f056
--- /dev/null
+++ b/content/migrated_blog/google_open_source_blogpost_on.markdown
@@ -0,0 +1,20 @@
+---
+layout: post
+title: Google Open Source blogpost on ASF's GSOC2013 participants
+date: '2013-10-07T06:36:58+00:00'
+permalink: google_open_source_blogpost_on
+---
+<p>The <a href="http://google-opensource.blogspot.co.uk/">Google open source blog</a> has just <a href="http://google-opensource.blogspot.co.uk/2013/10/google-summer-of-code-veteran-orgs.html">posted the write-up</a> that ASF provided on some of its students for GSOC 2013. I contributed a couple of paragraphs on how <a href="http://isis.apache.org">Apache Isis</a>' two students, Dimuthu Upeksha and Bhargav Golla, got on.
+
+</p>
+  <p>Here's what I said:
+
+</p>
+  <blockquote>Apache Isis -- Students: Bhargav Golla and Dimuthu Upeksha
+
+
+    <p>Apache Isis is a Java framework for rapidly developing domain-driven apps. This summer we had two students working on new “viewers” that interact with a REST API that Isis automatically generates, reflecting the structure and behavior of the domain objects. In the past the Isis community has worked on single-page HTML5/JS viewer and on a Windows Store App viewer. For Google Summer of Code our two students are each building their own viewers, one for Android, and one using JQueryMobile (to be packaged using Apache Cordova/PhoneGap).
+</p>
+    <p>
+Both students have become quite fluent in the REST API, and both have a viewer running that is quite usable and can be deployed to an Android mobile device. The two viewers are broadly similar in terms of features implemented, and indeed towards the end of the project hit the limits of the available features in the REST API. Both students have said they are keen to continue developing their viewers after the Google Summer of Code program ends.</p>
+  </blockquote>
diff --git a/content/migrated_blog/infoq_article_introducing_restful_objects.markdown b/content/migrated_blog/infoq_article_introducing_restful_objects.markdown
new file mode 100644
index 0000000..9f9b22f
--- /dev/null
+++ b/content/migrated_blog/infoq_article_introducing_restful_objects.markdown
@@ -0,0 +1,21 @@
+---
+layout: post
+title: InfoQ article introducing Restful Objects (implemented by Apache Isis)
+date: '2012-07-19T11:53:48+00:00'
+permalink: infoq_article_introducing_restful_objects
+---
+<div style="font-family: arial; font-size: small; "> 
+    <p>Just to say that InfoQ have posted an article [1] that introduces the Restful Objects spec [2],&nbsp;and its two implementations, Apache Isis [3] being one of them.</p> 
+  </div> 
+  <div style="font-family: arial; font-size: small; ">Restful Objects is all about providing a hypermedia API from a domain model. &nbsp;In the case of Isis, this is done automatically, leveraging its internal metamodel. &nbsp;</div> 
+  <div style="font-family: arial; font-size: small; "> 
+    <p>Because Restful Objects is a spec, it also opens up possibilities for independently developed clients (eg Javascript) and server implementations; indeed this is already happening and has brought some &quot;new blood&quot; into our community. &nbsp;</p> 
+    <p>Anyway, if the idea of marrying up REST and domain models&nbsp;sounds of interest, check out the article.</p> 
+  </div> 
+  <div style="font-family: arial; font-size: small; "><br /></div> 
+  <div style="font-family: arial; font-size: small; ">Dan Haywood<br />committer: Apache Isis (incubating)&nbsp;</div> 
+  <div style="font-family: arial; font-size: small; "><br /></div> 
+  <div style="font-family: arial; font-size: small; "><br /></div> 
+  <div style="font-family: arial; font-size: small; ">[1]&nbsp;<a href="http://www.infoq.com/articles/Intro_Restful_Objects">http://www.infoq.com/articles/Intro_Restful_Objects</a></div> 
+  <div style="font-family: arial; font-size: small; ">[2]&nbsp;<a href="http://restfulobjects.org/">http://restfulobjects.org/</a></div> 
+  <div style="font-family: arial; font-size: small; ">[3]&nbsp;<a href="http://incubator.apache.org/isis/">http://incubator.apache.org/isis/</a></div>
diff --git a/content/migrated_blog/jquerymobile_demo_app_now_included.markdown b/content/migrated_blog/jquerymobile_demo_app_now_included.markdown
new file mode 100644
index 0000000..bfbfe2e
--- /dev/null
+++ b/content/migrated_blog/jquerymobile_demo_app_now_included.markdown
@@ -0,0 +1,10 @@
+---
+layout: post
+title: JQueryMobile demo app now included in the online demo
+date: '2012-02-01T23:42:43+00:00'
+permalink: jquerymobile_demo_app_now_included
+---
+<p>
+If you're interested in REST or in mobile apps, you might want to check out two recent blogs posts&nbsp;which highlight a <a href="http://mmyco.co.uk:8180/isis-onlinedemo" target="_blank">demo app</a> written in JQueryMobile, and consume the <a href="http://restfulobjects.org" target="_blank">RESTful API</a> provided by the Apache Isis json-viewer.&nbsp;</p> 
+  <p>The <a href="http://danhaywood.com/2012/01/20/jquerymobile-on-apache-isis-rest-api/">first of the blog posts</a> shows&nbsp;some screenshots of the new app in action, while the <a href="http://danhaywood.com/2012/02/01/jquerymobile-demo-app-walkthr/">second post</a> has a fairly detailed code walk-thru of that app. &nbsp;</p> 
+  <p><br /></p>
diff --git a/content/migrated_blog/marrying_dhtmlx_with_apache_isis.markdown b/content/migrated_blog/marrying_dhtmlx_with_apache_isis.markdown
new file mode 100644
index 0000000..c8f01be
--- /dev/null
+++ b/content/migrated_blog/marrying_dhtmlx_with_apache_isis.markdown
@@ -0,0 +1,11 @@
+---
+layout: post
+title: Marrying DHTMLX with Apache Isis
+date: '2013-02-26T21:20:19+00:00'
+permalink: marrying_dhtmlx_with_apache_isis
+---
+<p>Mylaensys have just publicised on <a href="http://blog.mylaensys.com/2013/02/about-apache-isis.html">their blog</a> the fact that they are working on an integration between&nbsp;<a href="http://dhtmlx.com/">DHTMLX</a>&nbsp;and <a href="http://isis.apache.org">Apache Isis</a>.&nbsp;</p>
+  <p>They previously have integrated DHTMLX&nbsp;and Spring Framework (<a href="http://www.mylaensys.com/dhtmlx-spring-integration.html">DHTMLX Spring Link</a>), so they have a proven track record... and I've been impressed how quickly they've produced some early prototypes.</p>
+  <p>If the idea of rapidly building domain-driven apps with a customizable UI appeals, then keep an eye on their progress through the Apache <a href="http://isis.apache.org/support.html">Isis mailing lists</a>.
+
+</p>
diff --git a/content/migrated_blog/online_demo_now_available.markdown b/content/migrated_blog/online_demo_now_available.markdown
new file mode 100644
index 0000000..06e2617
--- /dev/null
+++ b/content/migrated_blog/online_demo_now_available.markdown
@@ -0,0 +1,14 @@
+---
+layout: post
+title: Online Demo now available
+date: '2011-12-09T08:17:16+00:00'
+permalink: online_demo_now_available
+---
+<a href="http://mmyco.co.uk:8180/isis-onlinedemo/"><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; "><img src="http://danhaywood.files.wordpress.com/2011/12/apacheisisonlinedemoscreenshot.png?w=150" align="right" style="border-width: initial; border-color: initial; border-width: initial; border-color: initial; border-width: initial; border-color: initial; border-width: initial; border-color: initial; " /></span> </a>
+  <p><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">We'v</span><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">e finally got around to putting together an online demo of </span><a title="Apache Isis" href="http://incubator.apache.org/isis" target="_blank" data-mce-href="http://incubator.apache.org/isis" style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">Apache Isis</a><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">&nbsp;for would-be users to quickly grok what Isis&nbsp;</span><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">&nbsp;is a</span><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">ll about. If you don't fancy reading any further but just want to play, you can find it&nbsp;</span><a title="here" href="http://mmyco.co.uk:8180/isis-onlinedemo/" target="_blank" data-mce-href="http://mmyco.co.uk:8180/isis-onlinedemo/" style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">here</a><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">.</span></p> 
+  <div> </div> 
+  <div> 
+    <p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">If you're still with me, you'll find that the online demo shows how Isis can dynamically generate a (human-usable) webapp and a (machine-usable) RESTful API from the same domain object model. The REST API is that&nbsp;defined by the <a title="Restful Objects" href="http://restfulobjects.org/" target="_blank" data-mce-href="http://restfulobjects.org">Restful Objects</a> spec.</p> 
+    <p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">The online demo bundles its own documentation, which shows the full source code for the domain model (all 3 classes) along with guidance on how to use Chrome (or similar) extensions to play with the REST API directly from your browser.</p> 
+    <p><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">Feedback very welcome on the</span><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; "> </span><a title="isis-dev" href="mailto:isis-dev@incubator.apache.org" target="_blank" data-mce-href="mailto:isis-dev@incubator.apache.org" style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">isis-dev</a><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; "> </span><span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">mailing list.</span> </p> 
+  </div>
diff --git a/content/migrated_blog/rad_race_2015_7_proprietary.markdown b/content/migrated_blog/rad_race_2015_7_proprietary.markdown
new file mode 100644
index 0000000..0bef565
--- /dev/null
+++ b/content/migrated_blog/rad_race_2015_7_proprietary.markdown
@@ -0,0 +1,22 @@
+---
+layout: post
+title: 'RAD RACE 2015: 7 proprietary CASE tools, and Apache Isis'
+date: '2015-10-03T15:01:33+00:00'
+permalink: rad_race_2015_7_proprietary
+---
+<p>
+On Sept 25th and 26th we (Jeroen van der Wal &amp; Dan Haywood) took part in the Original RAD Race competition. This is a competition staged each year, this year (as in previous years) hosted and sponsored by Cap Gemini, and held in their offices in Utrecht, Netherlands.&nbsp;</p> 
+  <p>The competition consists of teams of exactly two team members; there were eight in total. The competition is held under very strict conditions: 8 hours of development on the first day, and a further 4 hours of coding the next. If you do the maths you’ll work out that means a sum total of 24 hours (2 team members x 12 hours), or 3 person-days.
+
+</p> 
+  <p>We asked and were granted permission to develop our application as open source; our entry is in a <a href="https://github.com/incodehq/radrace2015">github repo</a>. If you look through the commit history you’ll see that all the work was done in those 12 hours (8 on 25 Sept 2015, a further 4 on 26 Sept).
+
+All the other teams used proprietary tools such as NoutBuilder, ThinkWise, Progress, SalesForce, Uniface and Mendix. We were the only open source entry, using <a href="http://isis.apache.org/">Apache Isis</a> (along with supporting modules in <a href="http://www.isisaddons.org/">Isis Addons</a>); in fact we think we are the first open source entry in the 17 years history of the competition.
+</p> 
+  <p>
+OK, we didn’t win…​  but we got the impression we were mid-table, which we think is pretty good in the face of the competition. But you can judge for yourself; either download and build the code, or simply take a look at the various screenshots/our commentary on the <a href="https://github.com/incodehq/radrace2015">README of the repo</a>.</p> 
+  <p>
+
+The README also has some of our &quot;learnings&quot; that we concluded from taking part in the competition.</p>
+  <p><br /></p>
+  <p><br /></p>
diff --git a/content/migrated_blog/restful_objects.markdown b/content/migrated_blog/restful_objects.markdown
new file mode 100644
index 0000000..74a6689
--- /dev/null
+++ b/content/migrated_blog/restful_objects.markdown
@@ -0,0 +1,21 @@
+---
+layout: post
+title: Restful Objects
+date: '2011-08-03T13:02:38+00:00'
+permalink: restful_objects
+---
+<span style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; "> 
+    <p>Now that we have our <a title="Apache Isis 0.1.2 (incubating)&nbsp;Released" href="http://danhaywood.com/2011/07/18/apache-isis-0-1-2-incubating-released/" data-mce-href="http://danhaywood.com/2011/07/18/apache-isis-0-1-2-incubating-released/">first release of Apache Isis</a> out of the door, I've been spending some time on&nbsp;<a title="Restful Objects" href="http://restfulobjects.org/" data-mce-href="http://restfulobjects.org/">Restful Objects</a>, which forms the basis of the <a title="Apache Isis JSON Viewer" href="http://incubator.apache.org/isis/viewer/json/index.html" data-mce-href="http://incubator.apache.org/isis/viewer/json/index.html">JSON viewer</a> within Isis.</p> 
+    <p>The idea of Restful Objects&nbsp;is to provide a standard, generic RESTful interface for domain object models, exposing representations of their structure using JSON and enabling interactions with domain object instances using HTTP GET, POST, PUT and DELETE.</p> 
+    <p><img class="mceWPmore mceItemNoResize" title="More..." src="http://danhaywood.wordpress.com/wp-includes/js/tinymce/plugins/wordpress/img/trans.gif" data-mce-src="http://danhaywood.wordpress.com/wp-includes/js/tinymce/plugins/wordpress/img/trans.gif" style="border-top-width: 1px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; border-style: initial; border-color: initial; border-top-style: dotted; border-top-color: #cccccc; display: block; width: 792px; height: 12px; margin-top: 15px; margin-right: auto; margin-bottom: 0px; margin-left: auto; background-image: url(http://danhaywood.wordpress.com/wp-includes/js/tinymce/plugins/wordpress/img/more_bug.gif); background-attachment: initial; background-origin: initial; background-clip: initial; background-color: transparent; background-position: 100% 0%; background-repeat: no-repeat no-repeat; " />The <a title="Restful Objects" href="http://restfulobjects.org/" data-mce-href="http://restfulobjects.org/">Restful Objects</a> website is a place where the specification will be documented as it evolves, and if you take a look through the spec as it stands you may realize that it's very much based on the idea of a domain model as envisaged by naked objects. &nbsp; That is:</p> 
+    <ul> 
+      <li>the start page provides links to the set of registered services/repositories</li> 
+      <li>from these services, references to domain object instances can be obtained</li> 
+      <li>each domain object has properties, collections and actions</li> 
+      <li>the usual business rules (hiding, disabling and validating) are supported</li> 
+      <li>actions (idempotent or non-idempotent) can be invoked</li> 
+    </ul> 
+    <p>More generally, you'll see that all the representations are fully self-describing, opening up the possibility of generic viewers to be implemented if required, eg in languages such as HTML5/Ajax, Flex, Silverlight etc etc.</p> 
+    <p>Alternatively, the representations can be consumed directly by a bespoke application.</p> 
+    <p>One of the nice things about this specification is that it is completely language-independent. &nbsp;As you might expect, I'll be implementing this specification through the Isis JSON viewer, and using that implementation to refine the spec. &nbsp;In addition Richard Pawson is hoping to commit to working on a similar implementation for <a title="Naked Objects MVC" href="http://nakedobjects.net/" data-mce-href="http://nakedobjects.net">Naked Objects MVC</a> (he's a co-author on the Restful Objects site).</p> 
+    <p>And, if you know of or are the author of another naked objects-style framework, eg written in Ruby or Python, and the idea of Restful Objects interests you, then I'd love to hear from you.</p></span>
diff --git a/content/migrated_blog/updated_apache_isis_presentations.markdown b/content/migrated_blog/updated_apache_isis_presentations.markdown
new file mode 100644
index 0000000..a556a37
--- /dev/null
+++ b/content/migrated_blog/updated_apache_isis_presentations.markdown
@@ -0,0 +1,10 @@
+---
+layout: post
+title: Updated Apache Isis Presentations
+date: '2011-12-16T07:29:56+00:00'
+permalink: updated_apache_isis_presentations
+---
+<p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">If you're thinking of introducing <a title="Apache Isis" href="http://incubator.apache.org/isis" target="_blank" data-mce-href="http://incubator.apache.org/isis">Apache Isis</a> to your co-workers, you might be interested to know that Isis already has an &quot;Introducing Apache Isis&quot; presentation slide deck (in <a href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.odp" target="_blank" data-mce-href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.odp">ODP</a>,&nbsp;&nbsp;<a href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.pptx" target="_blank" data-mce-href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.pptx">PPTX</a>&nbsp;or&nbsp;<a href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.ppt" target="_blank" data-mce-href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis.ppt">PPT</a>,&nbsp;PDF <a href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis-slides.pdf" target="_blank" data-mce-href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis-slides.pdf">slides</a> or <a href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis-notes.pdf" target="_blank" data-mce-href="http://incubator.apache.org/isis/presentations/IntroducingApacheIsis-notes.pdf">notes</a>). &nbsp;You are free to use this as you will.</p> 
+  <p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">I've just updated the deck in line with the forthcoming v0.2.0 release; the most significant new content includes an overview of the main use cases for Apache Isis. &nbsp;The <a title="Apache Isis Online Demo" href="http://mmyco.co.uk:8180/isis-onlinedemo" target="_blank" data-mce-href="http://mmyco.co.uk:8180/isis-onlinedemo">online demo</a> for Isis also gets a link.</p> 
+  <p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; "><a href="http://danhaywood.files.wordpress.com/2011/12/isisusecases.png" data-mce-href="http://danhaywood.files.wordpress.com/2011/12/isisusecases.png"><img class=" wp-image-853 alignnone" title="IsisUseCases" src="http://danhaywood.files.wordpress.com/2011/12/isisusecases.png?w=300" width="450" height="177" data-mce-src="http://danhaywood.files.wordpress.com/2011/12/isisusecases.png?w=300" style="border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-style: initial; border-color: initial; " /></a></p> 
+  <p style="font-family: Georgia, 'Times New Roman', 'Bitstream Charter', Times, serif; line-height: 19px; ">As ever, feedback welcome!</p>
diff --git a/content/migrated_blog/welcoming_oscar_bou_as_a.markdown b/content/migrated_blog/welcoming_oscar_bou_as_a.markdown
new file mode 100644
index 0000000..d696057
--- /dev/null
+++ b/content/migrated_blog/welcoming_oscar_bou_as_a.markdown
@@ -0,0 +1,16 @@
+---
+layout: post
+title: Welcoming Oscar Bou as a new committer to Apache Isis
+date: '2013-08-12T10:11:02+00:00'
+permalink: welcoming_oscar_bou_as_a
+---
+<p>I'm delighted to announce that Oscar Bou has been voted in as a committer on <a href="http://isis.apache.org" target="_blank">Apache Isis</a>, and also to as a member of the Isis PMC. The first gives Oscar the right to commit changes directly to Isis' codebase, the second gives him the right to be involved in future votes.
+
+</p>
+  <p>Oscar has ticked the boxes in terms of being a committer: using the mailing lists appropriately, raising JIRA tickets, provided patches to address specific issues, providing help to others in the community. But he's gone beyond that in raising a number of insightful - sometimes challenging - questions regarding Isis' design/responsibilities as a framework, and shown that he's keen to address these issues and thus improve Isis as a product.
+
+</p>
+  <p>I'm looking forward to working with Oscar in the future; another great addition to Isis' committers.
+
+</p><hr /> 
+  <p>As a bit of tidying up, we have also voted for Jeroen van der Wal, and Maurizio Taverna, to be members of the Isis PMC.</p>
