From b7033da88c0b3101235ecdbb7bb60e358e9f5af4 Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 09:48:37 +0000
Subject: [PATCH 01/11] checking in a failing test so that roman can take a
 look at it.

---
 .../chronicle/map/ChronicleMapTest.java       | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index 941a1cf87..a5334bc91 100755
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -1487,8 +1487,31 @@ public class ChronicleMapTest {
 
         }
 
+
     }
 
+
+    @Test
+    public void testOnheapAcquireUsingLockedStringBuilder() throws IOException {
+
+        try (final ChronicleMap<CharSequence, StringBuilder> map = ChronicleMapBuilder
+                .of(CharSequence.class, StringBuilder.class)
+                .entries(1000)
+                .defaultValue(new StringBuilder())
+                .entrySize(40).create()) {
+
+            StringBuilder value = new StringBuilder();
+
+
+            try (WriteContext<?, StringBuilder> context = map.acquireUsingLocked("one", value)) {
+                value.append("Hello World");
+            }
+
+            assertEquals("Hello World", value.toString());
+        }
+    }
+
+
     @Test
     public void testOnheapAcquireUsingLocked() throws IOException {
         ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder

From 0fd6e98bed0d07092a53c9de67d6c4c36a1b330f Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 11:58:12 +0000
Subject: [PATCH 02/11] HCOLL-81 StatelessClient : Add a visitor pattern to
 Chronicle Map ( tested with lamda expressions in java8 )

---
 .../net/openhft/chronicle/java8/Function.java | 27 +++++++++++++++++
 .../chronicle/map/StatelessChronicleMap.java  |  7 +++--
 .../openhft/chronicle/map/TcpReplicator.java  | 11 +++++--
 .../chronicle/map/VanillaChronicleMap.java    | 29 +++++++++++++++++++
 .../chronicle/map/ChronicleMapTest.java       |  2 +-
 .../chronicle/map/StatelessClientTest.java    | 26 +++++++++++++++--
 6 files changed, 92 insertions(+), 10 deletions(-)
 create mode 100644 src/main/java/net/openhft/chronicle/java8/Function.java

diff --git a/src/main/java/net/openhft/chronicle/java8/Function.java b/src/main/java/net/openhft/chronicle/java8/Function.java
new file mode 100644
index 000000000..9cb4e1ca4
--- /dev/null
+++ b/src/main/java/net/openhft/chronicle/java8/Function.java
@@ -0,0 +1,27 @@
+package net.openhft.chronicle.java8;
+
+import java.io.Serializable;
+
+/**
+ * Represents a function that accepts one argument and produces a result.
+ *
+ * <p>This is a <a href="package-summary.html">functional interface</a> whose functional method is {@link
+ * #apply(Object)}.
+ *
+ * @param <T> the type of the input to the function
+ * @param <R> the type of the result of the function
+ * @since 1.8
+ */
+@FunctionalInterface
+public interface Function<T, R> extends Serializable {
+
+    /**
+     * Applies this function to the given argument.
+     *
+     * @param t the function argument
+     * @return the function result
+     */
+    R apply(T t);
+
+
+}
diff --git a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
index 9c10faa0f..667d0a6ae 100644
--- a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
@@ -20,6 +20,7 @@ package net.openhft.chronicle.map;
 
 import com.sun.jdi.connect.spi.ClosedConnectionException;
 import net.openhft.chronicle.hash.RemoteCallTimeoutException;
+import net.openhft.chronicle.java8.Function;
 import net.openhft.lang.io.ByteBufferBytes;
 import net.openhft.lang.io.Bytes;
 import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -35,7 +36,6 @@ import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.channels.SocketChannel;
 import java.util.*;
-import java.util.function.Function;
 
 import static java.nio.ByteBuffer.allocateDirect;
 import static net.openhft.chronicle.map.AbstractChannelReplicator.SIZE_OF_SIZE;
@@ -468,9 +468,9 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
 
 
     private <R> void writeObject(@NotNull Function<V, R> function) {
+        long start   = bytes.position();
         for (; ; ) {
             try {
-
                 bytes.writeObject(function);
                 return;
             } catch (IllegalStateException e) {
@@ -480,6 +480,8 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
                 if (cause instanceof IOException && cause.getMessage().contains("Not enough available space")) {
                     LOG.debug("resizing buffer");
                     resizeBuffer(buffer.capacity() + 1024);
+                    bytes.limit(bytes.capacity());
+                    bytes.position(start);
 
                 } else
                     throw e;
@@ -557,7 +559,6 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
 
             writeKey(key, local);
 
-
             final V value = e.getValue();
 
             final Class<?> valueClass = value.getClass();
diff --git a/src/main/java/net/openhft/chronicle/map/TcpReplicator.java b/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
index dff0d86e6..b86f16cd1 100644
--- a/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
+++ b/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
@@ -21,6 +21,7 @@ package net.openhft.chronicle.map;
 import net.openhft.chronicle.hash.replication.RemoteNodeValidator;
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.hash.replication.ThrottlingConfig;
+import net.openhft.chronicle.java8.Function;
 import net.openhft.lang.io.ByteBufferBytes;
 import net.openhft.lang.io.Bytes;
 import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -38,7 +39,6 @@ import java.nio.channels.*;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Function;
 
 import static java.nio.channels.SelectionKey.*;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -1350,10 +1350,15 @@ class StatelessServerConnector<K, V> {
 
         V value = using.getAndSet(null);
         if (value == null) {
-            // a simple way to create a value
-            value = map.getUsing(key, null);
+
+            //value = map.createValueInstance();
+
+            // todo replace this
+            value = map.acquireUsing(key, null);
         }
 
+
+
         final Function<V, ?> o = (Function<V, ?>) reader.readObject();
 
         try (WriteContext<K, V> wc = map.acquireUsingLocked(key, value)) {
diff --git a/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java b/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
index d8e45fb3a..400b55c2e 100755
--- a/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
@@ -29,7 +29,10 @@ import net.openhft.lang.collection.DirectBitSet;
 import net.openhft.lang.collection.SingleThreadedDirectBitSet;
 import net.openhft.lang.io.*;
 import net.openhft.lang.io.serialization.JDKObjectSerializer;
+import net.openhft.lang.io.serialization.impl.AllocateInstanceObjectFactory;
 import net.openhft.lang.io.serialization.impl.VanillaBytesMarshallerFactory;
+import net.openhft.lang.model.Byteable;
+import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.model.constraints.Nullable;
 import net.openhft.lang.threadlocal.Provider;
 import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -349,6 +352,32 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
                 replaceIfPresent);
     }
 
+
+    V createValueInstance() {
+
+        if (vClass.isAssignableFrom(Byteable.class))
+            return DataValueClasses.newDirectReference(vClass);
+        else {
+
+
+            try {
+                return vClass.newInstance();
+            } catch (InstantiationException e) {
+                try {
+                    return (V) (new AllocateInstanceObjectFactory<V>(vClass)).create();
+                } catch (Exception e1) {
+                    LOG.error("", e);
+                    return null;
+                }
+            } catch (IllegalAccessException e) {
+                LOG.error("", e);
+                return null;
+            }
+
+
+        }
+    }
+
     enum LockType {READ_LOCK, WRITE_LOCK}
 
     @Override
diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index a5334bc91..fc4b0d2d3 100755
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -1497,7 +1497,7 @@ public class ChronicleMapTest {
         try (final ChronicleMap<CharSequence, StringBuilder> map = ChronicleMapBuilder
                 .of(CharSequence.class, StringBuilder.class)
                 .entries(1000)
-                .defaultValue(new StringBuilder())
+
                 .entrySize(40).create()) {
 
             StringBuilder value = new StringBuilder();
diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index db8a40030..884b369fd 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -19,17 +19,16 @@
 package net.openhft.chronicle.map;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
+import net.openhft.chronicle.java8.Function;
 import org.junit.Assert;
 import org.junit.Test;
 
 import java.io.IOException;
-import java.io.Serializable;
 import java.net.InetSocketAddress;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Function;
 
 
 /**
@@ -41,7 +40,7 @@ public class StatelessClientTest {
     public static final int SIZE = 100000;
 
 
-    static class StringBuilderToStringFunction implements Function<StringBuilder, String>, Serializable {
+    static class StringBuilderToStringFunction implements Function<StringBuilder, String> {
 
         @Override
         public String apply(StringBuilder stringBuilder) {
@@ -50,6 +49,27 @@ public class StatelessClientTest {
     }
 
 
+   /* @Test
+    public void testMapForKeyLambda() throws IOException, InterruptedException {
+
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
+                StringBuilder.class)
+                .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
+
+            serverMap.put(10, new StringBuilder("Hello World"));
+
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapBuilder.of(Integer
+                    .class, StringBuilder.class)
+                    .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
+
+                String actual = (String) ((StatelessChronicleMap) statelessMap).mapForKey(10, b -> b.toString());
+
+                Assert.assertEquals("Hello World", actual);
+            }
+        }
+    }*/
+
+
     @Test
     public void testMapForKey() throws IOException, InterruptedException {
 

From 0b48fa564e4d4241d642193b45808c38844f627d Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 12:00:09 +0000
Subject: [PATCH 03/11] HCOLL-81 commented out test as its a java8 only test

---
 .../java/net/openhft/chronicle/map/StatelessClientTest.java   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index 884b369fd..b7392efa9 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -49,8 +49,8 @@ public class StatelessClientTest {
     }
 
 
-   /* @Test
-    public void testMapForKeyLambda() throws IOException, InterruptedException {
+  /* Java8 test only
+  public void testMapForKeyLambda() throws IOException, InterruptedException {
 
         try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
                 StringBuilder.class)

From d3dd3f5ee7bcf7f507c5e715d6f715f1dccb4edc Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 12:07:43 +0000
Subject: [PATCH 04/11] HCOLL-81 removed - @FunctionalInterface

---
 src/main/java/net/openhft/chronicle/java8/Function.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/net/openhft/chronicle/java8/Function.java b/src/main/java/net/openhft/chronicle/java8/Function.java
index 9cb4e1ca4..3d680e259 100644
--- a/src/main/java/net/openhft/chronicle/java8/Function.java
+++ b/src/main/java/net/openhft/chronicle/java8/Function.java
@@ -12,7 +12,7 @@ import java.io.Serializable;
  * @param <R> the type of the result of the function
  * @since 1.8
  */
-@FunctionalInterface
+
 public interface Function<T, R> extends Serializable {
 
     /**

From e772737f3630ce42ba52e653f49fceb92f21192a Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 12:59:03 +0000
Subject: [PATCH 05/11] HCOLL-81 renamed ChronicleMap to
 ChronicleMapOnHeapUpdatableBuilder as Peter wanted the OffHeapUpdated Builder
 to be the default ChronicleMapBuilder.

---
 .../chronicle/hash/ChronicleHashBuilder.java  |  10 +-
 .../map/AbstractChronicleMapBuilder.java      |  18 +-
 .../net/openhft/chronicle/map/Alignment.java  |   2 +-
 .../openhft/chronicle/map/ChronicleMap.java   |   8 +-
 .../chronicle/map/ChronicleMapBuilder.java    | 270 ++++-------------
 .../ChronicleMapOnHeapUpdatableBuilder.java   | 284 ++++++++++++++++++
 .../openhft/chronicle/map/NodeDiscovery.java  |   2 +-
 .../OffHeapUpdatableChronicleMapBuilder.java  | 140 ---------
 .../chronicle/map/PrepareValueBytes.java      |  10 +-
 .../chronicle/set/ChronicleSetBuilder.java    |  66 ++--
 src/test/java/eg/BigData.java                 |   6 +-
 .../chronicle/map/AcquireGetUsingMain.java    |   2 +-
 .../net/openhft/chronicle/map/Builder.java    |   4 +-
 .../chronicle/map/CHMLatencyTestMain.java     |   2 +-
 .../chronicle/map/CHMMetaDataTest.java        |   2 +-
 .../net/openhft/chronicle/map/CHMTest5.java   |   4 +-
 .../chronicle/map/CHMTestIterator1.java       |   2 +-
 .../chronicle/map/ChannelReplicationTest.java |   8 +-
 .../chronicle/map/ChronicleMapTest.java       |  40 +--
 .../chronicle/map/ConcurrentMap8Test.java     |   4 +-
 .../map/ConstantSizeBySampleTest.java         |   8 +-
 .../chronicle/map/DefaultValueTest.java       |   4 +-
 .../chronicle/map/DemoChronicleMapTest.java   |   4 +-
 .../chronicle/map/EntryCountMapTest.java      |   2 +-
 ...tListenerTestWithTCPSocketReplication.java |  16 +-
 .../net/openhft/chronicle/map/GuavaTest.java  |   4 +-
 .../chronicle/map/IntValueMapTest.java        |   2 +-
 .../openhft/chronicle/map/Issue42Test.java    |   2 +-
 .../openhft/chronicle/map/KeySizesTest.java   |   2 +-
 .../openhft/chronicle/map/OSResizesMain.java  |   2 +-
 .../map/PostChannelCreationTest.java          |   8 +-
 .../map/ProcessInstanceLimiterMain.java       |   4 +-
 .../map/RecursiveRefereneChMapTest.java       |   2 +-
 .../map/ReplicatedChronicleMapTest.java       |   4 +-
 .../openhft/chronicle/map/SerializerTest.java |   4 +-
 .../chronicle/map/SingleMapChannelTest.java   |   4 +-
 .../chronicle/map/StatelessClientTest.java    |  52 ++--
 ...cketReplication3wayPutReturnsNullTest.java |   2 +-
 .../TCPSocketReplicationBootStrapTest.java    |   4 +-
 .../map/TCPSocketReplicationIntValueTest.java |   2 +-
 .../map/TCPSocketReplicationNativeTest.java   |   4 +-
 ...CPSocketReplicationPostConnectionTest.java |   2 +-
 .../map/TCPSocketReplicationTest.java         |   2 +-
 .../chronicle/map/TestBooleanValues.java      |   2 +-
 .../map/TimeBasedReplicationTest.java         |  20 +-
 .../map/TwoMapOnDifferentServersTest.java     |   4 +-
 .../map/UDPSocketReplicationTest.java         |   2 +-
 .../chronicle/map/example/ChannelExample.java |  10 +-
 .../map/example/DistributedSequenceMain.java  |   5 +-
 .../chronicle/map/example/ServersMapMain.java |   8 +-
 .../chronicle/map/example/StringsMapMain.java |   8 +-
 .../OpenJDKAndHashMapExamplesTest.java        |   6 +-
 .../pingpong_latency/PingPongCASLeft.java     |   5 +-
 .../map/ipc/StateMachineTutorial.java         |   4 +-
 .../map/jrs166/map/ChronicleMapTest.java      |  14 +-
 .../chronicle/map/jrs166/map/MapCheck.java    |   4 +-
 .../jrs166/map/StatelessChronicleMapTest.java |  14 +-
 .../map/utility/ProcessInstanceLimiter.java   |   6 +-
 58 files changed, 567 insertions(+), 569 deletions(-)
 create mode 100644 src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
 delete mode 100644 src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java

diff --git a/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java b/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java
index 74c757787..be25be9b4 100644
--- a/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java
+++ b/src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java
@@ -45,7 +45,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
 /**
- * This interface defines the meaning of configurations, common to {@link ChronicleMapBuilder} and
+ * This interface defines the meaning of configurations, common to {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder} and
  * {@link ChronicleSetBuilder}, i. e. <i>Chronicle hash container</i> configurations.
  *
  * <p>{@code ChronicleHashBuilder} is mutable. Configuration methods mutate the builder and return
@@ -56,7 +56,7 @@ import java.util.concurrent.TimeUnit;
  * @param <K> the type of keys in hash containers, created by this builder
  * @param <C> the container type, created by this builder, i. e. {@link ChronicleMap} or {@link
  *            ChronicleSet}
- * @param <B> the concrete builder type, i. e. {@link ChronicleMapBuilder} or {@link
+ * @param <B> the concrete builder type, i. e. {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder} or {@link
  *            ChronicleSetBuilder}
  */
 public interface ChronicleHashBuilder<K, C extends ChronicleHash,
@@ -130,7 +130,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
      *
      * <p>There are three major patterns of this configuration usage: <ol> <li>Key (and value, in
      * {@code ChronicleMap} case) sizes are constant. Configure them via {@link
-     * #constantKeySizeBySample(Object)} and {@link ChronicleMapBuilder#constantValueSizeBySample(Object)}
+     * #constantKeySizeBySample(Object)} and {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder#constantValueSizeBySample(Object)}
      * methods, and you will experience no memory waste at all.</li> <li>Key (and/or value size, in
      * {@code ChronicleMap} case) varies moderately. Specify them using corresponding methods, or
      * specify entry size directly by calling this method, by sizes somewhere between average and
@@ -154,7 +154,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
      * efficient manner, for example as {@code long[]} arrays. Typical number of connections is
      * 100-300, maximum is 3000. In this case entry size of
      * 50 * (8 bytes for each id) = 400 bytes would be a good choice: <pre>{@code
-     * Map<Long, long[]> socialGraph = ChronicleMapBuilder
+     * Map<Long, long[]> socialGraph = ChronicleMapOnHeapUpdatableBuilder
      *     .of(Long.class, long[].class)
      *     // given that graph should have of 1 billion nodes, and 150 average adjacency list size
      *     // => values takes 3 chuncks on average
@@ -183,7 +183,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
      * memory unit).</li> <li>If key (and/or value, in {@code ChronicleMap} case) size varies
      * moderately, you should pass to this method the maximum number of entries + 5-25%, depending
      * on your data properties and configured {@linkplain #keySize(int) key}/{@linkplain
-     * ChronicleMapBuilder#valueSize(int) value}/{@linkplain #entrySize(int) entry} sizes.</li>
+     * net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder#valueSize(int) value}/{@linkplain #entrySize(int) entry} sizes.</li>
      * <li>If your data size varies in a wide range, pass the maximum number of entries multiplied
      * by average data size and divided by the configured "entry size" (i. e. chunk size). See an
      * example in the documentation to {@link #entrySize(int)} method.</li> </ol>
diff --git a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
index 432b64bfc..c7cfe7fac 100644
--- a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
@@ -57,19 +57,19 @@ import static net.openhft.chronicle.map.Objects.builderEquals;
 
 /**
  * {@code AbstractChronicleMapBuilder} manages most of {@link ChronicleMap} configurations; has two concrete
- * subclasses: {@link ChronicleMapBuilder} should be used to create maps with ordinary values, {@link
- * OffHeapUpdatableChronicleMapBuilder} -- maps with {@link Byteable} values, which point directly to off-heap
+ * subclasses: {@link ChronicleMapOnHeapUpdatableBuilder} should be used to create maps with ordinary values, {@link
+ * ChronicleMapBuilder} -- maps with {@link Byteable} values, which point directly to off-heap
  * memory; could be used as a classic builder and/or factory. This means
  * that in addition to the standard builder usage pattern: <pre>{@code
- * ChronicleMap<Key, Value> map = ChronicleMapBuilder
+ * ChronicleMap<Key, Value> map = ChronicleMapOnHeapUpdatableBuilder
  *     .of(Key.class, Value.class)
  *     .entries(100500)
  *     // ... other configurations
  *     .create();}</pre>
- * one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link ChronicleMapBuilder} or {@link
- * OffHeapUpdatableChronicleMapBuilder}, could be prepared and used to create many similar
+ * one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link ChronicleMapOnHeapUpdatableBuilder} or {@link
+ * ChronicleMapBuilder}, could be prepared and used to create many similar
  * maps: <pre>{@code
- * OffHeapUpdatableChronicleMapBuilder<Key, Value> builder = OffHeapUpdatableChronicleMapBuilder
+ * ChronicleMapBuilder<Key, Value> builder = ChronicleMapBuilder
  *     .of(Key.class, Value.class)
  *     .entries(100500);
  *
@@ -201,7 +201,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
      *
      * <p>Example: if keys in your map(s) are English words in {@link String} form, keys size 10
      * (a bit more than average English word length) would be a good choice: <pre>{@code
-     * ChronicleMap<String, LongValue> wordFrequencies = OffHeapUpdatableChronicleMapBuilder
+     * ChronicleMap<String, LongValue> wordFrequencies = ChronicleMapBuilder
      *     .of(String.class, LongValue.class)
      *     .entries(50000)
      *     .keySize(10)
@@ -227,7 +227,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
      *
      * <p>For example, if your keys are Git commit hashes:<pre>{@code
      * Map<byte[], String> gitCommitMessagesByHash =
-     *     ChronicleMapBuilder.of(byte[].class, String.class)
+     *     ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, String.class)
      *     .constantKeySizeBySample(new byte[20])
      *     .create();}</pre>
      *
@@ -532,7 +532,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
 
     @Override
     public String toString() {
-        return "ChronicleMapBuilder{" +
+        return "ChronicleMapOnHeapUpdatableBuilder{" +
                 "actualSegments=" + pretty(actualSegments) +
                 ", minSegments=" + pretty(minSegments) +
                 ", actualEntriesPerSegment=" + pretty(actualEntriesPerSegment) +
diff --git a/src/main/java/net/openhft/chronicle/map/Alignment.java b/src/main/java/net/openhft/chronicle/map/Alignment.java
index d470b5305..d2ef30ae0 100644
--- a/src/main/java/net/openhft/chronicle/map/Alignment.java
+++ b/src/main/java/net/openhft/chronicle/map/Alignment.java
@@ -23,7 +23,7 @@ import net.openhft.lang.io.Bytes;
 /**
  * Memory addresses alignment strategies.
  *
- * @see OffHeapUpdatableChronicleMapBuilder#entryAndValueAlignment(Alignment)
+ * @see ChronicleMapBuilder#entryAndValueAlignment(Alignment)
  */
 public enum Alignment {
     /**
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
index 72e021a9f..0a0066f03 100644
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
@@ -93,7 +93,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
      * for the key
      * @see #get(Object)
      * @see #acquireUsing(Object, Object)
-     * @see ChronicleMapBuilder#valueMarshaller(BytesMarshaller)
+     * @see ChronicleMapOnHeapUpdatableBuilder#valueMarshaller(BytesMarshaller)
      */
     V getUsing(K key, V usingValue);
 
@@ -134,7 +134,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
      * no mapping for the key
      * @see #get(Object)
      * @see #getUsing(Object, Object)
-     * @see ChronicleMapBuilder#valueMarshaller(BytesMarshaller)
+     * @see ChronicleMapOnHeapUpdatableBuilder#valueMarshaller(BytesMarshaller)
      */
     @NotNull
     ReadContext<K, V> getUsingLocked(@NotNull K key, @NotNull V usingValue);
@@ -166,8 +166,8 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
      * defaultValueProvider.}
      *
      * <p>If the {@code ChronicleMap} is off-heap updatable, i. e. created via {@link
-     * OffHeapUpdatableChronicleMapBuilder} builder (values are {@link Byteable}), there is one more option of
-     * what to do if the key is absent in the map, see {@link OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}.
+     * ChronicleMapBuilder} builder (values are {@link Byteable}), there is one more option of
+     * what to do if the key is absent in the map, see {@link ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}.
      * By default, value bytes are just zeroed out, no default value, either provided for key or constant, is
      * put for the absent key.
      *
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
index c501004d6..8d28b4966 100644
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
@@ -16,64 +16,31 @@
 
 package net.openhft.chronicle.map;
 
-import net.openhft.chronicle.hash.ChronicleHashBuilder;
-import net.openhft.chronicle.hash.serialization.*;
-import net.openhft.lang.io.Bytes;
-import net.openhft.lang.io.serialization.BytesMarshallable;
-import net.openhft.lang.io.serialization.BytesMarshaller;
-import net.openhft.lang.io.serialization.ObjectFactory;
-import net.openhft.lang.io.serialization.ObjectSerializer;
 import net.openhft.lang.model.Byteable;
+import net.openhft.lang.model.DataValueClasses;
 import org.jetbrains.annotations.NotNull;
 
-import java.io.Externalizable;
-import java.io.Serializable;
-
-
-/**
- * {@code ChronicleMapBuilder} is intended to be used to configure {@link ChronicleMap}s with
- * non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives
- * ({@link Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values
- * implementing {@link BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface,
- * or any other values for which {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller}
- * is provided.
- *
- * <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain
- * a {@code ChronicleMapBuilder} instance.
- *
- * @param <K> key type of the maps, created by this builder
- * @param <V> value type of the maps, created by this builder
- * @see OffHeapUpdatableChronicleMapBuilder
- * @see AbstractChronicleMapBuilder
- * @see ChronicleHashBuilder
- */
 public final class ChronicleMapBuilder<K, V>
         extends AbstractChronicleMapBuilder<K, V, ChronicleMapBuilder<K, V>> {
 
-    /**
-     * Returns a new {@code ChronicleMapBuilder} instance which is able to {@linkplain #create()
-     * create} maps with the specified key and value classes.
-     *
-     * <p>{@code ChronicleMapBuilder} analyzes provided key and value classes and automatically
-     * chooses the most specific and effective serializer which it is aware about. Read
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
-     * serialization in Chronicle Map manual</a> for more information.
-     *
-     * @param keyClass class object used to infer key type and discover it's properties
-     *                 via reflection
-     * @param valueClass class object used to infer value type and discover it's properties
-     *                   via reflection
-     * @param <K> key type of the maps, created by the returned builder
-     * @param <V> value type of the maps, created by the returned builder
-     * @return a new builder for the given key and value classes
-     */
     public static <K, V> ChronicleMapBuilder<K, V> of(
             @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+        if (keyClass.isInterface() && keyClass != CharSequence.class) {
+            keyClass = DataValueClasses.directClassFor(keyClass);
+        }
+        if (valueClass.isInterface()) {
+            valueClass = DataValueClasses.directClassFor(valueClass);
+        } else if (!offHeapReference(valueClass)) {
+            throw new IllegalArgumentException(
+                    "Value class should be either Byteable subclass or interface," +
+                            "allowing direct Byteable implementation generation");
+        }
         return new ChronicleMapBuilder<K, V>(keyClass, valueClass);
     }
 
     ChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
         super(keyClass, valueClass);
+        prepareValueBytesOnAcquire(new ZeroOutValueBytes<K, V>(valueSize()));
     }
 
     @Override
@@ -82,121 +49,52 @@ public final class ChronicleMapBuilder<K, V>
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
      *
-     * @see #constantKeySizeBySample(Object)
-     * @see #valueSize(int)
-     * @see #entrySize(int)
+     * <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
+     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30,
+     * and entry alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32
+     * (30 aligned to 4 bytes).
+     *
+     * @see #entryAndValueAlignment(Alignment)
+     * @see #entries(long)
      */
     @Override
-    public ChronicleMapBuilder<K, V> keySize(int keySize) {
-        return super.keySize(keySize);
+    public ChronicleMapBuilder<K, V> entrySize(int entrySize) {
+        return super.entrySize(entrySize);
     }
 
     /**
-     * {@inheritDoc}
+     * Configures alignment strategy of address in memory of entries and independently of address in
+     * memory of values within entries in ChronicleMaps, created by this builder.
      *
-     * @see #keySize(int)
-     * @see #constantValueSizeBySample(Object)
+     * <p>Useful when values of the map are updated intensively, particularly fields with volatile
+     * access, because it doesn't work well if the value crosses cache lines. Also, on some
+     * (nowadays rare) architectures any misaligned memory access is more expensive than aligned.
+     *
+     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this
+     * alignment. I. e. if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual
+     * entry size will be 24 (20 aligned to 8 bytes).
+     *
+     * <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
+     *
+     * @param alignment the new alignment of the maps constructed by this builder
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
      */
     @Override
-    public ChronicleMapBuilder<K, V> constantKeySizeBySample(K sampleKey) {
-        return super.constantKeySizeBySample(sampleKey);
+    public ChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
+        return super.entryAndValueAlignment(alignment);
     }
 
     /**
-     * Configures the optimal number of bytes, taken by serialized form of values, put into maps,
-     * created by this builder. If value size is always the same, call {@link
-     * #constantValueSizeBySample(Object)} method instead of this one.
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
+     * configuration to this {@code ChronicleMapBuilder}.
      *
-     * <p>If value is a boxed primitive type, i. e. if value size is known statically,
-     * it is automatically accounted and shouldn't be specified by user.
-     *
-     * <p>If value size varies moderately, specify the size higher than average, but lower than the
-     * maximum possible, to minimize average memory overuse. If value size varies in a wide range,
-     * it's better to use {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it
-     * directly.
-     *
-     * @param valueSize number of bytes, taken by serialized form of values
-     * @return this {@code ChronicleMapBuilder} back
-     * @see #constantValueSizeBySample(Object)
-     * @see #keySize(int)
-     * @see #entrySize(int)
-     */
-    @Override
-    public ChronicleMapBuilder<K, V> valueSize(int valueSize) {
-        return super.valueSize(valueSize);
-    }
-
-    /**
-     * Configures the constant number of bytes, taken by serialized form of values, put into maps,
-     * created by this builder. This is done by providing the {@code sampleValue}, all values should
-     * take the same number of bytes in serialized form, as this sample object.
-     *
-     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
-     * known statically, it is automatically accounted and this method shouldn't be called.
-     *
-     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be
-     * called instead of this one.
-     *
-     * @param sampleValue the sample value
-     * @return this builder back
-     * @see #valueSize(int)
-     * @see #constantKeySizeBySample(Object)
-     */
-
-    @Override
-    public ChronicleMapBuilder<K, V> constantValueSizeBySample(
-            @NotNull V sampleValue) {
-        return super.constantValueSizeBySample(sampleValue);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>Example: <pre>{@code Map<Key, Value> map =
-     *     ChronicleMapBuilder.of(Key.class, Value.class)
-     *     .entries(1_000_000)
-     *     .keySize(50).valueSize(200)
-     *     // this class hasn't implemented yet, just for example
-     *     .objectSerializer(new KryoObjectSerializer())
-     *     .create();}</pre>
-     *
-     * <p>This serializer is used to serialize both keys and values, if they both require this:
-     * loosely typed, nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and
-     * {@linkplain #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
-     */
-    @Override
-    public ChronicleMapBuilder<K, V> objectSerializer(
-            @NotNull ObjectSerializer objectSerializer) {
-        return super.objectSerializer(objectSerializer);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured,
-     * this configuration is unused, because it is incapsulated in {@link
-     * BytesMarshaller#read(Bytes)} method (without provided instance to read the data into),
-     * i. e. it's is the user-side responsibility. Actually this is just a convenience method
-     * supporting value marshaller configurations, made initially during {@link #of(Class, Class)}
-     * call, if the value class is {@link BytesMarshallable} or {@link Externalizable} subclass.
-     *
-     * @throws IllegalStateException if custom value marshaller is specified or value class is not
-     *         either {@code BytesMarshallable} or {@code Externalizable}
-     */
-    @Override
-    public ChronicleMapBuilder<K, V> valueDeserializationFactory(
-            @NotNull ObjectFactory<V> valueDeserializationFactory) {
-        return super.valueDeserializationFactory(valueDeserializationFactory);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>By default, the default value is set to {@code null}.
+     * <p>By default, the default value is not specified, default {@linkplain
+     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
      *
      * @see #defaultValueProvider(DefaultValueProvider)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
      */
     @Override
     public ChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
@@ -204,12 +102,14 @@ public final class ChronicleMapBuilder<K, V>
     }
 
     /**
-     * {@inheritDoc}
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
+     * configuration to this {@code ChronicleMapBuilder}.
      *
-     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default
-     * value} is specified instead.
+     * <p>By default, the default value provider is not specified, default {@linkplain
+     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
      *
      * @see #defaultValue(Object)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
      */
     @Override
     public ChronicleMapBuilder<K, V> defaultValueProvider(
@@ -218,67 +118,23 @@ public final class ChronicleMapBuilder<K, V>
     }
 
     /**
-     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap
-     * memory in maps, created by this builder. See
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
-     * section about serialization in ChronicleMap manual</a> for more information.
+     * Configures the procedure which is called on the bytes, which later the returned value is
+     * pointing to, if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object)
+     * acquireUsing()} call on maps, created by this builder. See {@link PrepareValueBytes} for
+     * more information.
      *
-     * @param valueMarshaller the marshaller used to serialize values
+     * <p>The default preparation callback zeroes out the value bytes.
+     *
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the
+     *                          {@link Byteable} value to return from {@code acquireUsing()} call
      * @return this builder back
-     * @see #valueMarshallers(BytesWriter, BytesReader)
-     * @see OffHeapUpdatableChronicleMapBuilder
-     * @see #objectSerializer(ObjectSerializer)
+     * @see PrepareValueBytes
+     * @see #defaultValue(Object)
+     * @see #defaultValueProvider(DefaultValueProvider)
      */
-    public ChronicleMapBuilder<K, V> valueMarshaller(
-            @NotNull BytesMarshaller<V> valueMarshaller) {
-        valueBuilder.marshaller(valueMarshaller);
-        return this;
-    }
-
-    /**
-     * Configures the marshallers, used to serialize/deserialize values to/from off-heap
-     * memory in maps, created by this builder. See
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
-     * serialization in ChronicleMap manual</a> for more information.
-     *
-     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout
-     * of the map, comparing to a single interface configuration:
-     * {@link #valueMarshaller(BytesMarshaller)}.
-     *
-     * <p>Passing {@link BytesInterop} instead of plain {@link BytesWriter} is, of cause, possible,
-     * but currently pointless for values.
-     *
-     * @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
-     * @param valueReader the new {@link Bytes} &rarr; value object reader strategy
-     * @return this builder back
-     * @see #valueMarshaller(BytesMarshaller)
-     */
-    public ChronicleMapBuilder<K, V> valueMarshallers(
-            @NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
-        valueBuilder.writer(valueWriter);
-        valueBuilder.reader(valueReader);
-        return this;
-    }
-
-    /**
-     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps,
-     * created by this builder.
-     *
-     * <p>Default value size marshaller is so-called {@linkplain SizeMarshallers#stopBit()
-     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant
-     * value size} is configured, or defaulted if the value type is always constant and {@code
-     * ChronicleHashBuilder} implementation knows about it, this configuration takes no effect,
-     * because a special {@link SizeMarshaller} implementation, which doesn't actually do any
-     * marshalling, and just returns the known constant size on {@link SizeMarshaller#readSize(
-     * Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this method.
-     *
-     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to
-     *                            off-heap memory
-     * @return this builder back
-     */
-    public ChronicleMapBuilder<K, V> valueSizeMarshaller(
-            @NotNull SizeMarshaller valueSizeMarshaller) {
-        valueBuilder.sizeMarshaller(valueSizeMarshaller);
-        return this;
+    @Override
+    public ChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
+            @NotNull PrepareValueBytes<K, V> prepareValueBytes) {
+        return super.prepareValueBytesOnAcquire(prepareValueBytes);
     }
 }
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
new file mode 100644
index 000000000..8b9e98ee6
--- /dev/null
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.chronicle.map;
+
+import net.openhft.chronicle.hash.ChronicleHashBuilder;
+import net.openhft.chronicle.hash.serialization.*;
+import net.openhft.lang.io.Bytes;
+import net.openhft.lang.io.serialization.BytesMarshallable;
+import net.openhft.lang.io.serialization.BytesMarshaller;
+import net.openhft.lang.io.serialization.ObjectFactory;
+import net.openhft.lang.io.serialization.ObjectSerializer;
+import net.openhft.lang.model.Byteable;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.Externalizable;
+import java.io.Serializable;
+
+
+/**
+ * {@code ChronicleMapOnHeapUpdatableBuilder} is intended to be used to configure {@link ChronicleMap}s with
+ * non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives
+ * ({@link Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values
+ * implementing {@link BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface,
+ * or any other values for which {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller}
+ * is provided.
+ *
+ * <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain
+ * a {@code ChronicleMapOnHeapUpdatableBuilder} instance.
+ *
+ * @param <K> key type of the maps, created by this builder
+ * @param <V> value type of the maps, created by this builder
+ * @see ChronicleMapBuilder
+ * @see AbstractChronicleMapBuilder
+ * @see ChronicleHashBuilder
+ */
+public final class ChronicleMapOnHeapUpdatableBuilder<K, V>
+        extends AbstractChronicleMapBuilder<K, V, ChronicleMapOnHeapUpdatableBuilder<K, V>> {
+
+    /**
+     * Returns a new {@code ChronicleMapOnHeapUpdatableBuilder} instance which is able to {@linkplain #create()
+     * create} maps with the specified key and value classes.
+     *
+     * <p>{@code ChronicleMapOnHeapUpdatableBuilder} analyzes provided key and value classes and automatically
+     * chooses the most specific and effective serializer which it is aware about. Read
+     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
+     * serialization in Chronicle Map manual</a> for more information.
+     *
+     * @param keyClass class object used to infer key type and discover it's properties
+     *                 via reflection
+     * @param valueClass class object used to infer value type and discover it's properties
+     *                   via reflection
+     * @param <K> key type of the maps, created by the returned builder
+     * @param <V> value type of the maps, created by the returned builder
+     * @return a new builder for the given key and value classes
+     */
+    public static <K, V> ChronicleMapOnHeapUpdatableBuilder<K, V> of(
+            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+        return new ChronicleMapOnHeapUpdatableBuilder<K, V>(keyClass, valueClass);
+    }
+
+    ChronicleMapOnHeapUpdatableBuilder(Class<K> keyClass, Class<V> valueClass) {
+        super(keyClass, valueClass);
+    }
+
+    @Override
+    ChronicleMapOnHeapUpdatableBuilder<K, V> self() {
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #constantKeySizeBySample(Object)
+     * @see #valueSize(int)
+     * @see #entrySize(int)
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> keySize(int keySize) {
+        return super.keySize(keySize);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #keySize(int)
+     * @see #constantValueSizeBySample(Object)
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> constantKeySizeBySample(K sampleKey) {
+        return super.constantKeySizeBySample(sampleKey);
+    }
+
+    /**
+     * Configures the optimal number of bytes, taken by serialized form of values, put into maps,
+     * created by this builder. If value size is always the same, call {@link
+     * #constantValueSizeBySample(Object)} method instead of this one.
+     *
+     * <p>If value is a boxed primitive type, i. e. if value size is known statically,
+     * it is automatically accounted and shouldn't be specified by user.
+     *
+     * <p>If value size varies moderately, specify the size higher than average, but lower than the
+     * maximum possible, to minimize average memory overuse. If value size varies in a wide range,
+     * it's better to use {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it
+     * directly.
+     *
+     * @param valueSize number of bytes, taken by serialized form of values
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     * @see #constantValueSizeBySample(Object)
+     * @see #keySize(int)
+     * @see #entrySize(int)
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueSize(int valueSize) {
+        return super.valueSize(valueSize);
+    }
+
+    /**
+     * Configures the constant number of bytes, taken by serialized form of values, put into maps,
+     * created by this builder. This is done by providing the {@code sampleValue}, all values should
+     * take the same number of bytes in serialized form, as this sample object.
+     *
+     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
+     * known statically, it is automatically accounted and this method shouldn't be called.
+     *
+     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be
+     * called instead of this one.
+     *
+     * @param sampleValue the sample value
+     * @return this builder back
+     * @see #valueSize(int)
+     * @see #constantKeySizeBySample(Object)
+     */
+
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> constantValueSizeBySample(
+            @NotNull V sampleValue) {
+        return super.constantValueSizeBySample(sampleValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Example: <pre>{@code Map<Key, Value> map =
+     *     ChronicleMapOnHeapUpdatableBuilder.of(Key.class, Value.class)
+     *     .entries(1_000_000)
+     *     .keySize(50).valueSize(200)
+     *     // this class hasn't implemented yet, just for example
+     *     .objectSerializer(new KryoObjectSerializer())
+     *     .create();}</pre>
+     *
+     * <p>This serializer is used to serialize both keys and values, if they both require this:
+     * loosely typed, nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and
+     * {@linkplain #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> objectSerializer(
+            @NotNull ObjectSerializer objectSerializer) {
+        return super.objectSerializer(objectSerializer);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured,
+     * this configuration is unused, because it is incapsulated in {@link
+     * BytesMarshaller#read(Bytes)} method (without provided instance to read the data into),
+     * i. e. it's is the user-side responsibility. Actually this is just a convenience method
+     * supporting value marshaller configurations, made initially during {@link #of(Class, Class)}
+     * call, if the value class is {@link BytesMarshallable} or {@link Externalizable} subclass.
+     *
+     * @throws IllegalStateException if custom value marshaller is specified or value class is not
+     *         either {@code BytesMarshallable} or {@code Externalizable}
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueDeserializationFactory(
+            @NotNull ObjectFactory<V> valueDeserializationFactory) {
+        return super.valueDeserializationFactory(valueDeserializationFactory);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, the default value is set to {@code null}.
+     *
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> defaultValue(V defaultValue) {
+        return super.defaultValue(defaultValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default
+     * value} is specified instead.
+     *
+     * @see #defaultValue(Object)
+     */
+    @Override
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> defaultValueProvider(
+            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
+        return super.defaultValueProvider(defaultValueProvider);
+    }
+
+    /**
+     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap
+     * memory in maps, created by this builder. See
+     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * @param valueMarshaller the marshaller used to serialize values
+     * @return this builder back
+     * @see #valueMarshallers(BytesWriter, BytesReader)
+     * @see ChronicleMapBuilder
+     * @see #objectSerializer(ObjectSerializer)
+     */
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueMarshaller(
+            @NotNull BytesMarshaller<V> valueMarshaller) {
+        valueBuilder.marshaller(valueMarshaller);
+        return this;
+    }
+
+    /**
+     * Configures the marshallers, used to serialize/deserialize values to/from off-heap
+     * memory in maps, created by this builder. See
+     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
+     * serialization in ChronicleMap manual</a> for more information.
+     *
+     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout
+     * of the map, comparing to a single interface configuration:
+     * {@link #valueMarshaller(BytesMarshaller)}.
+     *
+     * <p>Passing {@link BytesInterop} instead of plain {@link BytesWriter} is, of cause, possible,
+     * but currently pointless for values.
+     *
+     * @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
+     * @param valueReader the new {@link Bytes} &rarr; value object reader strategy
+     * @return this builder back
+     * @see #valueMarshaller(BytesMarshaller)
+     */
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueMarshallers(
+            @NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
+        valueBuilder.writer(valueWriter);
+        valueBuilder.reader(valueReader);
+        return this;
+    }
+
+    /**
+     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps,
+     * created by this builder.
+     *
+     * <p>Default value size marshaller is so-called {@linkplain SizeMarshallers#stopBit()
+     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant
+     * value size} is configured, or defaulted if the value type is always constant and {@code
+     * ChronicleHashBuilder} implementation knows about it, this configuration takes no effect,
+     * because a special {@link SizeMarshaller} implementation, which doesn't actually do any
+     * marshalling, and just returns the known constant size on {@link SizeMarshaller#readSize(
+     * Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this method.
+     *
+     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to
+     *                            off-heap memory
+     * @return this builder back
+     */
+    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueSizeMarshaller(
+            @NotNull SizeMarshaller valueSizeMarshaller) {
+        valueBuilder.sizeMarshaller(valueSizeMarshaller);
+        return this;
+    }
+}
diff --git a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
index 6e614410c..877b69312 100644
--- a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
+++ b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
@@ -231,7 +231,7 @@ public class NodeDiscovery {
         LOG.info("Using Remote identifier=" + identifier);
         nodeDiscoveryEventListenerAtomicReference.set(null);
 
-        return ChronicleMapBuilder.of(Integer.class,
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                 CharSequence.class)
                 .entries(20000L)
                 .replication(SingleChronicleHashReplication.builder()
diff --git a/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
deleted file mode 100644
index 41ef51679..000000000
--- a/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.openhft.chronicle.map;
-
-import net.openhft.lang.model.Byteable;
-import net.openhft.lang.model.DataValueClasses;
-import org.jetbrains.annotations.NotNull;
-
-public final class OffHeapUpdatableChronicleMapBuilder<K, V>
-        extends AbstractChronicleMapBuilder<K, V, OffHeapUpdatableChronicleMapBuilder<K, V>> {
-
-    public static <K, V> OffHeapUpdatableChronicleMapBuilder<K, V> of(
-            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
-        if (keyClass.isInterface() && keyClass != CharSequence.class) {
-            keyClass = DataValueClasses.directClassFor(keyClass);
-        }
-        if (valueClass.isInterface()) {
-            valueClass = DataValueClasses.directClassFor(valueClass);
-        } else if (!offHeapReference(valueClass)) {
-            throw new IllegalArgumentException(
-                    "Value class should be either Byteable subclass or interface," +
-                            "allowing direct Byteable implementation generation");
-        }
-        return new OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
-    }
-
-    OffHeapUpdatableChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
-        super(keyClass, valueClass);
-        prepareValueBytesOnAcquire(new ZeroOutValueBytes<K, V>(valueSize()));
-    }
-
-    @Override
-    OffHeapUpdatableChronicleMapBuilder<K, V> self() {
-        return this;
-    }
-
-    /**
-     * {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
-     *
-     * <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
-     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30,
-     * and entry alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32
-     * (30 aligned to 4 bytes).
-     *
-     * @see #entryAndValueAlignment(Alignment)
-     * @see #entries(long)
-     */
-    @Override
-    public OffHeapUpdatableChronicleMapBuilder<K, V> entrySize(int entrySize) {
-        return super.entrySize(entrySize);
-    }
-
-    /**
-     * Configures alignment strategy of address in memory of entries and independently of address in
-     * memory of values within entries in ChronicleMaps, created by this builder.
-     *
-     * <p>Useful when values of the map are updated intensively, particularly fields with volatile
-     * access, because it doesn't work well if the value crosses cache lines. Also, on some
-     * (nowadays rare) architectures any misaligned memory access is more expensive than aligned.
-     *
-     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this
-     * alignment. I. e. if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual
-     * entry size will be 24 (20 aligned to 8 bytes).
-     *
-     * <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
-     *
-     * @param alignment the new alignment of the maps constructed by this builder
-     * @return this {@code ChronicleMapBuilder} back
-     */
-    @Override
-    public OffHeapUpdatableChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
-        return super.entryAndValueAlignment(alignment);
-    }
-
-    /**
-     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
-     * configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
-     *
-     * <p>By default, the default value is not specified, default {@linkplain
-     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
-     *
-     * @see #defaultValueProvider(DefaultValueProvider)
-     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
-     */
-    @Override
-    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
-        return super.defaultValue(defaultValue);
-    }
-
-    /**
-     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
-     * configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
-     *
-     * <p>By default, the default value provider is not specified, default {@linkplain
-     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
-     *
-     * @see #defaultValue(Object)
-     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
-     */
-    @Override
-    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValueProvider(
-            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
-        return super.defaultValueProvider(defaultValueProvider);
-    }
-
-    /**
-     * Configures the procedure which is called on the bytes, which later the returned value is
-     * pointing to, if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object)
-     * acquireUsing()} call on maps, created by this builder. See {@link PrepareValueBytes} for
-     * more information.
-     *
-     * <p>The default preparation callback zeroes out the value bytes.
-     *
-     * @param prepareValueBytes what to do with the value bytes before assigning them into the
-     *                          {@link Byteable} value to return from {@code acquireUsing()} call
-     * @return this builder back
-     * @see PrepareValueBytes
-     * @see #defaultValue(Object)
-     * @see #defaultValueProvider(DefaultValueProvider)
-     */
-    @Override
-    public OffHeapUpdatableChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
-            @NotNull PrepareValueBytes<K, V> prepareValueBytes) {
-        return super.prepareValueBytesOnAcquire(prepareValueBytes);
-    }
-}
diff --git a/src/main/java/net/openhft/chronicle/map/PrepareValueBytes.java b/src/main/java/net/openhft/chronicle/map/PrepareValueBytes.java
index e2b726fec..87462f6a8 100644
--- a/src/main/java/net/openhft/chronicle/map/PrepareValueBytes.java
+++ b/src/main/java/net/openhft/chronicle/map/PrepareValueBytes.java
@@ -26,11 +26,11 @@ import java.io.Serializable;
  * value during {@link ChronicleMap#acquireUsing(Object, Object)
  * chronicleMap.acquireUsing()} call, when the given key is absent in the map. Example: if you
  * want {@code 1L} to be the off-heap updatable ChronicleMap's {@linkplain
- * OffHeapUpdatableChronicleMapBuilder#defaultValue(Object) default value}, the most simple way
- * to achieve this is to {@linkplain OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(
+ * ChronicleMapBuilder#defaultValue(Object) default value}, the most simple way
+ * to achieve this is to {@linkplain ChronicleMapBuilder#prepareValueBytesOnAcquire(
  * PrepareValueBytes) configure} custom {@code PrepareValueBytes} strategy in {@link
- * OffHeapUpdatableChronicleMapBuilder}: <pre>{@code
- * OffHeapUpdatableChronicleMapBuilder.of(Key.class, LongValue.class)
+ * ChronicleMapBuilder}: <pre>{@code
+ * ChronicleMapBuilder.of(Key.class, LongValue.class)
  *     .prepareValueBytesOnAcquire((bytes, k) -> bytes.writeLong(1L))
  *     ...
  *     .create();}</pre>
@@ -41,7 +41,7 @@ import java.io.Serializable;
  *
  * @param <K> the key type of {@link ChronicleMap}, on which {@code acquireUsing()} is queried
  * @param <V> the value type of {@link ChronicleMap}, on which {@code acquireUsing()} is queried
- * @see OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)
+ * @see ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)
  */
 public interface PrepareValueBytes<K, V> extends Serializable {
 
diff --git a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
index 017bf24f3..a31e08960 100644
--- a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
+++ b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
@@ -29,7 +29,7 @@ import net.openhft.chronicle.hash.serialization.BytesReader;
 import net.openhft.chronicle.hash.serialization.BytesWriter;
 import net.openhft.chronicle.hash.serialization.SizeMarshaller;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.lang.io.serialization.BytesMarshaller;
 import net.openhft.lang.io.serialization.BytesMarshallerFactory;
 import net.openhft.lang.io.serialization.ObjectFactory;
@@ -45,20 +45,20 @@ import java.util.concurrent.TimeUnit;
  * {@code ChronicleSetBuilder} manages the whole set of {@link ChronicleSet} configurations, could be used as
  * a classic builder and/or factory.
  *
- * <p>{@code ChronicleMapBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
+ * <p>{@code ChronicleMapOnHeapUpdatableBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
  * documentation.
  *
  * @param <E> element type of the sets, created by this builder
  * @see ChronicleSet
- * @see ChronicleMapBuilder
+ * @see net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder
  */
 public class ChronicleSetBuilder<E>
         implements ChronicleHashBuilder<E, ChronicleSet<E>, ChronicleSetBuilder<E>> {
 
-    private ChronicleMapBuilder<E, DummyValue> chronicleMapBuilder;
+    private ChronicleMapOnHeapUpdatableBuilder<E, DummyValue> chronicleMapBuilderOnHeap;
 
     ChronicleSetBuilder(Class<E> keyClass) {
-        chronicleMapBuilder = ChronicleMapBuilder.of(keyClass, DummyValue.class)
+        chronicleMapBuilderOnHeap = ChronicleMapOnHeapUpdatableBuilder.of(keyClass, DummyValue.class)
                 .valueMarshallers(DummyValueMarshaller.INSTANCE, DummyValueMarshaller.INSTANCE)
                 .valueSizeMarshaller(DummyValueMarshaller.INSTANCE);
     }
@@ -72,7 +72,7 @@ public class ChronicleSetBuilder<E>
         try {
             @SuppressWarnings("unchecked")
             final ChronicleSetBuilder<E> result = (ChronicleSetBuilder<E>) super.clone();
-            result.chronicleMapBuilder = chronicleMapBuilder.clone();
+            result.chronicleMapBuilderOnHeap = chronicleMapBuilderOnHeap.clone();
             return result;
         } catch (CloneNotSupportedException e) {
             throw new AssertionError(e);
@@ -81,19 +81,19 @@ public class ChronicleSetBuilder<E>
 
     @Override
     public ChronicleSetBuilder<E> actualSegments(int actualSegments) {
-        chronicleMapBuilder.actualSegments(actualSegments);
+        chronicleMapBuilderOnHeap.actualSegments(actualSegments);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> minSegments(int minSegments) {
-        chronicleMapBuilder.minSegments(minSegments);
+        chronicleMapBuilderOnHeap.minSegments(minSegments);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> actualEntriesPerSegment(long actualEntriesPerSegment) {
-        chronicleMapBuilder.actualEntriesPerSegment(actualEntriesPerSegment);
+        chronicleMapBuilderOnHeap.actualEntriesPerSegment(actualEntriesPerSegment);
         return this;
     }
 
@@ -116,7 +116,7 @@ public class ChronicleSetBuilder<E>
      */
     @Override
     public ChronicleSetBuilder<E> keySize(int keySize) {
-        chronicleMapBuilder.keySize(keySize);
+        chronicleMapBuilderOnHeap.keySize(keySize);
         return this;
     }
 
@@ -132,7 +132,7 @@ public class ChronicleSetBuilder<E>
      */
     @Override
     public ChronicleSetBuilder<E> constantKeySizeBySample(E sampleKey) {
-        chronicleMapBuilder.constantKeySizeBySample(sampleKey);
+        chronicleMapBuilderOnHeap.constantKeySizeBySample(sampleKey);
         return this;
     }
 
@@ -149,38 +149,38 @@ public class ChronicleSetBuilder<E>
      */
     @Override
     public ChronicleSetBuilder<E> entrySize(int entrySize) {
-        chronicleMapBuilder.entrySize(entrySize);
+        chronicleMapBuilderOnHeap.entrySize(entrySize);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> entries(long entries) {
-        chronicleMapBuilder.entries(entries);
+        chronicleMapBuilderOnHeap.entries(entries);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> lockTimeOut(long lockTimeOut, TimeUnit unit) {
-        chronicleMapBuilder.lockTimeOut(lockTimeOut, unit);
+        chronicleMapBuilderOnHeap.lockTimeOut(lockTimeOut, unit);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> errorListener(ChronicleHashErrorListener errorListener) {
-        chronicleMapBuilder.errorListener(errorListener);
+        chronicleMapBuilderOnHeap.errorListener(errorListener);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> metaDataBytes(int metaDataBytes) {
-        chronicleMapBuilder.metaDataBytes(metaDataBytes);
+        chronicleMapBuilderOnHeap.metaDataBytes(metaDataBytes);
         return this;
     }
 
     @Override
     public String toString() {
         return " ChronicleSetBuilder{" +
-                "chronicleMapBuilder=" + chronicleMapBuilder +
+                "chronicleMapBuilderOnHeap=" + chronicleMapBuilderOnHeap +
                 '}';
     }
 
@@ -189,7 +189,7 @@ public class ChronicleSetBuilder<E>
     public boolean equals(Object o) {
         if (!(o instanceof ChronicleSetBuilder))
             return false;
-        return chronicleMapBuilder.equals(((ChronicleSetBuilder) o).chronicleMapBuilder);
+        return chronicleMapBuilderOnHeap.equals(((ChronicleSetBuilder) o).chronicleMapBuilderOnHeap);
     }
 
     @Override
@@ -199,14 +199,14 @@ public class ChronicleSetBuilder<E>
 
     @Override
     public ChronicleSetBuilder<E> timeProvider(TimeProvider timeProvider) {
-        chronicleMapBuilder.timeProvider(timeProvider);
+        chronicleMapBuilderOnHeap.timeProvider(timeProvider);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> bytesMarshallerFactory(
             BytesMarshallerFactory bytesMarshallerFactory) {
-        chronicleMapBuilder.bytesMarshallerFactory(bytesMarshallerFactory);
+        chronicleMapBuilderOnHeap.bytesMarshallerFactory(bytesMarshallerFactory);
         return this;
     }
 
@@ -222,26 +222,26 @@ public class ChronicleSetBuilder<E>
      */
     @Override
     public ChronicleSetBuilder<E> objectSerializer(ObjectSerializer objectSerializer) {
-        chronicleMapBuilder.objectSerializer(objectSerializer);
+        chronicleMapBuilderOnHeap.objectSerializer(objectSerializer);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> keyMarshaller(@NotNull BytesMarshaller<E> keyMarshaller) {
-        chronicleMapBuilder.keyMarshaller(keyMarshaller);
+        chronicleMapBuilderOnHeap.keyMarshaller(keyMarshaller);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> keyMarshallers(@NotNull BytesWriter<E> keyWriter,
                                                  @NotNull BytesReader<E> keyReader) {
-        chronicleMapBuilder.keyMarshallers(keyWriter, keyReader);
+        chronicleMapBuilderOnHeap.keyMarshallers(keyWriter, keyReader);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> keySizeMarshaller(@NotNull SizeMarshaller keySizeMarshaller) {
-        chronicleMapBuilder.keySizeMarshaller(keySizeMarshaller);
+        chronicleMapBuilderOnHeap.keySizeMarshaller(keySizeMarshaller);
         return this;
     }
 
@@ -258,54 +258,54 @@ public class ChronicleSetBuilder<E>
     @Override
     public ChronicleSetBuilder<E> keyDeserializationFactory(
             @NotNull ObjectFactory<E> keyDeserializationFactory) {
-        chronicleMapBuilder.keyDeserializationFactory(keyDeserializationFactory);
+        chronicleMapBuilderOnHeap.keyDeserializationFactory(keyDeserializationFactory);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> immutableKeys() {
-        chronicleMapBuilder.immutableKeys();
+        chronicleMapBuilderOnHeap.immutableKeys();
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> replication(SingleChronicleHashReplication replication) {
-        chronicleMapBuilder.replication(replication);
+        chronicleMapBuilderOnHeap.replication(replication);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork) {
-        chronicleMapBuilder.replication(identifier, tcpTransportAndNetwork);
+        chronicleMapBuilderOnHeap.replication(identifier, tcpTransportAndNetwork);
         return this;
     }
 
     @Override
     public ChronicleSetBuilder<E> replication(byte identifier) {
-        chronicleMapBuilder.replication(identifier);
+        chronicleMapBuilderOnHeap.replication(identifier);
         return this;
     }
 
     @Override
     public StatelessClientConfig<ChronicleSet<E>> statelessClient(
             InetSocketAddress remoteAddress) {
-        return new StatelessSetConfig<>(chronicleMapBuilder.statelessClient(remoteAddress));
+        return new StatelessSetConfig<>(chronicleMapBuilderOnHeap.statelessClient(remoteAddress));
     }
 
     @Override
     public ChronicleHashInstanceConfig<ChronicleSet<E>> instance() {
-        return new InstanceConfig<>(chronicleMapBuilder.instance());
+        return new InstanceConfig<>(chronicleMapBuilderOnHeap.instance());
     }
 
     @Override
     public ChronicleSet<E> create() throws IOException {
-        final ChronicleMap<E, DummyValue> map = chronicleMapBuilder.create();
+        final ChronicleMap<E, DummyValue> map = chronicleMapBuilderOnHeap.create();
         return new SetFromMap<E>(map);
     }
 
     @Override
     public ChronicleSet<E> createPersistedTo(File file) throws IOException {
-        ChronicleMap<E, DummyValue> map = chronicleMapBuilder.createPersistedTo(file);
+        ChronicleMap<E, DummyValue> map = chronicleMapBuilderOnHeap.createPersistedTo(file);
         return new SetFromMap<E>(map);
     }
 
diff --git a/src/test/java/eg/BigData.java b/src/test/java/eg/BigData.java
index 177b1059f..90588218e 100644
--- a/src/test/java/eg/BigData.java
+++ b/src/test/java/eg/BigData.java
@@ -19,7 +19,7 @@
 package eg;
 
 import net.openhft.affinity.AffinitySupport;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.lang.io.Bytes;
 
 import java.io.*;
@@ -40,8 +40,8 @@ public class BigData {
     //run 1st test with no map, and Highwatermark set to 0
     //then switch to Highwatermark set to MAXSIZE for subsequent test repeats
     static AtomicInteger Highwatermark = new AtomicInteger((int) MAXSIZE);
-    static final ChronicleMapBuilder<Long, BigDataStuff> builder =
-            ChronicleMapBuilder.of(Long.class, BigDataStuff.class);
+    static final ChronicleMapOnHeapUpdatableBuilder<Long, BigDataStuff> builder =
+            ChronicleMapOnHeapUpdatableBuilder.of(Long.class, BigDataStuff.class);
 
     //    static AtomicInteger Highwatermark = new AtomicInteger(0);
     static {
diff --git a/src/test/java/net/openhft/chronicle/map/AcquireGetUsingMain.java b/src/test/java/net/openhft/chronicle/map/AcquireGetUsingMain.java
index fe6b10497..7dfcbf72b 100644
--- a/src/test/java/net/openhft/chronicle/map/AcquireGetUsingMain.java
+++ b/src/test/java/net/openhft/chronicle/map/AcquireGetUsingMain.java
@@ -30,7 +30,7 @@ public class AcquireGetUsingMain {
     public static void main(String[] args) throws Exception {
         File file = new File(System.getProperty("java.io.tmpdir") + "/test1");
         ChronicleMap<String, Data> theSharedMap =
-                OffHeapUpdatableChronicleMapBuilder.of(String.class, Data.class)
+                ChronicleMapBuilder.of(String.class, Data.class)
                         .createPersistedTo(file);
         Data data = DataValueClasses.newDirectReference(Data.class);
         String processType = "testkey";
diff --git a/src/test/java/net/openhft/chronicle/map/Builder.java b/src/test/java/net/openhft/chronicle/map/Builder.java
index 073e204fb..c64ec78bc 100644
--- a/src/test/java/net/openhft/chronicle/map/Builder.java
+++ b/src/test/java/net/openhft/chronicle/map/Builder.java
@@ -67,14 +67,14 @@ public class Builder {
                 identifier, serverPort, endpoints).create();
     }
 
-    public static <K, V> ChronicleMapBuilder<K, V> newTcpSocketShmBuilder(
+    public static <K, V> ChronicleMapOnHeapUpdatableBuilder<K, V> newTcpSocketShmBuilder(
             Class<K> kClass, Class<V> vClass,
             final byte identifier,
             final int serverPort,
             final InetSocketAddress... endpoints) throws IOException {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(serverPort, Arrays.asList(endpoints))
                 .heartBeatInterval(1L, TimeUnit.SECONDS);
-        return ChronicleMapBuilder.of(kClass, vClass)
+        return ChronicleMapOnHeapUpdatableBuilder.of(kClass, vClass)
                 .replication(identifier,  tcpConfig);
     }
 
diff --git a/src/test/java/net/openhft/chronicle/map/CHMLatencyTestMain.java b/src/test/java/net/openhft/chronicle/map/CHMLatencyTestMain.java
index 6649c1d86..8e6863439 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMLatencyTestMain.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMLatencyTestMain.java
@@ -76,7 +76,7 @@ public class CHMLatencyTestMain {
 //        File file = new File("testCHMLatency.deleteme");
         file.delete();
         ChronicleMap<LongValue, LongValue> countersMap =
-                OffHeapUpdatableChronicleMapBuilder.of(LongValue.class, LongValue.class)
+                ChronicleMapBuilder.of(LongValue.class, LongValue.class)
                 .entries(KEYS)
                 .entrySize(16)
                 .createPersistedTo(file);
diff --git a/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java b/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
index 65f699a45..79706aa7d 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
@@ -35,7 +35,7 @@ public class CHMMetaDataTest {
         File file = new File(TMP, "testAccessTimes");
         MapEventListener<String, String, ChronicleMap<String, String>> listener =
                 new StringStringMapEventListener(new AtomicLong(1));
-        ChronicleMap<String, String> map = ChronicleMapBuilder.of(String.class, String.class)
+        ChronicleMap<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class)
                 .metaDataBytes(8)
                 .eventListener(listener).create();
 
diff --git a/src/test/java/net/openhft/chronicle/map/CHMTest5.java b/src/test/java/net/openhft/chronicle/map/CHMTest5.java
index 6979bc473..046e30845 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMTest5.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMTest5.java
@@ -34,8 +34,8 @@ public class CHMTest5 {
 
     public static void main(String[] args) throws Exception {
         //First create (or access if already created) the shared map
-        OffHeapUpdatableChronicleMapBuilder<String, CHMTest5Data> builder =
-                OffHeapUpdatableChronicleMapBuilder.of(String.class, CHMTest5Data.class)
+        ChronicleMapBuilder<String, CHMTest5Data> builder =
+                ChronicleMapBuilder.of(String.class, CHMTest5Data.class)
                         .entries(1000);
 
         //// don't include this, just to check it is as expected.
diff --git a/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java b/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
index e4b9c1e56..b2baa5de7 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
@@ -30,7 +30,7 @@ public class CHMTestIterator1 {
         AtomicLong alValue = new AtomicLong();
         AtomicLong alKey = new AtomicLong();
         int runs = 3000000;
-        ChronicleMapBuilder<String, Long> builder = ChronicleMapBuilder.of(String.class, Long.class)
+        ChronicleMapOnHeapUpdatableBuilder<String, Long> builder = ChronicleMapOnHeapUpdatableBuilder.of(String.class, Long.class)
                 .entries(runs);
 
         ChronicleMap<String, Long> chm = builder.create();
diff --git a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
index 717e943d4..2fdaafe2d 100644
--- a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
@@ -61,7 +61,7 @@ public class ChannelReplicationTest {
                     .tcpTransportAndNetwork(tcpConfig)
                     .createWithId((byte) 1);
 
-            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
         }
@@ -73,7 +73,7 @@ public class ChannelReplicationTest {
             hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig)
                     .createWithId((byte) 2);
 
-            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1)).create();
         }
@@ -95,12 +95,12 @@ public class ChannelReplicationTest {
     @Test
     public void test() throws IOException, InterruptedException {
 
-        map2b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .instance().replicatedViaChannel(hubB.createChannel((short) 2)).create();
 
 
-        map2a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        map2a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .instance().replicatedViaChannel(hubA.createChannel((short) 2)).create();
 
diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index fc4b0d2d3..d8e3558c1 100755
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -110,7 +110,7 @@ public class ChronicleMapTest {
     private static ChronicleMap<CharSequence, LongValue> getSharedMap(
             long entries, int segments, int entrySize, Alignment alignment)
             throws IOException {
-        return OffHeapUpdatableChronicleMapBuilder.of(CharSequence.class, LongValue.class)
+        return ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
                 .entries(entries)
                 .minSegments(segments)
                 .entrySize(entrySize)
@@ -136,7 +136,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKey() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
         assertFalse(map.containsKey("key3"));
@@ -181,7 +181,7 @@ public class ChronicleMapTest {
     public void testSize() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(1024)
                         .removeReturnsNull(true).create();
 
@@ -203,7 +203,7 @@ public class ChronicleMapTest {
     public void testRemoveInteger() throws IOException {
 
         int count = 300;
-        final ChronicleMap<Object, Object> map = ChronicleMapBuilder.of(Object.class, Object.class)
+        final ChronicleMap<Object, Object> map = ChronicleMapOnHeapUpdatableBuilder.of(Object.class, Object.class)
                 .entrySize(count)
                 .minSegments(2).create();
 
@@ -228,7 +228,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKeyAndRemoveReturnsNull() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2)
                         .removeReturnsNull(true).create();
 
@@ -274,7 +274,7 @@ public class ChronicleMapTest {
     public void testReplaceWithKey() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
 
@@ -339,7 +339,7 @@ public class ChronicleMapTest {
     public void testReplaceWithKeyAnd2Params() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
         map.put("key1", "one");
@@ -381,7 +381,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKeyAndValue() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
 
@@ -582,7 +582,7 @@ public class ChronicleMapTest {
             // JAVA 8 produces more garbage than previous versions for internal work.
 //            System.gc();
             final long entries = runs * 1000 * 1000L;
-            OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> builder = OffHeapUpdatableChronicleMapBuilder
+            ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
                     .of(CharSequence.class, LongValue.class)
                     .entries(entries)
                     .actualSegments(8 * 1024)
@@ -654,7 +654,7 @@ public class ChronicleMapTest {
             // JAVA 8 produces more garbage than previous versions for internal work.
 //            System.gc();
             final long entries = runs * 1000 * 1000L;
-            OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> builder = OffHeapUpdatableChronicleMapBuilder
+            ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
                     .of(CharSequence.class, LongValue.class)
                     .entries(entries)
                     .entryAndValueAlignment(OF_8_BYTES)
@@ -728,7 +728,7 @@ public class ChronicleMapTest {
             // JAVA 8 produces more garbage than previous versions for internal work.
 //            System.gc();
             final long entries = runs * 1000 * 1000L;
-            OffHeapUpdatableChronicleMapBuilder<LongValue, LongValue> builder = OffHeapUpdatableChronicleMapBuilder
+            ChronicleMapBuilder<LongValue, LongValue> builder = ChronicleMapBuilder
                     .of(LongValue.class, LongValue.class)
                     .entries(entries)
                     .entryAndValueAlignment(OF_8_BYTES)
@@ -855,7 +855,7 @@ public class ChronicleMapTest {
         String TMP = System.getProperty("java.io.tmpdir");
         int entries = 100 * 1000;
         ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(entries)
                         .minSegments(16)
                         .entrySize(32)
@@ -1284,7 +1284,7 @@ public class ChronicleMapTest {
 
     private ChronicleMap<Integer, CharSequence> getViewTestMap(int noOfElements) throws IOException {
         ChronicleMap<Integer, CharSequence> map =
-                ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                         .entries(noOfElements * 2 + 100)
                         .valueSize((noOfElements + "").length())
                         .putReturnsNull(true)
@@ -1304,7 +1304,7 @@ public class ChronicleMapTest {
 
     @Test
     public void testOversizeEntriesPutRemoveReplace() throws IOException {
-        ChronicleMapBuilder builder = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .minSegments(1)
                 .entrySize(10);
@@ -1356,13 +1356,13 @@ public class ChronicleMapTest {
 
     @Test
     public void equalsTest() throws IOException {
-        final ChronicleMap<Integer, String> map1 = ChronicleMapBuilder
+        final ChronicleMap<Integer, String> map1 = ChronicleMapOnHeapUpdatableBuilder
                 .of(Integer.class, String.class).create();
 
         map1.put(1, "one");
         map1.put(2, "two");
 
-        final ChronicleMap<Integer, String> map2 = ChronicleMapBuilder
+        final ChronicleMap<Integer, String> map2 = ChronicleMapOnHeapUpdatableBuilder
                 .of(Integer.class, String.class).create();
 
         map2.put(1, "one");
@@ -1406,7 +1406,7 @@ public class ChronicleMapTest {
 
     @Test
     public void testOffheapAcquireUsingLocked() throws IOException {
-        OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> builder = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
                 .of(CharSequence.class, LongValue.class)
                 .entries(1000)
                 .entrySize(16);
@@ -1469,7 +1469,7 @@ public class ChronicleMapTest {
     @Test(expected = IllegalArgumentException.class)
     public void testAcquireUsingLockedWithString() throws IOException {
 
-        ChronicleMapBuilder<CharSequence, String> builder = ChronicleMapBuilder
+        ChronicleMapOnHeapUpdatableBuilder<CharSequence, String> builder = ChronicleMapOnHeapUpdatableBuilder
                 .of(CharSequence.class, String.class)
                 .entries(1000)
                 .defaultValue("")
@@ -1494,7 +1494,7 @@ public class ChronicleMapTest {
     @Test
     public void testOnheapAcquireUsingLockedStringBuilder() throws IOException {
 
-        try (final ChronicleMap<CharSequence, StringBuilder> map = ChronicleMapBuilder
+        try (final ChronicleMap<CharSequence, StringBuilder> map = ChronicleMapOnHeapUpdatableBuilder
                 .of(CharSequence.class, StringBuilder.class)
                 .entries(1000)
 
@@ -1514,7 +1514,7 @@ public class ChronicleMapTest {
 
     @Test
     public void testOnheapAcquireUsingLocked() throws IOException {
-        ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
+        ChronicleMapOnHeapUpdatableBuilder<CharSequence, LongValue> builder = ChronicleMapOnHeapUpdatableBuilder
                 .of(CharSequence.class, LongValue.class)
                 .entries(1000)
                 .entrySize(40);
diff --git a/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java b/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
index 1d1596e20..2dd42a58a 100644
--- a/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
+++ b/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
@@ -42,7 +42,7 @@ public class ConcurrentMap8Test extends JSR166TestCase {
    /* private static ConcurrentMap<Long, Long> newLongMap() {
         //First create (or access if already created) the shared map
 
-        final ChronicleMapBuilder<Long, Long> builder = ChronicleMapBuilder.of(Long.class, Long.class);
+        final ChronicleMapOnHeapUpdatableBuilder<Long, Long> builder = ChronicleMapOnHeapUpdatableBuilder.of(Long.class, Long.class);
 
 
         //// don't include this, just to check it is as expected.
@@ -64,7 +64,7 @@ public class ConcurrentMap8Test extends JSR166TestCase {
     private static ConcurrentMap newIntegerStringMap() {
 
 
-        final ChronicleMapBuilder<Integer, String> builder = ChronicleMapBuilder.of(Integer.class,
+        final ChronicleMapOnHeapUpdatableBuilder<Integer, String> builder = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                 String.class);
 
 
diff --git a/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java b/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
index 78ab35c73..57b010cb9 100644
--- a/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
@@ -32,7 +32,7 @@ public class ConstantSizeBySampleTest {
 
     @Test
     public void testConstantKeys() throws IOException {
-        ChronicleMap<byte[], Long> map = ChronicleMapBuilder.of(byte[].class, Long.class)
+        ChronicleMap<byte[], Long> map = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, Long.class)
                 .constantKeySizeBySample(new byte[8])
                 .immutableKeys()
                 .entries(100)
@@ -52,7 +52,7 @@ public class ConstantSizeBySampleTest {
 
     @Test
     public void testUnexpectedlyLongConstantByteArrayValues() throws IOException {
-        ChronicleMap<Long, byte[]> map = ChronicleMapBuilder.of(Long.class, byte[].class)
+        ChronicleMap<Long, byte[]> map = ChronicleMapOnHeapUpdatableBuilder.of(Long.class, byte[].class)
                 .constantValueSizeBySample(new byte[512 * 1024])
                 .entries(100)
                 .actualSegments(1)
@@ -89,7 +89,7 @@ public class ConstantSizeBySampleTest {
     @Test
     public void testUnexpectedlyLongConstantExternalizableValues() throws IOException {
         ChronicleMap<Long, ExternalizableData> map =
-                ChronicleMapBuilder.of(Long.class, ExternalizableData.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(Long.class, ExternalizableData.class)
                         .constantValueSizeBySample(new ExternalizableData())
                         .entries(100)
                         .actualSegments(1)
@@ -116,7 +116,7 @@ public class ConstantSizeBySampleTest {
     @Ignore
     public void testUnexpectedlyLongConstantSerializableValues() throws IOException {
         ChronicleMap<Long, SerializableData> map =
-                ChronicleMapBuilder.of(Long.class, SerializableData.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(Long.class, SerializableData.class)
                         .constantValueSizeBySample(new SerializableData())
                         .entries(100)
                         .actualSegments(1)
diff --git a/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java b/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
index 7e47e4bf0..4c09bd6f8 100644
--- a/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
+++ b/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
@@ -37,7 +37,7 @@ public class DefaultValueTest {
 
             ArrayList<Integer> defaultValue = new ArrayList<Integer>();
             defaultValue.add(42);
-            try (ChronicleMap<String, List<Integer>> map = ChronicleMapBuilder
+            try (ChronicleMap<String, List<Integer>> map = ChronicleMapOnHeapUpdatableBuilder
                     .of(String.class, (Class<List<Integer>>) ((Class) List.class))
                     .defaultValue(defaultValue).createPersistedTo(file)) {
                 ArrayList<Integer> using = new ArrayList<Integer>();
@@ -49,7 +49,7 @@ public class DefaultValueTest {
             }
 
             ArrayList<Integer> using = new ArrayList<Integer>();
-            try (ChronicleMap<String, List<Integer>> map = ChronicleMapBuilder
+            try (ChronicleMap<String, List<Integer>> map = ChronicleMapOnHeapUpdatableBuilder
                     .of(String.class, (Class<List<Integer>>) ((Class) List.class))
                     .createPersistedTo(file)) {
                 assertEquals(defaultValue, map.acquireUsing("c", using));
diff --git a/src/test/java/net/openhft/chronicle/map/DemoChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/DemoChronicleMapTest.java
index c85c8f86f..c970ab11c 100755
--- a/src/test/java/net/openhft/chronicle/map/DemoChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/DemoChronicleMapTest.java
@@ -17,7 +17,7 @@ public class DemoChronicleMapTest {
         File file = File.createTempFile("DummyOrders", ".test");
         file.deleteOnExit();
         int maxEntries = 1000;
-        ChronicleMap<IntValue, DemoOrderVOInterface> map = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMap<IntValue, DemoOrderVOInterface> map = ChronicleMapBuilder
                 .of(IntValue.class, DemoOrderVOInterface.class)
                 .putReturnsNull(true)
                 .removeReturnsNull(true)
@@ -59,7 +59,7 @@ public class DemoChronicleMapTest {
         File file = File.createTempFile("DummyOrders", ".test");
         file.deleteOnExit();
         int maxEntries = 1000;
-        ChronicleMap<IntValue, DemoOrderVOInterface> map = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMap<IntValue, DemoOrderVOInterface> map = ChronicleMapBuilder
                 .of(IntValue.class, DemoOrderVOInterface.class)
                 .putReturnsNull(true)
                 .removeReturnsNull(true)
diff --git a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
index 742366961..cc3de97c9 100644
--- a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
@@ -51,7 +51,7 @@ public class EntryCountMapTest {
     private static ChronicleMap<CharSequence, LongValue> getSharedMap(
             long entries, int segments, int entrySize, Alignment alignment)
             throws IOException {
-        OffHeapUpdatableChronicleMapBuilder<CharSequence, LongValue> mapBuilder = OffHeapUpdatableChronicleMapBuilder.of(CharSequence.class, LongValue.class)
+        ChronicleMapBuilder<CharSequence, LongValue> mapBuilder = ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
                 .entries(entries)
                 .actualSegments(segments)
                 .entrySize(entrySize)
diff --git a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
index 49beb7104..f7ecadd8f 100644
--- a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
+++ b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
@@ -99,14 +99,14 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
         }
         // ---------- SERVER2 2 on the same server as ----------
 
         {
-            ChronicleMapBuilder<Integer, CharSequence> map2Builder = clientBuilder();
+            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2Builder = clientBuilder();
 
             map2 = map2Builder.create();
         }
@@ -135,7 +135,7 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
 
@@ -206,7 +206,7 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
 
@@ -237,9 +237,9 @@ public class EventListenerTestWithTCPSocketReplication {
         Assert.assertEquals(null, map2.get(5));
     }
 
-    private ChronicleMapBuilder<Integer, CharSequence> clientBuilder() {
+    private ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> clientBuilder() {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(8077);
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000L)
                 .replication((byte) 1, tcpConfig)
                 .eventListener(eventListener);
@@ -256,9 +256,9 @@ public class EventListenerTestWithTCPSocketReplication {
         }
     }
 
-    private ChronicleMapBuilder<Integer, CharSequence> serverBuilder() {
+    private ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> serverBuilder() {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(8076, new InetSocketAddress("localhost", 8077));
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000L)
                 .replication((byte) 2, tcpConfig);
     }
diff --git a/src/test/java/net/openhft/chronicle/map/GuavaTest.java b/src/test/java/net/openhft/chronicle/map/GuavaTest.java
index 4c096767d..d08560df9 100644
--- a/src/test/java/net/openhft/chronicle/map/GuavaTest.java
+++ b/src/test/java/net/openhft/chronicle/map/GuavaTest.java
@@ -99,8 +99,8 @@ public class GuavaTest extends TestCase {
     }
 
     static class CHMTestGenerator extends TestGenerator {
-        ChronicleMapBuilder<CharSequence, CharSequence> builder =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> builder =
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(100)
                         .minSegments(2);
 
diff --git a/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java b/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
index 59a14633b..37378ba50 100644
--- a/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
@@ -37,7 +37,7 @@ public class IntValueMapTest {
     @Test
     public void test() throws IOException {
 
-        final ChronicleMap<IntValue, CharSequence> map = ChronicleMapBuilder
+        final ChronicleMap<IntValue, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
                 .of(IntValue.class, CharSequence.class)
                 .entries(20000)
                 .keyMarshaller(ByteableIntValueMarshaller.INSTANCE).create();
diff --git a/src/test/java/net/openhft/chronicle/map/Issue42Test.java b/src/test/java/net/openhft/chronicle/map/Issue42Test.java
index a3fcc7aac..13bd20459 100755
--- a/src/test/java/net/openhft/chronicle/map/Issue42Test.java
+++ b/src/test/java/net/openhft/chronicle/map/Issue42Test.java
@@ -32,7 +32,7 @@ public class Issue42Test {
         if (!Jvm.isWindows())
             return;
 
-        final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapBuilder
+        final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
                 .of(CharSequence.class, CharSequence.class)
                 .entrySize(18)
                 .entries(1500000)
diff --git a/src/test/java/net/openhft/chronicle/map/KeySizesTest.java b/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
index b9af5ffc1..d2a436054 100644
--- a/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
+++ b/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
@@ -33,7 +33,7 @@ public class KeySizesTest {
     @Test
     public void testDifferentKeySizes() throws IOException {
 
-        Map<String, String> map = ChronicleMapBuilder.of(String.class, String.class).create();
+        Map<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class).create();
 
         String k = "";
         for (int i = 0; i < 100; i++) {
diff --git a/src/test/java/net/openhft/chronicle/map/OSResizesMain.java b/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
index cc1af2ad4..c09a5ecc3 100755
--- a/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
+++ b/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
@@ -35,7 +35,7 @@ import java.util.Arrays;
 public class OSResizesMain {
     public static void main(String[] args) throws IOException, InterruptedException {
         File file = File.createTempFile("over-sized", "deleteme");
-        ChronicleMap<String, String> map = ChronicleMapBuilder.of(String.class, String.class)
+        ChronicleMap<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class)
                 .entrySize(100 * 1024 * 1024)
                 .entries(1000 * 1000)
                 .createPersistedTo(file);
diff --git a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
index a7db4b5fc..93bd564e9 100644
--- a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
@@ -70,11 +70,11 @@ public class PostChannelCreationTest {
                     .createWithId((byte) 1);
 
             // this is how you add maps after the custer is created
-            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
 
-            map2a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map2a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 2)).create();
         }
@@ -89,11 +89,11 @@ public class PostChannelCreationTest {
                     .createWithId((byte) 2);
 
             // this is how you add maps after the custer is created
-            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1)).create();
 
-            map2b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 2)).create();
         }
diff --git a/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java b/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
index 5bea1f6ae..dd2dcf80f 100644
--- a/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
+++ b/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
@@ -36,8 +36,8 @@ public class ProcessInstanceLimiterMain implements Runnable {
     public ProcessInstanceLimiterMain(String sharedMapName, Callback callback) throws IOException {
         this.sharedMapName = sharedMapName;
         this.callback = callback;
-        ChronicleMapBuilder<String, Data> builder =
-                ChronicleMapBuilder.of(String.class, Data.class);
+        ChronicleMapOnHeapUpdatableBuilder<String, Data> builder =
+                ChronicleMapOnHeapUpdatableBuilder.of(String.class, Data.class);
         builder.entries(10000);
         builder.minSegments(2);
         File file = new File(System.getProperty("java.io.tmpdir") + "/" + sharedMapName);
diff --git a/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java b/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
index 790b84265..b5bd950d4 100644
--- a/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
@@ -33,7 +33,7 @@ public class RecursiveRefereneChMapTest {
     public void testRecursive() throws IOException {
         File file = new File(TMP + "/test." + System.nanoTime() + ".tmp");
         file.deleteOnExit();
-        Map<String, StupidCycle> map = ChronicleMapBuilder.of(String.class, StupidCycle.class)
+        Map<String, StupidCycle> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, StupidCycle.class)
                 .entries(64)
                 .objectSerializer(JDKObjectSerializer.INSTANCE).create();
         map.put("Test", new StupidCycle());
diff --git a/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
index 382c299cc..34a87018b 100644
--- a/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
@@ -38,14 +38,14 @@ public class ReplicatedChronicleMapTest extends JSR166TestCase {
 
 
     ChronicleMap<Integer, CharSequence> newShmIntString() throws IOException {
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .create();
 
     }
 
 
     ChronicleMap<CharSequence, CharSequence> newShmStringString() throws IOException {
-        return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .create();
 
     }
diff --git a/src/test/java/net/openhft/chronicle/map/SerializerTest.java b/src/test/java/net/openhft/chronicle/map/SerializerTest.java
index 4bf4a05e7..e1ddf2573 100644
--- a/src/test/java/net/openhft/chronicle/map/SerializerTest.java
+++ b/src/test/java/net/openhft/chronicle/map/SerializerTest.java
@@ -72,7 +72,7 @@ public class SerializerTest {
         final ByteBufferBytes out = new ByteBufferBytes(ByteBuffer.allocateDirect(1024));
         ByteBufferBytes in = out.slice();
 
-        ChronicleMapBuilder builder = ChronicleMapBuilder.of(Integer.class, valueClass);
+        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, valueClass);
         builder.preMapConstruction(false);
 
         Serializer v = new Serializer(builder.valueBuilder);
@@ -95,7 +95,7 @@ public class SerializerTest {
         final ByteBufferBytes out = new ByteBufferBytes(ByteBuffer.allocateDirect(1024));
         ByteBufferBytes in = out.slice();
 
-        ChronicleMapBuilder builder = ChronicleMapBuilder.of(clazz, Integer.class);
+        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(clazz, Integer.class);
         builder.preMapConstruction(false);
         {
             Serializer v = new Serializer(builder.keyBuilder);
diff --git a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
index 315cd86e6..3c78880e6 100644
--- a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
+++ b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
@@ -70,7 +70,7 @@ public class SingleMapChannelTest {
                     .tcpTransportAndNetwork(tcpConfig)
                     .createWithId(identifier);
             // this is how you add maps after the custer is created
-            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
         }
@@ -84,7 +84,7 @@ public class SingleMapChannelTest {
             hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig).createWithId((byte) 2);
 
             // this is how you add maps after the custer is created
-            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1))
                     .create();
diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index b7392efa9..dc747b148 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -52,13 +52,13 @@ public class StatelessClientTest {
   /* Java8 test only
   public void testMapForKeyLambda() throws IOException, InterruptedException {
 
-        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                 StringBuilder.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, new StringBuilder("Hello World"));
 
-            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, StringBuilder.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -74,13 +74,13 @@ public class StatelessClientTest {
     public void testMapForKey() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                 StringBuilder.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, new StringBuilder("Hello World"));
 
-            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, StringBuilder.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -96,10 +96,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllAndEntrySet() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -129,10 +129,10 @@ public class StatelessClientTest {
     @Test
     public void testBufferOverFlowPutAllAndValues() throws IOException, InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -161,10 +161,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllAndKeySet() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -193,11 +193,11 @@ public class StatelessClientTest {
     public void test() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, "EXAMPLE-10");
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -212,10 +212,10 @@ public class StatelessClientTest {
     @Test
     public void testClientCreatedBeforeServer() throws IOException, InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -236,10 +236,10 @@ public class StatelessClientTest {
 
     @Test
     public void testBufferOverFlowPutAll() throws IOException, InterruptedException {
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -267,10 +267,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllWherePutReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -299,10 +299,10 @@ public class StatelessClientTest {
     public void testPutWherePutReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -321,10 +321,10 @@ public class StatelessClientTest {
     public void testRemoveWhereRemoveReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -355,9 +355,9 @@ public class StatelessClientTest {
 
         // server
         {
-            serverMap1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            serverMap1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create();
-            serverMap2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+            serverMap2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                     .replication((byte) 2, TcpTransportAndNetworkConfig.of(8077)).create();
 
         }
@@ -365,10 +365,10 @@ public class StatelessClientTest {
 
         // stateless client
         {
-            statelessMap1 = ChronicleMapBuilder.of(Integer
+            statelessMap1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create();
-            statelessMap2 = ChronicleMapBuilder.of(Integer
+            statelessMap2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8077)).create();
         }
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
index 3af0a9cc2..4f6a72af8 100755
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
@@ -50,7 +50,7 @@ public class TCPSocketReplication3wayPutReturnsNullTest {
             final InetSocketAddress... endpoints) throws IOException {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(serverPort, Arrays.asList(endpoints));
 
-        return (T) ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return (T) ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .putReturnsNull(true)
                 .replication(identifier, tcpConfig).create();
     }
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
index 041c066b4..dce3e622b 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
@@ -47,7 +47,7 @@ public class TCPSocketReplicationBootStrapTest {
 
         map1 = newTcpSocketShmIntString((byte) 1, 8069);
 
-        ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
+        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2aBuilder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 2, 8066, new InetSocketAddress("localhost", 8069));
         final ChronicleMap<Integer, CharSequence> map2a =
@@ -108,7 +108,7 @@ public class TCPSocketReplicationBootStrapTest {
 
         {
             // restart map 2 but does not connect it to map1
-            final ChronicleMap<Integer, CharSequence> map2b = ChronicleMapBuilder.of(Integer.class,
+            final ChronicleMap<Integer, CharSequence> map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                     CharSequence.class).replication((byte) 2).createPersistedTo(persistenceFile);
             // add data into it
             map2b.put(11, "ADDED WHEN DISCONNECTED TO MAP1");
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
index 93429dd23..991dde467 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
@@ -45,7 +45,7 @@ import static org.junit.Assert.assertTrue;
 
 public class TCPSocketReplicationIntValueTest {
 
-    private ChronicleMapBuilder<IntValue, CharSequence> map1Builder;
+    private ChronicleMapOnHeapUpdatableBuilder<IntValue, CharSequence> map1Builder;
     private ChronicleMap<IntValue, CharSequence> map1;
     private ChronicleMap<IntValue, CharSequence> map2;
     private IntValue value;
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationNativeTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationNativeTest.java
index 6db9d081f..5b6e479fd 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationNativeTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationNativeTest.java
@@ -53,13 +53,13 @@ public class TCPSocketReplicationNativeTest {
         TcpTransportAndNetworkConfig tcpConfig1 = TcpTransportAndNetworkConfig.of(8076, endpoint)
                 .heartBeatInterval(1L, TimeUnit.SECONDS);
 
-        map1 = OffHeapUpdatableChronicleMapBuilder.of(Integer.class, LongValue.class)
+        map1 = ChronicleMapBuilder.of(Integer.class, LongValue.class)
                 .replication((byte) 1, tcpConfig1).create();
 
         TcpTransportAndNetworkConfig tcpConfig2 = TcpTransportAndNetworkConfig.of(8077)
                 .heartBeatInterval(1L, TimeUnit.SECONDS);
 
-        map2 = OffHeapUpdatableChronicleMapBuilder.of(Integer.class, LongValue.class)
+        map2 = ChronicleMapBuilder.of(Integer.class, LongValue.class)
                 .replication((byte) 2, tcpConfig2).create();
 
     }
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
index 2a931292b..79cf9983c 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
@@ -76,7 +76,7 @@ public class TCPSocketReplicationPostConnectionTest {
     @Test
     public void testBootStrapIntoNewMapWithNewFile() throws IOException, InterruptedException {
 
-        ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
+        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2aBuilder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 2, 8077, new InetSocketAddress("localhost", 8076));
         try (final ChronicleMap<Integer, CharSequence> map2a =
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
index f8e8f7a52..a964ffed2 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
@@ -47,7 +47,7 @@ public class TCPSocketReplicationTest {
 
     @Before
     public void setup() throws IOException {
-        ChronicleMapBuilder<Integer, CharSequence> map1Builder =
+        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 1, 8076, new InetSocketAddress("localhost", 8077));
         map1 = map1Builder.createPersistedTo(getPersistenceFile());
diff --git a/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java b/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
index eff5fa333..4be12c3b8 100644
--- a/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
+++ b/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
@@ -35,7 +35,7 @@ public class TestBooleanValues {
     @Test
     public void testTestBooleanValues() throws IOException, InterruptedException {
         ChronicleMap<Integer, Boolean> map =
-                ChronicleMapBuilder.of(Integer.class, Boolean.class).create();
+                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, Boolean.class).create();
         map.put(7, true);
         Assert.assertEquals(true, map.get(7));
     }
diff --git a/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java b/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
index 639da0acd..189a3a599 100644
--- a/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
@@ -49,7 +49,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALatePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -78,7 +78,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALatePutIfAbsent() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -108,7 +108,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateReplace() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -141,7 +141,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateReplaceWithValue() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -171,7 +171,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateRemoveWithValue() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -200,7 +200,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateRemove() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -229,7 +229,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreWithRemoteRemove() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -259,7 +259,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
 
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -289,7 +289,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testRemoveFollowedByLatePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -317,7 +317,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testPutRemovePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
diff --git a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
index 484c8c769..8ca1838c5 100644
--- a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
@@ -48,11 +48,11 @@ public class TwoMapOnDifferentServersTest {
                         .heartBeatInterval(1, SECONDS);
 
 
-        map1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        map1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000)
                 .replication((byte) 1, tcpConfig).create();
 
-        map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        map2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8077)
                         .heartBeatInterval(1, SECONDS)).create();
diff --git a/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java b/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
index 4f44e0b29..0ff22fdde 100644
--- a/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
@@ -44,7 +44,7 @@ public class UDPSocketReplicationTest {
         UdpTransportConfig udpConfig = UdpTransportConfig
                 .of(Inet4Address.getByName("255.255.255.255"), udpPort);
 
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .replication(SingleChronicleHashReplication.builder().udpTransport(udpConfig)
                                 .createWithId((byte) identifier))
diff --git a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
index 6adebf43c..1bc1457b7 100644
--- a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
+++ b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
@@ -3,7 +3,7 @@ package net.openhft.chronicle.map.example;
 import net.openhft.chronicle.hash.replication.ReplicationHub;
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -63,8 +63,8 @@ public class ChannelExample {
 
     // server 1 with  identifier = 1
     {
-        ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(1000);
 
         byte identifier = (byte) 1;
@@ -98,8 +98,8 @@ public class ChannelExample {
 
     // server 2 with  identifier = 2
     {
-        ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
-                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
+                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(1000);
 
         byte identifier = (byte) 2;
diff --git a/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java b/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
index 1a8d3b140..77331fca3 100644
--- a/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
@@ -19,11 +19,10 @@
 package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.values.LongValue;
 
-import java.io.File;
 import java.io.IOException;
 
 public class DistributedSequenceMain {
@@ -31,7 +30,7 @@ public class DistributedSequenceMain {
     public static void main(String... ignored) throws IOException {
         Class<LongValue> longValueClass = DataValueClasses.directClassFor(LongValue.class);
         ChronicleMap<String, LongValue> map =
-                ChronicleMapBuilder.of(String.class, longValueClass)
+                ChronicleMapOnHeapUpdatableBuilder.of(String.class, longValueClass)
                         .entries(128)
                         .actualSegments(1).create();
         LongValue value = DataValueClasses.newDirectReference(longValueClass);
diff --git a/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java b/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
index 57706e3c0..441f3003a 100644
--- a/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 
 import java.io.File;
 import java.io.IOException;
@@ -39,7 +39,7 @@ public class ServersMapMain {
     public static void startServer() throws IOException {
         File file = File.createTempFile("testServersMapMain", ".deleteme");
         file.deleteOnExit();
-        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapBuilder.of(byte[].class, byte[].class)
+        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .entrySize(50)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port))
@@ -52,7 +52,7 @@ public class ServersMapMain {
     public static void startRemoteClient(String hostname) throws IOException {
         final ChronicleMap<byte[], byte[]> map;
         if (stateless) {
-            map = ChronicleMapBuilder.of(
+            map = ChronicleMapOnHeapUpdatableBuilder.of(
                     byte[].class, byte[].class)
                     .putReturnsNull(true)
                     .statelessClient(new InetSocketAddress(hostname, port)).create();
@@ -61,7 +61,7 @@ public class ServersMapMain {
             file.deleteOnExit();
             TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(port, new InetSocketAddress(hostname, port));
 
-            map = ChronicleMapBuilder.of(
+            map = ChronicleMapOnHeapUpdatableBuilder.of(
                     byte[].class, byte[].class)
                     .putReturnsNull(true)
                     .replication((byte) 1, tcpConfig)
diff --git a/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java b/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
index b4729d9a9..9bf177ee5 100644
--- a/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 
 import java.io.File;
 import java.io.IOException;
@@ -38,7 +38,7 @@ public class StringsMapMain {
     public static void startServer() throws IOException {
         File file = File.createTempFile("testServersMapMain", ".deleteme");
         file.deleteOnExit();
-        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapBuilder
+        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder
                 .of(CharSequence.class, CharSequence.class)
                 .putReturnsNull(true)
                 .entrySize(50)
@@ -52,7 +52,7 @@ public class StringsMapMain {
     public static void startRemoteClient(String hostname) throws IOException {
         final ChronicleMap<CharSequence, CharSequence> map;
         if (stateless) {
-            map = ChronicleMapBuilder
+            map = ChronicleMapOnHeapUpdatableBuilder
                     .of(CharSequence.class, CharSequence.class)
                     .putReturnsNull(true)
                     .statelessClient(new InetSocketAddress(hostname, port)).create();
@@ -61,7 +61,7 @@ public class StringsMapMain {
             file.deleteOnExit();
             TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(port, new InetSocketAddress(hostname, port));
 
-            map = ChronicleMapBuilder
+            map = ChronicleMapOnHeapUpdatableBuilder
                     .of(CharSequence.class, CharSequence.class)
                     .putReturnsNull(true)
                     .replication((byte) 1, tcpConfig)
diff --git a/src/test/java/net/openhft/chronicle/map/fromdocs/OpenJDKAndHashMapExamplesTest.java b/src/test/java/net/openhft/chronicle/map/fromdocs/OpenJDKAndHashMapExamplesTest.java
index 949c4b117..c2cfed303 100644
--- a/src/test/java/net/openhft/chronicle/map/fromdocs/OpenJDKAndHashMapExamplesTest.java
+++ b/src/test/java/net/openhft/chronicle/map/fromdocs/OpenJDKAndHashMapExamplesTest.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.fromdocs;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.OffHeapUpdatableChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.chronicle.map.ReadContext;
 import net.openhft.chronicle.map.WriteContext;
 import net.openhft.lang.model.DataValueClasses;
@@ -56,7 +56,7 @@ public class OpenJDKAndHashMapExamplesTest {
         File file = new File(TMP + "/chm-myBondPortfolioCHM-" + System.nanoTime());
         file.deleteOnExit();
 
-        ChronicleMap<String, BondVOInterface> chm = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMap<String, BondVOInterface> chm = ChronicleMapBuilder
                 .of(String.class, BondVOInterface.class)
                 .keySize(10)
                 .createPersistedTo(file);
@@ -76,7 +76,7 @@ public class OpenJDKAndHashMapExamplesTest {
             mpx1030.setBidPx(107.6);
         }
 
-        ChronicleMap<String, BondVOInterface> chmB = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMap<String, BondVOInterface> chmB = ChronicleMapBuilder
                 .of(String.class, BondVOInterface.class)
                 .keySize(10)
                 .createPersistedTo(file);
diff --git a/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java b/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
index 0d31aaade..fdcee15c4 100644
--- a/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
+++ b/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
@@ -20,10 +20,9 @@ package net.openhft.chronicle.map.fromdocs.pingpong_latency;
 
 import net.openhft.affinity.AffinitySupport;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.chronicle.map.fromdocs.BondVOInterface;
 
-import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
 
@@ -90,7 +89,7 @@ public class PingPongCASLeft {
     static ChronicleMap<String, BondVOInterface> acquireCHM() throws IOException {
         // ensure thread ids are globally unique.
         AffinitySupport.setThreadId();
-        return ChronicleMapBuilder.of(String.class, BondVOInterface.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(String.class, BondVOInterface.class)
                 .entries(16)
                 .entrySize(64).create();
     }
diff --git a/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java b/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
index 7cc518e78..bf8986368 100644
--- a/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
+++ b/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.ipc;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -40,7 +40,7 @@ public class StateMachineTutorial {
 
         try {
             File dataFile = new File(System.getProperty("java.io.tmpdir"), "hft-state-machine");
-            map = ChronicleMapBuilder.of(Integer.class, StateMachineData.class)
+            map = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, StateMachineData.class)
                     .entries(8).create();
 
             if (args.length > 0) {
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
index c3665fa8c..6c28aa50c 100644
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.chronicle.map.jrs166.JSR166TestCase;
 import org.junit.Test;
 
@@ -49,33 +49,33 @@ public class ChronicleMapTest extends JSR166TestCase {
     }
 
     static ChronicleMap<Integer, CharSequence> newShmIntString(int size) throws IOException {
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
                 .entries(size).create();
 
     }
 
     static ChronicleMap<ArrayList, CharSequence> newShmListBoolean(int size) throws IOException {
-        return ChronicleMapBuilder.of(ArrayList.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(ArrayList.class, CharSequence.class)
                 .entries(size).create();
     }
 
 
     static ChronicleMap<ArrayList, CharSequence> newShmListBoolean() throws IOException {
-        return ChronicleMapBuilder.of(ArrayList.class, CharSequence.class).create();
+        return ChronicleMapOnHeapUpdatableBuilder.of(ArrayList.class, CharSequence.class).create();
     }
 
     static ChronicleMap<CharSequence, CharSequence> newShmStringString(int size) throws IOException {
-        return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        return ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(size).create();
     }
 
 
     static ChronicleMap<Integer, CharSequence> newShmIntString() throws IOException {
-        return ChronicleMapBuilder.of(Integer.class, CharSequence.class).create();
+        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class).create();
     }
 
     static ChronicleMap<BI, Boolean> newShmBiBoolean() throws IOException {
-        return ChronicleMapBuilder.of(BI.class, Boolean.class).create();
+        return ChronicleMapOnHeapUpdatableBuilder.of(BI.class, Boolean.class).create();
     }
 
     /**
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
index e97ce82af..8d4edab60 100644
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 
 import java.io.*;
 import java.util.*;
@@ -123,7 +123,7 @@ public class MapCheck {
 
     static Map newMap() {
         try {
-            return ChronicleMapBuilder.of(Object.class, Object.class).create();
+            return ChronicleMapOnHeapUpdatableBuilder.of(Object.class, Object.class).create();
 
         } catch (Exception e) {
             throw new RuntimeException("Can't instantiate CHM : " + e);
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
index 51b9e8fa4..debe6f367 100755
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.chronicle.map.ReadContext;
 import net.openhft.chronicle.map.WriteContext;
 import net.openhft.chronicle.map.jrs166.JSR166TestCase;
@@ -193,10 +193,10 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<Integer, String> newShmIntString(int port) throws IOException {
 
         final ChronicleMap<Integer, String> serverMap =
-                ChronicleMapBuilder.of(Integer.class, String.class)
+                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, String.class)
                         .replication((byte) 1, TcpTransportAndNetworkConfig.of(port)).create();
 
-        final ChronicleMap<Integer, String> statelessMap = ChronicleMapBuilder.of(Integer
+        final ChronicleMap<Integer, String> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
                 .class, String.class)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
 
@@ -207,11 +207,11 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<CharSequence, CharSequence> newStrStrMap(int port) throws
             IOException {
 
-        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
+        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port)).create();
 
 
-        final ChronicleMap<CharSequence, CharSequence> statelessMap = ChronicleMapBuilder.of(CharSequence
+        final ChronicleMap<CharSequence, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence
                 .class, CharSequence.class)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
 
@@ -221,12 +221,12 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<byte[], byte[]> newByteArrayMap(int port) throws
             IOException {
 
-        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapBuilder.of(byte[].class, byte[].class)
+        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port)).create();
 
 
-        final ChronicleMap<byte[], byte[]> statelessMap = ChronicleMapBuilder.of(
+        final ChronicleMap<byte[], byte[]> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(
                 byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
diff --git a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
index cecae189c..d93f2878d 100644
--- a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
+++ b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.utility;
 
 import net.openhft.affinity.AffinitySupport;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
 import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.model.constraints.MaxSize;
 
@@ -134,8 +134,8 @@ public class ProcessInstanceLimiter implements Runnable {
     public ProcessInstanceLimiter(String sharedMapPath, Callback callback) throws IOException {
         this.sharedMapPath = sharedMapPath;
         this.callback = callback;
-        ChronicleMapBuilder<String, Data> builder =
-                ChronicleMapBuilder.of(String.class, Data.class);
+        ChronicleMapOnHeapUpdatableBuilder<String, Data> builder =
+                ChronicleMapOnHeapUpdatableBuilder.of(String.class, Data.class);
         builder.entries(1000);
         builder.entrySize(1024);
         this.theSharedMap = builder.createPersistedTo(new File(sharedMapPath));

From 54b5412e5300841baa5172cbe2458524078581cb Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 15:05:07 +0000
Subject: [PATCH 06/11] HCOLL-81 simplified code by using lookupUsing

---
 .../openhft/chronicle/map/TcpReplicator.java  | 17 +++---------
 .../chronicle/map/VanillaChronicleMap.java    | 26 -------------------
 .../chronicle/map/ChronicleMapTest.java       | 12 ++++-----
 3 files changed, 10 insertions(+), 45 deletions(-)

diff --git a/src/main/java/net/openhft/chronicle/map/TcpReplicator.java b/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
index b86f16cd1..1b895a7c1 100644
--- a/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
+++ b/src/main/java/net/openhft/chronicle/map/TcpReplicator.java
@@ -1348,21 +1348,12 @@ class StatelessServerConnector<K, V> {
         final ThreadLocalCopies local = keyValueSerializer.threadLocalCopies();
         final K key = readKey(reader, local);
 
-        V value = using.getAndSet(null);
-        if (value == null) {
-
-            //value = map.createValueInstance();
-
-            // todo replace this
-            value = map.acquireUsing(key, null);
-        }
-
-
-
+        final V value = using.getAndSet(null);
         final Function<V, ?> o = (Function<V, ?>) reader.readObject();
 
-        try (WriteContext<K, V> wc = map.acquireUsingLocked(key, value)) {
-            Object result = o.apply(value);
+        try (WriteContext<K, V> wc = map.lookupUsing(key, value, VanillaChronicleMap.LockType.WRITE_LOCK,
+                false)) {
+            Object result = o.apply(wc.value());
             keyValueSerializer.writeObject(result, writer);
 
         } catch (RuntimeException e) {
diff --git a/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java b/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
index 400b55c2e..908ee3ccc 100755
--- a/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
@@ -29,10 +29,7 @@ import net.openhft.lang.collection.DirectBitSet;
 import net.openhft.lang.collection.SingleThreadedDirectBitSet;
 import net.openhft.lang.io.*;
 import net.openhft.lang.io.serialization.JDKObjectSerializer;
-import net.openhft.lang.io.serialization.impl.AllocateInstanceObjectFactory;
 import net.openhft.lang.io.serialization.impl.VanillaBytesMarshallerFactory;
-import net.openhft.lang.model.Byteable;
-import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.model.constraints.Nullable;
 import net.openhft.lang.threadlocal.Provider;
 import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -353,30 +350,7 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
     }
 
 
-    V createValueInstance() {
 
-        if (vClass.isAssignableFrom(Byteable.class))
-            return DataValueClasses.newDirectReference(vClass);
-        else {
-
-
-            try {
-                return vClass.newInstance();
-            } catch (InstantiationException e) {
-                try {
-                    return (V) (new AllocateInstanceObjectFactory<V>(vClass)).create();
-                } catch (Exception e1) {
-                    LOG.error("", e);
-                    return null;
-                }
-            } catch (IllegalAccessException e) {
-                LOG.error("", e);
-                return null;
-            }
-
-
-        }
-    }
 
     enum LockType {READ_LOCK, WRITE_LOCK}
 
diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index d8e3558c1..4bec46de5 100755
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -1494,16 +1494,16 @@ public class ChronicleMapTest {
     @Test
     public void testOnheapAcquireUsingLockedStringBuilder() throws IOException {
 
-        try (final ChronicleMap<CharSequence, StringBuilder> map = ChronicleMapOnHeapUpdatableBuilder
-                .of(CharSequence.class, StringBuilder.class)
+        try (final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
+                .of(CharSequence.class, CharSequence.class)
                 .entries(1000)
-
-                .entrySize(40).create()) {
+                .entrySize(40)
+                .defaultValue("")
+                .create()) {
 
             StringBuilder value = new StringBuilder();
 
-
-            try (WriteContext<?, StringBuilder> context = map.acquireUsingLocked("one", value)) {
+            try (WriteContext<?, CharSequence> context = map.acquireUsingLocked("one", value)) {
                 value.append("Hello World");
             }
 

From 48c588c4aa02abf9201b3c6ea12d63b768c5d3e4 Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 15:11:53 +0000
Subject: [PATCH 07/11] HCOLL-81 added test for when there is no entry

---
 .../chronicle/map/StatelessClientTest.java    | 30 +++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index dc747b148..21a3d3ba2 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -71,11 +71,12 @@ public class StatelessClientTest {
 
 
     @Test
-    public void testMapForKey() throws IOException, InterruptedException {
+    public void testMapForKeyWithEntry() throws IOException, InterruptedException {
 
 
         try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
                 StringBuilder.class)
+                .defaultValue(new StringBuilder())
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, new StringBuilder("Hello World"));
@@ -84,7 +85,8 @@ public class StatelessClientTest {
                     .class, StringBuilder.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
-                String actual = (String) ((StatelessChronicleMap) statelessMap).mapForKey(10, new StringBuilderToStringFunction());
+                String actual = (String) ((StatelessChronicleMap) statelessMap).mapForKey(10, new
+                        StringBuilderToStringFunction());
 
                 Assert.assertEquals("Hello World", actual);
             }
@@ -92,6 +94,30 @@ public class StatelessClientTest {
     }
 
 
+
+    @Test
+    public void testMapForKeyWhenNoEntry() throws IOException, InterruptedException {
+
+
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+                StringBuilder.class)
+                .defaultValue(new StringBuilder())
+                .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
+
+            serverMap.put(10, new StringBuilder("Hello World"));
+
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+                    .class, StringBuilder.class)
+                    .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
+
+                String actual = (String) ((StatelessChronicleMap) statelessMap).mapForKey(11, new
+                        StringBuilderToStringFunction());
+
+                Assert.assertEquals("", actual);
+            }
+        }
+    }
+
     @Test(timeout = 5000)
     public void testBufferOverFlowPutAllAndEntrySet() throws IOException, InterruptedException {
 

From cc94c22ab9b87c92592a31862e4a2c3af5805a4e Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 15:57:09 +0000
Subject: [PATCH 08/11] HCOLL-81 moved java8 code to its own module

---
 pom.xml                                       |  2 +-
 .../chronicle/map/StatelessClientTest.java    | 21 -------------------
 2 files changed, 1 insertion(+), 22 deletions(-)

diff --git a/pom.xml b/pom.xml
index 27d2dfc31..72d5d7bdb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -144,7 +144,7 @@
                 <artifactId>maven-javadoc-plugin</artifactId>
                 <configuration>
                     <links>
-                        <link>http://openhft.github.io/Java-Lang/apidocs/</link>
+                        <link>http://openhft.github.io/Chronicle-Map/apidocs/</link>
                     </links>
                     <excludePackageNames>net.openhft.chronicle.hash.serialization.internal</excludePackageNames>
                 </configuration>
diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index 21a3d3ba2..1842fd8a6 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -49,27 +49,6 @@ public class StatelessClientTest {
     }
 
 
-  /* Java8 test only
-  public void testMapForKeyLambda() throws IOException, InterruptedException {
-
-        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
-                StringBuilder.class)
-                .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
-
-            serverMap.put(10, new StringBuilder("Hello World"));
-
-            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
-                    .class, StringBuilder.class)
-                    .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
-
-                String actual = (String) ((StatelessChronicleMap) statelessMap).mapForKey(10, b -> b.toString());
-
-                Assert.assertEquals("Hello World", actual);
-            }
-        }
-    }*/
-
-
     @Test
     public void testMapForKeyWithEntry() throws IOException, InterruptedException {
 

From 88df95fc76f9ebdded18eb38b0fee4f07214e6e5 Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Fri, 14 Nov 2014 17:40:03 +0000
Subject: [PATCH 09/11] HCOLL-81 updated - What is the difference between
 [SharedHashMap](https://github.com/OpenHFT/HugeCollections) and Chronicle Map

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 7385846ad..25aee887c 100644
--- a/README.md
+++ b/README.md
@@ -117,9 +117,9 @@ hardware or get more hardware. Chronicle Map on the other hand sends the latest
 This will naturally drop updates and is a more natural choice for low bandwidth connections.
 
 #### What is the difference between [SharedHashMap](https://github.com/OpenHFT/HugeCollections) and Chronicle Map
-SharedHashMap is an outdated version of ChronicleMap project.
-Effectively SharedHashMap has just been renamed to ChronicleMap, to further enrich the Chronicle
-product suite. In addition, The original Chronicle has been renamed to Chronicle Queue.
+SharedHashMap was the old name given to ChronicleMap, Since the last release of SharedHashMap
+ we have added a lot of new features to ChronicleMap, most of these are listed in this readme.
+
 
 
 ## Getting Started

From 49fc12375573acb16475762c34ce448b81d8b0cf Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Sat, 15 Nov 2014 09:05:26 +0000
Subject: [PATCH 10/11] HCOLL-81 made publicly a single ChronicleMapBuilder,
 that delegates onto internal implementations

---
 .../map/AbstractChronicleMapBuilder.java      |  10 +-
 .../openhft/chronicle/map/ChronicleMap.java   |   4 +-
 .../chronicle/map/ChronicleMapBuilder.java    | 488 +++++++++++++++---
 .../chronicle/map/ChronicleMapBuilderI.java   | 299 +++++++++++
 .../ChronicleMapOnHeapUpdatableBuilder.java   | 284 ----------
 .../openhft/chronicle/map/NodeDiscovery.java  |   4 +-
 .../OffHeapUpdatableChronicleMapBuilder.java  | 172 ++++++
 .../OnHeapUpdatableChronicleMapBuilder.java   | 311 +++++++++++
 .../chronicle/map/StatelessChronicleMap.java  |   7 +-
 .../chronicle/set/ChronicleSetBuilder.java    |   6 +-
 .../net/openhft/chronicle/set/DummyValue.java |   2 +-
 src/test/java/eg/BigData.java                 |   7 +-
 .../net/openhft/chronicle/map/Builder.java    |   7 +-
 .../chronicle/map/CHMMetaDataTest.java        |   2 +-
 .../net/openhft/chronicle/map/CHMTest5.java   |   2 +-
 .../chronicle/map/CHMTestIterator1.java       |   2 +-
 .../chronicle/map/ChannelReplicationTest.java |   8 +-
 .../chronicle/map/ChronicleMapTest.java       |  30 +-
 .../chronicle/map/ConcurrentMap8Test.java     |   4 +-
 .../map/ConstantSizeBySampleTest.java         |   8 +-
 .../chronicle/map/DefaultValueTest.java       |   4 +-
 .../chronicle/map/EntryCountMapTest.java      |   3 +-
 ...tListenerTestWithTCPSocketReplication.java |  16 +-
 .../net/openhft/chronicle/map/GuavaTest.java  |   4 +-
 .../chronicle/map/IntValueMapTest.java        |   2 +-
 .../openhft/chronicle/map/Issue42Test.java    |   2 +-
 .../openhft/chronicle/map/KeySizesTest.java   |   2 +-
 .../openhft/chronicle/map/OSResizesMain.java  |   2 +-
 .../map/PostChannelCreationTest.java          |   8 +-
 .../map/ProcessInstanceLimiterMain.java       |   4 +-
 .../map/RecursiveRefereneChMapTest.java       |   2 +-
 .../map/ReplicatedChronicleMapTest.java       |   4 +-
 .../openhft/chronicle/map/SerializerTest.java |  13 +-
 .../chronicle/map/SingleMapChannelTest.java   |   4 +-
 .../chronicle/map/StatelessClientTest.java    |  52 +-
 ...cketReplication3wayPutReturnsNullTest.java |   2 +-
 .../TCPSocketReplicationBootStrapTest.java    |   4 +-
 .../map/TCPSocketReplicationIntValueTest.java |   2 +-
 ...CPSocketReplicationPostConnectionTest.java |   2 +-
 .../map/TCPSocketReplicationTest.java         |   2 +-
 .../chronicle/map/TestBooleanValues.java      |   2 +-
 .../map/TimeBasedReplicationTest.java         |  20 +-
 .../map/TwoMapOnDifferentServersTest.java     |   4 +-
 .../map/UDPSocketReplicationTest.java         |   2 +-
 .../chronicle/map/example/ChannelExample.java |  11 +-
 .../map/example/DistributedSequenceMain.java  |   4 +-
 .../chronicle/map/example/ServersMapMain.java |   8 +-
 .../chronicle/map/example/StringsMapMain.java |   9 +-
 .../pingpong_latency/PingPongCASLeft.java     |   4 +-
 .../map/ipc/StateMachineTutorial.java         |   4 +-
 .../map/jrs166/map/ChronicleMapTest.java      |  14 +-
 .../chronicle/map/jrs166/map/MapCheck.java    |   4 +-
 .../jrs166/map/StatelessChronicleMapTest.java |  14 +-
 .../map/utility/ProcessInstanceLimiter.java   |   6 +-
 54 files changed, 1373 insertions(+), 524 deletions(-)
 create mode 100644 src/main/java/net/openhft/chronicle/map/ChronicleMapBuilderI.java
 delete mode 100644 src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
 create mode 100644 src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
 create mode 100644 src/main/java/net/openhft/chronicle/map/OnHeapUpdatableChronicleMapBuilder.java

diff --git a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
index c7cfe7fac..7aaed90a9 100644
--- a/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
@@ -57,7 +57,7 @@ import static net.openhft.chronicle.map.Objects.builderEquals;
 
 /**
  * {@code AbstractChronicleMapBuilder} manages most of {@link ChronicleMap} configurations; has two concrete
- * subclasses: {@link ChronicleMapOnHeapUpdatableBuilder} should be used to create maps with ordinary values, {@link
+ * subclasses: {@link OnHeapUpdatableChronicleMapBuilder} should be used to create maps with ordinary values, {@link
  * ChronicleMapBuilder} -- maps with {@link Byteable} values, which point directly to off-heap
  * memory; could be used as a classic builder and/or factory. This means
  * that in addition to the standard builder usage pattern: <pre>{@code
@@ -66,7 +66,7 @@ import static net.openhft.chronicle.map.Objects.builderEquals;
  *     .entries(100500)
  *     // ... other configurations
  *     .create();}</pre>
- * one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link ChronicleMapOnHeapUpdatableBuilder} or {@link
+ * one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link OnHeapUpdatableChronicleMapBuilder} or {@link
  * ChronicleMapBuilder}, could be prepared and used to create many similar
  * maps: <pre>{@code
  * ChronicleMapBuilder<Key, Value> builder = ChronicleMapBuilder
@@ -227,7 +227,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
      *
      * <p>For example, if your keys are Git commit hashes:<pre>{@code
      * Map<byte[], String> gitCommitMessagesByHash =
-     *     ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, String.class)
+     *     ChronicleMapBuilder.of(byte[].class, String.class)
      *     .constantKeySizeBySample(new byte[20])
      *     .create();}</pre>
      *
@@ -839,12 +839,10 @@ public abstract class AbstractChronicleMapBuilder<K, V,
     }
 
     /**
-     * Only for testing. Shouldn't be called concurrently on a single builder instance.
-     *
      * @param identifier id
      * @return map
      */
-    ChronicleMap<K, V> createReplicated(byte identifier) throws IOException {
+    public  ChronicleMap<K, V> createReplicated(byte identifier) throws IOException {
         preMapConstruction(true);
         VanillaChronicleMap<K, ?, ?, V, ?, ?> map =
                 new ReplicatedChronicleMap<K, Object, MetaBytesInterop<K, Object>,
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
index 0a0066f03..4bc5d71ed 100644
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMap.java
@@ -93,7 +93,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
      * for the key
      * @see #get(Object)
      * @see #acquireUsing(Object, Object)
-     * @see ChronicleMapOnHeapUpdatableBuilder#valueMarshaller(BytesMarshaller)
+     * @see OnHeapUpdatableChronicleMapBuilder#valueMarshaller(BytesMarshaller)
      */
     V getUsing(K key, V usingValue);
 
@@ -134,7 +134,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
      * no mapping for the key
      * @see #get(Object)
      * @see #getUsing(Object, Object)
-     * @see ChronicleMapOnHeapUpdatableBuilder#valueMarshaller(BytesMarshaller)
+     * @see OnHeapUpdatableChronicleMapBuilder#valueMarshaller(BytesMarshaller)
      */
     @NotNull
     ReadContext<K, V> getUsingLocked(@NotNull K key, @NotNull V usingValue);
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
index 8d28b4966..6f3c4d73a 100644
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
@@ -1,80 +1,109 @@
-/*
- * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package net.openhft.chronicle.map;
 
+import net.openhft.chronicle.hash.ChronicleHashErrorListener;
+import net.openhft.chronicle.hash.ChronicleHashInstanceConfig;
+import net.openhft.chronicle.hash.StatelessClientConfig;
+import net.openhft.chronicle.hash.replication.SingleChronicleHashReplication;
+import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
+import net.openhft.chronicle.hash.replication.TimeProvider;
+import net.openhft.chronicle.hash.serialization.BytesReader;
+import net.openhft.chronicle.hash.serialization.BytesWriter;
+import net.openhft.chronicle.hash.serialization.SizeMarshaller;
+import net.openhft.lang.io.serialization.BytesMarshaller;
+import net.openhft.lang.io.serialization.BytesMarshallerFactory;
+import net.openhft.lang.io.serialization.ObjectFactory;
+import net.openhft.lang.io.serialization.ObjectSerializer;
 import net.openhft.lang.model.Byteable;
 import net.openhft.lang.model.DataValueClasses;
 import org.jetbrains.annotations.NotNull;
 
-public final class ChronicleMapBuilder<K, V>
-        extends AbstractChronicleMapBuilder<K, V, ChronicleMapBuilder<K, V>> {
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
 
+/**
+ * {@code ChronicleMapBuilder} is intended to be used to create {@link ChronicleMap}s
+ *
+ * @param <K> key type of the maps, created by this builder
+ * @param <V> value type of the maps, created by this builder
+ * @see AbstractChronicleMapBuilder
+ * @see net.openhft.chronicle.hash.ChronicleHashBuilder
+ */
+public final class ChronicleMapBuilder<K, V> implements ChronicleMapBuilderI<K, V> {
+
+    final ChronicleMapBuilderI<K, V> delegate;
+
+    /**
+     * Returns a new {@code ChronicleMapBuilder} instance which is able to {@linkplain #create() create} maps
+     * with the specified key and value classes.
+     *
+     * <p>{@code ChronicleMapBuilder} analyzes provided key and value classes and automatically chooses the
+     * most specific internal builder.
+     *
+     * @param keyClass   class object used to infer key type and discover it's properties via reflection
+     * @param valueClass class object used to infer value type and discover it's properties via reflection
+     * @param <K>        key type of the maps, created by the returned builder
+     * @param <V>        value type of the maps, created by the returned builder
+     * @return a new builder for the given key and value classes
+     */
     public static <K, V> ChronicleMapBuilder<K, V> of(
             @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+
+        if (valueClass.isEnum())
+            return new ChronicleMapBuilder<K, V>(OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass));
+
         if (keyClass.isInterface() && keyClass != CharSequence.class) {
             keyClass = DataValueClasses.directClassFor(keyClass);
         }
-        if (valueClass.isInterface()) {
+
+        if ((valueClass.isInterface() && valueClass != CharSequence.class)) {
             valueClass = DataValueClasses.directClassFor(valueClass);
         } else if (!offHeapReference(valueClass)) {
-            throw new IllegalArgumentException(
-                    "Value class should be either Byteable subclass or interface," +
-                            "allowing direct Byteable implementation generation");
+            return new ChronicleMapBuilder<K, V>(OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass));
         }
-        return new ChronicleMapBuilder<K, V>(keyClass, valueClass);
+        OffHeapUpdatableChronicleMapBuilder<K, V> kvOffHeapUpdatableChronicleMapBuilder = new
+                OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
+        return new ChronicleMapBuilder<K, V>(kvOffHeapUpdatableChronicleMapBuilder);
     }
 
-    ChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
-        super(keyClass, valueClass);
-        prepareValueBytesOnAcquire(new ZeroOutValueBytes<K, V>(valueSize()));
+    ChronicleMapBuilder(ChronicleMapBuilderI<K, V> delegate) {
+        this.delegate = delegate;
     }
 
-    @Override
-    ChronicleMapBuilder<K, V> self() {
-        return this;
+
+    private static boolean offHeapReference(Class valueClass) {
+        return Byteable.class.isAssignableFrom(valueClass);
     }
 
+
     /**
      * {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
      *
      * <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
-     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30,
-     * and entry alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32
-     * (30 aligned to 4 bytes).
+     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
+     * alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
+     * bytes).
      *
-     * @see #entryAndValueAlignment(Alignment)
-     * @see #entries(long)
+     * @see #entryAndValueAlignment(Alignment) //  * @see #entries(long)
      */
     @Override
     public ChronicleMapBuilder<K, V> entrySize(int entrySize) {
-        return super.entrySize(entrySize);
+        delegate.entrySize(entrySize);
+        return this;
     }
 
     /**
-     * Configures alignment strategy of address in memory of entries and independently of address in
-     * memory of values within entries in ChronicleMaps, created by this builder.
+     * Configures alignment strategy of address in memory of entries and independently of address in memory of
+     * values within entries in ChronicleMaps, created by this builder.
      *
-     * <p>Useful when values of the map are updated intensively, particularly fields with volatile
-     * access, because it doesn't work well if the value crosses cache lines. Also, on some
-     * (nowadays rare) architectures any misaligned memory access is more expensive than aligned.
+     * <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
+     * because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
+     * architectures any misaligned memory access is more expensive than aligned.
      *
-     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this
-     * alignment. I. e. if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual
-     * entry size will be 24 (20 aligned to 8 bytes).
+     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
+     * if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
+     * aligned to 8 bytes).
      *
      * <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
      *
@@ -83,58 +112,369 @@ public final class ChronicleMapBuilder<K, V>
      */
     @Override
     public ChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
-        return super.entryAndValueAlignment(alignment);
+        delegate.entryAndValueAlignment(alignment);
+        return this;
     }
 
     /**
-     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
-     * configuration to this {@code ChronicleMapBuilder}.
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
+     * {@code ChronicleMapBuilder}.
      *
-     * <p>By default, the default value is not specified, default {@linkplain
-     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
+     * <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
+     * prepare value bytes routine} is specified instead.
      *
      * @see #defaultValueProvider(DefaultValueProvider)
      * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
      */
     @Override
     public ChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
-        return super.defaultValue(defaultValue);
+        delegate.defaultValue(defaultValue);
+        return this;
     }
 
     /**
-     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
-     * configuration to this {@code ChronicleMapBuilder}.
-     *
-     * <p>By default, the default value provider is not specified, default {@linkplain
-     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
-     *
-     * @see #defaultValue(Object)
-     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
-     */
-    @Override
-    public ChronicleMapBuilder<K, V> defaultValueProvider(
-            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
-        return super.defaultValueProvider(defaultValueProvider);
-    }
-
-    /**
-     * Configures the procedure which is called on the bytes, which later the returned value is
-     * pointing to, if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object)
-     * acquireUsing()} call on maps, created by this builder. See {@link PrepareValueBytes} for
-     * more information.
+     * Configures the procedure which is called on the bytes, which later the returned value is pointing to,
+     * if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
+     * created by this builder. See {@link PrepareValueBytes} for more information.
      *
      * <p>The default preparation callback zeroes out the value bytes.
      *
-     * @param prepareValueBytes what to do with the value bytes before assigning them into the
-     *                          {@link Byteable} value to return from {@code acquireUsing()} call
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
+     *                          net.openhft.lang.model.Byteable} value to return from {@code acquireUsing()}
+     *                          call
      * @return this builder back
      * @see PrepareValueBytes
      * @see #defaultValue(Object)
      * @see #defaultValueProvider(DefaultValueProvider)
      */
     @Override
-    public ChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
-            @NotNull PrepareValueBytes<K, V> prepareValueBytes) {
-        return super.prepareValueBytesOnAcquire(prepareValueBytes);
+    public ChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(@NotNull PrepareValueBytes<K, V> prepareValueBytes) {
+        delegate.prepareValueBytesOnAcquire(prepareValueBytes);
+        return this;
     }
+
+
+    @Override
+    public ChronicleMapBuilder<K, V> keySize(int keySize) {
+        delegate.keySize(keySize);
+        return this;
+    }
+
+
+    @Override
+    public ChronicleMapBuilder<K, V> constantKeySizeBySample(K sampleKey) {
+        delegate.constantKeySizeBySample(sampleKey);
+        return this;
+    }
+
+    /**
+     * Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
+     * instead of this one.
+     *
+     * <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
+     * accounted and shouldn't be specified by user.
+     *
+     * <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
+     * possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
+     * {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
+     *
+     * @param valueSize number of bytes, taken by serialized form of values
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     * @see #constantValueSizeBySample(Object)
+     * @see #keySize(int)
+     * @see #entrySize(int)
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> valueSize(int valueSize) {
+        delegate.valueSize(valueSize);
+        return this;
+    }
+
+    /**
+     * Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. This is done by providing the {@code sampleValue}, all values should take the same number
+     * of bytes in serialized form, as this sample object.
+     *
+     * <p>If values are of boxed primitive type or {@link net.openhft.lang.model.Byteable} subclass, i. e. if
+     * value size is known statically, it is automatically accounted and this method shouldn't be called.
+     *
+     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
+     * instead of this one.
+     *
+     * @param sampleValue the sample value
+     * @return this builder back
+     * @see #valueSize(int)
+     * @see #constantKeySizeBySample(Object)
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> constantValueSizeBySample(@NotNull V sampleValue) {
+        delegate.constantValueSizeBySample(sampleValue);
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Example: <pre>{@code Map<Key, Value> map =
+     *     ChronicleMapBuilder.of(Key.class, Value.class)
+     *     .entries(1_000_000)
+     *     .keySize(50).valueSize(200)
+     *     // this class hasn't implemented yet, just for example
+     *     .objectSerializer(new KryoObjectSerializer())
+     *     .create();}</pre>
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> objectSerializer(@NotNull ObjectSerializer objectSerializer) {
+        delegate.objectSerializer(objectSerializer);
+        return this;
+    }
+
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws IllegalStateException if custom value marshaller is specified or value class is not either
+     *                               {@code BytesMarshallable} or {@code Externalizable}
+     */
+
+    @Override
+    public ChronicleMapBuilder<K, V> valueDeserializationFactory(@NotNull ObjectFactory<V> valueDeserializationFactory) {
+        delegate.valueDeserializationFactory(valueDeserializationFactory);
+        return this;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
+     * specified instead.
+     *
+     * @see #defaultValue(Object)
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> defaultValueProvider(@NotNull DefaultValueProvider<K, V> defaultValueProvider) {
+        delegate.defaultValueProvider(defaultValueProvider);
+        return this;
+    }
+
+    /**
+     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
+     * maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * @param valueMarshaller the marshaller used to serialize values
+     * @return this builder back
+     * @see #valueMarshallers(net.openhft.chronicle.hash.serialization.BytesWriter,
+     * net.openhft.chronicle.hash.serialization.BytesReader)
+     * @see ChronicleMapBuilder
+     * @see #objectSerializer(ObjectSerializer)
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> valueMarshaller(
+            @NotNull BytesMarshaller<V> valueMarshaller) {
+        delegate.valueMarshaller(valueMarshaller);
+        return this;
+    }
+
+    /**
+     * Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
+     * created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
+     * comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
+     *
+     * <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
+     * net.openhft.chronicle.hash.serialization.BytesWriter} is, of cause, possible, but currently pointless
+     * for values.
+     *
+     * @param valueWriter the new value object &rarr; {@link net.openhft.lang.io.Bytes} writer (interop)
+     *                    strategy
+     * @param valueReader the new {@link net.openhft.lang.io.Bytes} &rarr; value object reader strategy
+     * @return this builder back
+     * @see #valueMarshaller(BytesMarshaller)
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> valueMarshallers(@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
+        delegate.valueMarshallers(valueWriter, valueReader);
+        return this;
+    }
+
+
+    /**
+     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
+     * this builder.
+     *
+     * <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
+     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
+     * is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
+     * implementation knows about it, this configuration takes no effect, because a special {@link
+     * net.openhft.chronicle.hash.serialization.SizeMarshaller} implementation, which doesn't actually do any
+     * marshalling, and just returns the known constant size on {@link net.openhft.chronicle.hash.serialization.SizeMarshaller#readSize(
+     *net.openhft.lang.io.Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this
+     * method.
+     *
+     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
+     * @return this builder back
+     */
+    @Override
+    public ChronicleMapBuilder<K, V> valueSizeMarshaller(@NotNull SizeMarshaller valueSizeMarshaller) {
+        delegate.valueSizeMarshaller(valueSizeMarshaller);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> entries(long l) {
+        delegate.entries(l);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> replication(SingleChronicleHashReplication withId) {
+        delegate.replication(withId);
+        return this;
+
+    }
+
+    @Override
+    public ChronicleMap create() throws IOException {
+        return delegate.create();
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> actualSegments(int actualSegments) {
+        delegate.actualSegments(actualSegments);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> minSegments(int minSegments) {
+        delegate.minSegments(minSegments);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> actualEntriesPerSegment(long actualEntriesPerSegment) {
+        delegate.actualEntriesPerSegment(actualEntriesPerSegment);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> lockTimeOut(long lockTimeOut, TimeUnit unit) {
+        delegate.lockTimeOut(lockTimeOut, unit);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> errorListener(ChronicleHashErrorListener errorListener) {
+        delegate.errorListener(errorListener);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> metaDataBytes(int metaDataBytes) {
+        delegate.metaDataBytes(metaDataBytes);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> timeProvider(TimeProvider timeProvider) {
+        delegate.timeProvider(timeProvider);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> bytesMarshallerFactory(BytesMarshallerFactory bytesMarshallerFactory) {
+        delegate.bytesMarshallerFactory(bytesMarshallerFactory);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> keyMarshaller(BytesMarshaller<K> keyMarshaller) {
+        delegate.keyMarshaller(keyMarshaller);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> keyMarshallers(BytesWriter<K> keyWriter, BytesReader<K> keyReader) {
+        delegate.keyMarshallers(keyWriter, keyReader);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> keySizeMarshaller(SizeMarshaller keySizeMarshaller) {
+        delegate.keySizeMarshaller(keySizeMarshaller);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> keyDeserializationFactory(ObjectFactory<K> keyDeserializationFactory) {
+        delegate.keyDeserializationFactory(keyDeserializationFactory);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> immutableKeys() {
+        delegate.immutableKeys();
+        return this;
+    }
+
+
+    @Override
+    public StatelessClientConfig<ChronicleMap<K, V>> statelessClient(InetSocketAddress remoteAddress) {
+        return delegate.statelessClient(remoteAddress);
+    }
+
+    @Override
+    public ChronicleHashInstanceConfig<ChronicleMap<K, V>> instance() {
+        return delegate.instance();
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> replication(byte identifier) {
+        delegate.replication(identifier);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork) {
+        delegate.replication(identifier, tcpTransportAndNetwork);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> clone() {
+        delegate.clone();
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> putReturnsNull(boolean b) {
+        delegate.putReturnsNull(b);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> removeReturnsNull(boolean b) {
+        delegate.removeReturnsNull(b);
+        return this;
+    }
+
+    @Override
+    public ChronicleMapBuilder<K, V> eventListener(MapEventListener<K, V, ChronicleMap<K, V>> eventListener) {
+        delegate.eventListener(eventListener);
+        return this;
+    }
+
+    @Override
+    public ChronicleMap<K, V> createReplicated(byte b) throws IOException {
+        return delegate.createReplicated(b);
+    }
+
+    @Override
+    public ChronicleMap<K, V> createPersistedTo(File file) throws IOException {
+        return delegate.createPersistedTo(file);
+    }
+
 }
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilderI.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilderI.java
new file mode 100644
index 000000000..f121b6c7e
--- /dev/null
+++ b/src/main/java/net/openhft/chronicle/map/ChronicleMapBuilderI.java
@@ -0,0 +1,299 @@
+package net.openhft.chronicle.map;
+
+import net.openhft.chronicle.hash.ChronicleHashErrorListener;
+import net.openhft.chronicle.hash.ChronicleHashInstanceConfig;
+import net.openhft.chronicle.hash.StatelessClientConfig;
+import net.openhft.chronicle.hash.replication.SingleChronicleHashReplication;
+import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
+import net.openhft.chronicle.hash.replication.TimeProvider;
+import net.openhft.chronicle.hash.serialization.BytesReader;
+import net.openhft.chronicle.hash.serialization.BytesWriter;
+import net.openhft.chronicle.hash.serialization.SizeMarshaller;
+import net.openhft.lang.io.serialization.BytesMarshaller;
+import net.openhft.lang.io.serialization.BytesMarshallerFactory;
+import net.openhft.lang.io.serialization.ObjectFactory;
+import net.openhft.lang.io.serialization.ObjectSerializer;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author Rob Austin.
+ */
+interface ChronicleMapBuilderI<K, V> {
+
+
+    /**
+     * {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
+     *
+     * <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
+     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
+     * alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
+     * bytes).
+     *
+     * @see #entryAndValueAlignment(Alignment) //  * @see #entries(long)
+     */
+    ChronicleMapBuilderI<K, V> entrySize(int entrySize);
+
+    /**
+     * Configures alignment strategy of address in memory of entries and independently of address in memory of
+     * values within entries in ChronicleMaps, created by this builder.
+     *
+     * <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
+     * because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
+     * architectures any misaligned memory access is more expensive than aligned.
+     *
+     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
+     * if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
+     * aligned to 8 bytes).
+     *
+     * <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
+     *
+     * @param alignment the new alignment of the maps constructed by this builder
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     */
+    ChronicleMapBuilderI<K, V> entryAndValueAlignment(Alignment alignment);
+
+
+    /**
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
+     * {@code ChronicleMapBuilder}.
+     *
+     * <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
+     * prepare value bytes routine} is specified instead.
+     *
+     * @see #defaultValueProvider(DefaultValueProvider)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
+     */
+    ChronicleMapBuilderI<K, V> defaultValue(V defaultValue);
+
+
+    /**
+     * Configures the procedure which is called on the bytes, which later the returned value is pointing to,
+     * if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
+     * created by this builder. See {@link PrepareValueBytes} for more information.
+     *
+     * <p>The default preparation callback zeroes out the value bytes.
+     *
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
+     *                          net.openhft.lang.model.Byteable} value to return from {@code acquireUsing()}
+     *                          call
+     * @return this builder back
+     * @see PrepareValueBytes
+     * @see #defaultValue(Object)
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    ChronicleMapBuilderI<K, V> prepareValueBytesOnAcquire(
+            @NotNull PrepareValueBytes<K, V> prepareValueBytes);
+
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #constantKeySizeBySample(Object)
+     * @see #valueSize(int)
+     * @see #entrySize(int)
+     */
+    ChronicleMapBuilderI<K, V> keySize(int keySize);
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #keySize(int)
+     * @see #constantValueSizeBySample(Object)
+     */
+
+    ChronicleMapBuilderI<K, V> constantKeySizeBySample(K sampleKey);
+
+    /**
+     * Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
+     * instead of this one.
+     *
+     * <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
+     * accounted and shouldn't be specified by user.
+     *
+     * <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
+     * possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
+     * {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
+     *
+     * @param valueSize number of bytes, taken by serialized form of values
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     * @see #constantValueSizeBySample(Object)
+     * @see #keySize(int)
+     * @see #entrySize(int)
+     */
+
+    ChronicleMapBuilderI<K, V> valueSize(int valueSize);
+
+    /**
+     * Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. This is done by providing the {@code sampleValue}, all values should take the same number
+     * of bytes in serialized form, as this sample object.
+     *
+     * <p>If values are of boxed primitive type or {@link net.openhft.lang.model.Byteable} subclass, i. e. if
+     * value size is known statically, it is automatically accounted and this method shouldn't be called.
+     *
+     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
+     * instead of this one.
+     *
+     * @param sampleValue the sample value
+     * @return this builder back
+     * @see #valueSize(int)
+     * @see #constantKeySizeBySample(Object)
+     */
+
+
+    ChronicleMapBuilderI<K, V> constantValueSizeBySample(
+            @NotNull V sampleValue);
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Example: <pre>{@code Map<Key, Value> map =
+     *     ChronicleMapBuilder.of(Key.class, Value.class)
+     *     .entries(1_000_000)
+     *     .keySize(50).valueSize(200)
+     *     // this class hasn't implemented yet, just for example
+     *     .objectSerializer(new KryoObjectSerializer())
+     *     .create();}</pre>
+     */
+
+    ChronicleMapBuilderI<K, V> objectSerializer(
+            @NotNull ObjectSerializer objectSerializer);
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws IllegalStateException if custom value marshaller is specified or value class is not either
+     *                               {@code BytesMarshallable} or {@code Externalizable}
+     */
+
+    ChronicleMapBuilderI<K, V> valueDeserializationFactory(
+            @NotNull ObjectFactory<V> valueDeserializationFactory);
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
+     * specified instead.
+     *
+     * @see #defaultValue(Object)
+     */
+
+    ChronicleMapBuilderI<K, V> defaultValueProvider(
+            @NotNull DefaultValueProvider<K, V> defaultValueProvider);
+
+    /**
+     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
+     * maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * @param valueMarshaller the marshaller used to serialize values
+     * @return this builder back
+     * @see #valueMarshallers(net.openhft.chronicle.hash.serialization.BytesWriter,
+     * net.openhft.chronicle.hash.serialization.BytesReader)
+     * @see ChronicleMapBuilder
+     * @see #objectSerializer(ObjectSerializer)
+     */
+   ChronicleMapBuilderI<K, V> valueMarshaller(
+            @NotNull BytesMarshaller<V> valueMarshaller);
+
+
+    /**
+     * Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
+     * created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
+     * comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
+     *
+     * <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
+     * net.openhft.chronicle.hash.serialization.BytesWriter} is, of cause, possible, but currently pointless
+     * for values.
+     *
+     * @param valueWriter the new value object &rarr; {@link net.openhft.lang.io.Bytes} writer (interop)
+     *                    strategy
+     * @param valueReader the new {@link net.openhft.lang.io.Bytes} &rarr; value object reader strategy
+     * @return this builder back
+     * @see #valueMarshaller(BytesMarshaller)
+     */
+    ChronicleMapBuilderI<K, V> valueMarshallers(
+            @NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader);
+
+    /**
+     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
+     * this builder.
+     *
+     * <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
+     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
+     * is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
+     * implementation knows about it, this configuration takes no effect, because a special {@link
+     * net.openhft.chronicle.hash.serialization.SizeMarshaller} implementation, which doesn't actually do any
+     * marshalling, and just returns the known constant size on {@link net.openhft.chronicle.hash.serialization.SizeMarshaller#readSize(
+     *net.openhft.lang.io.Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this
+     * method.
+     *
+     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
+     * @return this builder back
+     */
+    ChronicleMapBuilderI<K, V> valueSizeMarshaller(
+            @NotNull SizeMarshaller valueSizeMarshaller);
+
+    ChronicleMapBuilderI<K, V> entries(long l);
+
+    ChronicleMapBuilderI<K, V> replication(SingleChronicleHashReplication withId);
+
+    ChronicleMap<K, V> create() throws IOException;
+
+    ChronicleMapBuilderI<K, V> actualSegments(int actualSegments);
+
+    ChronicleMapBuilderI<K, V> minSegments(int minSegments);
+
+    ChronicleMapBuilderI<K, V> actualEntriesPerSegment(long actualEntriesPerSegment);
+
+    ChronicleMapBuilderI<K, V> lockTimeOut(long lockTimeOut, TimeUnit unit);
+
+    ChronicleMapBuilderI<K, V> errorListener(ChronicleHashErrorListener errorListener);
+
+    ChronicleMapBuilderI<K, V> metaDataBytes(int metaDataBytes);
+
+    ChronicleMapBuilderI<K, V> timeProvider(TimeProvider timeProvider);
+
+    ChronicleMapBuilderI<K, V> bytesMarshallerFactory(BytesMarshallerFactory bytesMarshallerFactory);
+
+    ChronicleMapBuilderI<K, V> keyMarshaller(BytesMarshaller<K> keyMarshaller);
+
+    ChronicleMapBuilderI<K, V> keyMarshallers(BytesWriter<K> keyWriter, BytesReader<K> keyReader);
+
+    ChronicleMapBuilderI<K, V> keySizeMarshaller(SizeMarshaller keySizeMarshaller);
+
+    ChronicleMapBuilderI<K, V> keyDeserializationFactory(ObjectFactory<K> keyDeserializationFactory);
+
+    ChronicleMapBuilderI<K, V> immutableKeys();
+
+    ChronicleMap<K, V> createPersistedTo(File file) throws IOException;
+
+    StatelessClientConfig<ChronicleMap<K, V>> statelessClient(InetSocketAddress remoteAddress);
+
+    ChronicleHashInstanceConfig<ChronicleMap<K, V>> instance();
+
+    ChronicleMapBuilderI<K, V> replication(byte identifier);
+
+    ChronicleMapBuilderI<K, V> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork);
+
+    ChronicleMapBuilderI<K, V> clone();
+
+    ChronicleMapBuilderI<K, V> eventListener(MapEventListener<K, V, ChronicleMap<K, V>> eventListener);
+
+    ChronicleMapBuilderI<K, V> putReturnsNull(boolean b);
+
+    ChronicleMap<K, V> createReplicated(byte b) throws IOException;
+
+    ChronicleMapBuilderI<K, V> removeReturnsNull(boolean b);
+
+
+}
diff --git a/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java b/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
deleted file mode 100644
index 8b9e98ee6..000000000
--- a/src/main/java/net/openhft/chronicle/map/ChronicleMapOnHeapUpdatableBuilder.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.openhft.chronicle.map;
-
-import net.openhft.chronicle.hash.ChronicleHashBuilder;
-import net.openhft.chronicle.hash.serialization.*;
-import net.openhft.lang.io.Bytes;
-import net.openhft.lang.io.serialization.BytesMarshallable;
-import net.openhft.lang.io.serialization.BytesMarshaller;
-import net.openhft.lang.io.serialization.ObjectFactory;
-import net.openhft.lang.io.serialization.ObjectSerializer;
-import net.openhft.lang.model.Byteable;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.Externalizable;
-import java.io.Serializable;
-
-
-/**
- * {@code ChronicleMapOnHeapUpdatableBuilder} is intended to be used to configure {@link ChronicleMap}s with
- * non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives
- * ({@link Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values
- * implementing {@link BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface,
- * or any other values for which {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller}
- * is provided.
- *
- * <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain
- * a {@code ChronicleMapOnHeapUpdatableBuilder} instance.
- *
- * @param <K> key type of the maps, created by this builder
- * @param <V> value type of the maps, created by this builder
- * @see ChronicleMapBuilder
- * @see AbstractChronicleMapBuilder
- * @see ChronicleHashBuilder
- */
-public final class ChronicleMapOnHeapUpdatableBuilder<K, V>
-        extends AbstractChronicleMapBuilder<K, V, ChronicleMapOnHeapUpdatableBuilder<K, V>> {
-
-    /**
-     * Returns a new {@code ChronicleMapOnHeapUpdatableBuilder} instance which is able to {@linkplain #create()
-     * create} maps with the specified key and value classes.
-     *
-     * <p>{@code ChronicleMapOnHeapUpdatableBuilder} analyzes provided key and value classes and automatically
-     * chooses the most specific and effective serializer which it is aware about. Read
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
-     * serialization in Chronicle Map manual</a> for more information.
-     *
-     * @param keyClass class object used to infer key type and discover it's properties
-     *                 via reflection
-     * @param valueClass class object used to infer value type and discover it's properties
-     *                   via reflection
-     * @param <K> key type of the maps, created by the returned builder
-     * @param <V> value type of the maps, created by the returned builder
-     * @return a new builder for the given key and value classes
-     */
-    public static <K, V> ChronicleMapOnHeapUpdatableBuilder<K, V> of(
-            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
-        return new ChronicleMapOnHeapUpdatableBuilder<K, V>(keyClass, valueClass);
-    }
-
-    ChronicleMapOnHeapUpdatableBuilder(Class<K> keyClass, Class<V> valueClass) {
-        super(keyClass, valueClass);
-    }
-
-    @Override
-    ChronicleMapOnHeapUpdatableBuilder<K, V> self() {
-        return this;
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @see #constantKeySizeBySample(Object)
-     * @see #valueSize(int)
-     * @see #entrySize(int)
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> keySize(int keySize) {
-        return super.keySize(keySize);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * @see #keySize(int)
-     * @see #constantValueSizeBySample(Object)
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> constantKeySizeBySample(K sampleKey) {
-        return super.constantKeySizeBySample(sampleKey);
-    }
-
-    /**
-     * Configures the optimal number of bytes, taken by serialized form of values, put into maps,
-     * created by this builder. If value size is always the same, call {@link
-     * #constantValueSizeBySample(Object)} method instead of this one.
-     *
-     * <p>If value is a boxed primitive type, i. e. if value size is known statically,
-     * it is automatically accounted and shouldn't be specified by user.
-     *
-     * <p>If value size varies moderately, specify the size higher than average, but lower than the
-     * maximum possible, to minimize average memory overuse. If value size varies in a wide range,
-     * it's better to use {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it
-     * directly.
-     *
-     * @param valueSize number of bytes, taken by serialized form of values
-     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
-     * @see #constantValueSizeBySample(Object)
-     * @see #keySize(int)
-     * @see #entrySize(int)
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueSize(int valueSize) {
-        return super.valueSize(valueSize);
-    }
-
-    /**
-     * Configures the constant number of bytes, taken by serialized form of values, put into maps,
-     * created by this builder. This is done by providing the {@code sampleValue}, all values should
-     * take the same number of bytes in serialized form, as this sample object.
-     *
-     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
-     * known statically, it is automatically accounted and this method shouldn't be called.
-     *
-     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be
-     * called instead of this one.
-     *
-     * @param sampleValue the sample value
-     * @return this builder back
-     * @see #valueSize(int)
-     * @see #constantKeySizeBySample(Object)
-     */
-
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> constantValueSizeBySample(
-            @NotNull V sampleValue) {
-        return super.constantValueSizeBySample(sampleValue);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>Example: <pre>{@code Map<Key, Value> map =
-     *     ChronicleMapOnHeapUpdatableBuilder.of(Key.class, Value.class)
-     *     .entries(1_000_000)
-     *     .keySize(50).valueSize(200)
-     *     // this class hasn't implemented yet, just for example
-     *     .objectSerializer(new KryoObjectSerializer())
-     *     .create();}</pre>
-     *
-     * <p>This serializer is used to serialize both keys and values, if they both require this:
-     * loosely typed, nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and
-     * {@linkplain #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> objectSerializer(
-            @NotNull ObjectSerializer objectSerializer) {
-        return super.objectSerializer(objectSerializer);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured,
-     * this configuration is unused, because it is incapsulated in {@link
-     * BytesMarshaller#read(Bytes)} method (without provided instance to read the data into),
-     * i. e. it's is the user-side responsibility. Actually this is just a convenience method
-     * supporting value marshaller configurations, made initially during {@link #of(Class, Class)}
-     * call, if the value class is {@link BytesMarshallable} or {@link Externalizable} subclass.
-     *
-     * @throws IllegalStateException if custom value marshaller is specified or value class is not
-     *         either {@code BytesMarshallable} or {@code Externalizable}
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueDeserializationFactory(
-            @NotNull ObjectFactory<V> valueDeserializationFactory) {
-        return super.valueDeserializationFactory(valueDeserializationFactory);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>By default, the default value is set to {@code null}.
-     *
-     * @see #defaultValueProvider(DefaultValueProvider)
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> defaultValue(V defaultValue) {
-        return super.defaultValue(defaultValue);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default
-     * value} is specified instead.
-     *
-     * @see #defaultValue(Object)
-     */
-    @Override
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> defaultValueProvider(
-            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
-        return super.defaultValueProvider(defaultValueProvider);
-    }
-
-    /**
-     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap
-     * memory in maps, created by this builder. See
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
-     * section about serialization in ChronicleMap manual</a> for more information.
-     *
-     * @param valueMarshaller the marshaller used to serialize values
-     * @return this builder back
-     * @see #valueMarshallers(BytesWriter, BytesReader)
-     * @see ChronicleMapBuilder
-     * @see #objectSerializer(ObjectSerializer)
-     */
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueMarshaller(
-            @NotNull BytesMarshaller<V> valueMarshaller) {
-        valueBuilder.marshaller(valueMarshaller);
-        return this;
-    }
-
-    /**
-     * Configures the marshallers, used to serialize/deserialize values to/from off-heap
-     * memory in maps, created by this builder. See
-     * <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
-     * serialization in ChronicleMap manual</a> for more information.
-     *
-     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout
-     * of the map, comparing to a single interface configuration:
-     * {@link #valueMarshaller(BytesMarshaller)}.
-     *
-     * <p>Passing {@link BytesInterop} instead of plain {@link BytesWriter} is, of cause, possible,
-     * but currently pointless for values.
-     *
-     * @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
-     * @param valueReader the new {@link Bytes} &rarr; value object reader strategy
-     * @return this builder back
-     * @see #valueMarshaller(BytesMarshaller)
-     */
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueMarshallers(
-            @NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
-        valueBuilder.writer(valueWriter);
-        valueBuilder.reader(valueReader);
-        return this;
-    }
-
-    /**
-     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps,
-     * created by this builder.
-     *
-     * <p>Default value size marshaller is so-called {@linkplain SizeMarshallers#stopBit()
-     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant
-     * value size} is configured, or defaulted if the value type is always constant and {@code
-     * ChronicleHashBuilder} implementation knows about it, this configuration takes no effect,
-     * because a special {@link SizeMarshaller} implementation, which doesn't actually do any
-     * marshalling, and just returns the known constant size on {@link SizeMarshaller#readSize(
-     * Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this method.
-     *
-     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to
-     *                            off-heap memory
-     * @return this builder back
-     */
-    public ChronicleMapOnHeapUpdatableBuilder<K, V> valueSizeMarshaller(
-            @NotNull SizeMarshaller valueSizeMarshaller) {
-        valueBuilder.sizeMarshaller(valueSizeMarshaller);
-        return this;
-    }
-}
diff --git a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
index 877b69312..be5755ed2 100644
--- a/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
+++ b/src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
@@ -124,8 +124,6 @@ public class NodeDiscovery {
 
                         if (proposedIdentifier == ourProposedIdentifier.get())
                             useAnotherIdentifier.set(true);
-
-
                     }
                 }
                 countDownLatch.get().countDown();
@@ -231,7 +229,7 @@ public class NodeDiscovery {
         LOG.info("Using Remote identifier=" + identifier);
         nodeDiscoveryEventListenerAtomicReference.set(null);
 
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+        return ChronicleMapBuilder.of(Integer.class,
                 CharSequence.class)
                 .entries(20000L)
                 .replication(SingleChronicleHashReplication.builder()
diff --git a/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
new file mode 100644
index 000000000..fa50e5db0
--- /dev/null
+++ b/src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.chronicle.map;
+
+import net.openhft.chronicle.hash.serialization.BytesReader;
+import net.openhft.chronicle.hash.serialization.BytesWriter;
+import net.openhft.chronicle.hash.serialization.SizeMarshaller;
+import net.openhft.lang.io.serialization.BytesMarshaller;
+import net.openhft.lang.model.Byteable;
+import net.openhft.lang.model.DataValueClasses;
+import org.jetbrains.annotations.NotNull;
+
+final class OffHeapUpdatableChronicleMapBuilder<K, V>
+        extends AbstractChronicleMapBuilder<K, V, OffHeapUpdatableChronicleMapBuilder<K, V>> implements ChronicleMapBuilderI<K, V> {
+
+    public static <K, V> ChronicleMapBuilderI<K, V> of(
+            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+
+        if (valueClass.isEnum())
+            return OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass);
+
+        if (keyClass.isInterface() && keyClass != CharSequence.class) {
+            keyClass = DataValueClasses.directClassFor(keyClass);
+        }
+
+        if ((valueClass.isInterface() && valueClass != CharSequence.class)) {
+            valueClass = DataValueClasses.directClassFor(valueClass);
+        } else if (!offHeapReference(valueClass)) {
+            return OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass);
+        }
+        return new OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
+    }
+
+    OffHeapUpdatableChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
+        super(keyClass, valueClass);
+        prepareValueBytesOnAcquire(new ZeroOutValueBytes<K, V>(valueSize()));
+    }
+
+    @Override
+    OffHeapUpdatableChronicleMapBuilder<K, V> self() {
+        return this;
+    }
+
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> valueSize(int valueSize) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
+     *
+     * <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
+     * #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
+     * alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
+     * bytes).
+     *
+     * @see #entryAndValueAlignment(Alignment)
+     * @see #entries(long)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> entrySize(int entrySize) {
+        return super.entrySize(entrySize);
+    }
+
+    /**
+     * Configures alignment strategy of address in memory of entries and independently of address in memory of
+     * values within entries in ChronicleMaps, created by this builder.
+     *
+     * <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
+     * because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
+     * architectures any misaligned memory access is more expensive than aligned.
+     *
+     * <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
+     * if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
+     * aligned to 8 bytes).
+     *
+     * <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
+     *
+     * @param alignment the new alignment of the maps constructed by this builder
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
+        return super.entryAndValueAlignment(alignment);
+    }
+
+    /**
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
+     * {@code ChronicleMapBuilder}.
+     *
+     * <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
+     * prepare value bytes routine} is specified instead.
+     *
+     * @see #defaultValueProvider(DefaultValueProvider)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
+        return super.defaultValue(defaultValue);
+    }
+
+    /**
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
+     * {@code ChronicleMapBuilder}.
+     *
+     * <p>By default, the default value provider is not specified, default {@linkplain
+     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
+     *
+     * @see #defaultValue(Object)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValueProvider(
+            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
+        return super.defaultValueProvider(defaultValueProvider);
+    }
+
+    /**
+     * Configures the procedure which is called on the bytes, which later the returned value is pointing to,
+     * if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
+     * created by this builder. See {@link PrepareValueBytes} for more information.
+     *
+     * <p>The default preparation callback zeroes out the value bytes.
+     *
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
+     *                          Byteable} value to return from {@code acquireUsing()} call
+     * @return this builder back
+     * @see PrepareValueBytes
+     * @see #defaultValue(Object)
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
+            @NotNull PrepareValueBytes<K, V> prepareValueBytes) {
+        return super.prepareValueBytesOnAcquire(prepareValueBytes);
+    }
+
+    public ChronicleMapBuilderI<K, V> valueMarshaller(@NotNull BytesMarshaller<V> valueMarshaller) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+
+    public ChronicleMapBuilderI<K, V> valueMarshallers(@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+
+    public ChronicleMapBuilderI<K, V> valueSizeMarshaller(@NotNull SizeMarshaller valueSizeMarshaller) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> constantValueSizeBySample(V sampleValue) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+
+}
diff --git a/src/main/java/net/openhft/chronicle/map/OnHeapUpdatableChronicleMapBuilder.java b/src/main/java/net/openhft/chronicle/map/OnHeapUpdatableChronicleMapBuilder.java
new file mode 100644
index 000000000..485099233
--- /dev/null
+++ b/src/main/java/net/openhft/chronicle/map/OnHeapUpdatableChronicleMapBuilder.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.openhft.chronicle.map;
+
+import net.openhft.chronicle.hash.ChronicleHashBuilder;
+import net.openhft.chronicle.hash.serialization.BytesReader;
+import net.openhft.chronicle.hash.serialization.BytesWriter;
+import net.openhft.chronicle.hash.serialization.SizeMarshaller;
+import net.openhft.lang.io.Bytes;
+import net.openhft.lang.io.serialization.BytesMarshallable;
+import net.openhft.lang.io.serialization.BytesMarshaller;
+import net.openhft.lang.io.serialization.ObjectFactory;
+import net.openhft.lang.io.serialization.ObjectSerializer;
+import net.openhft.lang.model.Byteable;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.Serializable;
+
+
+/**
+ * {@code ChronicleMapOnHeapUpdatableBuilder} is intended to be used to configure {@link ChronicleMap}s with
+ * non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives ({@link
+ * Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values implementing {@link
+ * BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface, or any other values for which
+ * {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller} is provided.
+ *
+ * <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain a {@code
+ * ChronicleMapOnHeapUpdatableBuilder} instance.
+ *
+ * @param <K> key type of the maps, created by this builder
+ * @param <V> value type of the maps, created by this builder
+ * @see ChronicleMapBuilder
+ * @see AbstractChronicleMapBuilder
+ * @see ChronicleHashBuilder
+ */
+final class OnHeapUpdatableChronicleMapBuilder<K, V>
+        extends AbstractChronicleMapBuilder<K, V, OnHeapUpdatableChronicleMapBuilder<K, V>> implements
+        ChronicleMapBuilderI<K, V> {
+
+    /**
+     * Returns a new {@code ChronicleMapOnHeapUpdatableBuilder} instance which is able to {@linkplain
+     * #create() create} maps with the specified key and value classes.
+     *
+     * <p>{@code ChronicleMapOnHeapUpdatableBuilder} analyzes provided key and value classes and automatically
+     * chooses the most specific and effective serializer which it is aware about. Read <a
+     * href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about serialization in
+     * Chronicle Map manual</a> for more information.
+     *
+     * @param keyClass   class object used to infer key type and discover it's properties via reflection
+     * @param valueClass class object used to infer value type and discover it's properties via reflection
+     * @param <K>        key type of the maps, created by the returned builder
+     * @param <V>        value type of the maps, created by the returned builder
+     * @return a new builder for the given key and value classes
+     */
+    public static <K, V> ChronicleMapBuilderI<K, V> of(
+            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+        return new OnHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
+    }
+
+    OnHeapUpdatableChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
+        super(keyClass, valueClass);
+    }
+
+    @Override
+    OnHeapUpdatableChronicleMapBuilder<K, V> self() {
+        return this;
+    }
+
+    public ChronicleMap<K, V> create() throws IOException {
+        return super.create();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #constantKeySizeBySample(Object)
+     * @see #valueSize(int)
+     * @see #entrySize(int)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> keySize(int keySize) {
+        return super.keySize(keySize);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @see #keySize(int)
+     * @see #constantValueSizeBySample(Object)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> constantKeySizeBySample(K sampleKey) {
+        return super.constantKeySizeBySample(sampleKey);
+    }
+
+    /**
+     * Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
+     * instead of this one.
+     *
+     * <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
+     * accounted and shouldn't be specified by user.
+     *
+     * <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
+     * possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
+     * {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
+     *
+     * @param valueSize number of bytes, taken by serialized form of values
+     * @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
+     * @see #constantValueSizeBySample(Object)
+     * @see #keySize(int)
+     * @see #entrySize(int)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> valueSize(int valueSize) {
+        return super.valueSize(valueSize);
+    }
+
+    /**
+     * Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
+     * this builder. This is done by providing the {@code sampleValue}, all values should take the same number
+     * of bytes in serialized form, as this sample object.
+     *
+     * <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is known
+     * statically, it is automatically accounted and this method shouldn't be called.
+     *
+     * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
+     * instead of this one.
+     *
+     * @param sampleValue the sample value
+     * @return this builder back
+     * @see #valueSize(int)
+     * @see #constantKeySizeBySample(Object)
+     */
+
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> constantValueSizeBySample(
+            @NotNull V sampleValue) {
+        return super.constantValueSizeBySample(sampleValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>Example: <pre>{@code Map<Key, Value> map =
+     *     ChronicleMapBuilder.of(Key.class, Value.class)
+     *     .entries(1_000_000)
+     *     .keySize(50).valueSize(200)
+     *     // this class hasn't implemented yet, just for example
+     *     .objectSerializer(new KryoObjectSerializer())
+     *     .create();}</pre>
+     *
+     * <p>This serializer is used to serialize both keys and values, if they both require this: loosely typed,
+     * nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and {@linkplain
+     * #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> objectSerializer(
+            @NotNull ObjectSerializer objectSerializer) {
+        return super.objectSerializer(objectSerializer);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured, this
+     * configuration is unused, because it is incapsulated in {@link BytesMarshaller#read(Bytes)} method
+     * (without provided instance to read the data into), i. e. it's is the user-side responsibility. Actually
+     * this is just a convenience method supporting value marshaller configurations, made initially during
+     * {@link #of(Class, Class)} call, if the value class is {@link BytesMarshallable} or {@link
+     * Externalizable} subclass.
+     *
+     * @throws IllegalStateException if custom value marshaller is specified or value class is not either
+     *                               {@code BytesMarshallable} or {@code Externalizable}
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> valueDeserializationFactory(
+            @NotNull ObjectFactory<V> valueDeserializationFactory) {
+        return super.valueDeserializationFactory(valueDeserializationFactory);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, the default value is set to {@code null}.
+     *
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
+        return super.defaultValue(defaultValue);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
+     * specified instead.
+     *
+     * @see #defaultValue(Object)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> defaultValueProvider(
+            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
+        return super.defaultValueProvider(defaultValueProvider);
+    }
+
+    /**
+     * Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
+     * maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * @param valueMarshaller the marshaller used to serialize values
+     * @return this builder back
+     * @see #valueMarshallers(BytesWriter, BytesReader)
+     * @see ChronicleMapBuilder
+     * @see #objectSerializer(ObjectSerializer)
+     */
+    public OnHeapUpdatableChronicleMapBuilder<K, V> valueMarshaller(
+            @NotNull BytesMarshaller<V> valueMarshaller) {
+        valueBuilder.marshaller(valueMarshaller);
+        return this;
+    }
+
+    /**
+     * Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
+     * created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
+     * section about serialization in ChronicleMap manual</a> for more information.
+     *
+     * <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
+     * comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
+     *
+     * <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
+     * BytesWriter} is, of cause, possible, but currently pointless for values.
+     *
+     * @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
+     * @param valueReader the new {@link Bytes} &rarr; value object reader strategy
+     * @return this builder back
+     * @see #valueMarshaller(BytesMarshaller)
+     */
+    public OnHeapUpdatableChronicleMapBuilder<K, V> valueMarshallers(
+            @NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
+        valueBuilder.writer(valueWriter);
+        valueBuilder.reader(valueReader);
+        return this;
+    }
+
+    /**
+     * Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
+     * this builder.
+     *
+     * <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
+     * stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
+     * is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
+     * implementation knows about it, this configuration takes no effect, because a special {@link
+     * SizeMarshaller} implementation, which doesn't actually do any marshalling, and just returns the known
+     * constant size on {@link SizeMarshaller#readSize(Bytes)} calls, is used instead of any {@code
+     * SizeMarshaller} configured using this method.
+     *
+     * @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
+     * @return this builder back
+     */
+    public OnHeapUpdatableChronicleMapBuilder<K, V> valueSizeMarshaller(
+            @NotNull SizeMarshaller valueSizeMarshaller) {
+        valueBuilder.sizeMarshaller(valueSizeMarshaller);
+        return this;
+    }
+
+    /**
+     * Configures the procedure which is called on the bytes, which later the returned value is pointing to,
+     * if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
+     * created by this builder. See {@link PrepareValueBytes} for more information.
+     *
+     * <p>The default preparation callback zeroes out the value bytes.
+     *
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
+     *                          Byteable} value to return from {@code acquireUsing()} call
+     * @return this builder back
+     * @see PrepareValueBytes
+     * @see #defaultValue(Object)
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    @Override
+    public OnHeapUpdatableChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
+            @NotNull PrepareValueBytes<K, V> prepareValueBytes) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+
+    public OnHeapUpdatableChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment a) {
+        throw new UnsupportedOperationException("not supported for this combination of key/value type");
+    }
+
+
+}
diff --git a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
index 667d0a6ae..1c1303cac 100644
--- a/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
+++ b/src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
@@ -138,7 +138,7 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
                 result = AbstractChannelReplicator.openSocketChannel(closeables);
                 result.connect(builder.remoteAddress());
                 result.socket().setTcpNoDelay(true);
-                result.socket().setReuseAddress(true);
+
 
                 doHandShaking(result);
                 break;
@@ -240,6 +240,11 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
         if (closeables != null)
             closeables.closeQuietly();
         closeables = null;
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            //
+        }
 
     }
 
diff --git a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
index a31e08960..afd9b463f 100644
--- a/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
+++ b/src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
@@ -29,7 +29,7 @@ import net.openhft.chronicle.hash.serialization.BytesReader;
 import net.openhft.chronicle.hash.serialization.BytesWriter;
 import net.openhft.chronicle.hash.serialization.SizeMarshaller;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.lang.io.serialization.BytesMarshaller;
 import net.openhft.lang.io.serialization.BytesMarshallerFactory;
 import net.openhft.lang.io.serialization.ObjectFactory;
@@ -55,10 +55,10 @@ import java.util.concurrent.TimeUnit;
 public class ChronicleSetBuilder<E>
         implements ChronicleHashBuilder<E, ChronicleSet<E>, ChronicleSetBuilder<E>> {
 
-    private ChronicleMapOnHeapUpdatableBuilder<E, DummyValue> chronicleMapBuilderOnHeap;
+    private ChronicleMapBuilder<E, DummyValue> chronicleMapBuilderOnHeap;
 
     ChronicleSetBuilder(Class<E> keyClass) {
-        chronicleMapBuilderOnHeap = ChronicleMapOnHeapUpdatableBuilder.of(keyClass, DummyValue.class)
+        chronicleMapBuilderOnHeap = ChronicleMapBuilder.of(keyClass, DummyValue.class)
                 .valueMarshallers(DummyValueMarshaller.INSTANCE, DummyValueMarshaller.INSTANCE)
                 .valueSizeMarshaller(DummyValueMarshaller.INSTANCE);
     }
diff --git a/src/main/java/net/openhft/chronicle/set/DummyValue.java b/src/main/java/net/openhft/chronicle/set/DummyValue.java
index 5145f9239..a7e4fb305 100644
--- a/src/main/java/net/openhft/chronicle/set/DummyValue.java
+++ b/src/main/java/net/openhft/chronicle/set/DummyValue.java
@@ -18,6 +18,6 @@
 
 package net.openhft.chronicle.set;
 
-enum DummyValue {
+  enum DummyValue {
     DUMMY_VALUE
 }
diff --git a/src/test/java/eg/BigData.java b/src/test/java/eg/BigData.java
index 90588218e..8c8fe917f 100644
--- a/src/test/java/eg/BigData.java
+++ b/src/test/java/eg/BigData.java
@@ -19,7 +19,8 @@
 package eg;
 
 import net.openhft.affinity.AffinitySupport;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.lang.io.Bytes;
 
 import java.io.*;
@@ -40,8 +41,8 @@ public class BigData {
     //run 1st test with no map, and Highwatermark set to 0
     //then switch to Highwatermark set to MAXSIZE for subsequent test repeats
     static AtomicInteger Highwatermark = new AtomicInteger((int) MAXSIZE);
-    static final ChronicleMapOnHeapUpdatableBuilder<Long, BigDataStuff> builder =
-            ChronicleMapOnHeapUpdatableBuilder.of(Long.class, BigDataStuff.class);
+    static final ChronicleMapBuilder<Long, BigDataStuff> builder =
+            ChronicleMapBuilder.of(Long.class, BigDataStuff.class);
 
     //    static AtomicInteger Highwatermark = new AtomicInteger(0);
     static {
diff --git a/src/test/java/net/openhft/chronicle/map/Builder.java b/src/test/java/net/openhft/chronicle/map/Builder.java
index c64ec78bc..dd0773d38 100644
--- a/src/test/java/net/openhft/chronicle/map/Builder.java
+++ b/src/test/java/net/openhft/chronicle/map/Builder.java
@@ -67,17 +67,16 @@ public class Builder {
                 identifier, serverPort, endpoints).create();
     }
 
-    public static <K, V> ChronicleMapOnHeapUpdatableBuilder<K, V> newTcpSocketShmBuilder(
+    public static <K, V> ChronicleMapBuilder<K, V> newTcpSocketShmBuilder(
             Class<K> kClass, Class<V> vClass,
             final byte identifier,
             final int serverPort,
             final InetSocketAddress... endpoints) throws IOException {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(serverPort, Arrays.asList(endpoints))
                 .heartBeatInterval(1L, TimeUnit.SECONDS);
-        return ChronicleMapOnHeapUpdatableBuilder.of(kClass, vClass)
-                .replication(identifier,  tcpConfig);
+        return ChronicleMapBuilder.of(kClass, vClass)
+                .replication(identifier, tcpConfig);
     }
 
 
-
 }
diff --git a/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java b/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
index 79706aa7d..65f699a45 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMMetaDataTest.java
@@ -35,7 +35,7 @@ public class CHMMetaDataTest {
         File file = new File(TMP, "testAccessTimes");
         MapEventListener<String, String, ChronicleMap<String, String>> listener =
                 new StringStringMapEventListener(new AtomicLong(1));
-        ChronicleMap<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class)
+        ChronicleMap<String, String> map = ChronicleMapBuilder.of(String.class, String.class)
                 .metaDataBytes(8)
                 .eventListener(listener).create();
 
diff --git a/src/test/java/net/openhft/chronicle/map/CHMTest5.java b/src/test/java/net/openhft/chronicle/map/CHMTest5.java
index 046e30845..b6fd2b907 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMTest5.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMTest5.java
@@ -39,7 +39,7 @@ public class CHMTest5 {
                         .entries(1000);
 
         //// don't include this, just to check it is as expected.
-        assertEquals(8, builder.minSegments());
+        assertEquals(8, ((AbstractChronicleMapBuilder) builder.delegate).minSegments());
         //// end of test
 
         String chmPath = System.getProperty("java.io.tmpdir") + System.getProperty("file.separator") + "CHMTest5";
diff --git a/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java b/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
index b2baa5de7..e4b9c1e56 100644
--- a/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
+++ b/src/test/java/net/openhft/chronicle/map/CHMTestIterator1.java
@@ -30,7 +30,7 @@ public class CHMTestIterator1 {
         AtomicLong alValue = new AtomicLong();
         AtomicLong alKey = new AtomicLong();
         int runs = 3000000;
-        ChronicleMapOnHeapUpdatableBuilder<String, Long> builder = ChronicleMapOnHeapUpdatableBuilder.of(String.class, Long.class)
+        ChronicleMapBuilder<String, Long> builder = ChronicleMapBuilder.of(String.class, Long.class)
                 .entries(runs);
 
         ChronicleMap<String, Long> chm = builder.create();
diff --git a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
index 2fdaafe2d..717e943d4 100644
--- a/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChannelReplicationTest.java
@@ -61,7 +61,7 @@ public class ChannelReplicationTest {
                     .tcpTransportAndNetwork(tcpConfig)
                     .createWithId((byte) 1);
 
-            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
         }
@@ -73,7 +73,7 @@ public class ChannelReplicationTest {
             hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig)
                     .createWithId((byte) 2);
 
-            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1)).create();
         }
@@ -95,12 +95,12 @@ public class ChannelReplicationTest {
     @Test
     public void test() throws IOException, InterruptedException {
 
-        map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        map2b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .instance().replicatedViaChannel(hubB.createChannel((short) 2)).create();
 
 
-        map2a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        map2a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .instance().replicatedViaChannel(hubA.createChannel((short) 2)).create();
 
diff --git a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
index 4bec46de5..e3bb59119 100755
--- a/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ChronicleMapTest.java
@@ -136,7 +136,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKey() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
         assertFalse(map.containsKey("key3"));
@@ -181,7 +181,7 @@ public class ChronicleMapTest {
     public void testSize() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(1024)
                         .removeReturnsNull(true).create();
 
@@ -203,7 +203,7 @@ public class ChronicleMapTest {
     public void testRemoveInteger() throws IOException {
 
         int count = 300;
-        final ChronicleMap<Object, Object> map = ChronicleMapOnHeapUpdatableBuilder.of(Object.class, Object.class)
+        final ChronicleMap<Object, Object> map = ChronicleMapBuilder.of(Object.class, Object.class)
                 .entrySize(count)
                 .minSegments(2).create();
 
@@ -228,7 +228,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKeyAndRemoveReturnsNull() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2)
                         .removeReturnsNull(true).create();
 
@@ -274,7 +274,7 @@ public class ChronicleMapTest {
     public void testReplaceWithKey() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
 
@@ -339,7 +339,7 @@ public class ChronicleMapTest {
     public void testReplaceWithKeyAnd2Params() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
         map.put("key1", "one");
@@ -381,7 +381,7 @@ public class ChronicleMapTest {
     public void testRemoveWithKeyAndValue() throws Exception {
 
         final ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .minSegments(2).create();
 
 
@@ -855,7 +855,7 @@ public class ChronicleMapTest {
         String TMP = System.getProperty("java.io.tmpdir");
         int entries = 100 * 1000;
         ChronicleMap<CharSequence, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(entries)
                         .minSegments(16)
                         .entrySize(32)
@@ -1284,7 +1284,7 @@ public class ChronicleMapTest {
 
     private ChronicleMap<Integer, CharSequence> getViewTestMap(int noOfElements) throws IOException {
         ChronicleMap<Integer, CharSequence> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+                ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                         .entries(noOfElements * 2 + 100)
                         .valueSize((noOfElements + "").length())
                         .putReturnsNull(true)
@@ -1304,7 +1304,7 @@ public class ChronicleMapTest {
 
     @Test
     public void testOversizeEntriesPutRemoveReplace() throws IOException {
-        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapBuilder builder = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .minSegments(1)
                 .entrySize(10);
@@ -1356,13 +1356,13 @@ public class ChronicleMapTest {
 
     @Test
     public void equalsTest() throws IOException {
-        final ChronicleMap<Integer, String> map1 = ChronicleMapOnHeapUpdatableBuilder
+        final ChronicleMap<Integer, String> map1 = OnHeapUpdatableChronicleMapBuilder
                 .of(Integer.class, String.class).create();
 
         map1.put(1, "one");
         map1.put(2, "two");
 
-        final ChronicleMap<Integer, String> map2 = ChronicleMapOnHeapUpdatableBuilder
+        final ChronicleMap<Integer, String> map2 = OnHeapUpdatableChronicleMapBuilder
                 .of(Integer.class, String.class).create();
 
         map2.put(1, "one");
@@ -1469,7 +1469,7 @@ public class ChronicleMapTest {
     @Test(expected = IllegalArgumentException.class)
     public void testAcquireUsingLockedWithString() throws IOException {
 
-        ChronicleMapOnHeapUpdatableBuilder<CharSequence, String> builder = ChronicleMapOnHeapUpdatableBuilder
+        ChronicleMapBuilder<CharSequence, String> builder = ChronicleMapBuilder
                 .of(CharSequence.class, String.class)
                 .entries(1000)
                 .defaultValue("")
@@ -1494,7 +1494,7 @@ public class ChronicleMapTest {
     @Test
     public void testOnheapAcquireUsingLockedStringBuilder() throws IOException {
 
-        try (final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
+        try (final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapBuilder
                 .of(CharSequence.class, CharSequence.class)
                 .entries(1000)
                 .entrySize(40)
@@ -1514,7 +1514,7 @@ public class ChronicleMapTest {
 
     @Test
     public void testOnheapAcquireUsingLocked() throws IOException {
-        ChronicleMapOnHeapUpdatableBuilder<CharSequence, LongValue> builder = ChronicleMapOnHeapUpdatableBuilder
+        ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
                 .of(CharSequence.class, LongValue.class)
                 .entries(1000)
                 .entrySize(40);
diff --git a/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java b/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
index 2dd42a58a..3c1b31f1e 100644
--- a/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
+++ b/src/test/java/net/openhft/chronicle/map/ConcurrentMap8Test.java
@@ -42,7 +42,7 @@ public class ConcurrentMap8Test extends JSR166TestCase {
    /* private static ConcurrentMap<Long, Long> newLongMap() {
         //First create (or access if already created) the shared map
 
-        final ChronicleMapOnHeapUpdatableBuilder<Long, Long> builder = ChronicleMapOnHeapUpdatableBuilder.of(Long.class, Long.class);
+        final ChronicleMapOnHeapUpdatableBuilder<Long, Long> builder = ChronicleMapBuilder.of(Long.class, Long.class);
 
 
         //// don't include this, just to check it is as expected.
@@ -64,7 +64,7 @@ public class ConcurrentMap8Test extends JSR166TestCase {
     private static ConcurrentMap newIntegerStringMap() {
 
 
-        final ChronicleMapOnHeapUpdatableBuilder<Integer, String> builder = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+        final ChronicleMapOnHeapUpdatableBuilder<Integer, String> builder = ChronicleMapBuilder.of(Integer.class,
                 String.class);
 
 
diff --git a/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java b/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
index 57b010cb9..78ab35c73 100644
--- a/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ConstantSizeBySampleTest.java
@@ -32,7 +32,7 @@ public class ConstantSizeBySampleTest {
 
     @Test
     public void testConstantKeys() throws IOException {
-        ChronicleMap<byte[], Long> map = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, Long.class)
+        ChronicleMap<byte[], Long> map = ChronicleMapBuilder.of(byte[].class, Long.class)
                 .constantKeySizeBySample(new byte[8])
                 .immutableKeys()
                 .entries(100)
@@ -52,7 +52,7 @@ public class ConstantSizeBySampleTest {
 
     @Test
     public void testUnexpectedlyLongConstantByteArrayValues() throws IOException {
-        ChronicleMap<Long, byte[]> map = ChronicleMapOnHeapUpdatableBuilder.of(Long.class, byte[].class)
+        ChronicleMap<Long, byte[]> map = ChronicleMapBuilder.of(Long.class, byte[].class)
                 .constantValueSizeBySample(new byte[512 * 1024])
                 .entries(100)
                 .actualSegments(1)
@@ -89,7 +89,7 @@ public class ConstantSizeBySampleTest {
     @Test
     public void testUnexpectedlyLongConstantExternalizableValues() throws IOException {
         ChronicleMap<Long, ExternalizableData> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(Long.class, ExternalizableData.class)
+                ChronicleMapBuilder.of(Long.class, ExternalizableData.class)
                         .constantValueSizeBySample(new ExternalizableData())
                         .entries(100)
                         .actualSegments(1)
@@ -116,7 +116,7 @@ public class ConstantSizeBySampleTest {
     @Ignore
     public void testUnexpectedlyLongConstantSerializableValues() throws IOException {
         ChronicleMap<Long, SerializableData> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(Long.class, SerializableData.class)
+                ChronicleMapBuilder.of(Long.class, SerializableData.class)
                         .constantValueSizeBySample(new SerializableData())
                         .entries(100)
                         .actualSegments(1)
diff --git a/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java b/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
index 4c09bd6f8..d0b773361 100644
--- a/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
+++ b/src/test/java/net/openhft/chronicle/map/DefaultValueTest.java
@@ -37,7 +37,7 @@ public class DefaultValueTest {
 
             ArrayList<Integer> defaultValue = new ArrayList<Integer>();
             defaultValue.add(42);
-            try (ChronicleMap<String, List<Integer>> map = ChronicleMapOnHeapUpdatableBuilder
+            try (ChronicleMap<String, List<Integer>> map = OnHeapUpdatableChronicleMapBuilder
                     .of(String.class, (Class<List<Integer>>) ((Class) List.class))
                     .defaultValue(defaultValue).createPersistedTo(file)) {
                 ArrayList<Integer> using = new ArrayList<Integer>();
@@ -49,7 +49,7 @@ public class DefaultValueTest {
             }
 
             ArrayList<Integer> using = new ArrayList<Integer>();
-            try (ChronicleMap<String, List<Integer>> map = ChronicleMapOnHeapUpdatableBuilder
+            try (ChronicleMap<String, List<Integer>> map = OnHeapUpdatableChronicleMapBuilder
                     .of(String.class, (Class<List<Integer>>) ((Class) List.class))
                     .createPersistedTo(file)) {
                 assertEquals(defaultValue, map.acquireUsing("c", using));
diff --git a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
index cc3de97c9..f98d29ee3 100644
--- a/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/EntryCountMapTest.java
@@ -51,7 +51,8 @@ public class EntryCountMapTest {
     private static ChronicleMap<CharSequence, LongValue> getSharedMap(
             long entries, int segments, int entrySize, Alignment alignment)
             throws IOException {
-        ChronicleMapBuilder<CharSequence, LongValue> mapBuilder = ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
+        ChronicleMapBuilder<CharSequence, LongValue> mapBuilder = ChronicleMapBuilder.of(CharSequence
+                .class, LongValue.class)
                 .entries(entries)
                 .actualSegments(segments)
                 .entrySize(entrySize)
diff --git a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
index f7ecadd8f..49beb7104 100644
--- a/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
+++ b/src/test/java/net/openhft/chronicle/map/EventListenerTestWithTCPSocketReplication.java
@@ -99,14 +99,14 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
         }
         // ---------- SERVER2 2 on the same server as ----------
 
         {
-            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2Builder = clientBuilder();
+            ChronicleMapBuilder<Integer, CharSequence> map2Builder = clientBuilder();
 
             map2 = map2Builder.create();
         }
@@ -135,7 +135,7 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
 
@@ -206,7 +206,7 @@ public class EventListenerTestWithTCPSocketReplication {
 
             // we connect the maps via a TCP socket connection on port 8077
 
-            ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder = serverBuilder();
+            ChronicleMapBuilder<Integer, CharSequence> map1Builder = serverBuilder();
 
             map1 = map1Builder.create();
 
@@ -237,9 +237,9 @@ public class EventListenerTestWithTCPSocketReplication {
         Assert.assertEquals(null, map2.get(5));
     }
 
-    private ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> clientBuilder() {
+    private ChronicleMapBuilder<Integer, CharSequence> clientBuilder() {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(8077);
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000L)
                 .replication((byte) 1, tcpConfig)
                 .eventListener(eventListener);
@@ -256,9 +256,9 @@ public class EventListenerTestWithTCPSocketReplication {
         }
     }
 
-    private ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> serverBuilder() {
+    private ChronicleMapBuilder<Integer, CharSequence> serverBuilder() {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(8076, new InetSocketAddress("localhost", 8077));
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000L)
                 .replication((byte) 2, tcpConfig);
     }
diff --git a/src/test/java/net/openhft/chronicle/map/GuavaTest.java b/src/test/java/net/openhft/chronicle/map/GuavaTest.java
index d08560df9..4c096767d 100644
--- a/src/test/java/net/openhft/chronicle/map/GuavaTest.java
+++ b/src/test/java/net/openhft/chronicle/map/GuavaTest.java
@@ -99,8 +99,8 @@ public class GuavaTest extends TestCase {
     }
 
     static class CHMTestGenerator extends TestGenerator {
-        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> builder =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapBuilder<CharSequence, CharSequence> builder =
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(100)
                         .minSegments(2);
 
diff --git a/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java b/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
index 37378ba50..597bb622e 100644
--- a/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/IntValueMapTest.java
@@ -37,7 +37,7 @@ public class IntValueMapTest {
     @Test
     public void test() throws IOException {
 
-        final ChronicleMap<IntValue, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
+        final ChronicleMap<IntValue, CharSequence> map = OnHeapUpdatableChronicleMapBuilder
                 .of(IntValue.class, CharSequence.class)
                 .entries(20000)
                 .keyMarshaller(ByteableIntValueMarshaller.INSTANCE).create();
diff --git a/src/test/java/net/openhft/chronicle/map/Issue42Test.java b/src/test/java/net/openhft/chronicle/map/Issue42Test.java
index 13bd20459..4b1681623 100755
--- a/src/test/java/net/openhft/chronicle/map/Issue42Test.java
+++ b/src/test/java/net/openhft/chronicle/map/Issue42Test.java
@@ -32,7 +32,7 @@ public class Issue42Test {
         if (!Jvm.isWindows())
             return;
 
-        final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapOnHeapUpdatableBuilder
+        final ChronicleMap<CharSequence, CharSequence> map = OnHeapUpdatableChronicleMapBuilder
                 .of(CharSequence.class, CharSequence.class)
                 .entrySize(18)
                 .entries(1500000)
diff --git a/src/test/java/net/openhft/chronicle/map/KeySizesTest.java b/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
index d2a436054..b9af5ffc1 100644
--- a/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
+++ b/src/test/java/net/openhft/chronicle/map/KeySizesTest.java
@@ -33,7 +33,7 @@ public class KeySizesTest {
     @Test
     public void testDifferentKeySizes() throws IOException {
 
-        Map<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class).create();
+        Map<String, String> map = ChronicleMapBuilder.of(String.class, String.class).create();
 
         String k = "";
         for (int i = 0; i < 100; i++) {
diff --git a/src/test/java/net/openhft/chronicle/map/OSResizesMain.java b/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
index c09a5ecc3..cc1af2ad4 100755
--- a/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
+++ b/src/test/java/net/openhft/chronicle/map/OSResizesMain.java
@@ -35,7 +35,7 @@ import java.util.Arrays;
 public class OSResizesMain {
     public static void main(String[] args) throws IOException, InterruptedException {
         File file = File.createTempFile("over-sized", "deleteme");
-        ChronicleMap<String, String> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, String.class)
+        ChronicleMap<String, String> map = ChronicleMapBuilder.of(String.class, String.class)
                 .entrySize(100 * 1024 * 1024)
                 .entries(1000 * 1000)
                 .createPersistedTo(file);
diff --git a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
index 93bd564e9..a7db4b5fc 100644
--- a/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/PostChannelCreationTest.java
@@ -70,11 +70,11 @@ public class PostChannelCreationTest {
                     .createWithId((byte) 1);
 
             // this is how you add maps after the custer is created
-            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
 
-            map2a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map2a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 2)).create();
         }
@@ -89,11 +89,11 @@ public class PostChannelCreationTest {
                     .createWithId((byte) 2);
 
             // this is how you add maps after the custer is created
-            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1)).create();
 
-            map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map2b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 2)).create();
         }
diff --git a/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java b/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
index dd2dcf80f..5bea1f6ae 100644
--- a/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
+++ b/src/test/java/net/openhft/chronicle/map/ProcessInstanceLimiterMain.java
@@ -36,8 +36,8 @@ public class ProcessInstanceLimiterMain implements Runnable {
     public ProcessInstanceLimiterMain(String sharedMapName, Callback callback) throws IOException {
         this.sharedMapName = sharedMapName;
         this.callback = callback;
-        ChronicleMapOnHeapUpdatableBuilder<String, Data> builder =
-                ChronicleMapOnHeapUpdatableBuilder.of(String.class, Data.class);
+        ChronicleMapBuilder<String, Data> builder =
+                ChronicleMapBuilder.of(String.class, Data.class);
         builder.entries(10000);
         builder.minSegments(2);
         File file = new File(System.getProperty("java.io.tmpdir") + "/" + sharedMapName);
diff --git a/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java b/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
index b5bd950d4..790b84265 100644
--- a/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/RecursiveRefereneChMapTest.java
@@ -33,7 +33,7 @@ public class RecursiveRefereneChMapTest {
     public void testRecursive() throws IOException {
         File file = new File(TMP + "/test." + System.nanoTime() + ".tmp");
         file.deleteOnExit();
-        Map<String, StupidCycle> map = ChronicleMapOnHeapUpdatableBuilder.of(String.class, StupidCycle.class)
+        Map<String, StupidCycle> map = ChronicleMapBuilder.of(String.class, StupidCycle.class)
                 .entries(64)
                 .objectSerializer(JDKObjectSerializer.INSTANCE).create();
         map.put("Test", new StupidCycle());
diff --git a/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
index 34a87018b..382c299cc 100644
--- a/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/ReplicatedChronicleMapTest.java
@@ -38,14 +38,14 @@ public class ReplicatedChronicleMapTest extends JSR166TestCase {
 
 
     ChronicleMap<Integer, CharSequence> newShmIntString() throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .create();
 
     }
 
 
     ChronicleMap<CharSequence, CharSequence> newShmStringString() throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .create();
 
     }
diff --git a/src/test/java/net/openhft/chronicle/map/SerializerTest.java b/src/test/java/net/openhft/chronicle/map/SerializerTest.java
index e1ddf2573..7551c4037 100644
--- a/src/test/java/net/openhft/chronicle/map/SerializerTest.java
+++ b/src/test/java/net/openhft/chronicle/map/SerializerTest.java
@@ -72,7 +72,13 @@ public class SerializerTest {
         final ByteBufferBytes out = new ByteBufferBytes(ByteBuffer.allocateDirect(1024));
         ByteBufferBytes in = out.slice();
 
-        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, valueClass);
+
+        ChronicleMapBuilder cBuilder = ChronicleMapBuilder.of(Integer
+                .class, valueClass);
+
+        OnHeapUpdatableChronicleMapBuilder builder = (OnHeapUpdatableChronicleMapBuilder) cBuilder.delegate;
+
+
         builder.preMapConstruction(false);
 
         Serializer v = new Serializer(builder.valueBuilder);
@@ -95,7 +101,10 @@ public class SerializerTest {
         final ByteBufferBytes out = new ByteBufferBytes(ByteBuffer.allocateDirect(1024));
         ByteBufferBytes in = out.slice();
 
-        ChronicleMapOnHeapUpdatableBuilder builder = ChronicleMapOnHeapUpdatableBuilder.of(clazz, Integer.class);
+        ChronicleMapBuilder cBuilder = ChronicleMapBuilder.of(clazz, Integer.class);
+
+        OnHeapUpdatableChronicleMapBuilder builder = (OnHeapUpdatableChronicleMapBuilder) cBuilder.delegate;
+
         builder.preMapConstruction(false);
         {
             Serializer v = new Serializer(builder.keyBuilder);
diff --git a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
index 3c78880e6..315cd86e6 100644
--- a/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
+++ b/src/test/java/net/openhft/chronicle/map/SingleMapChannelTest.java
@@ -70,7 +70,7 @@ public class SingleMapChannelTest {
                     .tcpTransportAndNetwork(tcpConfig)
                     .createWithId(identifier);
             // this is how you add maps after the custer is created
-            map1a = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
         }
@@ -84,7 +84,7 @@ public class SingleMapChannelTest {
             hubB = ReplicationHub.builder().tcpTransportAndNetwork(tcpConfig).createWithId((byte) 2);
 
             // this is how you add maps after the custer is created
-            map1b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .entries(1000)
                     .instance().replicatedViaChannel(hubB.createChannel((short) 1))
                     .create();
diff --git a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
index 1842fd8a6..d2385a1cb 100644
--- a/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
+++ b/src/test/java/net/openhft/chronicle/map/StatelessClientTest.java
@@ -53,14 +53,14 @@ public class StatelessClientTest {
     public void testMapForKeyWithEntry() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
                 StringBuilder.class)
                 .defaultValue(new StringBuilder())
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, new StringBuilder("Hello World"));
 
-            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, StringBuilder.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -78,14 +78,14 @@ public class StatelessClientTest {
     public void testMapForKeyWhenNoEntry() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+        try (ChronicleMap<Integer, StringBuilder> serverMap = ChronicleMapBuilder.of(Integer.class,
                 StringBuilder.class)
                 .defaultValue(new StringBuilder())
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, new StringBuilder("Hello World"));
 
-            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, StringBuilder> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, StringBuilder.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -101,10 +101,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllAndEntrySet() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -134,10 +134,10 @@ public class StatelessClientTest {
     @Test
     public void testBufferOverFlowPutAllAndValues() throws IOException, InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -166,10 +166,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllAndKeySet() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -198,11 +198,11 @@ public class StatelessClientTest {
     public void test() throws IOException, InterruptedException {
 
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
             serverMap.put(10, "EXAMPLE-10");
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -217,10 +217,10 @@ public class StatelessClientTest {
     @Test
     public void testClientCreatedBeforeServer() throws IOException, InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -241,10 +241,10 @@ public class StatelessClientTest {
 
     @Test
     public void testBufferOverFlowPutAll() throws IOException, InterruptedException {
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -272,10 +272,10 @@ public class StatelessClientTest {
     public void testBufferOverFlowPutAllWherePutReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -304,10 +304,10 @@ public class StatelessClientTest {
     public void testPutWherePutReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -326,10 +326,10 @@ public class StatelessClientTest {
     public void testRemoveWhereRemoveReturnsNull() throws IOException,
             InterruptedException {
 
-        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        try (ChronicleMap<Integer, CharSequence> serverMap = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create()) {
 
-            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            try (ChronicleMap<Integer, CharSequence> statelessMap = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create()) {
 
@@ -360,9 +360,9 @@ public class StatelessClientTest {
 
         // server
         {
-            serverMap1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            serverMap1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .replication((byte) 2, TcpTransportAndNetworkConfig.of(8056)).create();
-            serverMap2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+            serverMap2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                     .replication((byte) 2, TcpTransportAndNetworkConfig.of(8077)).create();
 
         }
@@ -370,10 +370,10 @@ public class StatelessClientTest {
 
         // stateless client
         {
-            statelessMap1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            statelessMap1 = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8056)).create();
-            statelessMap2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+            statelessMap2 = ChronicleMapBuilder.of(Integer
                     .class, CharSequence.class)
                     .statelessClient(new InetSocketAddress("localhost", 8077)).create();
         }
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
index 4f6a72af8..3af0a9cc2 100755
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplication3wayPutReturnsNullTest.java
@@ -50,7 +50,7 @@ public class TCPSocketReplication3wayPutReturnsNullTest {
             final InetSocketAddress... endpoints) throws IOException {
         TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(serverPort, Arrays.asList(endpoints));
 
-        return (T) ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return (T) ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .putReturnsNull(true)
                 .replication(identifier, tcpConfig).create();
     }
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
index dce3e622b..041c066b4 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationBootStrapTest.java
@@ -47,7 +47,7 @@ public class TCPSocketReplicationBootStrapTest {
 
         map1 = newTcpSocketShmIntString((byte) 1, 8069);
 
-        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2aBuilder =
+        ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 2, 8066, new InetSocketAddress("localhost", 8069));
         final ChronicleMap<Integer, CharSequence> map2a =
@@ -108,7 +108,7 @@ public class TCPSocketReplicationBootStrapTest {
 
         {
             // restart map 2 but does not connect it to map1
-            final ChronicleMap<Integer, CharSequence> map2b = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class,
+            final ChronicleMap<Integer, CharSequence> map2b = ChronicleMapBuilder.of(Integer.class,
                     CharSequence.class).replication((byte) 2).createPersistedTo(persistenceFile);
             // add data into it
             map2b.put(11, "ADDED WHEN DISCONNECTED TO MAP1");
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
index 991dde467..93429dd23 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationIntValueTest.java
@@ -45,7 +45,7 @@ import static org.junit.Assert.assertTrue;
 
 public class TCPSocketReplicationIntValueTest {
 
-    private ChronicleMapOnHeapUpdatableBuilder<IntValue, CharSequence> map1Builder;
+    private ChronicleMapBuilder<IntValue, CharSequence> map1Builder;
     private ChronicleMap<IntValue, CharSequence> map1;
     private ChronicleMap<IntValue, CharSequence> map2;
     private IntValue value;
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
index 79cf9983c..2a931292b 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationPostConnectionTest.java
@@ -76,7 +76,7 @@ public class TCPSocketReplicationPostConnectionTest {
     @Test
     public void testBootStrapIntoNewMapWithNewFile() throws IOException, InterruptedException {
 
-        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map2aBuilder =
+        ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 2, 8077, new InetSocketAddress("localhost", 8076));
         try (final ChronicleMap<Integer, CharSequence> map2a =
diff --git a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
index a964ffed2..f8e8f7a52 100644
--- a/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TCPSocketReplicationTest.java
@@ -47,7 +47,7 @@ public class TCPSocketReplicationTest {
 
     @Before
     public void setup() throws IOException {
-        ChronicleMapOnHeapUpdatableBuilder<Integer, CharSequence> map1Builder =
+        ChronicleMapBuilder<Integer, CharSequence> map1Builder =
                 newTcpSocketShmBuilder(Integer.class, CharSequence.class,
                         (byte) 1, 8076, new InetSocketAddress("localhost", 8077));
         map1 = map1Builder.createPersistedTo(getPersistenceFile());
diff --git a/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java b/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
index 4be12c3b8..eff5fa333 100644
--- a/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
+++ b/src/test/java/net/openhft/chronicle/map/TestBooleanValues.java
@@ -35,7 +35,7 @@ public class TestBooleanValues {
     @Test
     public void testTestBooleanValues() throws IOException, InterruptedException {
         ChronicleMap<Integer, Boolean> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, Boolean.class).create();
+                ChronicleMapBuilder.of(Integer.class, Boolean.class).create();
         map.put(7, true);
         Assert.assertEquals(true, map.get(7));
     }
diff --git a/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java b/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
index 189a3a599..639da0acd 100644
--- a/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TimeBasedReplicationTest.java
@@ -49,7 +49,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALatePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -78,7 +78,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALatePutIfAbsent() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -108,7 +108,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateReplace() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -141,7 +141,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateReplaceWithValue() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -171,7 +171,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateRemoveWithValue() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -200,7 +200,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreALateRemove() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -229,7 +229,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testIgnoreWithRemoteRemove() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -259,7 +259,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
 
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -289,7 +289,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testRemoveFollowedByLatePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ReplicatedChronicleMap map = (ReplicatedChronicleMap) ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
@@ -317,7 +317,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
     public void testPutRemovePut() throws IOException {
 
         final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
-        ChronicleMap map = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(10)
                 .timeProvider(timeProvider)
                 .createReplicated((byte) 1);
diff --git a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
index 8ca1838c5..484c8c769 100644
--- a/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
+++ b/src/test/java/net/openhft/chronicle/map/TwoMapOnDifferentServersTest.java
@@ -48,11 +48,11 @@ public class TwoMapOnDifferentServersTest {
                         .heartBeatInterval(1, SECONDS);
 
 
-        map1 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        map1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000)
                 .replication((byte) 1, tcpConfig).create();
 
-        map2 = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(20000)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(8077)
                         .heartBeatInterval(1, SECONDS)).create();
diff --git a/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java b/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
index 0ff22fdde..4f44e0b29 100644
--- a/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
+++ b/src/test/java/net/openhft/chronicle/map/UDPSocketReplicationTest.java
@@ -44,7 +44,7 @@ public class UDPSocketReplicationTest {
         UdpTransportConfig udpConfig = UdpTransportConfig
                 .of(Inet4Address.getByName("255.255.255.255"), udpPort);
 
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(1000)
                 .replication(SingleChronicleHashReplication.builder().udpTransport(udpConfig)
                                 .createWithId((byte) identifier))
diff --git a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
index 1bc1457b7..0189fa77b 100644
--- a/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
+++ b/src/test/java/net/openhft/chronicle/map/example/ChannelExample.java
@@ -3,7 +3,8 @@ package net.openhft.chronicle.map.example;
 import net.openhft.chronicle.hash.replication.ReplicationHub;
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -63,8 +64,8 @@ public class ChannelExample {
 
     // server 1 with  identifier = 1
     {
-        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(1000);
 
         byte identifier = (byte) 1;
@@ -98,8 +99,8 @@ public class ChannelExample {
 
     // server 2 with  identifier = 2
     {
-        ChronicleMapOnHeapUpdatableBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
-                ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
+                ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                         .entries(1000);
 
         byte identifier = (byte) 2;
diff --git a/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java b/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
index 77331fca3..13f03e882 100644
--- a/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/DistributedSequenceMain.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.values.LongValue;
 
@@ -30,7 +30,7 @@ public class DistributedSequenceMain {
     public static void main(String... ignored) throws IOException {
         Class<LongValue> longValueClass = DataValueClasses.directClassFor(LongValue.class);
         ChronicleMap<String, LongValue> map =
-                ChronicleMapOnHeapUpdatableBuilder.of(String.class, longValueClass)
+                ChronicleMapBuilder.of(String.class, longValueClass)
                         .entries(128)
                         .actualSegments(1).create();
         LongValue value = DataValueClasses.newDirectReference(longValueClass);
diff --git a/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java b/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
index 441f3003a..57706e3c0 100644
--- a/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/ServersMapMain.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 
 import java.io.File;
 import java.io.IOException;
@@ -39,7 +39,7 @@ public class ServersMapMain {
     public static void startServer() throws IOException {
         File file = File.createTempFile("testServersMapMain", ".deleteme");
         file.deleteOnExit();
-        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, byte[].class)
+        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapBuilder.of(byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .entrySize(50)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port))
@@ -52,7 +52,7 @@ public class ServersMapMain {
     public static void startRemoteClient(String hostname) throws IOException {
         final ChronicleMap<byte[], byte[]> map;
         if (stateless) {
-            map = ChronicleMapOnHeapUpdatableBuilder.of(
+            map = ChronicleMapBuilder.of(
                     byte[].class, byte[].class)
                     .putReturnsNull(true)
                     .statelessClient(new InetSocketAddress(hostname, port)).create();
@@ -61,7 +61,7 @@ public class ServersMapMain {
             file.deleteOnExit();
             TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(port, new InetSocketAddress(hostname, port));
 
-            map = ChronicleMapOnHeapUpdatableBuilder.of(
+            map = ChronicleMapBuilder.of(
                     byte[].class, byte[].class)
                     .putReturnsNull(true)
                     .replication((byte) 1, tcpConfig)
diff --git a/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java b/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
index 9bf177ee5..08b700c13 100644
--- a/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
+++ b/src/test/java/net/openhft/chronicle/map/example/StringsMapMain.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.example;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 
 import java.io.File;
 import java.io.IOException;
@@ -38,7 +38,7 @@ public class StringsMapMain {
     public static void startServer() throws IOException {
         File file = File.createTempFile("testServersMapMain", ".deleteme");
         file.deleteOnExit();
-        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder
+        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapBuilder
                 .of(CharSequence.class, CharSequence.class)
                 .putReturnsNull(true)
                 .entrySize(50)
@@ -52,8 +52,7 @@ public class StringsMapMain {
     public static void startRemoteClient(String hostname) throws IOException {
         final ChronicleMap<CharSequence, CharSequence> map;
         if (stateless) {
-            map = ChronicleMapOnHeapUpdatableBuilder
-                    .of(CharSequence.class, CharSequence.class)
+            map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                     .putReturnsNull(true)
                     .statelessClient(new InetSocketAddress(hostname, port)).create();
         } else {
@@ -61,7 +60,7 @@ public class StringsMapMain {
             file.deleteOnExit();
             TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(port, new InetSocketAddress(hostname, port));
 
-            map = ChronicleMapOnHeapUpdatableBuilder
+            map = ChronicleMapBuilder
                     .of(CharSequence.class, CharSequence.class)
                     .putReturnsNull(true)
                     .replication((byte) 1, tcpConfig)
diff --git a/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java b/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
index fdcee15c4..cd1a98c5e 100644
--- a/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
+++ b/src/test/java/net/openhft/chronicle/map/fromdocs/pingpong_latency/PingPongCASLeft.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.fromdocs.pingpong_latency;
 
 import net.openhft.affinity.AffinitySupport;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.chronicle.map.fromdocs.BondVOInterface;
 
 import java.io.IOException;
@@ -89,7 +89,7 @@ public class PingPongCASLeft {
     static ChronicleMap<String, BondVOInterface> acquireCHM() throws IOException {
         // ensure thread ids are globally unique.
         AffinitySupport.setThreadId();
-        return ChronicleMapOnHeapUpdatableBuilder.of(String.class, BondVOInterface.class)
+        return ChronicleMapBuilder.of(String.class, BondVOInterface.class)
                 .entries(16)
                 .entrySize(64).create();
     }
diff --git a/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java b/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
index bf8986368..7cc518e78 100644
--- a/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
+++ b/src/test/java/net/openhft/chronicle/map/ipc/StateMachineTutorial.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.ipc;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -40,7 +40,7 @@ public class StateMachineTutorial {
 
         try {
             File dataFile = new File(System.getProperty("java.io.tmpdir"), "hft-state-machine");
-            map = ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, StateMachineData.class)
+            map = ChronicleMapBuilder.of(Integer.class, StateMachineData.class)
                     .entries(8).create();
 
             if (args.length > 0) {
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
index 6c28aa50c..c3665fa8c 100644
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/ChronicleMapTest.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.chronicle.map.jrs166.JSR166TestCase;
 import org.junit.Test;
 
@@ -49,33 +49,33 @@ public class ChronicleMapTest extends JSR166TestCase {
     }
 
     static ChronicleMap<Integer, CharSequence> newShmIntString(int size) throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class)
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
                 .entries(size).create();
 
     }
 
     static ChronicleMap<ArrayList, CharSequence> newShmListBoolean(int size) throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(ArrayList.class, CharSequence.class)
+        return ChronicleMapBuilder.of(ArrayList.class, CharSequence.class)
                 .entries(size).create();
     }
 
 
     static ChronicleMap<ArrayList, CharSequence> newShmListBoolean() throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(ArrayList.class, CharSequence.class).create();
+        return ChronicleMapBuilder.of(ArrayList.class, CharSequence.class).create();
     }
 
     static ChronicleMap<CharSequence, CharSequence> newShmStringString(int size) throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .entries(size).create();
     }
 
 
     static ChronicleMap<Integer, CharSequence> newShmIntString() throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, CharSequence.class).create();
+        return ChronicleMapBuilder.of(Integer.class, CharSequence.class).create();
     }
 
     static ChronicleMap<BI, Boolean> newShmBiBoolean() throws IOException {
-        return ChronicleMapOnHeapUpdatableBuilder.of(BI.class, Boolean.class).create();
+        return ChronicleMapBuilder.of(BI.class, Boolean.class).create();
     }
 
     /**
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
index 8d4edab60..e97ce82af 100644
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/MapCheck.java
@@ -19,7 +19,7 @@
 package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 
 import java.io.*;
 import java.util.*;
@@ -123,7 +123,7 @@ public class MapCheck {
 
     static Map newMap() {
         try {
-            return ChronicleMapOnHeapUpdatableBuilder.of(Object.class, Object.class).create();
+            return ChronicleMapBuilder.of(Object.class, Object.class).create();
 
         } catch (Exception e) {
             throw new RuntimeException("Can't instantiate CHM : " + e);
diff --git a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
index debe6f367..51b9e8fa4 100755
--- a/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
+++ b/src/test/java/net/openhft/chronicle/map/jrs166/map/StatelessChronicleMapTest.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.jrs166.map;
 
 import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.chronicle.map.ReadContext;
 import net.openhft.chronicle.map.WriteContext;
 import net.openhft.chronicle.map.jrs166.JSR166TestCase;
@@ -193,10 +193,10 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<Integer, String> newShmIntString(int port) throws IOException {
 
         final ChronicleMap<Integer, String> serverMap =
-                ChronicleMapOnHeapUpdatableBuilder.of(Integer.class, String.class)
+                ChronicleMapBuilder.of(Integer.class, String.class)
                         .replication((byte) 1, TcpTransportAndNetworkConfig.of(port)).create();
 
-        final ChronicleMap<Integer, String> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(Integer
+        final ChronicleMap<Integer, String> statelessMap = ChronicleMapBuilder.of(Integer
                 .class, String.class)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
 
@@ -207,11 +207,11 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<CharSequence, CharSequence> newStrStrMap(int port) throws
             IOException {
 
-        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence.class, CharSequence.class)
+        final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port)).create();
 
 
-        final ChronicleMap<CharSequence, CharSequence> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(CharSequence
+        final ChronicleMap<CharSequence, CharSequence> statelessMap = ChronicleMapBuilder.of(CharSequence
                 .class, CharSequence.class)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
 
@@ -221,12 +221,12 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
     static ChronicleMap<byte[], byte[]> newByteArrayMap(int port) throws
             IOException {
 
-        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapOnHeapUpdatableBuilder.of(byte[].class, byte[].class)
+        final ChronicleMap<byte[], byte[]> serverMap = ChronicleMapBuilder.of(byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .replication((byte) 2, TcpTransportAndNetworkConfig.of(port)).create();
 
 
-        final ChronicleMap<byte[], byte[]> statelessMap = ChronicleMapOnHeapUpdatableBuilder.of(
+        final ChronicleMap<byte[], byte[]> statelessMap = ChronicleMapBuilder.of(
                 byte[].class, byte[].class)
                 .putReturnsNull(true)
                 .statelessClient(new InetSocketAddress("localhost", port)).create();
diff --git a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
index d93f2878d..cecae189c 100644
--- a/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
+++ b/src/test/java/net/openhft/chronicle/map/utility/ProcessInstanceLimiter.java
@@ -20,7 +20,7 @@ package net.openhft.chronicle.map.utility;
 
 import net.openhft.affinity.AffinitySupport;
 import net.openhft.chronicle.map.ChronicleMap;
-import net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder;
+import net.openhft.chronicle.map.ChronicleMapBuilder;
 import net.openhft.lang.model.DataValueClasses;
 import net.openhft.lang.model.constraints.MaxSize;
 
@@ -134,8 +134,8 @@ public class ProcessInstanceLimiter implements Runnable {
     public ProcessInstanceLimiter(String sharedMapPath, Callback callback) throws IOException {
         this.sharedMapPath = sharedMapPath;
         this.callback = callback;
-        ChronicleMapOnHeapUpdatableBuilder<String, Data> builder =
-                ChronicleMapOnHeapUpdatableBuilder.of(String.class, Data.class);
+        ChronicleMapBuilder<String, Data> builder =
+                ChronicleMapBuilder.of(String.class, Data.class);
         builder.entries(1000);
         builder.entrySize(1024);
         this.theSharedMap = builder.createPersistedTo(new File(sharedMapPath));

From e98be88e600216f8b38a39b1706bd6768c94788d Mon Sep 17 00:00:00 2001
From: Rob Austin <rob.austin@boundedbuffer>
Date: Sat, 15 Nov 2014 09:10:17 +0000
Subject: [PATCH 11/11] HCOLL-81 updated readme - changed
 OffHeapUpdatableChronicleMapBuilder to ChronicleMapBuilder

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 25aee887c..88cac1466 100644
--- a/README.md
+++ b/README.md
@@ -189,7 +189,7 @@ this for best performance.
 
 or value objects that are created through, a directClass interface, for example : 
 ``` java
-      ChronicleMap<String, BondVOInterface> chm = OffHeapUpdatableChronicleMapBuilder
+      ChronicleMap<String, BondVOInterface> chm = ChronicleMapBuilder
                .of(String.class, BondVOInterface.class)
                .create();
 
@@ -428,10 +428,10 @@ bond.getCoupon()
 lets say that it is only the `coupon` field that we are interested in, then its better not to have to
 deserialize the whole object that implements the `BondVOInterface`. It would be more efficient to just
 deserialize the field(s) that we require, in this example just the coupon. This is why we created
-the`OffHeapUpdatableChronicleMapBuilder`, when you use this builder chronicle will not create on heap copies of your whole data structure. You can instead use proxy objects that can read and write into the off heap data structures, this reduced serialisation can give you a big performance boost. Below we show you how you can work directly with the off heap entries.
+the`ChronicleMapBuilder`, when you use this builder chronicle will not create on heap copies of your whole data structure. You can instead use proxy objects that can read and write into the off heap data structures, this reduced serialisation can give you a big performance boost. Below we show you how you can work directly with the off heap entries.
 
 ``` java
-        ChronicleMap<String, BondVOInterface> chm = OffHeapUpdatableChronicleMapBuilder
+        ChronicleMap<String, BondVOInterface> chm = ChronicleMapBuilder
                 .of(String.class, BondVOInterface.class)
                 .keySize(10)
                 .create();