diff --git a/logback-access/pom.xml b/logback-access/pom.xml
index ba1802104688f790cddfb1aac055195549faac8d..422bb0b9fb58e7a8380fa0c1afd0b4e1f4b93a96 100755
--- a/logback-access/pom.xml
+++ b/logback-access/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-parent</artifactId>
-    <version>1.1.4</version>
+    <version>1.1.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>logback-access</artifactId>
diff --git a/logback-classic/pom.xml b/logback-classic/pom.xml
index ca4af6357ca20946a66b33976cb4a284e6299f4b..bb22539ab2d47b26d14a1f49e82d158a1fcc9670 100755
--- a/logback-classic/pom.xml
+++ b/logback-classic/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-parent</artifactId>
-    <version>1.1.4</version>
+    <version>1.1.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>logback-classic</artifactId>
diff --git a/logback-core/pom.xml b/logback-core/pom.xml
index e7d15c53d2bb6c6915740fa1fb66b32d7eb041a3..2b8cb576870218472f37007a6011df855adaaaa6 100755
--- a/logback-core/pom.xml
+++ b/logback-core/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-parent</artifactId>
-    <version>1.1.4</version>
+    <version>1.1.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>logback-core</artifactId>
diff --git a/logback-core/src/test/java/ch/qos/logback/core/AsyncAppenderBaseTest.java b/logback-core/src/test/java/ch/qos/logback/core/AsyncAppenderBaseTest.java
index 5306df896927a85a4aee769313cb80f919fb19bf..d87d2aafec9bd8d75fedd1c5824d3cd2b1d51f74 100755
--- a/logback-core/src/test/java/ch/qos/logback/core/AsyncAppenderBaseTest.java
+++ b/logback-core/src/test/java/ch/qos/logback/core/AsyncAppenderBaseTest.java
@@ -13,274 +13,266 @@
  */
 package ch.qos.logback.core;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
 import ch.qos.logback.core.helpers.NOPAppender;
 import ch.qos.logback.core.read.ListAppender;
-import ch.qos.logback.core.testUtil.DelayingListAppender;
 import ch.qos.logback.core.status.OnConsoleStatusListener;
 import ch.qos.logback.core.status.StatusChecker;
+import ch.qos.logback.core.testUtil.DelayingListAppender;
 import ch.qos.logback.core.testUtil.NPEAppender;
 
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 /**
  * @author Ceki G&uuml;lc&uuml;
  * @author Torsten Juergeleit
  */
 public class AsyncAppenderBaseTest {
 
-	Context context = new ContextBase();
-	AsyncAppenderBase<Integer> asyncAppenderBase = new AsyncAppenderBase<Integer>();
-	LossyAsyncAppender lossyAsyncAppender = new LossyAsyncAppender();
-	DelayingListAppender<Integer> delayingListAppender = new DelayingListAppender<Integer>();
-	ListAppender<Integer> listAppender = new ListAppender<Integer>();
-	OnConsoleStatusListener onConsoleStatusListener = new OnConsoleStatusListener();
-	StatusChecker statusChecker = new StatusChecker(context);
-
-	@Before
-	public void setUp() {
-		onConsoleStatusListener.setContext(context);
-		context.getStatusManager().add(onConsoleStatusListener);
-		onConsoleStatusListener.start();
-
-		asyncAppenderBase.setContext(context);
-		lossyAsyncAppender.setContext(context);
-
-		listAppender.setContext(context);
-		listAppender.setName("list");
-		listAppender.start();
-
-		delayingListAppender.setContext(context);
-		delayingListAppender.setName("list");
-		delayingListAppender.start();
-	}
-
-	@Test(timeout = 2000)
-	public void smoke() {
-		asyncAppenderBase.addAppender(listAppender);
-		asyncAppenderBase.start();
-		asyncAppenderBase.doAppend(0);
-		asyncAppenderBase.stop();
-		verify(listAppender, 1);
-	}
-
-	@Test
-	public void exceptionsShouldNotCauseHalting() throws InterruptedException {
-		NPEAppender<Integer> npeAppender = new NPEAppender<Integer>();
-		npeAppender.setName("bad");
-		npeAppender.setContext(context);
-		npeAppender.start();
-
-		asyncAppenderBase.addAppender(npeAppender);
-		asyncAppenderBase.start();
-		assertTrue(asyncAppenderBase.isStarted());
-		for (int i = 0; i < 10; i++)
-			asyncAppenderBase.append(i);
-
-		asyncAppenderBase.stop();
-		assertFalse(asyncAppenderBase.isStarted());
-		assertEquals(AppenderBase.ALLOWED_REPEATS,
-				statusChecker
-						.matchCount("Appender \\[bad\\] failed to append."));
-	}
-
-	@Test(timeout = 2000)
-	public void emptyQueueShouldBeStoppable() {
-		asyncAppenderBase.addAppender(listAppender);
-		asyncAppenderBase.start();
-		asyncAppenderBase.stop();
-		verify(listAppender, 0);
-	}
-
-	@Test(timeout = 2000)
-	public void workerShouldStopEvenIfInterruptExceptionConsumedWithinSubappender() {
-		delayingListAppender.delay = 100;
-		asyncAppenderBase.addAppender(delayingListAppender);
-		asyncAppenderBase.start();
-		asyncAppenderBase.doAppend(0);
-		asyncAppenderBase.stop();
-		verify(delayingListAppender, 1);
-		assertTrue(delayingListAppender.interrupted);
-	}
-
-	@Test(timeout = 2000)
-	public void noEventLoss() {
-		int bufferSize = 10;
-		int loopLen = bufferSize * 2;
-		asyncAppenderBase.addAppender(delayingListAppender);
-		asyncAppenderBase.setQueueSize(bufferSize);
-		asyncAppenderBase.start();
-		for (int i = 0; i < loopLen; i++) {
-			asyncAppenderBase.doAppend(i);
-		}
-		asyncAppenderBase.stop();
-		verify(delayingListAppender, loopLen);
-	}
-
-	@Test(timeout = 2000)
-	public void eventLossIfNeverBlock() {
-		int bufferSize = 10;
-		int loopLen = bufferSize * 2;
-		delayingListAppender.setDelay(5000); // something greater than the test timeout
-		asyncAppenderBase.addAppender(delayingListAppender);
-		asyncAppenderBase.setQueueSize(bufferSize);
-		asyncAppenderBase.setNeverBlock(true);
-		asyncAppenderBase.start();
-		for (int i = 0; i < loopLen; i++) {
-			asyncAppenderBase.doAppend(i);
-		}
-		asyncAppenderBase.stop();
-		// ListAppender size isn't a reliable test here, so just make sure we didn't
-		// have any errors, and that we could complete the test in time.
-		statusChecker.assertIsErrorFree();
-	}
-
-	@Test(timeout = 2000)
-	public void lossyAppenderShouldOnlyLooseCertainEvents() {
-		int bufferSize = 5;
-		int loopLen = bufferSize * 2;
-		lossyAsyncAppender.addAppender(delayingListAppender);
-		lossyAsyncAppender.setQueueSize(bufferSize);
-		lossyAsyncAppender.setDiscardingThreshold(1);
-		lossyAsyncAppender.start();
-		for (int i = 0; i < loopLen; i++) {
-			lossyAsyncAppender.doAppend(i);
-		}
-		lossyAsyncAppender.stop();
-		verify(delayingListAppender, loopLen - 2);
-	}
-
-	@Test(timeout = 2000)
-	public void lossyAppenderShouldBeNonLossyIfDiscardingThresholdIsZero() {
-		int bufferSize = 5;
-		int loopLen = bufferSize * 2;
-		lossyAsyncAppender.addAppender(delayingListAppender);
-		lossyAsyncAppender.setQueueSize(bufferSize);
-		lossyAsyncAppender.setDiscardingThreshold(0);
-		lossyAsyncAppender.start();
-		for (int i = 0; i < loopLen; i++) {
-			lossyAsyncAppender.doAppend(i);
-		}
-		lossyAsyncAppender.stop();
-		verify(delayingListAppender, loopLen);
-	}
-
-	@Test
-	public void invalidQueueCapacityShouldResultInNonStartedAppender() {
-		asyncAppenderBase.addAppender(new NOPAppender<Integer>());
-		asyncAppenderBase.setQueueSize(0);
-		assertEquals(0, asyncAppenderBase.getQueueSize());
-		asyncAppenderBase.start();
-		assertFalse(asyncAppenderBase.isStarted());
-		statusChecker.assertContainsMatch("Invalid queue size");
-	}
-
-	@SuppressWarnings("deprecation")
-	@Test
-	public void workerThreadFlushesOnStop() {
-		int loopLen = 5;
-		int maxRuntime = (loopLen + 1)
-				* Math.max(1000, delayingListAppender.delay);
-		ListAppender<Integer> la = delayingListAppender;
-		asyncAppenderBase.addAppender(la);
-		asyncAppenderBase.setDiscardingThreshold(0);
-		asyncAppenderBase.setMaxFlushTime(maxRuntime);
-		asyncAppenderBase.start();
-		asyncAppenderBase.worker.suspend();
-
-		for (int i = 0; i < loopLen; i++) {
-			asyncAppenderBase.doAppend(i);
-		}
-		assertEquals(loopLen, asyncAppenderBase.getNumberOfElementsInQueue());
-		assertEquals(0, la.list.size());
-
-		asyncAppenderBase.worker.resume();
-		asyncAppenderBase.stop();
-
-		assertEquals(0, asyncAppenderBase.getNumberOfElementsInQueue());
-		verify(la, loopLen);
-	}
-
-	@SuppressWarnings("deprecation")
-	@Test
-	public void stopExitsWhenMaxRuntimeReached() throws InterruptedException {
-		int maxRuntime = 1; // runtime of 0 means wait forever, so use 1 ms
-							// instead
-		int loopLen = 10;
-		ListAppender<Integer> la = delayingListAppender;
-		asyncAppenderBase.addAppender(la);
-		asyncAppenderBase.setMaxFlushTime(maxRuntime);
-		asyncAppenderBase.start();
-
-		for (int i = 0; i < loopLen; i++) {
-			asyncAppenderBase.doAppend(i);
-		}
-
-		asyncAppenderBase.stop();
-
-		// suspend the thread so that we can make the following assertions
-		// without race conditions
-		asyncAppenderBase.worker.suspend();
-
-		// confirms that stop exited when runtime reached
-		statusChecker.assertContainsMatch("Max queue flush timeout \\("
-				+ maxRuntime + " ms\\) exceeded.");
-
-		// confirms that the number of events posted are the number of events
-		// removed from the queue
-		assertEquals(la.list.size(),
-				loopLen - asyncAppenderBase.getNumberOfElementsInQueue());
-
-		// resume the thread to let it finish processing
-		asyncAppenderBase.worker.resume();
-
-		asyncAppenderBase.worker.join();
-
-		// confirms that all entries do end up being flushed if we wait long
-		// enough
-		verify(la, loopLen);
-	}
-
-
-	// Interruption of current thread when in doAppend method should not be consumed
-	// by async appender. See also http://jira.qos.ch/browse/LOGBACK-910
-	@Test
-	public void verifyInterruptionIsNotSwallowed() {
-		asyncAppenderBase.addAppender(delayingListAppender);
-		asyncAppenderBase.start();
-		Thread.currentThread().interrupt();
-		asyncAppenderBase.doAppend(new Integer(0));
-		assertTrue(Thread.currentThread().isInterrupted());
-		// clear flag for next test
-		Thread.interrupted();
-	}
-	
-	@Test
-	public void verifyInterruptionOfWorkerIsSwallowed() {
-      asyncAppenderBase.addAppender(delayingListAppender);
-	  asyncAppenderBase.start();
-	  asyncAppenderBase.stop();
-	  assertFalse(asyncAppenderBase.worker.isInterrupted());
-	}
-	
-	
-	private void verify(ListAppender<Integer> la, int expectedSize) {
-		assertFalse(la.isStarted());
-		assertEquals(expectedSize, la.list.size());
-		statusChecker.assertIsErrorFree();
-		statusChecker
-				.assertContainsMatch("Worker thread will flush remaining events before exiting.");
-	}
-
-	static class LossyAsyncAppender extends AsyncAppenderBase<Integer> {
-		@Override
-		protected boolean isDiscardable(Integer i) {
-			return (i % 3 == 0);
-		}
-	}
+    Context context = new ContextBase();
+    AsyncAppenderBase<Integer> asyncAppenderBase = new AsyncAppenderBase<Integer>();
+    LossyAsyncAppender lossyAsyncAppender = new LossyAsyncAppender();
+    DelayingListAppender<Integer> delayingListAppender = new DelayingListAppender<Integer>();
+    ListAppender<Integer> listAppender = new ListAppender<Integer>();
+    OnConsoleStatusListener onConsoleStatusListener = new OnConsoleStatusListener();
+    StatusChecker statusChecker = new StatusChecker(context);
+
+    @Before
+    public void setUp() {
+        onConsoleStatusListener.setContext(context);
+        context.getStatusManager().add(onConsoleStatusListener);
+        onConsoleStatusListener.start();
+
+        asyncAppenderBase.setContext(context);
+        lossyAsyncAppender.setContext(context);
+
+        listAppender.setContext(context);
+        listAppender.setName("list");
+        listAppender.start();
+
+        delayingListAppender.setContext(context);
+        delayingListAppender.setName("list");
+        delayingListAppender.start();
+    }
+
+    @Test(timeout = 2000)
+    public void smoke() {
+        asyncAppenderBase.addAppender(listAppender);
+        asyncAppenderBase.start();
+        asyncAppenderBase.doAppend(0);
+        asyncAppenderBase.stop();
+        verify(listAppender, 1);
+    }
+
+    @Test
+    public void exceptionsShouldNotCauseHalting() throws InterruptedException {
+        NPEAppender<Integer> npeAppender = new NPEAppender<Integer>();
+        npeAppender.setName("bad");
+        npeAppender.setContext(context);
+        npeAppender.start();
+
+        asyncAppenderBase.addAppender(npeAppender);
+        asyncAppenderBase.start();
+        assertTrue(asyncAppenderBase.isStarted());
+        for (int i = 0; i < 10; i++)
+            asyncAppenderBase.append(i);
+
+        asyncAppenderBase.stop();
+        assertFalse(asyncAppenderBase.isStarted());
+        assertEquals(AppenderBase.ALLOWED_REPEATS, statusChecker.matchCount("Appender \\[bad\\] failed to append."));
+    }
+
+    @Test(timeout = 2000)
+    public void emptyQueueShouldBeStoppable() {
+        asyncAppenderBase.addAppender(listAppender);
+        asyncAppenderBase.start();
+        asyncAppenderBase.stop();
+        verify(listAppender, 0);
+    }
+
+    @Test(timeout = 2000)
+    public void workerShouldStopEvenIfInterruptExceptionConsumedWithinSubappender() {
+        delayingListAppender.delay = 100;
+        asyncAppenderBase.addAppender(delayingListAppender);
+        asyncAppenderBase.start();
+        asyncAppenderBase.doAppend(0);
+        asyncAppenderBase.stop();
+        verify(delayingListAppender, 1);
+        assertTrue(delayingListAppender.interrupted);
+    }
+
+    @Test(timeout = 2000)
+    public void noEventLoss() {
+        int bufferSize = 10;
+        int loopLen = bufferSize * 2;
+        asyncAppenderBase.addAppender(delayingListAppender);
+        asyncAppenderBase.setQueueSize(bufferSize);
+        asyncAppenderBase.start();
+        for (int i = 0; i < loopLen; i++) {
+            asyncAppenderBase.doAppend(i);
+        }
+        asyncAppenderBase.stop();
+        verify(delayingListAppender, loopLen);
+    }
+
+    @Test(timeout = 2000)
+    public void eventLossIfNeverBlock() {
+        int bufferSize = 10;
+        int loopLen = bufferSize * 200;
+        delayingListAppender.setDelay(5); // (loopLen*delay) much bigger than test timeout
+        asyncAppenderBase.addAppender(delayingListAppender);
+        asyncAppenderBase.setQueueSize(bufferSize);
+        asyncAppenderBase.setNeverBlock(true);
+        asyncAppenderBase.start();
+        for (int i = 0; i < loopLen; i++) {
+            asyncAppenderBase.doAppend(i);
+        }
+        asyncAppenderBase.stop();
+        // ListAppender size isn't a reliable test here, so just make sure we didn't
+        // have any errors, and that we could complete the test in time.
+        statusChecker.assertIsErrorFree();
+    }
+
+    @Test(timeout = 2000)
+    public void lossyAppenderShouldOnlyLooseCertainEvents() {
+        int bufferSize = 5;
+        int loopLen = bufferSize * 2;
+        lossyAsyncAppender.addAppender(delayingListAppender);
+        lossyAsyncAppender.setQueueSize(bufferSize);
+        lossyAsyncAppender.setDiscardingThreshold(1);
+        lossyAsyncAppender.start();
+        for (int i = 0; i < loopLen; i++) {
+            lossyAsyncAppender.doAppend(i);
+        }
+        lossyAsyncAppender.stop();
+        verify(delayingListAppender, loopLen - 2);
+    }
+
+    @Test(timeout = 2000)
+    public void lossyAppenderShouldBeNonLossyIfDiscardingThresholdIsZero() {
+        int bufferSize = 5;
+        int loopLen = bufferSize * 2;
+        lossyAsyncAppender.addAppender(delayingListAppender);
+        lossyAsyncAppender.setQueueSize(bufferSize);
+        lossyAsyncAppender.setDiscardingThreshold(0);
+        lossyAsyncAppender.start();
+        for (int i = 0; i < loopLen; i++) {
+            lossyAsyncAppender.doAppend(i);
+        }
+        lossyAsyncAppender.stop();
+        verify(delayingListAppender, loopLen);
+    }
+
+    @Test
+    public void invalidQueueCapacityShouldResultInNonStartedAppender() {
+        asyncAppenderBase.addAppender(new NOPAppender<Integer>());
+        asyncAppenderBase.setQueueSize(0);
+        assertEquals(0, asyncAppenderBase.getQueueSize());
+        asyncAppenderBase.start();
+        assertFalse(asyncAppenderBase.isStarted());
+        statusChecker.assertContainsMatch("Invalid queue size");
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void workerThreadFlushesOnStop() {
+        int loopLen = 5;
+        int maxRuntime = (loopLen + 1) * Math.max(1000, delayingListAppender.delay);
+        ListAppender<Integer> la = delayingListAppender;
+        asyncAppenderBase.addAppender(la);
+        asyncAppenderBase.setDiscardingThreshold(0);
+        asyncAppenderBase.setMaxFlushTime(maxRuntime);
+        asyncAppenderBase.start();
+        asyncAppenderBase.worker.suspend();
+
+        for (int i = 0; i < loopLen; i++) {
+            asyncAppenderBase.doAppend(i);
+        }
+        assertEquals(loopLen, asyncAppenderBase.getNumberOfElementsInQueue());
+        assertEquals(0, la.list.size());
+
+        asyncAppenderBase.worker.resume();
+        asyncAppenderBase.stop();
+
+        assertEquals(0, asyncAppenderBase.getNumberOfElementsInQueue());
+        verify(la, loopLen);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void stopExitsWhenMaxRuntimeReached() throws InterruptedException {
+        int maxRuntime = 1; // runtime of 0 means wait forever, so use 1 ms
+        // instead
+        int loopLen = 10;
+        ListAppender<Integer> la = delayingListAppender;
+        asyncAppenderBase.addAppender(la);
+        asyncAppenderBase.setMaxFlushTime(maxRuntime);
+        asyncAppenderBase.start();
+
+        for (int i = 0; i < loopLen; i++) {
+            asyncAppenderBase.doAppend(i);
+        }
+
+        asyncAppenderBase.stop();
+
+        // suspend the thread so that we can make the following assertions
+        // without race conditions
+        asyncAppenderBase.worker.suspend();
+
+        // confirms that stop exited when runtime reached
+        statusChecker.assertContainsMatch("Max queue flush timeout \\(" + maxRuntime + " ms\\) exceeded.");
+
+        // confirms that the number of events posted are the number of events
+        // removed from the queue
+        assertEquals(la.list.size(), loopLen - asyncAppenderBase.getNumberOfElementsInQueue());
+
+        // resume the thread to let it finish processing
+        asyncAppenderBase.worker.resume();
+
+        asyncAppenderBase.worker.join();
+
+        // confirms that all entries do end up being flushed if we wait long
+        // enough
+        verify(la, loopLen);
+    }
+
+    // Interruption of current thread when in doAppend method should not be
+    // consumed
+    // by async appender. See also http://jira.qos.ch/browse/LOGBACK-910
+    @Test
+    public void verifyInterruptionIsNotSwallowed() {
+        asyncAppenderBase.addAppender(delayingListAppender);
+        asyncAppenderBase.start();
+        Thread.currentThread().interrupt();
+        asyncAppenderBase.doAppend(new Integer(0));
+        assertTrue(Thread.currentThread().isInterrupted());
+        // clear flag for next test
+        Thread.interrupted();
+    }
+
+    @Test
+    public void verifyInterruptionOfWorkerIsSwallowed() {
+        asyncAppenderBase.addAppender(delayingListAppender);
+        asyncAppenderBase.start();
+        asyncAppenderBase.stop();
+        assertFalse(asyncAppenderBase.worker.isInterrupted());
+    }
+
+    private void verify(ListAppender<Integer> la, int expectedSize) {
+        assertFalse(la.isStarted());
+        assertEquals(expectedSize, la.list.size());
+        statusChecker.assertIsErrorFree();
+        statusChecker.assertContainsMatch("Worker thread will flush remaining events before exiting.");
+    }
+
+    static class LossyAsyncAppender extends AsyncAppenderBase<Integer> {
+        @Override
+        protected boolean isDiscardable(Integer i) {
+            return (i % 3 == 0);
+        }
+    }
 }
diff --git a/logback-examples/pom.xml b/logback-examples/pom.xml
index 8c86e7e6f9c4bcd66b2965ef9f368e228d2b6a55..15ac31948c75388bc743fba33172b18a8936a863 100755
--- a/logback-examples/pom.xml
+++ b/logback-examples/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-parent</artifactId>
-    <version>1.1.4</version>
+    <version>1.1.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>logback-examples</artifactId>
diff --git a/logback-site/pom.xml b/logback-site/pom.xml
index 1d5b8dc1ecaec7fa556659577ac8713ae8520838..de54b1f2f0b2d6ad24b28aa85d4388de9f9097c3 100644
--- a/logback-site/pom.xml
+++ b/logback-site/pom.xml
@@ -7,7 +7,7 @@
   <parent>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-parent</artifactId>
-    <version>1.1.4</version>
+    <version>1.1.5-SNAPSHOT</version>
   </parent>
 
   <artifactId>logback-site</artifactId>
diff --git a/logback-site/src/site/pages/news.html b/logback-site/src/site/pages/news.html
index c449554ef8971996083f5291fca675f10aa74865..380ae664f5ce328dfd247e5b4034d32e6c01fc3c 100755
--- a/logback-site/src/site/pages/news.html
+++ b/logback-site/src/site/pages/news.html
@@ -29,6 +29,17 @@
 
     <hr width="80%" align="center" />
     
+    <h3>2016, Release of version 1.1.5</h3>
+
+
+    <p>AsyncAppender is now configurable to never block. This feature
+    was requested by Jeff Wartes in <a
+    href="http://jira.qos.ch/browse/LOGBACK-898">LOGBACK-898</a> with
+    Jeff Wartes and Gareth Davis providing the relevant patch.
+    </p>
+
+    <hr width="80%" align="center" />
+    
     <h3>February 11th, 2016, Release of version 1.1.4</h3>
 
     <div class="breaking">
diff --git a/pom.xml b/pom.xml
index 872f1845fbc23db22ca099efe077f07e9f5c4662..fa1cf49e668f3801356f9303914d98791e2311f2 100755
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
   <groupId>ch.qos.logback</groupId>
   <artifactId>logback-parent</artifactId>
-  <version>1.1.4</version>
+  <version>1.1.5-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Logback-Parent</name>
   <description>logback project pom.xml file</description>
diff --git a/release.sh b/release.sh
index 7685ce78387412a16763c981c031e31bedea70d6..c6a9c2a2ccebbfb65a139a0166b11f1e2537b75e 100755
--- a/release.sh
+++ b/release.sh
@@ -1,6 +1,6 @@
 # memory aid 
 
-mvn versions:set -DnewVersion=${VERSION_NUMBER} -DgenerateBackupPoms=false
+mvn versions:set -DgenerateBackupPoms=false -DnewVersion=${VERSION_NUMBER} 
 
 mvn clean
 mvn install
@@ -14,7 +14,7 @@ mvn deploy -P javadocjar,sign-artifacts
 #uncomment diffie-hellman support in /etc/ssh/sshd_config
 mvn site:deploy -N
 
-git tag -a v_${VERSION_NUMBER}
+git tag -m "tagging" -a v_${VERSION_NUMBER}
 git push --tags
 
 release version and add next version on jira