diff --git a/README.md b/README.md
index 609752c..fc651c7 100644
--- a/README.md
+++ b/README.md
@@ -40,6 +40,8 @@
 ---
 
 ## Build Instructions
+__NOTE:__ This component is temporarily broken until the new version of Memory is released.  Please use the formal release 1.3.0 obtained from [Downloads](https://datasketches.apache.org/docs/Community/Downloads.html)
+
 __NOTE:__ This component accesses resource files for testing. As a result, the directory elements of the full absolute path of the target installation directory must qualify as Java identifiers. In other words, the directory elements must not have any space characters (or non-Java identifier characters) in any of the path elements. This is required by the Oracle Java Specification in order to ensure location-independent access to resources: [See Oracle Location-Independent Access to Resources](https://docs.oracle.com/javase/8/docs/technotes/guides/lang/resources.html)
 
 ### JDK8/Hotspot is required to compile
diff --git a/pom.xml b/pom.xml
index 1c4fd61..aa6a4d5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -49,11 +49,11 @@
       <archive>https://mail-archives.apache.org/mod_mbox/datasketches-dev</archive>
     </mailingList>
     <mailingList>
-      <name>sketches-user</name>
-      <archive>https://groups.google.com/forum/#!forum/sketches-user</archive>
-      <subscribe>mailto:sketches-user%2Bsubscribe@googlegroups.com</subscribe>
-      <unsubscribe>mailto:sketches-user%2Bunsubscribe@googlegroups.com</unsubscribe>
-      <post>mailto:sketches-user@googlegroups.com</post>
+      <name>DataSketches Users</name>
+      <subscribe>user-subscribe@datasketches.apache.org</subscribe>
+      <unsubscribe>user-unsubscribe@datasketches.apache.org</unsubscribe>
+      <post>user@datasketches.apache.org</post>
+      <archive>https://mail-archives.apache.org/mod_mbox/datasketches-user</archive>
     </mailingList>
   </mailingLists>
 
@@ -83,12 +83,12 @@
 
   <properties>
     <!-- UNIQUE FOR THIS JAVA COMPONENT -->
-    <datasketches-memory.version>1.3.0</datasketches-memory.version>
-    <slf4j-simple.version>1.7.30</slf4j-simple.version>
+    <datasketches-memory.version>2.0.0</datasketches-memory.version>
+    <slf4j-simple.version>1.7.32</slf4j-simple.version>
     <!-- END:UNIQUE FOR THIS JAVA COMPONENT -->
 
     <!-- Test -->
-    <testng.version>7.1.0</testng.version>
+    <testng.version>7.4.0</testng.version>
 
     <!-- System-wide properties -->
     <maven.version>3.5.0</maven.version>
@@ -339,6 +339,7 @@
             <trimStackTrace>false</trimStackTrace>
             <useManifestOnlyJar>false</useManifestOnlyJar>
             <redirectTestOutputToFile>true</redirectTestOutputToFile>
+            <reportsDirectory>${project.build.directory}/test-output/${maven.build.timestamp}</reportsDirectory>
           </configuration>
         </plugin>
 
@@ -430,14 +431,12 @@
   </build>
   <profiles>
     <!-- Ignore nuisance warning from Apache parent plugin: 
-          "maven-remote-resources-plugin (goal "process") is ignored by m2e".
-          This also should fix the Maven warning that it can't find the lifecycle-mapping jar.
-          This profile is only active when the property "m2e.version" is set, 
-          which is the case when building in Eclipse with m2e.
-          The ignore below tells m2eclipse to skip the execution.
+         "maven-remote-resources-plugin (goal "process") is ignored by m2e".
+         This profile is only active when the property "m2e.version" is set, 
+         which is the case when building in Eclipse with m2e.
     -->
     <profile>
-      <id>m2e</id>
+      <id>only-eclipse</id>
       <activation>
         <property>
           <name>m2e.version</name>
@@ -447,31 +446,25 @@
         <pluginManagement>
           <plugins>
             <plugin>
-              <groupId>org.eclipse.m2e</groupId>
-              <artifactId>lifecycle-mapping</artifactId>
-              <version>${lifecycle-mapping.version}</version>
-              <configuration>
-                <lifecycleMappingMetadata>
-                  <pluginExecutions>
-                    <pluginExecution>
-                      <pluginExecutionFilter>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-remote-resources-plugin</artifactId>
-                        <versionRange>${maven-remote-resources-plugin.version}</versionRange>
-                        <goals>
-                          <goal>process</goal>
-                        </goals>
-                      </pluginExecutionFilter>
-                      <action>
-                        <ignore/>
-                      </action>
-                    </pluginExecution>
-                  </pluginExecutions>
-                </lifecycleMappingMetadata>
-              </configuration>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-remote-resources-plugin</artifactId>
+              <version>${maven-remote-resources-plugin.version}</version>
+              <executions>
+                <execution>
+                  <id>process-resource-bundles</id>
+                  <phase>none</phase>
+                </execution>
+              </executions>
             </plugin>
           </plugins>
         </pluginManagement>
+
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-remote-resources-plugin</artifactId>
+          </plugin>
+        </plugins>
       </build>
     </profile>
 
@@ -666,5 +659,61 @@
         </plugins>
       </build>
     </profile>
+
+    <profile>
+      <id>java8only</id>
+      <activation>
+        <jdk>[1.8,1.9),8</jdk>
+      </activation>
+      <build>
+        <pluginManagement>
+          <plugins>
+            <plugin>
+              <!-- Apache Parent pom, pluginManagement-->
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-surefire-plugin</artifactId>
+              <version>${maven-surefire-plugin.version}</version>
+              <configuration>
+                <trimStackTrace>false</trimStackTrace>
+                <useManifestOnlyJar>false</useManifestOnlyJar>
+                <redirectTestOutputToFile>true</redirectTestOutputToFile>
+                <reportsDirectory>${project.build.directory}/test-output/${maven.build.timestamp}</reportsDirectory>
+              </configuration>
+            </plugin>
+          </plugins>
+        </pluginManagement>
+      </build>
+    </profile>
+
+    <profile>
+      <id>java9plus</id>
+      <activation>
+        <jdk>[9,14)</jdk>
+      </activation>
+      <build>
+        <pluginManagement>
+          <plugins>
+            <plugin>
+              <!-- Apache Parent pom, pluginManagement-->
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-surefire-plugin</artifactId>
+              <version>${maven-surefire-plugin.version}</version>
+              <configuration>
+                <trimStackTrace>false</trimStackTrace>
+                <useManifestOnlyJar>false</useManifestOnlyJar>
+                <redirectTestOutputToFile>true</redirectTestOutputToFile>
+                <reportsDirectory>${project.build.directory}/test-output/${maven.build.timestamp}</reportsDirectory>
+                <argLine>
+                  --add-exports java.base/jdk.internal.misc=ALL-UNNAMED
+                  --add-exports java.base/jdk.internal.ref=ALL-UNNAMED
+                  --add-opens java.base/java.nio=ALL-UNNAMED
+                  --add-opens java.base/sun.nio.ch=ALL-UNNAMED
+                </argLine>
+              </configuration>
+            </plugin>
+          </plugins>
+        </pluginManagement>
+      </build>
+    </profile>
   </profiles>
 </project>
diff --git a/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
index b36cd9a..d97f19d 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfBooleansSerDe.java
@@ -20,7 +20,6 @@
 package org.apache.datasketches;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -44,7 +43,7 @@
   public byte[] serializeToByteArray(final Boolean[] items) {
     final int bytesNeeded = computeBytesNeeded(items.length);
     final byte[] bytes = new byte[bytesNeeded];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     byte val = 0;
     for (int i = 0; i < items.length; ++i) {
@@ -69,7 +68,7 @@
   @Override
   public Boolean[] deserializeFromMemory(final Memory mem, final int length) {
     final int numBytes = computeBytesNeeded(length);
-    UnsafeUtil.checkBounds(0, numBytes, mem.getCapacity());
+    Util.checkBounds(0, numBytes, mem.getCapacity());
     final Boolean[] array = new Boolean[length];
 
     byte srcVal = 0;
diff --git a/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
index ac754e4..968535d 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfDoublesSerDe.java
@@ -20,7 +20,6 @@
 package org.apache.datasketches;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -33,7 +32,7 @@
   @Override
   public byte[] serializeToByteArray(final Double[] items) {
     final byte[] bytes = new byte[Double.BYTES * items.length];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     long offsetBytes = 0;
     for (int i = 0; i < items.length; i++) {
       mem.putDouble(offsetBytes, items[i]);
@@ -44,7 +43,7 @@
 
   @Override
   public Double[] deserializeFromMemory(final Memory mem, final int length) {
-    UnsafeUtil.checkBounds(0, Double.BYTES, mem.getCapacity());
+    Util.checkBounds(0, Double.BYTES, mem.getCapacity());
     final Double[] array = new Double[length];
     long offsetBytes = 0;
     for (int i = 0; i < length; i++) {
diff --git a/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
index e7fee6a..951775b 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfLongsSerDe.java
@@ -20,7 +20,6 @@
 package org.apache.datasketches;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -33,7 +32,7 @@
   @Override
   public byte[] serializeToByteArray(final Long[] items) {
     final byte[] bytes = new byte[Long.BYTES * items.length];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     long offsetBytes = 0;
     for (int i = 0; i < items.length; i++) {
       mem.putLong(offsetBytes, items[i]);
@@ -44,7 +43,7 @@
 
   @Override
   public Long[] deserializeFromMemory(final Memory mem, final int length) {
-    UnsafeUtil.checkBounds(0, (long)length * Long.BYTES, mem.getCapacity());
+    Util.checkBounds(0, (long)length * Long.BYTES, mem.getCapacity());
     final Long[] array = new Long[length];
     long offsetBytes = 0;
     for (int i = 0; i < length; i++) {
diff --git a/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
index 3256a8b..42ffefb 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfNumbersSerDe.java
@@ -20,7 +20,6 @@
 package org.apache.datasketches;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -68,7 +67,7 @@
       }
     }
     final byte[] bytes = new byte[length];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     long offsetBytes = 0;
     for (final Number item: items) {
       if (item instanceof Long) {
@@ -105,38 +104,38 @@
     final Number[] array = new Number[length];
     long offsetBytes = 0;
     for (int i = 0; i < length; i++) {
-      UnsafeUtil.checkBounds(offsetBytes, Byte.BYTES, mem.getCapacity());
+      Util.checkBounds(offsetBytes, Byte.BYTES, mem.getCapacity());
       final byte numType = mem.getByte(offsetBytes);
       offsetBytes += Byte.BYTES;
 
       switch (numType) {
         case LONG_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Long.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Long.BYTES, mem.getCapacity());
           array[i] = mem.getLong(offsetBytes);
           offsetBytes += Long.BYTES;
           break;
         case INTEGER_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
           array[i] = mem.getInt(offsetBytes);
           offsetBytes += Integer.BYTES;
           break;
         case SHORT_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Short.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Short.BYTES, mem.getCapacity());
           array[i] = mem.getShort(offsetBytes);
           offsetBytes += Short.BYTES;
           break;
         case BYTE_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Byte.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Byte.BYTES, mem.getCapacity());
           array[i] = mem.getByte(offsetBytes);
           offsetBytes += Byte.BYTES;
           break;
         case DOUBLE_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Double.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Double.BYTES, mem.getCapacity());
           array[i] = mem.getDouble(offsetBytes);
           offsetBytes += Double.BYTES;
           break;
         case FLOAT_INDICATOR:
-          UnsafeUtil.checkBounds(offsetBytes, Float.BYTES, mem.getCapacity());
+          Util.checkBounds(offsetBytes, Float.BYTES, mem.getCapacity());
           array[i] = mem.getFloat(offsetBytes);
           offsetBytes += Float.BYTES;
           break;
diff --git a/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
index 1252950..ae269ee 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfStringsSerDe.java
@@ -22,7 +22,6 @@
 import java.nio.charset.StandardCharsets;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -45,7 +44,7 @@
       length += itemsBytes[i].length + Integer.BYTES;
     }
     final byte[] bytes = new byte[length];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     long offsetBytes = 0;
     for (int i = 0; i < items.length; i++) {
       mem.putInt(offsetBytes, itemsBytes[i].length);
@@ -61,11 +60,11 @@
     final String[] array = new String[numItems];
     long offsetBytes = 0;
     for (int i = 0; i < numItems; i++) {
-      UnsafeUtil.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
+      Util.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
       final int strLength = mem.getInt(offsetBytes);
       offsetBytes += Integer.BYTES;
       final byte[] bytes = new byte[strLength];
-      UnsafeUtil.checkBounds(offsetBytes, strLength, mem.getCapacity());
+      Util.checkBounds(offsetBytes, strLength, mem.getCapacity());
       mem.getByteArray(offsetBytes, bytes, 0, strLength);
       offsetBytes += strLength;
       array[i] = new String(bytes, StandardCharsets.UTF_8);
diff --git a/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java b/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
index 4c7477b..21fa727 100644
--- a/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
+++ b/src/main/java/org/apache/datasketches/ArrayOfUtf16StringsSerDe.java
@@ -20,7 +20,6 @@
 package org.apache.datasketches;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.UnsafeUtil;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -41,7 +40,7 @@
       length += (items[i].length() * Character.BYTES) + Integer.BYTES;
     }
     final byte[] bytes = new byte[length];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     long offsetBytes = 0;
     for (int i = 0; i < items.length; i++) {
       mem.putInt(offsetBytes, items[i].length());
@@ -57,11 +56,11 @@
     final String[] array = new String[numItems];
     long offsetBytes = 0;
     for (int i = 0; i < numItems; i++) {
-      UnsafeUtil.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
+      Util.checkBounds(offsetBytes, Integer.BYTES, mem.getCapacity());
       final int strLength = mem.getInt(offsetBytes);
       offsetBytes += Integer.BYTES;
       final char[] chars = new char[strLength];
-      UnsafeUtil.checkBounds(offsetBytes, (long) strLength * Character.BYTES, mem.getCapacity());
+      Util.checkBounds(offsetBytes, (long) strLength * Character.BYTES, mem.getCapacity());
       mem.getCharArray(offsetBytes, chars, 0, strLength);
       array[i] = new String(chars);
       offsetBytes += (long) strLength * Character.BYTES;
diff --git a/src/main/java/org/apache/datasketches/Util.java b/src/main/java/org/apache/datasketches/Util.java
index d32cc99..c5eda60 100644
--- a/src/main/java/org/apache/datasketches/Util.java
+++ b/src/main/java/org/apache/datasketches/Util.java
@@ -770,6 +770,25 @@
     return next;
   }
 
+  //Checks
+  
+  /**
+   * Check the requested offset and length against the allocated size.
+   * The invariants equation is: {@code 0 <= reqOff <= reqLen <= reqOff + reqLen <= allocSize}.
+   * If this equation is violated an {@link SketchesArgumentException} will be thrown.
+   * @param reqOff the requested offset
+   * @param reqLen the requested length
+   * @param allocSize the allocated size.
+   */
+  public static void checkBounds(final long reqOff, final long reqLen, final long allocSize) {
+    if ((reqOff | reqLen | (reqOff + reqLen) | (allocSize - (reqOff + reqLen))) < 0) {
+      throw new SketchesArgumentException(
+          "reqOffset: " + reqOff + ", reqLength: " + reqLen
+              + ", (reqOff + reqLen): " + (reqOff + reqLen) + ", allocSize: " + allocSize);
+    }
+  }
+  
+  
   /**
    * Checks that the given nomLongs is within bounds and returns the Log2 of the ceiling power of 2
    * of the given nomLongs.
@@ -786,8 +805,6 @@
     return lgNomLongs;
   }
 
-  //Other checks
-
   /**
    * Checks the given parameter to make sure it is positive and between 0.0 inclusive and 1.0
    * inclusive.
diff --git a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
index a4fd947..76a6a0b 100644
--- a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
@@ -498,7 +498,7 @@
       outBytes = ((preLongs + activeItems) << 3) + bytes.length;
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build first preLong empty or not
     long pre0 = 0L;
diff --git a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
index aab538f..a95f0ba 100644
--- a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
@@ -566,7 +566,7 @@
       outBytes = (preLongs + (2 * activeItems)) << 3; //2 because both keys and values are longs
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build first preLong empty or not
     long pre0 = 0L;
diff --git a/src/main/java/org/apache/datasketches/hash/MurmurHash3v2.java b/src/main/java/org/apache/datasketches/hash/MurmurHash3v2.java
deleted file mode 100644
index 1ad9f86..0000000
--- a/src/main/java/org/apache/datasketches/hash/MurmurHash3v2.java
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you 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 org.apache.datasketches.hash;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.memory.UnsafeUtil.unsafe;
-
-import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableMemory;
-
-/**
- * <p>The MurmurHash3 is a fast, non-cryptographic, 128-bit hash function that has
- * excellent avalanche and 2-way bit independence properties.</p>
- *
- * <p>Austin Appleby's C++
- * <a href="https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp">
- * MurmurHash3_x64_128(...), final revision 150</a>,
- * which is in the Public Domain, was the inspiration for this implementation in Java.</p>
- *
- * <p>This implementation of the MurmurHash3 allows hashing of a block of Memory defined by an offset
- * and length. The calling API also allows the user to supply the small output array of two longs,
- * so that the entire hash function is static and free of object allocations.</p>
- *
- * <p>This implementation produces exactly the same hash result as the
- * {@link MurmurHash3#hash} function given compatible inputs.</p>
- *
- * @author Lee Rhodes
- */
-public final class MurmurHash3v2 {
-  private static final long C1 = 0x87c37b91114253d5L;
-  private static final long C2 = 0x4cf5ad432745937fL;
-
-  //Provided for backward compatibility
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Provided for compatibility with older version of MurmurHash3,
-   * but empty or null input now returns a hash.
-   * @param in long array
-   * @param seed A long valued seed.
-   * @return the hash
-   */
-  public static long[] hash(final long[] in, final long seed) {
-    if ((in == null) || (in.length == 0)) {
-      return emptyOrNull(seed, new long[2]);
-    }
-    return hash(Memory.wrap(in), 0L, in.length << 3, seed, new long[2]);
-  }
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Provided for compatibility with older version of MurmurHash3,
-   * but empty or null input now returns a hash.
-   * @param in int array
-   * @param seed A long valued seed.
-   * @return the hash
-   */
-  public static long[] hash(final int[] in, final long seed) {
-    if ((in == null) || (in.length == 0)) {
-      return emptyOrNull(seed, new long[2]);
-    }
-    return hash(Memory.wrap(in), 0L, in.length << 2, seed, new long[2]);
-  }
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Provided for compatibility with older version of MurmurHash3,
-   * but empty or null input now returns a hash.
-   * @param in char array
-   * @param seed A long valued seed.
-   * @return the hash
-   */
-  public static long[] hash(final char[] in, final long seed) {
-    if ((in == null) || (in.length == 0)) {
-      return emptyOrNull(seed, new long[2]);
-    }
-    return hash(Memory.wrap(in), 0L, in.length << 1, seed, new long[2]);
-  }
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Provided for compatibility with older version of MurmurHash3,
-   * but empty or null input now returns a hash.
-   * @param in byte array
-   * @param seed A long valued seed.
-   * @return the hash
-   */
-  public static long[] hash(final byte[] in, final long seed) {
-    if ((in == null) || (in.length == 0)) {
-      return emptyOrNull(seed, new long[2]);
-    }
-    return hash(Memory.wrap(in), 0L, in.length, seed, new long[2]);
-  }
-
-  //Single primitive inputs
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Note the entropy of the resulting hash cannot be more than 64 bits.
-   * @param in a long
-   * @param seed A long valued seed.
-   * @param hashOut A long array of size 2
-   * @return the hash
-   */
-  public static long[] hash(final long in, final long seed, final long[] hashOut) {
-    final long h1 = seed ^ mixK1(in);
-    final long h2 = seed;
-    return finalMix128(h1, h2, 8, hashOut);
-  }
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * Note the entropy of the resulting hash cannot be more than 64 bits.
-   * @param in a double
-   * @param seed A long valued seed.
-   * @param hashOut A long array of size 2
-   * @return the hash
-   */
-  public static long[] hash(final double in, final long seed, final long[] hashOut) {
-    final double d = (in == 0.0) ? 0.0 : in;    // canonicalize -0.0, 0.0
-    final long k1 = Double.doubleToLongBits(d); // canonicalize all NaN forms
-    final long h1 = seed ^ mixK1(k1);
-    final long h2 = seed;
-    return finalMix128(h1, h2, 8, hashOut);
-  }
-
-  /**
-   * Returns a 128-bit hash of the input.
-   * @param in a String
-   * @param seed A long valued seed.
-   * @param hashOut A long array of size 2
-   * @return the hash
-   */
-  public static long[] hash(final String in, final long seed, final long[] hashOut) {
-    if ((in == null) || (in.length() == 0)) {
-      return emptyOrNull(seed, hashOut);
-    }
-    final byte[] byteArr = in.getBytes(UTF_8);
-    return hash(Memory.wrap(byteArr), 0L, byteArr.length, seed, hashOut);
-  }
-
-  //The main API call
-
-  /**
-   * Returns a 128-bit hash of the input as a long array of size 2.
-   *
-   * @param mem The input Memory. Must be non-null and non-empty.
-   * @param offsetBytes the starting point within Memory.
-   * @param lengthBytes the total number of bytes to be hashed.
-   * @param seed A long valued seed.
-   * @param hashOut the size 2 long array for the resulting 128-bit hash
-   * @return the hash.
-   */
-  @SuppressWarnings("restriction")
-  public static long[] hash(final Memory mem, final long offsetBytes, final long lengthBytes,
-      final long seed, final long[] hashOut) {
-    if ((mem == null) || (mem.getCapacity() == 0L)) {
-      return emptyOrNull(seed, hashOut);
-    }
-    final Object uObj = ((WritableMemory) mem).getArray(); //may be null
-    long cumOff = mem.getCumulativeOffset() + offsetBytes;
-
-    long h1 = seed;
-    long h2 = seed;
-    long rem = lengthBytes;
-
-    // Process the 128-bit blocks (the body) into the hash
-    while (rem >= 16L) {
-      final long k1 = unsafe.getLong(uObj, cumOff);     //0, 16, 32, ...
-      final long k2 = unsafe.getLong(uObj, cumOff + 8); //8, 24, 40, ...
-      cumOff += 16L;
-      rem -= 16L;
-
-      h1 ^= mixK1(k1);
-      h1 = Long.rotateLeft(h1, 27);
-      h1 += h2;
-      h1 = (h1 * 5) + 0x52dce729L;
-
-      h2 ^= mixK2(k2);
-      h2 = Long.rotateLeft(h2, 31);
-      h2 += h1;
-      h2 = (h2 * 5) + 0x38495ab5L;
-    }
-
-    // Get the tail (if any): 1 to 15 bytes
-    if (rem > 0L) {
-      long k1 = 0;
-      long k2 = 0;
-      switch ((int) rem) {
-        case 15: {
-          k2 ^= (unsafe.getByte(uObj, cumOff + 14) & 0xFFL) << 48;
-        }
-        //$FALL-THROUGH$
-        case 14: {
-          k2 ^= (unsafe.getShort(uObj, cumOff + 12) & 0xFFFFL) << 32;
-          k2 ^= (unsafe.getInt(uObj, cumOff + 8) & 0xFFFFFFFFL);
-          k1 = unsafe.getLong(uObj, cumOff);
-          break;
-        }
-
-        case 13: {
-          k2 ^= (unsafe.getByte(uObj, cumOff + 12) & 0xFFL) << 32;
-        }
-        //$FALL-THROUGH$
-        case 12: {
-          k2 ^= (unsafe.getInt(uObj, cumOff + 8) & 0xFFFFFFFFL);
-          k1 = unsafe.getLong(uObj, cumOff);
-          break;
-        }
-
-        case 11: {
-          k2 ^= (unsafe.getByte(uObj, cumOff + 10) & 0xFFL) << 16;
-        }
-        //$FALL-THROUGH$
-        case 10: {
-          k2 ^= (unsafe.getShort(uObj, cumOff +  8) & 0xFFFFL);
-          k1 = unsafe.getLong(uObj, cumOff);
-          break;
-        }
-
-        case  9: {
-          k2 ^= (unsafe.getByte(uObj, cumOff +  8) & 0xFFL);
-        }
-        //$FALL-THROUGH$
-        case  8: {
-          k1 = unsafe.getLong(uObj, cumOff);
-          break;
-        }
-
-        case  7: {
-          k1 ^= (unsafe.getByte(uObj, cumOff +  6) & 0xFFL) << 48;
-        }
-        //$FALL-THROUGH$
-        case  6: {
-          k1 ^= (unsafe.getShort(uObj, cumOff +  4) & 0xFFFFL) << 32;
-          k1 ^= (unsafe.getInt(uObj, cumOff) & 0xFFFFFFFFL);
-          break;
-        }
-
-        case  5: {
-          k1 ^= (unsafe.getByte(uObj, cumOff +  4) & 0xFFL) << 32;
-        }
-        //$FALL-THROUGH$
-        case  4: {
-          k1 ^= (unsafe.getInt(uObj, cumOff) & 0xFFFFFFFFL);
-          break;
-        }
-
-        case  3: {
-          k1 ^= (unsafe.getByte(uObj, cumOff +  2) & 0xFFL) << 16;
-        }
-        //$FALL-THROUGH$
-        case  2: {
-          k1 ^= (unsafe.getShort(uObj, cumOff) & 0xFFFFL);
-          break;
-        }
-
-        case  1: {
-          k1 ^= (unsafe.getByte(uObj, cumOff) & 0xFFL);
-          break;
-        }
-        //default: break; //can't happen
-      }
-
-      h1 ^= mixK1(k1);
-      h2 ^= mixK2(k2);
-    }
-    return finalMix128(h1, h2, lengthBytes, hashOut);
-  }
-
-  //--Helper methods----------------------------------------------------
-
-  /**
-   * Self mix of k1
-   *
-   * @param k1 input argument
-   * @return mix
-   */
-  private static long mixK1(long k1) {
-    k1 *= C1;
-    k1 = Long.rotateLeft(k1, 31);
-    k1 *= C2;
-    return k1;
-  }
-
-  /**
-   * Self mix of k2
-   *
-   * @param k2 input argument
-   * @return mix
-   */
-  private static long mixK2(long k2) {
-    k2 *= C2;
-    k2 = Long.rotateLeft(k2, 33);
-    k2 *= C1;
-    return k2;
-  }
-
-
-  /**
-   * Final self mix of h*.
-   *
-   * @param h input to final mix
-   * @return mix
-   */
-  private static long finalMix64(long h) {
-    h ^= h >>> 33;
-    h *= 0xff51afd7ed558ccdL;
-    h ^= h >>> 33;
-    h *= 0xc4ceb9fe1a85ec53L;
-    h ^= h >>> 33;
-    return h;
-  }
-
-  /**
-   * Finalization: Add the length into the hash and mix
-   * @param h1 intermediate hash
-   * @param h2 intermediate hash
-   * @param lengthBytes the length in bytes
-   * @param hashOut the output array of 2 longs
-   * @return hashOut
-   */
-  private static long[] finalMix128(long h1, long h2, final long lengthBytes, final long[] hashOut) {
-    h1 ^= lengthBytes;
-    h2 ^= lengthBytes;
-
-    h1 += h2;
-    h2 += h1;
-
-    h1 = finalMix64(h1);
-    h2 = finalMix64(h2);
-
-    h1 += h2;
-    h2 += h1;
-
-    hashOut[0] = h1;
-    hashOut[1] = h2;
-    return hashOut;
-  }
-
-  private static long[] emptyOrNull(final long seed, final long[] hashOut) {
-    return finalMix128(seed, seed, 0, hashOut);
-  }
-}
diff --git a/src/main/java/org/apache/datasketches/hash/XxHash.java b/src/main/java/org/apache/datasketches/hash/XxHash.java
index 27a96d2..397a325 100644
--- a/src/main/java/org/apache/datasketches/hash/XxHash.java
+++ b/src/main/java/org/apache/datasketches/hash/XxHash.java
@@ -40,12 +40,6 @@
  * @author Lee Rhodes
  */
 public class XxHash {
-  // Unsigned, 64-bit primes
-  private static final long P1 = -7046029288634856825L;
-  private static final long P2 = -4417276706812531889L;
-  private static final long P3 =  1609587929392839161L;
-  private static final long P4 = -8796714831421723037L;
-  private static final long P5 =  2870177450012600261L;
 
   /**
    * Compute the hash of the given Memory object.
@@ -67,24 +61,7 @@
    * @return the hash
    */
   public static long hash(final long in, final long seed) {
-    long hash = seed + P5;
-    hash += 8;
-    long k1 = in;
-    k1 *= P2;
-    k1 = Long.rotateLeft(k1, 31);
-    k1 *= P1;
-    hash ^= k1;
-    hash = (Long.rotateLeft(hash, 27) * P1) + P4;
-    return finalize(hash);
-  }
-
-  private static long finalize(long hash) {
-    hash ^= hash >>> 33;
-    hash *= P2;
-    hash ^= hash >>> 29;
-    hash *= P3;
-    hash ^= hash >>> 32;
-    return hash;
+    return org.apache.datasketches.memory.XxHash.hashLong(in, seed);
   }
 
 }
diff --git a/src/main/java/org/apache/datasketches/hll/DirectAuxHashMap.java b/src/main/java/org/apache/datasketches/hll/DirectAuxHashMap.java
index 0afa612..70a578b 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectAuxHashMap.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectAuxHashMap.java
@@ -192,7 +192,7 @@
 
     if (requestBytes > oldCapBytes) {
       final MemoryRequestServer svr = host.wmem.getMemoryRequestServer();
-      final WritableMemory newWmem = svr.request(requestBytes);
+      final WritableMemory newWmem = svr.request(host.wmem, requestBytes);
       host.wmem.copyTo(0, newWmem, 0, host.auxStart);
       newWmem.clear(host.auxStart, newAuxBytes); //clear space for new aux data
       svr.requestClose(host.wmem, newWmem); //old host.wmem is now invalid
diff --git a/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java b/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
index a56f135..970a0f9 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectHll4Array.java
@@ -152,7 +152,7 @@
     final boolean srcMemIsCompact = extractCompactFlag(mem);
     final int totBytes = getCompactSerializationBytes();
     final byte[] byteArr = new byte[totBytes];
-    final WritableMemory memOut = WritableMemory.wrap(byteArr);
+    final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
     if (srcMemIsCompact) { //mem is already consistent with result
       mem.copyTo(0, memOut, 0, totBytes);
       return byteArr;
@@ -179,7 +179,7 @@
     final boolean memIsCompact = extractCompactFlag(mem);
     final int totBytes = getUpdatableSerializationBytes();
     final byte[] byteArr = new byte[totBytes];
-    final WritableMemory memOut = WritableMemory.wrap(byteArr);
+    final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
 
     if (!memIsCompact) { //both mem and target are updatable
       mem.copyTo(0, memOut, 0, totBytes);
diff --git a/src/main/java/org/apache/datasketches/hll/DirectHllArray.java b/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
index f4b2446..d623b8c 100644
--- a/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
+++ b/src/main/java/org/apache/datasketches/hll/DirectHllArray.java
@@ -269,7 +269,7 @@
   byte[] toUpdatableByteArray() {
     final int totBytes = getCompactSerializationBytes();
     final byte[] byteArr = new byte[totBytes];
-    final WritableMemory memOut = WritableMemory.wrap(byteArr);
+    final WritableMemory memOut = WritableMemory.writableWrap(byteArr);
     mem.copyTo(0, memOut, 0, totBytes);
     insertCompactFlag(memOut, false);
     return byteArr;
diff --git a/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java b/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
index 131a53c..3e08144 100644
--- a/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/hll/ToByteArrayImpl.java
@@ -68,7 +68,7 @@
     }
     final int totBytes = HLL_BYTE_ARR_START + impl.getHllByteArrBytes() + auxBytes;
     final byte[] byteArr = new byte[totBytes];
-    final WritableMemory wmem = WritableMemory.wrap(byteArr);
+    final WritableMemory wmem = WritableMemory.writableWrap(byteArr);
     insertHll(impl, wmem, compact);
     return byteArr;
   }
@@ -146,7 +146,7 @@
         final int dataStart = impl.getMemDataStart();
         final int bytesOut = dataStart + (srcCouponArrInts << 2);
         byteArrOut = new byte[bytesOut];
-        final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+        final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
         copyCommonListAndSet(impl, memOut);
         insertCompactFlag(memOut, dstCompact);
 
@@ -174,7 +174,7 @@
         final int dataStart = impl.getMemDataStart();
         final int bytesOut = dataStart + (srcCouponCount << 2);
         byteArrOut = new byte[bytesOut];
-        final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+        final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
         copyCommonListAndSet(impl, memOut);
         insertCompactFlag(memOut, dstCompact);
 
@@ -201,7 +201,7 @@
         final int dataStart = impl.getMemDataStart();
         final int bytesOut = dataStart + (srcCouponCount << 2);
         byteArrOut = new byte[bytesOut];
-        final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+        final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
         copyCommonListAndSet(impl, memOut);
         insertCompactFlag(memOut, dstCompact);
 
@@ -221,7 +221,7 @@
         final int dataStart = impl.getMemDataStart();
         final int bytesOut = dataStart + (srcCouponArrInts << 2);
         byteArrOut = new byte[bytesOut];
-        final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+        final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
         copyCommonListAndSet(impl, memOut);
 
         memOut.putIntArray(dataStart, impl.getCouponIntArr(), 0, srcCouponArrInts);
diff --git a/src/main/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketch.java b/src/main/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketch.java
index 67b102b..6ee0319 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketch.java
@@ -251,7 +251,7 @@
 
     memReqSvr = (memReqSvr == null) ? mem_.getMemoryRequestServer() : memReqSvr;
 
-    final WritableMemory newMem = memReqSvr.request(needBytes);
+    final WritableMemory newMem = memReqSvr.request(mem_, needBytes);
 
     mem_.copyTo(0, newMem, 0, memBytes);
 
diff --git a/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java b/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
index 540fbe4..e59273d 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DoublesByteArrayImpl.java
@@ -58,7 +58,7 @@
 
     if (empty && !sketch.isDirect()) { //empty & on-heap
       final byte[] outByteArr = new byte[Long.BYTES];
-      final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+      final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
       final int preLongs = 1;
       insertPre0(memOut, preLongs, flags, sketch.getK());
       return outByteArr;
@@ -90,7 +90,7 @@
     final int outBytes = (compact ? sketch.getCompactStorageBytes() : sketch.getUpdatableStorageBytes());
 
     final byte[] outByteArr = new byte[outBytes];
-    final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+    final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
 
     //insert preamble-0, N, min, max
     insertPre0(memOut, preLongs, flags, k);
diff --git a/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java b/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
index 0036ba4..919020f 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ItemsByteArrayImpl.java
@@ -56,7 +56,7 @@
 
     if (empty) {
       final byte[] outByteArr = new byte[Long.BYTES];
-      final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+      final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
       final int preLongs = 1;
       insertPre0(memOut, preLongs, flags, sketch.getK());
       return outByteArr;
@@ -69,7 +69,7 @@
     final byte[] itemsByteArr = serDe.serializeToByteArray(dataArr);
     final int numOutBytes = (preLongs << 3) + itemsByteArr.length;
     final byte[] outByteArr = new byte[numOutBytes];
-    final WritableMemory memOut = WritableMemory.wrap(outByteArr);
+    final WritableMemory memOut = WritableMemory.writableWrap(outByteArr);
 
     //insert preamble
     insertPre0(memOut, preLongs, flags, sketch.getK());
diff --git a/src/main/java/org/apache/datasketches/req/FloatBuffer.java b/src/main/java/org/apache/datasketches/req/FloatBuffer.java
index 72c48b9..6d86316 100755
--- a/src/main/java/org/apache/datasketches/req/FloatBuffer.java
+++ b/src/main/java/org/apache/datasketches/req/FloatBuffer.java
@@ -398,7 +398,7 @@
   byte[] floatsToBytes() {
     final int bytes = Float.BYTES * count_;
     final byte[] arr = new byte[bytes];
-    final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+    final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
     if (spaceAtBottom_) {
       wbuf.putFloatArray(arr_, capacity_ - count_, count_);
     } else {
diff --git a/src/main/java/org/apache/datasketches/req/ReqCompactor.java b/src/main/java/org/apache/datasketches/req/ReqCompactor.java
index d1eede8..968eea7 100644
--- a/src/main/java/org/apache/datasketches/req/ReqCompactor.java
+++ b/src/main/java/org/apache/datasketches/req/ReqCompactor.java
@@ -297,7 +297,7 @@
   byte[] toByteArray() {
     final int bytes = getSerializationBytes();
     final byte[] arr = new byte[bytes];
-    final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+    final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
     wbuf.putLong(state);
     wbuf.putFloat(sectionSizeFlt);
     wbuf.putByte(lgWeight);
diff --git a/src/main/java/org/apache/datasketches/req/ReqSerDe.java b/src/main/java/org/apache/datasketches/req/ReqSerDe.java
index d5f7712..5164852 100644
--- a/src/main/java/org/apache/datasketches/req/ReqSerDe.java
+++ b/src/main/java/org/apache/datasketches/req/ReqSerDe.java
@@ -266,7 +266,7 @@
     final SerDeFormat serDeFormat = getSerFormat(sk);
     final int bytes = getSerBytes(sk, serDeFormat);
     final byte[] arr = new byte[bytes];
-    final WritableBuffer wbuf = WritableMemory.wrap(arr).asWritableBuffer();
+    final WritableBuffer wbuf = WritableMemory.writableWrap(arr).asWritableBuffer();
     final byte preInts = (byte)(serDeFormat == SerDeFormat.ESTIMATION ? 4 : 2);
     final byte flags = getFlags(sk);
     final byte numCompactors = sk.isEmpty() ? 0 : (byte) sk.getNumLevels();
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
index 3c4741c..d4344dd 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
@@ -475,7 +475,7 @@
       outBytes = (preLongs << 3) + bytes.length;
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // Common header elements
     PreambleUtil.insertPreLongs(mem, preLongs);                  // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
index 28e0e4d..6d56a57 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsUnion.java
@@ -300,7 +300,7 @@
       outBytes = (preLongs << 3) + gadgetBytes.length; // for longs, we know the size
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build preLong
     PreambleUtil.insertPreLongs(mem, preLongs);                       // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
index ee2ec59..62b430c 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
@@ -402,7 +402,7 @@
       outBytes = (preLongs + numItems) << 3; // for longs, we know the size
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build first preLong
     PreambleUtil.insertPreLongs(mem, preLongs);                 // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
index 891e9d2..50c891f 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsUnion.java
@@ -253,7 +253,7 @@
       outBytes = (preLongs << 3) + gadgetBytes.length; // longs, so we know the size
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // construct header
     PreambleUtil.insertPreLongs(mem, preLongs);                       // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSamples.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSamples.java
index 24614fe..b5b265c 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSamples.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSamples.java
@@ -57,6 +57,7 @@
   /**
    * A convenience class to allow easy iterator access to a VarOpt sample.
    */
+  //@SuppressWarnings("synthetic-access")
   public final class WeightedSample {
     private final int idx_;
     private double adjustedWeight_;
@@ -98,6 +99,7 @@
   /**
    * The standard iterator
    */
+  //@SuppressWarnings("synthetic-access")
   public class VarOptItemsIterator implements Iterator<WeightedSample> {
     int currIdx_;
     int finalIdx_; // inclusive final index
@@ -147,6 +149,7 @@
     }
   }
 
+  //@SuppressWarnings("synthetic-access")
   class WeightCorrectingRRegionIterator extends VarOptItemsIterator {
     private double cumWeight = 0.0;
 
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
index 055ebbb..0d1f832 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
@@ -584,7 +584,7 @@
       outBytes = (preLongs << 3) + (h_ * Double.BYTES) + numMarkBytes + itemBytes.length;
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build first preLong
     PreambleUtil.insertPreLongs(mem, preLongs);               // Byte 0
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
index 4c13abc..975ff17 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsUnion.java
@@ -328,7 +328,7 @@
       outBytes = (preLongs << 3) + gadgetBytes.length; // for longs, we know the size
     }
     final byte[] outArr = new byte[outBytes];
-    final WritableMemory mem = WritableMemory.wrap(outArr);
+    final WritableMemory mem = WritableMemory.writableWrap(outArr);
 
     // build preLong
     PreambleUtil.insertPreLongs(mem, preLongs);                    // Byte 0
diff --git a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketch.java b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketch.java
index 9e45db3..490f98f 100644
--- a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketch.java
@@ -296,7 +296,7 @@
 
           memReqSvr_ = (memReqSvr_ == null) ? wmem_.getMemoryRequestServer() : memReqSvr_;
 
-          final WritableMemory newDstMem = memReqSvr_.request(reqBytes);
+          final WritableMemory newDstMem = memReqSvr_.request(wmem_,reqBytes);
 
           moveAndResize(wmem_, preambleLongs, lgArrLongs, newDstMem, tgtLgArrLongs, thetaLong);
 
diff --git a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
index d79b71b..1958b90 100644
--- a/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
+++ b/src/main/java/org/apache/datasketches/theta/DirectQuickSelectSketchR.java
@@ -172,7 +172,7 @@
     checkIllegalCurCountAndEmpty(isEmpty(), extractCurCount(wmem_));
     final int lengthBytes = getCurrentBytes();
     final byte[] byteArray = new byte[lengthBytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     wmem_.copyTo(0, mem, 0, lengthBytes);
     final long thetaLong =
         correctThetaOnCompact(isEmpty(), extractCurCount(wmem_), extractThetaLong(wmem_));
@@ -219,7 +219,7 @@
     final long lgArrLongs = wmem_.getByte(LG_ARR_LONGS_BYTE) & 0XFF;
     final int preambleLongs = wmem_.getByte(PREAMBLE_LONGS_BYTE) & 0X3F;
     final long[] cacheArr = new long[1 << lgArrLongs];
-    final WritableMemory mem = WritableMemory.wrap(cacheArr);
+    final WritableMemory mem = WritableMemory.writableWrap(cacheArr);
     wmem_.copyTo(preambleLongs << 3, mem, 0, 8 << lgArrLongs);
     return cacheArr;
   }
diff --git a/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java b/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
index 432b4aa..e1f1ebb 100644
--- a/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/theta/HeapCompactSketch.java
@@ -158,7 +158,7 @@
   public byte[] toByteArray() {
     final int bytes = getCurrentBytes();
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory dstMem = WritableMemory.wrap(byteArray);
+    final WritableMemory dstMem = WritableMemory.writableWrap(byteArray);
     final int emptyBit = isEmpty() ? EMPTY_FLAG_MASK : 0;
     final int orderedBit = ordered_ ? ORDERED_FLAG_MASK : 0;
     final int singleItemBit = singleItem_ ? SINGLEITEM_FLAG_MASK : 0;
diff --git a/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java b/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
index 2bc2915..f0e67a2 100644
--- a/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
+++ b/src/main/java/org/apache/datasketches/theta/HeapUpdateSketch.java
@@ -113,7 +113,7 @@
     final int preBytes = (preLongs << 3) & 0X3F;
     final int dataBytes = getCurrentDataLongs() << 3;
     final byte[] byteArrOut = new byte[preBytes + dataBytes];
-    final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+    final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
 
     //preamble first 8 bytes. Note: only compact can be reduced to 8 bytes.
     final int lgRf = getResizeFactor().lg() & 0x3;
diff --git a/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java b/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
index 4a8811c..901ec42 100644
--- a/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
+++ b/src/main/java/org/apache/datasketches/theta/IntersectionImpl.java
@@ -363,7 +363,7 @@
       wmem_.getByteArray(0, byteArrOut, 0, preBytes + dataBytes);
     }
     else {
-      final WritableMemory memOut = WritableMemory.wrap(byteArrOut);
+      final WritableMemory memOut = WritableMemory.writableWrap(byteArrOut);
 
       //preamble
       memOut.putByte(PREAMBLE_LONGS_BYTE, (byte) CONST_PREAMBLE_LONGS); //RF not used = 0
diff --git a/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java b/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
index 1a60a9b..0b21f7b 100644
--- a/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
+++ b/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
@@ -49,7 +49,7 @@
   /**
    * Constructor for building a new SetOperation.  The default configuration is
    * <ul>
-   * <li>Nominal Entries: {@value org.apache.datasketches.Util#DEFAULT_NOMINAL_ENTRIES}</li>
+   * <li>Max Nominal Entries (max K): {@value org.apache.datasketches.Util#DEFAULT_NOMINAL_ENTRIES}</li>
    * <li>Seed: {@value org.apache.datasketches.Util#DEFAULT_UPDATE_SEED}</li>
    * <li>{@link ResizeFactor#X8}</li>
    * <li>Input Sampling Probability: 1.0</li>
@@ -65,11 +65,11 @@
   }
 
   /**
-   * Sets the Nominal Entries for this set operation. The minimum value is 16 and the maximum value
-   * is 67,108,864, which is 2^26. Be aware that Unions as large as this maximum value have not
-   * been thoroughly tested or characterized for performance.
+   * Sets the Maximum Nominal Entries (max K) for this set operation. The effective value of K of the result of a
+   * Set Operation can be less than max K, but never greater.  
+   * The minimum value is 16 and the maximum value is 67,108,864, which is 2^26. 
    * @param nomEntries <a href="{@docRoot}/resources/dictionary.html#nomEntries">Nominal Entres</a>
-   * This will become the ceiling power of 2 if it is not.
+   * This will become the ceiling power of 2 if it is not a power of 2.
    * @return this SetOperationBuilder
    */
   public SetOperationBuilder setNominalEntries(final int nomEntries) {
diff --git a/src/main/java/org/apache/datasketches/theta/UnionImpl.java b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
index 591d1ca..83888f6 100644
--- a/src/main/java/org/apache/datasketches/theta/UnionImpl.java
+++ b/src/main/java/org/apache/datasketches/theta/UnionImpl.java
@@ -260,7 +260,7 @@
   @Override
   public byte[] toByteArray() {
     final byte[] gadgetByteArr = gadget_.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(gadgetByteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(gadgetByteArr);
     insertUnionThetaLong(mem, unionThetaLong_);
     if (gadget_.isEmpty() != unionEmpty_) {
       clearEmpty(mem);
diff --git a/src/main/java/org/apache/datasketches/tuple/AnotB.java b/src/main/java/org/apache/datasketches/tuple/AnotB.java
index 9cf2380..a7fe752 100644
--- a/src/main/java/org/apache/datasketches/tuple/AnotB.java
+++ b/src/main/java/org/apache/datasketches/tuple/AnotB.java
@@ -339,7 +339,7 @@
     return da;
   }
 
-  @SuppressWarnings({ "unchecked"})
+  @SuppressWarnings("unchecked")
   private static <S extends Summary> DataArrays<S> getResultArraysTuple(
       final long minThetaLong,
       final int countA,
@@ -385,7 +385,7 @@
   }
 
 
-  @SuppressWarnings({ "unchecked"})
+  @SuppressWarnings("unchecked")
   private static <S extends Summary> DataArrays<S> getResultArraysTheta(
       final long minThetaLong,
       final int countA,
diff --git a/src/main/java/org/apache/datasketches/tuple/Util.java b/src/main/java/org/apache/datasketches/tuple/Util.java
index 8795d89..46f2027 100644
--- a/src/main/java/org/apache/datasketches/tuple/Util.java
+++ b/src/main/java/org/apache/datasketches/tuple/Util.java
@@ -24,9 +24,10 @@
 import static org.apache.datasketches.Util.ceilingPowerOf2;
 import static org.apache.datasketches.Util.startingSubMultiple;
 import static org.apache.datasketches.hash.MurmurHash3.hash;
+import static org.apache.datasketches.memory.XxHash.*;
 
 import org.apache.datasketches.SketchesArgumentException;
-import org.apache.datasketches.memory.XxHash64;
+
 
 /**
  * Common utility functions for Tuples
@@ -121,7 +122,7 @@
    * @return the hash of the string
    */
   public static long stringHash(final String s) {
-    return XxHash64.hashChars(s.toCharArray(), 0, s.length(), PRIME);
+    return hashString(s, 0, s.length(), PRIME);
   }
 
   /**
@@ -130,7 +131,7 @@
    */
   public static long stringArrHash(final String[] strArray) {
     final String s = stringConcat(strArray);
-    return XxHash64.hashChars(s.toCharArray(), 0, s.length(), PRIME);
+    return hashCharArr(s.toCharArray(), 0, s.length(), PRIME);
   }
 
 }
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
index 7835c82..ec781f9 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnion.java
@@ -199,7 +199,7 @@
   public byte[] toByteArray() {
     final int sizeBytes = PREAMBLE_SIZE_BYTES + sketch_.getSerializedSizeBytes();
     final byte[] byteArray = new byte[sizeBytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 1); // unused, always 1
     mem.putByte(SERIAL_VERSION_BYTE, serialVersionUID);
     mem.putByte(FAMILY_ID_BYTE, (byte) Family.TUPLE.getID());
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
index 3939e1b..8da948d 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketch.java
@@ -198,7 +198,7 @@
           + (SIZE_OF_VALUE_BYTES * count * numValues_);
     }
     final byte[] byteArray = new byte[sizeBytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem_.copyTo(0, mem, 0, sizeBytes);
     return byteArray;
   }
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
index 5c4e4b4..5341297 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketch.java
@@ -171,7 +171,7 @@
   public byte[] toByteArray() {
     final int sizeBytes = getSerializedSizeBytes();
     final byte[] byteArray = new byte[sizeBytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     serializeInto(mem);
     return byteArray;
   }
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
index 3ad23d4..1f34022 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketch.java
@@ -157,7 +157,7 @@
           ENTRIES_START + (SIZE_OF_KEY_BYTES * count) + (SIZE_OF_VALUE_BYTES * numValues_ * count);
     }
     final byte[] bytes = new byte[sizeBytes];
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 1);
     mem.putByte(SERIAL_VERSION_BYTE, serialVersionUID);
     mem.putByte(FAMILY_ID_BYTE, (byte) Family.TUPLE.getID());
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
index 5b10192..c4ce58c 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
@@ -153,7 +153,7 @@
   @Override
   public byte[] toByteArray() {
     final byte[] byteArray = new byte[getSerializedSizeBytes()];
-    final WritableMemory mem = WritableMemory.wrap(byteArray); // wrap the byte array to use the putX methods
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray); // wrap the byte array to use the putX methods
     serializeInto(mem);
     return byteArray;
   }
diff --git a/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java b/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
index 75ab751..08b1f51 100644
--- a/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
+++ b/src/main/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSummary.java
@@ -75,7 +75,7 @@
     final ComputeBytes cb = new ComputeBytes(nodesArr);
     final int totBytes = cb.totBytes_;
     final byte[] out = new byte[totBytes];
-    final WritableMemory wmem = WritableMemory.wrap(out);
+    final WritableMemory wmem = WritableMemory.writableWrap(out);
     final WritableBuffer wbuf = wmem.asWritableBuffer();
     wbuf.putInt(totBytes);
     wbuf.putByte(cb.numNodes_);
diff --git a/src/test/java/org/apache/datasketches/HashOperationsTest.java b/src/test/java/org/apache/datasketches/HashOperationsTest.java
index f7495aa..1c2e529 100644
--- a/src/test/java/org/apache/datasketches/HashOperationsTest.java
+++ b/src/test/java/org/apache/datasketches/HashOperationsTest.java
@@ -106,7 +106,7 @@
   @Test
   public void testHashInsertOnlyMemoryNoStride() {
     final long[] table = new long[32];
-    final WritableMemory mem = WritableMemory.wrap(table);
+    final WritableMemory mem = WritableMemory.writableWrap(table);
     final int index = hashInsertOnlyMemory(mem, 5, 1, 0);
     assertEquals(index, 1);
     assertEquals(table[1], 1L);
@@ -116,7 +116,7 @@
   public void testHashInsertOnlyMemoryWithStride() {
     final long[] table = new long[32];
     table[1] = 1;
-    final WritableMemory mem = WritableMemory.wrap(table);
+    final WritableMemory mem = WritableMemory.writableWrap(table);
     final int index = hashInsertOnlyMemory(mem, 5, 1, 0);
     assertEquals(index, 2);
     assertEquals(table[2], 1L);
@@ -151,7 +151,7 @@
   @Test
   public void checkFullDirectTableCatchesInfiniteLoop() {
     final long[] table = new long[32];
-    final WritableMemory mem = WritableMemory.wrap(table);
+    final WritableMemory mem = WritableMemory.writableWrap(table);
     for (int i = 1; i <= 32; ++i) {
       hashInsertOnlyMemory(mem, 5, i, 0);
     }
@@ -178,7 +178,7 @@
   @Test
   public void checkFullFastDirectTableCatchesInfiniteLoop() {
     final long[] table = new long[32];
-    final WritableMemory wmem = WritableMemory.wrap(table);
+    final WritableMemory wmem = WritableMemory.writableWrap(table);
 
     for (int i = 1; i <= 32; ++i) {
       hashInsertOnlyMemory(wmem, 5, i, 0);
diff --git a/src/test/java/org/apache/datasketches/UtilTest.java b/src/test/java/org/apache/datasketches/UtilTest.java
index db99aa2..8d575ca 100644
--- a/src/test/java/org/apache/datasketches/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/UtilTest.java
@@ -70,7 +70,6 @@
     checkIfPowerOf2(31, "31");
   }
 
-
   @Test
   public void numTrailingOnes() {
     long mask = 1L;
@@ -86,6 +85,11 @@
     }
   }
 
+  @Test(expectedExceptions = SketchesArgumentException.class)
+  public void checkBoundsTest() {
+    Util.checkBounds(999, 2, 1000);
+  }
+  
   @Test
   public void checkIsPowerOf2() {
     Assert.assertEquals(isPowerOf2(0), false);
diff --git a/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java b/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
index 3df8816..4600674 100644
--- a/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/CpcCBinariesTest.java
@@ -23,7 +23,6 @@
 import static org.testng.Assert.assertEquals;
 
 import java.io.File;
-import java.io.IOException;
 import java.io.PrintStream;
 
 import org.apache.datasketches.memory.MapHandle;
@@ -48,7 +47,7 @@
       println(PreambleUtil.toString(wmem, true));
       final CpcSketch sk = CpcSketch.heapify(wmem);
       assertEquals(sk.getFlavor(), Flavor.EMPTY);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -74,7 +73,7 @@
       for (int i = 0; i < 100; i++) { sk.update(i); }
       final double est2 = sk.getEstimate();
       assertEquals(est2, est1, 0); //assert no change
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -100,7 +99,7 @@
       for (long i = 0; i < 200; i++) { sk.update(i); }
       final double est2 = sk.getEstimate();
       assertEquals(est2, est1, 0); //assert no change
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -126,7 +125,7 @@
       for (long i = 0; i < 2000; i++) { sk.update(i); }
       final double est2 = sk.getEstimate();
       assertEquals(est2, est1, 0); //assert no change
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -152,7 +151,7 @@
       for (long i = 0; i < 20000; i++) { sk.update(i); }
       final double est2 = sk.getEstimate();
       assertEquals(est2, est1, 0);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -174,7 +173,7 @@
       final Memory mem2 = Memory.wrap(mem2ByteArr);
       assertEquals(mem.getCapacity(), mem2.getCapacity());
       assertEquals(memByteArr, mem2ByteArr);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -195,7 +194,7 @@
       final Memory mem2 = Memory.wrap(mem2ByteArr);
       assertEquals(mem.getCapacity(), mem2.getCapacity());
       assertEquals(memByteArr, mem2ByteArr);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -216,7 +215,7 @@
       final Memory mem2 = Memory.wrap(mem2ByteArr);
       assertEquals(mem.getCapacity(), mem2.getCapacity());
       assertEquals(memByteArr, mem2ByteArr);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -237,7 +236,7 @@
       final Memory mem2 = Memory.wrap(javaMemByteArr);
       assertEquals(mem.getCapacity(), mem2.getCapacity());
       assertEquals(cppMemByteArr, javaMemByteArr);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
@@ -258,7 +257,7 @@
       final Memory mem2 = Memory.wrap(mem2ByteArr);
       assertEquals(mem.getCapacity(), mem2.getCapacity());
       assertEquals(memByteArr, mem2ByteArr);
-    } catch (final IOException e) {
+    } catch (final Exception e) {
       e.printStackTrace();
     }
   }
diff --git a/src/test/java/org/apache/datasketches/cpc/LzTzSpeedTest.java b/src/test/java/org/apache/datasketches/cpc/LzTzSpeedTest.java
index b134eea..9936609 100644
--- a/src/test/java/org/apache/datasketches/cpc/LzTzSpeedTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/LzTzSpeedTest.java
@@ -164,7 +164,7 @@
    * @param s value to print
    */
   static void println(String s) {
-    System.out.println(s); //disable here
+    //System.out.println(s); //disable here
   }
 
   static {
diff --git a/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java b/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
index e0f7234..17e3582 100644
--- a/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
+++ b/src/test/java/org/apache/datasketches/cpc/SpecialCBinariesTest.java
@@ -53,7 +53,7 @@
       try {
         CpcSketch sk = CpcSketch.heapify(mem);
       } catch (SketchesArgumentException e) {} // Image was truncated by 4 bytes
-    } catch (IOException e) {
+    } catch (Exception e) {
       e.printStackTrace();
     }
   }
@@ -90,8 +90,8 @@
     assertTrue(file.isFile());
 
     try (WritableMapHandle wmh
-        = WritableMemory.map(file, 0, byteArr.length, ByteOrder.nativeOrder())) {
-      WritableMemory wmem = wmh.get();
+        = WritableMemory.writableMap(file, 0, byteArr.length, ByteOrder.nativeOrder())) {
+      WritableMemory wmem = wmh.getWritable();
       wmem.putByteArray(0, byteArr, 0, byteArr.length);
       wmh.force();
     } catch (IOException e) {
diff --git a/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java b/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
index 211aa8e..e0c515c 100644
--- a/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/ItemsSketchTest.java
@@ -346,7 +346,7 @@
     sk1.update(Long.valueOf(1), 1);
     ArrayOfLongsSerDe serDe = new ArrayOfLongsSerDe();
     byte[] byteArr = sk1.toByteArray(serDe);
-    WritableMemory mem = WritableMemory.wrap(byteArr);
+    WritableMemory mem = WritableMemory.writableWrap(byteArr);
     //FrequentItemsSketch<Long> sk2 = FrequentItemsSketch.getInstance(mem, serDe);
     //println(sk2.toString());
     long pre0 = mem.getLong(0); //The correct first 8 bytes.
diff --git a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
index 4f53204..e52dfcf 100644
--- a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
@@ -121,7 +121,7 @@
     //Empty Sketch
     LongsSketch sketch = new LongsSketch(16);
     byte[] bytearray0 = sketch.toByteArray();
-    WritableMemory mem0 = WritableMemory.wrap(bytearray0);
+    WritableMemory mem0 = WritableMemory.writableWrap(bytearray0);
     LongsSketch new_sketch0 = LongsSketch.getInstance(mem0);
     String str0 = LongsSketch.toString(mem0);
     println(str0);
@@ -284,7 +284,7 @@
     sk1.update(1L);
 
     byte[] bytearray0 = sk1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(bytearray0);
+    WritableMemory mem = WritableMemory.writableWrap(bytearray0);
     long pre0 = mem.getLong(0);
 
     tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt
@@ -386,7 +386,7 @@
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkGetInstanceMemory() {
-    WritableMemory mem = WritableMemory.wrap(new byte[4]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[4]);
     LongsSketch.getInstance(mem);
   }
 
diff --git a/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java b/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
index 2417cf7..2e80d3b 100644
--- a/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/SerDeCompatibilityTest.java
@@ -19,12 +19,11 @@
 
 package org.apache.datasketches.frequencies;
 
-import org.testng.Assert;
-import org.testng.annotations.Test;
-
-import org.apache.datasketches.memory.WritableMemory;
 import org.apache.datasketches.ArrayOfItemsSerDe;
 import org.apache.datasketches.ArrayOfLongsSerDe;
+import org.apache.datasketches.memory.WritableMemory;
+import org.testng.Assert;
+import org.testng.annotations.Test;
 
 @SuppressWarnings("javadoc")
 public class SerDeCompatibilityTest {
@@ -40,7 +39,7 @@
     sketch1.update(4L);
 
     byte[] bytes = sketch1.toByteArray(serDe);
-    LongsSketch sketch2 = LongsSketch.getInstance(WritableMemory.wrap(bytes));
+    LongsSketch sketch2 = LongsSketch.getInstance(WritableMemory.writableWrap(bytes));
     sketch2.update(2L);
     sketch2.update(3L);
     sketch2.update(2L);
@@ -63,7 +62,7 @@
     sketch1.update(4L);
 
     byte[] bytes = sketch1.toByteArray();
-    ItemsSketch<Long> sketch2 = ItemsSketch.getInstance(WritableMemory.wrap(bytes), serDe);
+    ItemsSketch<Long> sketch2 = ItemsSketch.getInstance(WritableMemory.writableWrap(bytes), serDe);
     sketch2.update(2L);
     sketch2.update(3L);
     sketch2.update(2L);
diff --git a/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java b/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
index 2e074bd..12b6a90 100644
--- a/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
+++ b/src/test/java/org/apache/datasketches/hash/MurmurHash3v2Test.java
@@ -19,12 +19,16 @@
 
 package org.apache.datasketches.hash;
 
+import java.util.Random;
+
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
 
 import org.testng.annotations.Test;
 
 import org.apache.datasketches.memory.Memory;
+import org.apache.datasketches.memory.MurmurHash3v2;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -32,7 +36,156 @@
  */
 @SuppressWarnings("javadoc")
 public class MurmurHash3v2Test {
+  private Random rand = new Random();
+  private static final int trials = 1 << 20;
+  
+  @Test
+  public void compareLongArrLong() { //long[]
+    int arrLen = 3;
+    int iPer = 8 / Long.BYTES;
+    long[] key = new long[arrLen];
+    for (int i = 0; i < trials; i++) { //trials
+      for (int j = 0; j < arrLen / iPer; j++) { //longs
+        long r = rand.nextLong();
+        key[j] = r;
+      }
+      long[] res1 = hashV1(key, 0);
+      long[] res2 = hashV2(key, 0);
+      assertEquals(res2, res1);
+    }
+  }
+  
+  @Test
+  public void compareIntArr() { //int[]
+    int bytes = Integer.BYTES;
+    int arrLen = 6;
+    int[] key = new int[arrLen];
+    int iPer = 8 / bytes;
+    int nLongs = arrLen / iPer;
+    int shift = 64 / iPer;
+    
+    for (int i = 0; i < trials; i++) { //trials
+      for (int j = 0; j < nLongs; j++) { //longs
+        long r = rand.nextLong();
+        for (int k = 0; k < iPer; k++) { //ints
+          int shft = k * shift;
+          key[k] = (int) (r >>> shft);
+        }
+      }
+      long[] res1 = hashV1(key, 0);
+      long[] res2 = hashV2(key, 0);
+      assertEquals(res2, res1);
+    }
+  }
+  
+  @Test
+  public void compareCharArr() { //char[]
+    int bytes = Character.BYTES;
+    int arrLen = 12;
+    char[] key = new char[arrLen];
+    int iPer = 8 / bytes;
+    int nLongs = arrLen / iPer;
+    int shift = 64 / iPer;
+    
+    for (int i = 0; i < trials; i++) { //trials
+      for (int j = 0; j < nLongs; j++) { //longs
+        long r = rand.nextLong();
+        for (int k = 0; k < iPer; k++) { //char
+          int shft = k * shift;
+          key[k] = (char) (r >>> shft);
+        }
+      }
+      long[] res1 = hashV1(key, 0);
+      long[] res2 = hashV2(key, 0);
+      assertEquals(res2, res1);
+    }
+  }
+  
+  @Test
+  public void compareByteArr() { //byte[]
+    int bytes = Byte.BYTES;
+    int arrLen = 12;
+    byte[] key = new byte[arrLen];
+    int iPer = 8 / bytes;
+    int nLongs = arrLen / iPer;
+    int shift = 64 / iPer;
+    
+    for (int i = 0; i < trials; i++) { //trials
+      for (int j = 0; j < nLongs; j++) { //longs
+        long r = rand.nextLong();
+        for (int k = 0; k < iPer; k++) { //bytes
+          int shft = k * shift;
+          key[k] = (byte) (r >>> shft);
+        }
+      }
+      long[] res1 = hashV1(key, 0);
+      long[] res2 = hashV2(key, 0);
+      assertEquals(res2, res1);
+    }
+  }
+  
+  @Test
+  public void compareLongVsLongArr() {
+    int arrLen = 1;
+    long[] key = new long[arrLen];
+    long[] out = new long[2];
+    for (int i = 0; i < trials; i++) { //trials
+      long r = rand.nextLong();
+      key[0] = r;
+      long[] res1 = hashV1(key, 0);
+      long[] res2 = hashV2(r, 0, out);
+      assertEquals(res2, res1);
+    }
+  }
+  
+  private static final long[] hashV1(long[] key, long seed) {
+    return MurmurHash3.hash(key, seed);
+  }
+  
+  private static final long[] hashV1(int[] key, long seed) {
+    return MurmurHash3.hash(key, seed);
+  }
 
+  private static final long[] hashV1(char[] key, long seed) {
+    return MurmurHash3.hash(key, seed);
+  }
+  
+  private static final long[] hashV1(byte[] key, long seed) {
+    return MurmurHash3.hash(key, seed);
+  }
+  
+  private static final long[] hashV2(long[] key, long seed) {
+    return MurmurHash3v2.hash(key, seed);
+  }
+  
+  private static final long[] hashV2(int[] key2, long seed) {
+    return MurmurHash3v2.hash(key2, seed);
+  }
+
+  private static final long[] hashV2(char[] key, long seed) {
+    return MurmurHash3v2.hash(key, seed);
+  }
+  
+  private static final long[] hashV2(byte[] key, long seed) {
+    return MurmurHash3v2.hash(key, seed);
+  }
+  
+  //V2 single primitives
+  
+  private static final long[] hashV2(long key, long seed, long[] out) {
+    return MurmurHash3v2.hash(key, seed, out);
+  }
+  
+//  private static final long[] hashV2(double key, long seed, long[] out) {
+//    return MurmurHash3v2.hash(key, seed, out);
+//  }
+  
+//  private static final long[] hashV2(String key, long seed, long[] out) {
+//    return MurmurHash3v2.hash(key, seed, out);
+//  }
+  
+  
+  
   @Test
   public void offsetChecks() {
     long seed = 12345;
@@ -66,7 +219,7 @@
     for (int j = 1; j < bytes; j++) {
       byte[] in = new byte[bytes];
 
-      WritableMemory wmem = WritableMemory.wrap(in);
+      WritableMemory wmem = WritableMemory.writableWrap(in);
       for (int i = 0; i < j; i++) { wmem.putByte(i, (byte) (-128 + i)); }
 
       long[] hash1 = MurmurHash3.hash(in, 0);
@@ -90,7 +243,7 @@
     for (int j = 1; j < chars; j++) {
       char[] in = new char[chars];
 
-      WritableMemory wmem = WritableMemory.wrap(in);
+      WritableMemory wmem = WritableMemory.writableWrap(in);
       for (int i = 0; i < j; i++) { wmem.putInt(i, i); }
 
       long[] hash1 = MurmurHash3.hash(in, 0);
@@ -114,7 +267,7 @@
     for (int j = 1; j < ints; j++) {
       int[] in = new int[ints];
 
-      WritableMemory wmem = WritableMemory.wrap(in);
+      WritableMemory wmem = WritableMemory.writableWrap(in);
       for (int i = 0; i < j; i++) { wmem.putInt(i, i); }
 
       long[] hash1 = MurmurHash3.hash(in, 0);
@@ -138,7 +291,7 @@
     for (int j = 1; j < longs; j++) {
       long[] in = new long[longs];
 
-      WritableMemory wmem = WritableMemory.wrap(in);
+      WritableMemory wmem = WritableMemory.writableWrap(in);
       for (int i = 0; i < j; i++) { wmem.putLong(i, i); }
 
       long[] hash1 = MurmurHash3.hash(in, 0);
@@ -158,7 +311,7 @@
 
     long[] hash2 = new long[2];
     long[] in = { 1 };
-    WritableMemory wmem = WritableMemory.wrap(in);
+    WritableMemory wmem = WritableMemory.writableWrap(in);
 
     long[] hash1 = MurmurHash3.hash(in, 0);
     hash2 = MurmurHash3v2.hash(wmem, offset, bytes, seed, hash2);
@@ -172,30 +325,65 @@
   public void checkEmptiesNulls() {
     long seed = 123;
     long[] hashOut = new long[2];
-    Memory mem = Memory.wrap(new long[0]);
-    long hash0 = MurmurHash3v2.hash(mem, 0, 0, seed, hashOut)[0];  //mem empty
-    mem = null;
-    assertEquals(MurmurHash3v2.hash(mem, 0, 0, seed, hashOut)[0], hash0); //mem null
-    String s = "";
-    assertEquals(MurmurHash3v2.hash(s, seed, hashOut)[0], hash0); //string empty
-    s = null;
-    assertEquals(MurmurHash3v2.hash(s, seed, hashOut)[0], hash0); //string null
-    byte[] barr = new byte[0];
-    assertEquals(MurmurHash3v2.hash(barr, seed)[0], hash0); //byte[] empty
-    barr = null;
-    assertEquals(MurmurHash3v2.hash(barr, seed)[0], hash0); //byte[] null
-    char[] carr = new char[0];
-    assertEquals(MurmurHash3v2.hash(carr, seed)[0], hash0); //char[] empty
-    carr = null;
-    assertEquals(MurmurHash3v2.hash(carr, seed)[0], hash0); //char[] null
-    int[] iarr = new int[0];
-    assertEquals(MurmurHash3v2.hash(iarr, seed)[0], hash0); //int[] empty
-    iarr = null;
-    assertEquals(MurmurHash3v2.hash(iarr, seed)[0], hash0); //int[] null
-    long[] larr = new long[0];
-    assertEquals(MurmurHash3v2.hash(larr, seed)[0], hash0); //long[] empty
-    larr = null;
-    assertEquals(MurmurHash3v2.hash(larr, seed)[0], hash0); //long[] empty
+    try {
+      MurmurHash3v2.hash(Memory.wrap(new long[0]), 0, 0, seed, hashOut);  //mem empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      Memory mem = null;
+      MurmurHash3v2.hash(mem, 0, 0, seed, hashOut); //mem null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      String s = "";
+      MurmurHash3v2.hash(s, seed, hashOut); //string empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      String s = null;
+      MurmurHash3v2.hash(s, seed, hashOut); //string null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      byte[] barr = new byte[0];
+      MurmurHash3v2.hash(barr, seed); //byte[] empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      byte[] barr = null;
+      MurmurHash3v2.hash(barr, seed); //byte[] null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      char[] carr = new char[0];
+      MurmurHash3v2.hash(carr, seed); //char[] empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      char[] carr = null;
+      MurmurHash3v2.hash(carr, seed); //char[] null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      int[] iarr = new int[0];
+      MurmurHash3v2.hash(iarr, seed); //int[] empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      int[] iarr = null;
+      MurmurHash3v2.hash(iarr, seed); //int[] null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      long[] larr = new long[0];
+      MurmurHash3v2.hash(larr, seed); //long[] empty
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
+    try {
+      long[] larr = null;
+      MurmurHash3v2.hash(larr, seed); //long[] null
+      fail();
+    } catch (final IllegalArgumentException e) { } //OK
   }
 
   @Test
@@ -231,7 +419,7 @@
     final long data = Double.doubleToLongBits(d);// canonicalize all NaN forms
     final long[] dataArr = { data };
 
-    WritableMemory wmem = WritableMemory.wrap(dataArr);
+    WritableMemory wmem = WritableMemory.writableWrap(dataArr);
     long[] hash1 = MurmurHash3.hash(dataArr, 0);
     hash2 = MurmurHash3v2.hash(wmem, offset, bytes, seed, hash2);
     long[] hash3 = MurmurHash3v2.hash(dbl, seed, hash2);
diff --git a/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java b/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
index e78e807..c3ee04b 100644
--- a/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
+++ b/src/test/java/org/apache/datasketches/hll/BaseHllSketchTest.java
@@ -94,7 +94,7 @@
     assertTrue(sk.isEstimationMode());
     sk.reset();
     assertEquals(BaseHllSketch.getSerializationVersion(), PreambleUtil.SER_VER);
-    WritableMemory wmem = WritableMemory.wrap(sk.toCompactByteArray());
+    WritableMemory wmem = WritableMemory.writableWrap(sk.toCompactByteArray());
     assertEquals(BaseHllSketch.getSerializationVersion(wmem), PreambleUtil.SER_VER);
   }
 
diff --git a/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java b/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
index d25efc6..be7b4f4 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectAuxHashMapTest.java
@@ -26,12 +26,14 @@
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
 
+import java.nio.ByteOrder;
 import java.util.HashMap;
 
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
 import org.testng.annotations.Test;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 import org.apache.datasketches.SketchesStateException;
 
@@ -49,8 +51,9 @@
     int n = 8; //put lgConfigK == 4 into HLL mode
     int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgConfigK, tgtHllType);
     HllSketch hllSketch;
-    try (WritableDirectHandle handle = WritableMemory.allocateDirect(bytes)) {
-      WritableMemory wmem = handle.get();
+    try (WritableHandle handle = WritableMemory.allocateDirect(bytes,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
+      WritableMemory wmem = handle.getWritable();
       hllSketch = new HllSketch(lgConfigK, tgtHllType, wmem);
       for (int i = 0; i < n; i++) {
         hllSketch.update(i);
@@ -74,7 +77,7 @@
 
       //Check wrap
       byteArray = hllSketch.toUpdatableByteArray();
-      WritableMemory wmem2 = WritableMemory.wrap(byteArray);
+      WritableMemory wmem2 = WritableMemory.writableWrap(byteArray);
       hllSketch2 = HllSketch.writableWrap(wmem2);
       //println(hllSketch2.toString(true, true, true, true));
       DirectHllArray dha2 = (DirectHllArray) hllSketch2.hllSketchImpl;
@@ -90,6 +93,8 @@
       assertTrue(hllSketch.isMemory());
       assertFalse(hllSketch.isOffHeap());
       assertFalse(hllSketch.isSameResource(wmem));
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -100,7 +105,7 @@
     TgtHllType type = TgtHllType.HLL_4;
     int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgK, type);
     byte[] memByteArr = new byte[bytes];
-    WritableMemory wmem = WritableMemory.wrap(memByteArr);
+    WritableMemory wmem = WritableMemory.writableWrap(memByteArr);
     HllSketch heapSk = new HllSketch(lgK, type);
     HllSketch dirSk = new HllSketch(lgK, type, wmem);
     for (int i = 0; i < (1 << lgU); i++) {
diff --git a/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java b/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
index c045272..0625094 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectCouponListTest.java
@@ -28,7 +28,7 @@
 import org.testng.annotations.Test;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -71,8 +71,8 @@
     //println("DIRECT");
     byte[] barr1;
     WritableMemory wmem = null;
-    try (WritableDirectHandle hand = WritableMemory.allocateDirect(bytes)) {
-      wmem = hand.get();
+    try (WritableHandle hand = WritableMemory.allocateDirect(bytes)) {
+      wmem = hand.getWritable();
       //byte[] byteArr = new byte[bytes];
       //WritableMemory wmem = WritableMemory.wrap(byteArr);
       hllSketch = new HllSketch(lgConfigK, tgtHllType, wmem);
@@ -93,6 +93,8 @@
       //println(PreambleUtil.toString(barr1));
       hllSketch.reset();
       assertTrue(hllSketch.isEmpty());
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
 
     //println("HEAP");
diff --git a/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java b/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
index d967747..b8015e1 100644
--- a/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
+++ b/src/test/java/org/apache/datasketches/hll/DirectUnionTest.java
@@ -412,7 +412,7 @@
     Union union = newUnion(lgConfigK);
     for (int i = 0; i < n; i++) { union.update(i); }
     double est = union.getEstimate();
-    Union union2 = Union.writableWrap(WritableMemory.wrap(union.toUpdatableByteArray()));
+    Union union2 = Union.writableWrap(WritableMemory.writableWrap(union.toUpdatableByteArray()));
     double est2 = union2.getEstimate();
     assertEquals(est2, est, 0.0);
   }
@@ -423,7 +423,7 @@
     int n = 128;
     HllSketch sk = new HllSketch(lgConfigK, HLL_6);
     for (int i = 0; i < n; i++) {sk.update(i); }
-    Union.writableWrap(WritableMemory.wrap(sk.toUpdatableByteArray()));
+    Union.writableWrap(WritableMemory.writableWrap(sk.toUpdatableByteArray()));
   }
 
   private static Union newUnion(int lgK) {
diff --git a/src/test/java/org/apache/datasketches/hll/HllSketchTest.java b/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
index a237c24..3b346d8 100644
--- a/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
+++ b/src/test/java/org/apache/datasketches/hll/HllSketchTest.java
@@ -400,7 +400,7 @@
     boolean resourceCompact = sk2.isCompact();
     if (resourceCompact) {
       try {
-        HllSketch.writableWrap(WritableMemory.wrap(byteArr));
+        HllSketch.writableWrap(WritableMemory.writableWrap(byteArr));
         fail();
       } catch (SketchesArgumentException e) {
         //OK
@@ -415,7 +415,7 @@
   public void checkWritableWrapOfCompact() {
     HllSketch sk = new HllSketch();
     byte[] byteArr = sk.toCompactByteArray();
-    WritableMemory wmem = WritableMemory.wrap(byteArr);
+    WritableMemory wmem = WritableMemory.writableWrap(byteArr);
     HllSketch sk2 = HllSketch.writableWrap(wmem);
   }
 
diff --git a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
index 9137276..93007f5 100644
--- a/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/hll/PreambleUtilTest.java
@@ -47,10 +47,10 @@
   public void preambleToString() { //TODO Check Visually
     int bytes = HllSketch.getMaxUpdatableSerializationBytes(8, TgtHllType.HLL_4);
     byte[] byteArr1 = new byte[bytes];
-    WritableMemory wmem1 = WritableMemory.wrap(byteArr1);
+    WritableMemory wmem1 = WritableMemory.writableWrap(byteArr1);
     HllSketch sk = new HllSketch(8, TgtHllType.HLL_4, wmem1);
     byte[] byteArr2 = sk.toCompactByteArray();
-    WritableMemory wmem2 = WritableMemory.wrap(byteArr2);
+    WritableMemory wmem2 = WritableMemory.writableWrap(byteArr2);
 
     assertEquals(sk.getCurMode(), CurMode.LIST);
     assertTrue(sk.isEmpty());
@@ -62,7 +62,7 @@
 
     for (int i = 0; i < 7; i++) { sk.update(i); }
     byteArr2 = sk.toCompactByteArray();
-    wmem2 = WritableMemory.wrap(byteArr2);
+    wmem2 = WritableMemory.writableWrap(byteArr2);
     assertEquals(sk.getCurMode(), CurMode.LIST);
     assertFalse(sk.isEmpty());
     s = HllSketch.toString(byteArr2);
@@ -73,7 +73,7 @@
 
     for (int i = 7; i < 24; i++) { sk.update(i); }
     byteArr2 = sk.toCompactByteArray();
-    wmem2 = WritableMemory.wrap(byteArr2);
+    wmem2 = WritableMemory.writableWrap(byteArr2);
     assertEquals(sk.getCurMode(), CurMode.SET);
     s = HllSketch.toString(byteArr2);
     println(s);
@@ -83,7 +83,7 @@
 
     sk.update(24);
     byteArr2 = sk.toCompactByteArray();
-    wmem2 = WritableMemory.wrap(byteArr2);
+    wmem2 = WritableMemory.writableWrap(byteArr2);
     assertEquals(sk.getCurMode(), CurMode.HLL);
     s = HllSketch.toString(Memory.wrap(byteArr2));
     println(s);
@@ -96,7 +96,7 @@
   public void checkCompactFlag() {
     HllSketch sk = new HllSketch(7);
     byte[] memObj = sk.toCompactByteArray();
-    WritableMemory wmem = WritableMemory.wrap(memObj);
+    WritableMemory wmem = WritableMemory.writableWrap(memObj);
     boolean compact = PreambleUtil.extractCompactFlag(wmem);
     assertTrue(compact);
 
@@ -110,7 +110,7 @@
   public void checkCorruptMemoryInput() {
     HllSketch sk = new HllSketch(12);
     byte[] memObj = sk.toCompactByteArray();
-    WritableMemory wmem = WritableMemory.wrap(memObj);
+    WritableMemory wmem = WritableMemory.writableWrap(memObj);
     long memAdd = wmem.getCumulativeOffset(0);
     HllSketch bad;
 
@@ -149,7 +149,7 @@
     //move to Set mode
     for (int i = 1; i <= 15; i++) { sk.update(i); }
     memObj = sk.toCompactByteArray();
-    wmem = WritableMemory.wrap(memObj);
+    wmem = WritableMemory.writableWrap(memObj);
     memAdd = wmem.getCumulativeOffset(0);
 
     //check wrong PreInts and SET
@@ -163,7 +163,7 @@
     //move to HLL mode
     for (int i = 15; i <= 1000; i++) { sk.update(i); }
     memObj = sk.toCompactByteArray();
-    wmem = WritableMemory.wrap(memObj);
+    wmem = WritableMemory.writableWrap(memObj);
     memAdd = wmem.getCumulativeOffset(0);
 
     //check wrong PreInts and HLL
diff --git a/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java b/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
index 1df65fe..b626310 100644
--- a/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
+++ b/src/test/java/org/apache/datasketches/hll/ToFromByteArrayTest.java
@@ -68,7 +68,7 @@
     //printSketch(dst, "DST");
     assertEquals(dst2.getEstimate(), src.getEstimate(), 0.0);
 
-    WritableMemory mem3 = WritableMemory.wrap(byteArr2);
+    WritableMemory mem3 = WritableMemory.writableWrap(byteArr2);
     HllSketch dst3 = HllSketch.heapify(mem3); //using WritableMemory interface
     //printSketch(dst, "DST");
     assertEquals(dst3.getEstimate(), src.getEstimate(), 0.0);
@@ -91,7 +91,7 @@
   private static void toFrom2(int lgConfigK, TgtHllType tgtHllType, int n) {
     int bytes = HllSketch.getMaxUpdatableSerializationBytes(lgConfigK, tgtHllType);
     byte[] byteArray = new byte[bytes];
-    WritableMemory wmem = WritableMemory.wrap(byteArray);
+    WritableMemory wmem = WritableMemory.writableWrap(byteArray);
     HllSketch src = new HllSketch(lgConfigK, tgtHllType, wmem);
     for (int i = 0; i < n; i++) {
       src.update(i);
@@ -107,7 +107,7 @@
 
     //Heapify updatable
     byte[] updatableByteArr = src.toUpdatableByteArray();
-    WritableMemory wmem2 = WritableMemory.wrap(updatableByteArr);
+    WritableMemory wmem2 = WritableMemory.writableWrap(updatableByteArr);
     HllSketch dst2 = HllSketch.heapify(wmem2); //using Memory interface
     //printSketch(dst2, "Heapify From Updatable");
     assertEquals(dst2.getEstimate(), src.getEstimate(), 0.0);
diff --git a/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java b/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
index e56f907..d718741 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DebugUnionTest.java
@@ -27,7 +27,7 @@
 
 import org.testng.annotations.Test;
 
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -62,11 +62,13 @@
     DoublesSketch.setRandom(1); //make deterministic for test
     DoublesUnion dUnion;
     DoublesSketch dSketch;
-    try ( WritableDirectHandle wdh = WritableMemory.allocateDirect(10_000_000) ) {
-      WritableMemory wmem = wdh.get();
+    try ( WritableHandle wdh = WritableMemory.allocateDirect(10_000_000) ) {
+      WritableMemory wmem = wdh.getWritable();
       dUnion = DoublesUnion.builder().setMaxK(8).build(wmem);
       for (int s = 0; s < numSketches; s++) { dUnion.update(sketchArr[s]); }
       dSketch = dUnion.getResult(); //result is on heap
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
 
     //iterates and counts errors
diff --git a/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java b/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
index a92abb7..9eb84e5 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DeprecatedAndMiscTest.java
@@ -46,7 +46,7 @@
 
     final DoublesUnion du3 = DoublesUnionBuilder.wrap(mem); //v2.0.0.
 
-    final WritableMemory wmem = WritableMemory.wrap(ds.toByteArray());
+    final WritableMemory wmem = WritableMemory.writableWrap(ds.toByteArray());
     final DoublesUnion du4 = DoublesUnionBuilder.wrap(wmem); //v2.0.0.
 
     final ItemsSketch<String> is = ItemsSketch.getInstance(64, Comparator.naturalOrder());
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
index 90f70bf..3121c8b 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectCompactDoublesSketchTest.java
@@ -65,7 +65,7 @@
     for (int i = n; i > 0; --i) {
       qs.update(i);
     }
-    final WritableMemory dstMem = WritableMemory.wrap(new byte[qs.getCompactStorageBytes()]);
+    final WritableMemory dstMem = WritableMemory.writableWrap(new byte[qs.getCompactStorageBytes()]);
     final DirectCompactDoublesSketch compactQs
             = DirectCompactDoublesSketch.createFromUpdateSketch(qs, dstMem);
 
@@ -153,7 +153,7 @@
       qs.update(startV + i);
     }
     final byte[] byteArr = new byte[qs.getCompactStorageBytes()];
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     return (DirectCompactDoublesSketch) qs.compact(mem);
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
index 42091e4..232365c 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectQuantilesMemoryRequestTest.java
@@ -24,10 +24,13 @@
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertTrue;
 
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
 import org.testng.annotations.Test;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 
 /**
@@ -46,8 +49,9 @@
 
     //########## Owning Implementation
     // This part would actually be part of the Memory owning implemention so it is faked here
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(initBytes)) {
-      final WritableMemory wmem = wdh.get();
+    try (WritableHandle wdh = WritableMemory.allocateDirect(initBytes,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
+      final WritableMemory wmem = wdh.getWritable();
       println("Initial mem size: " + wmem.getCapacity());
 
       //########## Receiving Application
@@ -70,6 +74,8 @@
       //The actual Memory has been re-allocated several times,
       // so the above wmem reference is invalid.
       println("\nFinal mem size: " + wmem.getCapacity());
+    } catch (Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -79,10 +85,11 @@
     final int u = 32; // don't need the BB to fill here
     final int initBytes = (4 + (u / 2)) << 3; // not enough to hold everything
 
-    try (WritableDirectHandle memHandler = WritableMemory.allocateDirect(initBytes)) {
+    try (WritableHandle memHandler = WritableMemory.allocateDirect(initBytes,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
       //final MemoryManager memMgr = new MemoryManager();
       //final WritableMemory mem1 = memMgr.request(initBytes);
-      final WritableMemory mem1 = memHandler.get();
+      final WritableMemory mem1 = memHandler.getWritable();
       println("Initial mem size: " + mem1.getCapacity());
       final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build(mem1);
       for (int i = 1; i <= u; i++) {
@@ -91,6 +98,8 @@
       final int currentSpace = usk1.getCombinedBufferItemCapacity();
       println("curCombBufItemCap: " + currentSpace);
       assertEquals(currentSpace, 2 * k);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -100,10 +109,11 @@
     final int u = (2 * k) - 1; //just to fill the BB
     final int initBytes = ((2 * k) + 4) << 3; //just room for BB
 
-    try (WritableDirectHandle memHandler = WritableMemory.allocateDirect(initBytes)) {
+    try (WritableHandle memHandler = WritableMemory.allocateDirect(initBytes,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
       //final MemoryManager memMgr = new MemoryManager();
       //final WritableMemory mem1 = memMgr.request(initBytes);
-      final WritableMemory mem1 = memHandler.get();
+      final WritableMemory mem1 = memHandler.getWritable();
       println("Initial mem size: " + mem1.getCapacity());
       final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build(mem1);
       for (int i = 1; i <= u; i++) {
@@ -116,6 +126,8 @@
       println("newCombBurItemCap: " + newSpace);
       assertEquals(newCB.length, 3 * k);
       //memMgr.free(mem1);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -127,8 +139,9 @@
     final UpdateDoublesSketch usk1 = DoublesSketch.builder().setK(k).build();
     final Memory origSketchMem = Memory.wrap(usk1.toByteArray());
 
-    try (WritableDirectHandle memHandle = WritableMemory.allocateDirect(initBytes)) {
-      WritableMemory mem = memHandle.get();
+    try (WritableHandle memHandle = WritableMemory.allocateDirect(initBytes,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
+      WritableMemory mem = memHandle.getWritable();
       origSketchMem.copyTo(0, mem, 0, initBytes);
       UpdateDoublesSketch usk2 = DirectUpdateDoublesSketch.wrapInstance(mem);
       assertTrue(mem.isSameResource(usk2.getMemory()));
@@ -145,6 +158,8 @@
 
       final int expectedSize = COMBINED_BUFFER + ((2 * k) << 3);
       assertEquals(mem2.getCapacity(), expectedSize);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
index 5bf3e10..33a8e50 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
@@ -150,7 +150,7 @@
   public void wrapEmptyUpdateSketch() {
     final UpdateDoublesSketch s1 = DoublesSketch.builder().build();
     final WritableMemory mem
-            = WritableMemory.wrap(ByteBuffer.wrap(s1.toByteArray()).order(ByteOrder.nativeOrder()));
+            = WritableMemory.writableWrap(ByteBuffer.wrap(s1.toByteArray()).order(ByteOrder.nativeOrder()));
     final UpdateDoublesSketch s2 = DirectUpdateDoublesSketch.wrapInstance(mem);
     assertTrue(s2.isEmpty());
 
@@ -166,7 +166,7 @@
   public void checkPutCombinedBuffer() {
     final int k = PreambleUtil.DEFAULT_K;
     final int cap = 32 + ((2 * k) << 3);
-    WritableMemory mem = WritableMemory.wrap(new byte[cap]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[cap]);
     final UpdateDoublesSketch qs = DoublesSketch.builder().setK(k).build(mem);
     mem = qs.getMemory();
     assertEquals(mem.getCapacity(), cap);
@@ -194,7 +194,7 @@
     int k = PreambleUtil.DEFAULT_K;
     int n = 48;
     int cap = 32 + ((2 * k) << 3);
-    WritableMemory mem = WritableMemory.wrap(new byte[cap]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[cap]);
     UpdateDoublesSketch qs = DoublesSketch.builder().setK(k).build(mem);
     mem = qs.getMemory();
     assertEquals(mem.getCapacity(), cap);
@@ -215,7 +215,7 @@
   @SuppressWarnings("unused")
   @Test
   public void variousExceptions() {
-    WritableMemory mem = WritableMemory.wrap(new byte[8]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[8]);
     try {
       int flags = PreambleUtil.COMPACT_FLAG_MASK;
       DirectUpdateDoublesSketchR.checkCompact(2, 0);
@@ -262,7 +262,7 @@
   @Test
   public void serializeDeserialize() {
     int sizeBytes = DoublesSketch.getUpdatableStorageBytes(128, 2000);
-    WritableMemory mem = WritableMemory.wrap(new byte[sizeBytes]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[sizeBytes]);
     UpdateDoublesSketch sketch1 = DoublesSketch.builder().build(mem);
     for (int i = 0; i < 1000; i++) {
       sketch1.update(i);
@@ -278,7 +278,7 @@
 
     byte[] arr2 = sketch2.toByteArray(false);
     assertEquals(arr2.length, sketch2.getStorageBytes());
-    DoublesSketch sketch3 = DoublesSketch.wrap(WritableMemory.wrap(arr2));
+    DoublesSketch sketch3 = DoublesSketch.wrap(WritableMemory.writableWrap(arr2));
     assertEquals(sketch3.getMinValue(), 0.0);
     assertEquals(sketch3.getMaxValue(), 1999.0);
     assertEquals(sketch3.getQuantile(0.5), 1000.0, 10.0);
@@ -303,7 +303,7 @@
     final int n = k * 2;
 
     final int memBytes = DoublesSketch.getUpdatableStorageBytes(k, n);
-    final WritableMemory mem = WritableMemory.wrap(new byte[memBytes]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[memBytes]);
     final DoublesSketchBuilder bldr = DoublesSketch.builder();
     final UpdateDoublesSketch ds = bldr.setK(k).build(mem);
     for (int i = 1; i <= n; i++) { // 1 ... n
@@ -324,7 +324,7 @@
     final int k = 128;
     final int n = 1_000_000;
     final int memBytes = DoublesSketch.getUpdatableStorageBytes(k, n);
-    final WritableMemory mem = WritableMemory.wrap(new byte[memBytes]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[memBytes]);
     final UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
     final double[] values = new double[n];
     for (int i = 0; i < n; i++) {
@@ -354,7 +354,7 @@
     if (cap < (2 * k)) { cap = 2 * k; }
     DoublesSketchBuilder bldr = new DoublesSketchBuilder();
     bldr.setK(k);
-    UpdateDoublesSketch dqs = bldr.build(WritableMemory.wrap(new byte[cap]));
+    UpdateDoublesSketch dqs = bldr.build(WritableMemory.writableWrap(new byte[cap]));
     return dqs;
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
index 618e954..5fe6b6e 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchBuilderTest.java
@@ -38,7 +38,7 @@
     println(bldr.toString());
     int bytes = DoublesSketch.getUpdatableStorageBytes(k, 0);
     byte[] byteArr = new byte[bytes];
-    WritableMemory mem = WritableMemory.wrap(byteArr);
+    WritableMemory mem = WritableMemory.writableWrap(byteArr);
     DoublesSketch ds = bldr.build(mem);
     assertTrue(ds.isDirect());
     println(bldr.toString());
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
index 3ae8e47..b2f9bf9 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesSketchTest.java
@@ -24,12 +24,14 @@
 import static org.testng.Assert.assertNull;
 import static org.testng.Assert.assertTrue;
 
+import java.nio.ByteOrder;
+
+import org.apache.datasketches.memory.DefaultMemoryRequestServer;
+import org.apache.datasketches.memory.WritableHandle;
+import org.apache.datasketches.memory.WritableMemory;
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
-import org.apache.datasketches.memory.WritableDirectHandle;
-import org.apache.datasketches.memory.WritableMemory;
-
 @SuppressWarnings("javadoc")
 public class DoublesSketchTest {
 
@@ -39,7 +41,7 @@
     for (int i = 0; i < 1000; i++) {
       heapSketch.update(i);
     }
-    DoublesSketch directSketch = DoublesSketch.wrap(WritableMemory.wrap(heapSketch.toByteArray(false)));
+    DoublesSketch directSketch = DoublesSketch.wrap(WritableMemory.writableWrap(heapSketch.toByteArray(false)));
 
     assertEquals(directSketch.getMinValue(), 0.0);
     assertEquals(directSketch.getMaxValue(), 999.0);
@@ -49,12 +51,12 @@
   @Test
   public void directToHeap() {
     int sizeBytes = 10000;
-    UpdateDoublesSketch directSketch = DoublesSketch.builder().build(WritableMemory.wrap(new byte[sizeBytes]));
+    UpdateDoublesSketch directSketch = DoublesSketch.builder().build(WritableMemory.writableWrap(new byte[sizeBytes]));
     for (int i = 0; i < 1000; i++) {
       directSketch.update(i);
     }
     UpdateDoublesSketch heapSketch;
-    heapSketch = (UpdateDoublesSketch) DoublesSketch.heapify(WritableMemory.wrap(directSketch.toByteArray()));
+    heapSketch = (UpdateDoublesSketch) DoublesSketch.heapify(WritableMemory.writableWrap(directSketch.toByteArray()));
     for (int i = 0; i < 1000; i++) {
       heapSketch.update(i + 1000);
     }
@@ -111,8 +113,8 @@
   @Test
   public void checkIsSameResource() {
     int k = 16;
-    WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
-    WritableMemory cmem = WritableMemory.wrap(new byte[8]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
+    WritableMemory cmem = WritableMemory.writableWrap(new byte[8]);
     DirectUpdateDoublesSketch duds =
             (DirectUpdateDoublesSketch) DoublesSketch.builder().setK(k).build(mem);
     assertTrue(duds.isSameResource(mem));
@@ -134,23 +136,47 @@
 
   @Test
   public void directSketchShouldMoveOntoHeapEventually() {
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(1000)) {
-      WritableMemory mem = wdh.get();
+    try (WritableHandle wdh = WritableMemory.allocateDirect(1000,
+            ByteOrder.nativeOrder(), new DefaultMemoryRequestServer())) {
+      WritableMemory mem = wdh.getWritable();
       UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
       Assert.assertTrue(sketch.isSameResource(mem));
       for (int i = 0; i < 1000; i++) {
         sketch.update(i);
       }
       Assert.assertFalse(sketch.isSameResource(mem));
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Test
+  public void directSketchShouldMoveOntoHeapEventually2() {
+    try (WritableHandle wdh = WritableMemory.allocateDirect(50)) {
+      WritableMemory mem = wdh.getWritable();
+      UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
+      Assert.assertTrue(sketch.isSameResource(mem));
+      for (int i = 0; i < 1000; i++) {
+        try {
+          sketch.update(i);
+          if (sketch.isSameResource(mem)) { continue; }
+        } catch (NullPointerException e) {
+          break;
+        }
+      }
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
   @Test
   public void checkEmptyDirect() {
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(1000)) {
-      WritableMemory mem = wdh.get();
+    try (WritableHandle wdh = WritableMemory.allocateDirect(1000)) {
+      WritableMemory mem = wdh.getWritable();
       UpdateDoublesSketch sketch = DoublesSketch.builder().build(mem);
       sketch.toByteArray(); //exercises a specific path
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
index 0c9f82d..7b5802e 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionBuilderTest.java
@@ -36,7 +36,7 @@
     for (int i=0; i<1000; i++) { qs1.update(i); }
 
     int bytes = qs1.getCompactStorageBytes();
-    WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
     qs1.putMemory(dstMem);
     Memory srcMem = dstMem;
 
@@ -63,7 +63,7 @@
   }
 
   int bytes = qs1.getCompactStorageBytes();
-  WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+  WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
   qs1.putMemory(dstMem);
   Memory srcMem = dstMem;
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
index 5972a78..e79d3d4 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUnionImplTest.java
@@ -145,7 +145,7 @@
     final int n2 = 2000;
     final DoublesSketch sketchIn1 = buildAndLoadQS(k1, n1);
     final int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n2);//just for size
-    final WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
     final DoublesUnion union = DoublesUnion.builder().setMaxK(k2).build(mem); //virgin 256
     union.update(sketchIn1);
     assertEquals(union.getMaxK(), k2);
@@ -164,7 +164,7 @@
     final int n2 = 2000;
     final DoublesSketch sketchIn1 = buildAndLoadDQS(k1, n1);
     final int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n2);//just for size
-    final WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
     final DoublesUnion union = DoublesUnion.builder().setMaxK(k2).build(mem); //virgin 256
     union.update(sketchIn1);
     assertEquals(union.getMaxK(), k2);
@@ -182,11 +182,11 @@
     final int k2 = 4;
     final int n2 = 2 * k2; //8
     final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
-    final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
     final UpdateDoublesSketch sketchIn1 = DoublesSketch.builder().setK(k1).build(skMem);
     for (int i = 0; i < n1; i++) { sketchIn1.update(i + 1); }
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
     final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
     //DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(); //virgin 256
     union.update(sketchIn1);
@@ -215,11 +215,11 @@
     final int k2 = 4;
     final int n2 = 2 * k2; //8
     final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
-    final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
     final UpdateDoublesSketch sketchIn1 = DoublesSketch.builder().setK(k1).build(skMem);
     for (int i = 0; i < n1; i++) { sketchIn1.update(i + 1); }
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
     final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
     union.update(sketchIn1);
     assertEquals(union.getResult().getN(), n1);
@@ -247,12 +247,12 @@
     final int k2 = 4;
     final int n2 = 5 * k2; //8
     final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//just for size
-    final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
     final UpdateDoublesSketch sketchIn0 = DoublesSketch.builder().setK(k1).build(skMem);
     for (int i = 0; i < n1; i++) { sketchIn0.update(i + 1); }
     final CompactDoublesSketch sketchIn1 = sketchIn0.compact();
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[bytes]);
     final DoublesUnion union = DoublesUnion.builder().setMaxK(256).build(uMem); //virgin 256
     union.update(sketchIn1);
     assertEquals(union.getResult().getN(), n1);
@@ -278,7 +278,7 @@
     final int k2 = 4;
     final int n2 = 2 * k2; //8
     final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//big enough
-    final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
     DoublesSketch.builder().setK(256).build(skMem);
 
     final DoublesUnion union = DoublesUnionImpl.heapifyInstance(skMem);
@@ -299,7 +299,7 @@
     final int k2 = 4;
     final int n2 = 2 * k2; //8
     final int bytes = DoublesSketch.getUpdatableStorageBytes(256, 50);//big enough
-    final WritableMemory skMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[bytes]);
     DoublesSketch.builder().setK(256).build(skMem);
 
     final DoublesUnion union = DoublesUnionImpl.heapifyInstance(skMem);
@@ -397,7 +397,7 @@
   public void checkUpdateMemory() {
     final DoublesSketch qs1 = buildAndLoadQS(256, 1000);
     final int bytes = qs1.getCompactStorageBytes();
-    final WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
     qs1.putMemory(dstMem);
     final Memory srcMem = dstMem;
 
@@ -415,7 +415,7 @@
   public void checkUpdateMemoryDirect() {
     final DoublesSketch qs1 = buildAndLoadDQS(256, 1000);
     final int bytes = qs1.getCompactStorageBytes();
-    final WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+    final WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
     qs1.putMemory(dstMem);
     final Memory srcMem = dstMem;
 
@@ -653,7 +653,7 @@
     Assert.assertEquals(bldr.getMaxK(), k);
     final int bytes = DoublesSketch.getUpdatableStorageBytes(k, n);
     final byte[] byteArr = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     final DoublesUnion union = bldr.build(mem);
     assertTrue(union.isEmpty());
     assertTrue(union.isDirect());
@@ -679,7 +679,7 @@
     Assert.assertEquals(skMedian, 500, 10);
 
     final byte[] byteArr = sketch.toByteArray(false);
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     final DoublesUnion union = DoublesUnion.wrap(mem);
     Assert.assertFalse(union.isEmpty());
     assertTrue(union.isDirect());
@@ -701,10 +701,10 @@
 
   @Test
   public void isSameResourceDirect() {
-    WritableMemory mem1 = WritableMemory.wrap(new byte[1000000]);
+    WritableMemory mem1 = WritableMemory.writableWrap(new byte[1000000]);
     DoublesUnion union = DoublesUnion.builder().build(mem1);
     Assert.assertTrue(union.isSameResource(mem1));
-    WritableMemory mem2 = WritableMemory.wrap(new byte[1000000]);
+    WritableMemory mem2 = WritableMemory.writableWrap(new byte[1000000]);
     Assert.assertFalse(union.isSameResource(mem2));
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java b/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
index 15670d9..0d00441 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DoublesUtilTest.java
@@ -67,7 +67,7 @@
     DoublesSketchTest.testSketchEquality(huds, target1);
 
     // DirectUpdateDoublesSketch
-    final WritableMemory mem1 = WritableMemory.wrap(huds.toByteArray());
+    final WritableMemory mem1 = WritableMemory.writableWrap(huds.toByteArray());
     final DirectUpdateDoublesSketch duds = (DirectUpdateDoublesSketch) UpdateDoublesSketch.wrap(mem1);
     final HeapUpdateDoublesSketch target2 = DoublesUtil.copyToHeap(duds);
     DoublesSketchTest.testSketchEquality(huds, duds);
diff --git a/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
index c07376c..5bc6ba6 100644
--- a/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/HeapCompactDoublesSketchTest.java
@@ -90,7 +90,7 @@
     }
     assertEquals(qs.getBaseBufferCount(), k);
     final byte[] sketchBytes = qs.toByteArray(true);
-    final WritableMemory mem = WritableMemory.wrap(sketchBytes);
+    final WritableMemory mem = WritableMemory.writableWrap(sketchBytes);
 
     // modify to make v2, clear compact flag, and insert a -1 in the middle of the base buffer
     PreambleUtil.insertSerVer(mem, 2);
diff --git a/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
index 8d7b903..7c017ed 100644
--- a/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/HeapUpdateDoublesSketchTest.java
@@ -352,7 +352,7 @@
     println(s);
     println("");
 
-    Memory srcMem = WritableMemory.wrap(qs.toByteArray());
+    Memory srcMem = WritableMemory.writableWrap(qs.toByteArray());
 
     HeapUpdateDoublesSketch qs2 = HeapUpdateDoublesSketch.heapifyInstance(srcMem);
     s = qs2.toString();
@@ -685,7 +685,7 @@
     UpdateDoublesSketch sketch2 = DoublesSketch.builder().setK(k2).build();
     DoublesSketch downSketch;
     int bytes = DoublesSketch.getUpdatableStorageBytes(k2, n);
-    WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
     for (int i = 0; i < n; i++) {
       sketch1.update (i);
       sketch2.update (i);
@@ -835,7 +835,7 @@
       qs1.update(i);
     }
     int bytes = qs1.getUpdatableStorageBytes();
-    WritableMemory dstMem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes]);
     qs1.putMemory(dstMem, false);
     Memory srcMem = dstMem;
     DoublesSketch qs2 = DoublesSketch.heapify(srcMem);
@@ -850,7 +850,7 @@
       qs1.update(i);
     }
     int bytes = qs1.getCompactStorageBytes();
-    WritableMemory dstMem = WritableMemory.wrap(new byte[bytes-1]); //too small
+    WritableMemory dstMem = WritableMemory.writableWrap(new byte[bytes-1]); //too small
     qs1.putMemory(dstMem);
   }
 
@@ -866,7 +866,7 @@
   @Test
   public void testIt() {
     java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocate(1<<20).order(ByteOrder.nativeOrder());
-    WritableMemory mem = WritableMemory.wrap(bb);
+    WritableMemory mem = WritableMemory.writableWrap(bb);
 
     int k = 1024;
     DoublesSketch qsk = new DoublesSketchBuilder().setK(k).build();
diff --git a/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
index 97c5c13..4c6a431 100644
--- a/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/ItemsSketchTest.java
@@ -376,7 +376,7 @@
     final ArrayOfDoublesSerDe serDe = new ArrayOfDoublesSerDe();
     final ItemsSketch<Double> sketch = ItemsSketch.getInstance(Comparator.naturalOrder());
     final byte[] byteArr = sketch.toByteArray(serDe);
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     mem.clearBits(PreambleUtil.FLAGS_BYTE, (byte) PreambleUtil.COMPACT_FLAG_MASK);
     println(PreambleUtil.toString(mem, false));
     ItemsSketch.getInstance(mem, Comparator.naturalOrder(), serDe);
@@ -389,7 +389,7 @@
       sketch.update(Integer.toString(i));
     }
     final byte[] byteArr = new byte[200];
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     sketch.putMemory(mem, new ArrayOfStringsSerDe());
   }
 
@@ -400,7 +400,7 @@
       sketch.update(Integer.toString(i));
     }
     final byte[] byteArr = new byte[100];
-    final WritableMemory mem = WritableMemory.wrap(byteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArr);
     sketch.putMemory(mem, new ArrayOfStringsSerDe());
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
index 265b047..1ae21c0 100644
--- a/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/PreambleUtilTest.java
@@ -40,7 +40,7 @@
 import org.testng.annotations.Test;
 
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 
 @SuppressWarnings("javadoc")
@@ -49,9 +49,9 @@
   @Test
   public void checkInsertsAndExtracts() {
     final int bytes = 32;
-    try (WritableDirectHandle offHeapMemHandler = WritableMemory.allocateDirect(bytes)) {
-      final WritableMemory offHeapMem = offHeapMemHandler.get();
-      final WritableMemory onHeapMem = WritableMemory.wrap(new byte[bytes]);
+    try (WritableHandle offHeapMemHandler = WritableMemory.allocateDirect(bytes)) {
+      final WritableMemory offHeapMem = offHeapMemHandler.getWritable();
+      final WritableMemory onHeapMem = WritableMemory.writableWrap(new byte[bytes]);
 
       onHeapMem.clear();
       offHeapMem.clear();
@@ -157,6 +157,8 @@
       assertEquals(offHD, vD);
       onHeapMem.clear();
       offHeapMem.clear();
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
diff --git a/src/test/java/org/apache/datasketches/req/FloatBufferTest.java b/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
index efe1aad..1b0e308 100644
--- a/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
+++ b/src/test/java/org/apache/datasketches/req/FloatBufferTest.java
@@ -267,7 +267,7 @@
     assertEquals(buf.getItemFromIndex(hra ? 199 : 1), 1.0f);
     assertEquals(buf.isSpaceAtBottom(), hra);
     //uses the serialization method
-    final WritableMemory wmem = WritableMemory.wrap(buf.floatsToBytes());
+    final WritableMemory wmem = WritableMemory.writableWrap(buf.floatsToBytes());
     final float[] farr2 = new float[101];
     wmem.getFloatArray(0, farr2, 0, 101);
     //uses the deserialization method
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
index 21dd451..723a3fe 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsSketchTest.java
@@ -425,7 +425,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] sketchBytes = ris.toByteArray(serDe);
-    final WritableMemory sketchMem = WritableMemory.wrap(sketchBytes);
+    final WritableMemory sketchMem = WritableMemory.writableWrap(sketchBytes);
 
     sketchMem.putByte(SER_VER_BYTE, (byte) 1);
     sketchMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -602,7 +602,7 @@
     assertEquals(ris.getK(), k);
 
     final byte[] sketchBytes = ris.toByteArray(new ArrayOfLongsSerDe());
-    return WritableMemory.wrap(sketchBytes);
+    return WritableMemory.writableWrap(sketchBytes);
   }
 
   private static void validateSerializeAndDeserialize(final ReservoirItemsSketch<Long> ris) {
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
index 88647c1..acb70ad 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirItemsUnionTest.java
@@ -164,7 +164,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] unionBytes = riu.toByteArray(serDe);
-    final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+    final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
 
     unionMem.putByte(SER_VER_BYTE, (byte) 1);
     unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -195,7 +195,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] unionBytes = rlu.toByteArray(serDe);
-    final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+    final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
 
     unionMem.putByte(SER_VER_BYTE, (byte) 1);
     unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -448,7 +448,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadPreLongs() {
     final ReservoirItemsUnion<Number> riu = ReservoirItemsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(riu.toByteArray(new ArrayOfNumbersSerDe()));
+    final WritableMemory mem = WritableMemory.writableWrap(riu.toByteArray(new ArrayOfNumbersSerDe()));
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 0); // corrupt the preLongs count
 
     ReservoirItemsUnion.heapify(mem, new ArrayOfNumbersSerDe());
@@ -458,7 +458,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadSerVer() {
     final ReservoirItemsUnion<String> riu = ReservoirItemsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(riu.toByteArray(new ArrayOfStringsSerDe()));
+    final WritableMemory mem = WritableMemory.writableWrap(riu.toByteArray(new ArrayOfStringsSerDe()));
     mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
 
     ReservoirItemsUnion.heapify(mem, new ArrayOfStringsSerDe());
@@ -468,7 +468,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadFamily() {
     final ReservoirItemsUnion<Double> rlu = ReservoirItemsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray(new ArrayOfDoublesSerDe()));
+    final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray(new ArrayOfDoublesSerDe()));
     mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
 
     ReservoirItemsUnion.heapify(mem, new ArrayOfDoublesSerDe());
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
index 1295c68..c448d2c 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsSketchTest.java
@@ -305,7 +305,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] sketchBytes = rls.toByteArray();
-    final WritableMemory sketchMem = WritableMemory.wrap(sketchBytes);
+    final WritableMemory sketchMem = WritableMemory.writableWrap(sketchBytes);
 
     sketchMem.putByte(SER_VER_BYTE, (byte) 1);
     sketchMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -477,7 +477,7 @@
     assertEquals(rls.getK(), k);
 
     final byte[] sketchBytes = rls.toByteArray();
-    return WritableMemory.wrap(sketchBytes);
+    return WritableMemory.writableWrap(sketchBytes);
   }
 
   private static void validateSerializeAndDeserialize(final ReservoirLongsSketch rls) {
diff --git a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
index c9530dc..184db27 100644
--- a/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/ReservoirLongsUnionTest.java
@@ -147,7 +147,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] unionBytes = rlu.toByteArray();
-    final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+    final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
 
     unionMem.putByte(SER_VER_BYTE, (byte) 1);
     unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -177,7 +177,7 @@
 
     // get a new byte[], manually revert to v1, then reconstruct
     final byte[] unionBytes = rlu.toByteArray();
-    final WritableMemory unionMem = WritableMemory.wrap(unionBytes);
+    final WritableMemory unionMem = WritableMemory.writableWrap(unionBytes);
 
     unionMem.putByte(SER_VER_BYTE, (byte) 1);
     unionMem.putInt(RESERVOIR_SIZE_INT, 0); // zero out all 4 bytes
@@ -370,7 +370,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadPreLongs() {
     final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+    final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 0); // corrupt the preLongs count
 
     ReservoirLongsUnion.heapify(mem);
@@ -380,7 +380,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadSerVer() {
     final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+    final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
     mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
 
     ReservoirLongsUnion.heapify(mem);
@@ -390,7 +390,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadFamily() {
     final ReservoirLongsUnion rlu = ReservoirLongsUnion.newInstance(1024);
-    final WritableMemory mem = WritableMemory.wrap(rlu.toByteArray());
+    final WritableMemory mem = WritableMemory.writableWrap(rlu.toByteArray());
     mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
 
     ReservoirLongsUnion.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java b/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
index 4454308..d701ce3 100644
--- a/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/VarOptItemsSketchTest.java
@@ -51,7 +51,7 @@
   public void checkBadSerVer() {
     final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(16, 16);
     final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
 
@@ -63,7 +63,7 @@
   public void checkBadFamily() {
     final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(32, 16);
     final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     mem.putByte(FAMILY_BYTE, (byte) 0); // corrupt the family ID
 
@@ -75,7 +75,7 @@
   public void checkBadPreLongs() {
     final VarOptItemsSketch<Long> sketch = getUnweightedLongsVIS(32, 33);
     final byte[] bytes = sketch.toByteArray(new ArrayOfLongsSerDe());
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     // corrupt the preLongs count to 0
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) (Family.VAROPT.getMinPreLongs() - 1));
@@ -132,7 +132,7 @@
 
     // we'll use the same initial sketch a few times, so grab a copy of it
     final byte[] copyBytes = new byte[sketchBytes.length];
-    final WritableMemory mem = WritableMemory.wrap(copyBytes);
+    final WritableMemory mem = WritableMemory.writableWrap(copyBytes);
 
     // copy the bytes
     srcMem.copyTo(0, mem, 0, sketchBytes.length);
@@ -235,7 +235,7 @@
     final VarOptItemsSketch<String> vis = VarOptItemsSketch.newInstance(12, ResizeFactor.X2);
     final byte[] sketchBytes = vis.toByteArray(new ArrayOfStringsSerDe());
     final byte[] dstByteArr = new byte[PreambleUtil.VO_PRELONGS_WARMUP << 3];
-    final WritableMemory mem = WritableMemory.wrap(dstByteArr);
+    final WritableMemory mem = WritableMemory.writableWrap(dstByteArr);
     mem.putByteArray(0, sketchBytes, 0, sketchBytes.length);
 
     // ensure non-empty but with H and R region sizes set to 0
@@ -266,7 +266,7 @@
     }
 
     final byte[] sketchBytes = vis.toByteArray(new ArrayOfStringsSerDe(), String.class);
-    final WritableMemory mem = WritableMemory.wrap(sketchBytes);
+    final WritableMemory mem = WritableMemory.writableWrap(sketchBytes);
 
     // weights will be stored in the first double after the preamble
     final int numPreLongs = PreambleUtil.extractPreLongs(mem);
diff --git a/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java b/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
index 18bdd3d..2189771 100644
--- a/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
+++ b/src/test/java/org/apache/datasketches/sampling/VarOptItemsUnionTest.java
@@ -48,7 +48,7 @@
     final VarOptItemsUnion<Long> union = VarOptItemsUnion.newInstance(k);
     union.update(getUnweightedLongsVIS(k, n));
     final byte[] bytes = union.toByteArray(new ArrayOfLongsSerDe());
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     mem.putByte(SER_VER_BYTE, (byte) 0); // corrupt the serialization version
 
@@ -63,7 +63,7 @@
     final VarOptItemsUnion<Long> union = VarOptItemsUnion.newInstance(k);
     union.update(getUnweightedLongsVIS(k, n));
     final byte[] bytes = union.toByteArray(new ArrayOfLongsSerDe());
-    final WritableMemory mem = WritableMemory.wrap(bytes);
+    final WritableMemory mem = WritableMemory.writableWrap(bytes);
 
     // corrupt the preLongs count to 0
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) (Family.VAROPT.getMinPreLongs() - 1));
diff --git a/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java b/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
index 3c4b49f..faf7433 100644
--- a/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/CompactSketchTest.java
@@ -28,7 +28,7 @@
 import org.apache.datasketches.Family;
 import org.apache.datasketches.SketchesArgumentException;
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 import org.testng.annotations.Test;
 
@@ -78,8 +78,8 @@
     //Prepare Memory for direct
     int bytes = usk.getCompactBytes(); //for Compact
 
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes)) {
-      WritableMemory directMem = wdh.get();
+    try (WritableHandle wdh = WritableMemory.allocateDirect(bytes)) {
+      WritableMemory directMem = wdh.getWritable();
 
       /**Via CompactSketch.compact**/
       refSk = usk.compact(ordered, directMem);
@@ -90,6 +90,8 @@
       /**Via CompactSketch.compact**/
       testSk = (CompactSketch)Sketch.wrap(directMem);
       checkByRange(refSk, testSk, u, ordered);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -193,7 +195,7 @@
 
     int bytes = usk.getCompactBytes();
     byte[] byteArray = new byte[bytes -8]; //too small
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     usk.compact(ordered, mem);
   }
 
@@ -209,7 +211,7 @@
 
     int bytes = usk.getCompactBytes();
     byte[] byteArray = new byte[bytes -8]; //too small
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     usk.compact(ordered, mem);
   }
 
diff --git a/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
index 023a326..b5c7760 100644
--- a/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketchTest.java
@@ -236,7 +236,7 @@
     int bytes = shared.getCompactBytes();
     assertEquals(bytes, (k*8) + (Family.COMPACT.getMaxPreLongs() << 3));
     byte[] memArr2 = new byte[bytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
     csk = shared.compact(false,  mem2);
     assertEquals(csk.getEstimate(), localEst);
@@ -276,7 +276,7 @@
     int bytes = local.getCompactBytes(); //compact form
     assertEquals(bytes, 8);
     byte[] memArr2 = new byte[bytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
     CompactSketch csk2 = shared.compact(false,  mem2);
     assertEquals(csk2.getEstimate(), localEst);
@@ -500,7 +500,7 @@
     double est2;
 
     serArr = shared.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(serArr);
+    WritableMemory mem = WritableMemory.writableWrap(serArr);
     UpdateSketch recoveredShared = Sketches.wrapUpdateSketch(mem);
 
     //reconstruct to Native/Direct
diff --git a/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
index 8e03aa3..e28cc74 100644
--- a/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketchTest.java
@@ -64,7 +64,7 @@
     assertEquals(shared.getRetainedEntries(false), u);
 
     byte[]  serArr = shared.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(serArr);
+    WritableMemory mem = WritableMemory.writableWrap(serArr);
     Sketch sk = Sketch.heapify(mem, sl.seed);
     assertTrue(sk instanceof HeapQuickSelectSketch); //Intentional promotion to Parent
 
@@ -112,7 +112,7 @@
     assertEquals(local.getEstimate(), u, 0.0);
     assertEquals(shared.getRetainedEntries(false), u);
     byte[] byteArray = shared.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
 
     //try to heapify the corruped mem
@@ -135,7 +135,7 @@
     int lgK = 4;
     SharedLocal sl = new SharedLocal(lgK);
     byte[]  serArr = sl.shared.toByteArray();
-    WritableMemory srcMem = WritableMemory.wrap(serArr);
+    WritableMemory srcMem = WritableMemory.writableWrap(serArr);
     srcMem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
     Sketch.heapify(srcMem, DEFAULT_UPDATE_SEED);
   }
@@ -312,7 +312,7 @@
     assertEquals(comp2.getClass().getSimpleName(), "HeapCompactSketch");
 
     byte[] memArr2 = new byte[sharedCompBytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);  //allocate mem for compact form
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);  //allocate mem for compact form
 
     comp3 = shared.compact(false,  mem2);  //load the mem2
 
@@ -359,7 +359,7 @@
     assertEquals(local.isEstimationMode(), estimating);
 
     byte[] arr2 = new byte[compBytes];
-    WritableMemory mem2 = WritableMemory.wrap(arr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(arr2);
 
     CompactSketch csk2 = shared.compact(false,  mem2);
     assertEquals(csk2.getEstimate(), localEst);
@@ -550,7 +550,7 @@
     int bytes = local.getCompactBytes();
     assertEquals(bytes, 8);
     byte[] memArr2 = new byte[bytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
     CompactSketch csk2 = shared.compact(false,  mem2);
     assertEquals(csk2.getEstimate(), localEst);
@@ -592,7 +592,7 @@
     for (int i = 0; i < k; i++) { sl.local.update(i); }
     waitForBgPropagationToComplete(sl.shared);
     byte[] badArray = sl.shared.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(badArray);
+    WritableMemory mem = WritableMemory.writableWrap(badArray);
     PreambleUtil.insertLgArrLongs(mem, 4); //corrupt
     PreambleUtil.insertThetaLong(mem, Long.MAX_VALUE / 2); //corrupt
     Sketch.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java b/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
index 5bbd384..5063957 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectIntersectionTest.java
@@ -62,7 +62,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     inter = SetOperation.builder().buildIntersection(iMem);
 
@@ -84,7 +84,7 @@
 
     final int bytes = rsk1.getCompactBytes();
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
 
     rsk1 = inter.getResult(!ordered, mem);
     assertEquals(rsk1.getEstimate(), 0.0);
@@ -111,7 +111,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     inter = SetOperation.builder().buildIntersection(iMem);
     inter.intersect(usk1);
@@ -128,7 +128,7 @@
 
     final int bytes = rsk1.getCompactBytes();
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
 
     rsk1 = inter.getResult(!ordered, mem); //executed twice to fully exercise the internal state machine
     assertEquals(rsk1.getEstimate(), k);
@@ -155,7 +155,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     final CompactSketch csk1 = usk1.compact(true, null);
     final CompactSketch csk2 = usk2.compact(true, null);
@@ -178,7 +178,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     inter = SetOperation.builder().buildIntersection(iMem);
     assertFalse(inter.hasResult());
@@ -191,7 +191,7 @@
     final int k = 1<<lgK;
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
     final Intersection inter = SetOperation.builder().buildIntersection(iMem);
     final UpdateSketch sk = null;
     try { inter.intersect(sk); fail(); }
@@ -213,7 +213,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = empty
     sk = UpdateSketch.builder().setNominalEntries(k).build(); //empty
@@ -246,7 +246,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = empty
     sk1 = UpdateSketch.builder().build(); //empty
@@ -285,7 +285,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = valid
     sk1 = UpdateSketch.builder().build();
@@ -340,7 +340,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = valid
     sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -381,7 +381,7 @@
 
     final int reqBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[reqBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = valid
     sk1 = UpdateSketch.builder().setNominalEntries(2 * k).build(); // bigger sketch
@@ -407,7 +407,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     //1st call = valid
     sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -460,7 +460,7 @@
     UpdateSketch sk1;
 
     final int memBytes = getMaxIntersectionBytes(k);
-    WritableMemory iMem = WritableMemory.wrap(new byte[memBytes]);
+    WritableMemory iMem = WritableMemory.writableWrap(new byte[memBytes]);
 
     inter1 = SetOperation.builder().buildIntersection(iMem); //virgin off-heap
     inter2 = Sketches.wrapIntersection(iMem); //virgin off-heap, identical to inter1
@@ -484,7 +484,7 @@
     assertTrue(inter2.hasResult());
 
     //test the path via toByteArray, wrap, now in a different state
-    iMem = WritableMemory.wrap(inter1.toByteArray());
+    iMem = WritableMemory.writableWrap(inter1.toByteArray());
     inter2 = Sketches.wrapIntersection((Memory)iMem);
     assertTrue(inter2.hasResult()); //still true
 
@@ -503,7 +503,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
     inter2 = Sketches.wrapIntersection(iMem);
@@ -531,7 +531,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     SetOperation.builder().buildIntersection(iMem);
   }
@@ -544,7 +544,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k/2);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
 
@@ -564,11 +564,11 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     final Intersection inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
     final byte[] byteArray = inter1.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 2);//RF not used = 0
     Sketches.wrapIntersection(mem);
@@ -581,11 +581,11 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     inter1 = SetOperation.builder().buildIntersection(iMem); //virgin
     final byte[] byteArray = inter1.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putByte(SER_VER_BYTE, (byte) 2);
     Sketches.wrapIntersection(mem); //throws in SetOperations
@@ -598,7 +598,7 @@
 
     union = SetOperation.builder().setNominalEntries(k).buildUnion();
     final byte[] byteArray = union.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     Sketches.wrapIntersection(mem);
   }
 
@@ -613,7 +613,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr1 = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr1);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr1);
 
     //1st call = valid
     sk1 = UpdateSketch.builder().setNominalEntries(k).build();
@@ -628,7 +628,7 @@
     inter.intersect(compSkIn1);
 
     final byte[] memArr2 = inter.toByteArray();
-    final WritableMemory srcMem = WritableMemory.wrap(memArr2);
+    final WritableMemory srcMem = WritableMemory.writableWrap(memArr2);
     inter2 = Sketches.wrapIntersection(srcMem);
 
     //2nd call = valid intersecting
@@ -647,7 +647,7 @@
     println("Est: "+est);
 
     final byte[] memArr3 = inter2.toByteArray();
-    final WritableMemory srcMem2 = WritableMemory.wrap(memArr3);
+    final WritableMemory srcMem2 = WritableMemory.writableWrap(memArr3);
     inter3 = Sketches.wrapIntersection(srcMem2);
     resultComp2 = inter3.getResult(false, null);
     est2 = resultComp2.getEstimate();
@@ -661,14 +661,14 @@
   @Test
   public void checkDefaultMinSize() {
     final int k = 32;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + PREBYTES]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + PREBYTES]);
     IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
   }
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkExceptionMinSize() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + PREBYTES]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + PREBYTES]);
     IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
   }
 
@@ -679,7 +679,7 @@
 
     final int memBytes = getMaxIntersectionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     final Intersection inter = Sketches.setOperationBuilder().buildIntersection(iMem);
     inter.intersect(sk);
@@ -691,7 +691,7 @@
   public void checkFamily() {
     //cheap trick
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
     final IntersectionImpl impl = IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
     assertEquals(impl.getFamily(), Family.INTERSECTION);
   }
@@ -699,7 +699,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkExceptions1() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
     IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
     //corrupt SerVer
     mem.putByte(PreambleUtil.SER_VER_BYTE, (byte) 2);
@@ -709,7 +709,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkExceptions2() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 + PREBYTES]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 + PREBYTES]);
     IntersectionImpl.initNewDirectInstance(DEFAULT_UPDATE_SEED, mem);
     //mem now has non-empty intersection
     //corrupt empty and CurCount
@@ -730,10 +730,10 @@
       sk1.update(i);
       sk2.update(k-2 +i); //overlap by 2
     }
-    final WritableMemory memIn1 = WritableMemory.wrap(new byte[memBytes]);
-    final WritableMemory memIn2 = WritableMemory.wrap(new byte[memBytes]);
-    final WritableMemory memInter = WritableMemory.wrap(new byte[memBytes]);
-    final WritableMemory memComp = WritableMemory.wrap(new byte[memBytes]);
+    final WritableMemory memIn1 = WritableMemory.writableWrap(new byte[memBytes]);
+    final WritableMemory memIn2 = WritableMemory.writableWrap(new byte[memBytes]);
+    final WritableMemory memInter = WritableMemory.writableWrap(new byte[memBytes]);
+    final WritableMemory memComp = WritableMemory.writableWrap(new byte[memBytes]);
     final CompactSketch csk1 = sk1.compact(true, memIn1);
     final CompactSketch csk2 = sk2.compact(true, memIn2);
     final Intersection inter = Sketches.setOperationBuilder().buildIntersection(memInter);
diff --git a/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
index 26e7b4c..41f56c8 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectQuickSelectSketchTest.java
@@ -47,7 +47,7 @@
 import org.apache.datasketches.SketchesArgumentException;
 import org.apache.datasketches.SketchesReadOnlyException;
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 import org.testng.annotations.Test;
 
@@ -57,11 +57,11 @@
 @SuppressWarnings("javadoc")
 public class DirectQuickSelectSketchTest {
 
-  @Test(expectedExceptions = SketchesArgumentException.class)
+  @Test//(expectedExceptions = SketchesArgumentException.class)
   public void checkBadSerVer() {
     int k = 512;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -77,24 +77,33 @@
       mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
 
       Sketch.wrap(mem);
+    } catch (final Exception e) {
+      if (e instanceof SketchesArgumentException) {}
+      else { throw new RuntimeException(e); }
     }
   }
 
-  @Test(expectedExceptions = SketchesArgumentException.class)
+  @Test//(expectedExceptions = SketchesArgumentException.class)
   public void checkConstructorKtooSmall() {
     int k = 8;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
       UpdateSketch.builder().setNominalEntries(k).build(mem);
+    } catch (final Exception e) {
+      if (e instanceof SketchesArgumentException) {}
+      else { throw new RuntimeException(e); }
     }
   }
 
-  @Test(expectedExceptions = SketchesArgumentException.class)
+  @Test//(expectedExceptions = SketchesArgumentException.class)
   public void checkConstructorMemTooSmall() {
     int k = 16;
-    try (WritableDirectHandle h = makeNativeMemory(k/2)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k/2)) {
+      WritableMemory mem = h.getWritable();
       UpdateSketch.builder().setNominalEntries(k).build(mem);
+    } catch (final Exception e) {
+      if (e instanceof SketchesArgumentException) {}
+      else { throw new RuntimeException(e); }
     }
   }
 
@@ -102,7 +111,7 @@
   public void checkHeapifyIllegalFamilyID_heapify() {
     int k = 512;
     int bytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
-    WritableMemory mem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[bytes]);
     UpdateSketch.builder().setNominalEntries(k).build(mem);
 
     mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Family ID byte
@@ -117,8 +126,8 @@
     int u = 2*k;
     boolean estimating = (u > k);
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
       for (int i=0; i<u; i++) { sk1.update(i); }
@@ -151,6 +160,8 @@
       assertFalse(sk2.isDirect());
       assertFalse(sk2.hasMemory());
       assertFalse(sk2.isDirty());
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -158,7 +169,7 @@
   public void checkWrapIllegalFamilyID_wrap() {
     int k = 512;
     int maxBytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
-    WritableMemory mem = WritableMemory.wrap(new byte[maxBytes]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[maxBytes]);
 
     UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -172,7 +183,7 @@
   public void checkWrapIllegalFamilyID_direct() {
     int k = 512;
     int maxBytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
-    WritableMemory mem = WritableMemory.wrap(new byte[maxBytes]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[maxBytes]);
 
     UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -182,37 +193,43 @@
     DirectQuickSelectSketch.writableWrap(mem, DEFAULT_UPDATE_SEED);
   }
 
-  @Test(expectedExceptions = SketchesArgumentException.class)
+  @Test //(expectedExceptions = SketchesArgumentException.class)
   public void checkHeapifySeedConflict() {
     int k = 512;
     long seed1 = 1021;
     long seed2 = DEFAULT_UPDATE_SEED;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setSeed(seed1).setNominalEntries(k).build(mem);
       byte[] byteArray = usk.toByteArray();
       Memory srcMem = Memory.wrap(byteArray);
       Sketch.heapify(srcMem, seed2);
+    } catch (final Exception e) {
+      if (e instanceof SketchesArgumentException) {}
+      else { throw new RuntimeException(e); }
     }
   }
 
-  @Test(expectedExceptions = SketchesArgumentException.class)
+  @Test//(expectedExceptions = SketchesArgumentException.class)
   public void checkCorruptLgNomLongs() {
     int k = 16;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
       UpdateSketch.builder().setNominalEntries(k).build(mem);
       mem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
       Sketch.heapify(mem, DEFAULT_UPDATE_SEED);
+    } catch (final Exception e) {
+      if (e instanceof SketchesArgumentException) {}
+      else { throw new RuntimeException(e); }
     }
   }
 
   @Test
   public void checkHeapifyByteArrayExact() {
     int k = 512;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -235,6 +252,8 @@
       // That is, this is being run for its side-effect of accessing things.
       // If something is wonky, it will generate an exception and fail the test.
       usk2.toString(true, true, 8, true);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -242,8 +261,8 @@
   public void checkHeapifyByteArrayEstimating() {
     int k = 4096;
     int u = 2*k;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
 
       for (int i=0; i<u; i++) { usk.update(i); }
@@ -262,6 +281,8 @@
       assertEquals(usk2.isEmpty(), false);
       assertEquals(usk2.isEstimationMode(), true);
       assertEquals(usk2.getClass().getSimpleName(), "HeapQuickSelectSketch");
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -271,8 +292,8 @@
     int u = 2*k;
     boolean estimating = (u > k);
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
       UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
       for (int i=0; i<u; i++) { sk1.update(i); }
 
@@ -288,6 +309,8 @@
       assertEquals(sk2.getUpperBound(2), sk1ub);
       assertEquals(sk2.isEmpty(), false);
       assertEquals(sk2.isEstimationMode(), estimating);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -296,8 +319,8 @@
     int k = 512;
     int u = 4*k;
     boolean estimating = (u > k);
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -339,7 +362,7 @@
       int bytes = usk.getCompactBytes();
       assertEquals(bytes, (k*8) + (Family.COMPACT.getMaxPreLongs() << 3));
       byte[] memArr2 = new byte[bytes];
-      WritableMemory mem2 = WritableMemory.wrap(memArr2);
+      WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
       csk = usk.compact(false,  mem2);
       assertEquals(csk.getEstimate(), uskEst);
@@ -358,14 +381,16 @@
       assertEquals(csk.isEstimationMode(), estimating);
       assertEquals(csk.getClass().getSimpleName(), "DirectCompactSketch");
       csk.toString(false, true, 0, false);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
   @Test
   public void checkDQStoCompactEmptyForms() {
     int k = 512;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -380,7 +405,7 @@
       int bytes = usk.getCompactBytes(); //compact form
       assertEquals(bytes, 8);
       byte[] memArr2 = new byte[bytes];
-      WritableMemory mem2 = WritableMemory.wrap(memArr2);
+      WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
       CompactSketch csk2 = usk.compact(false,  mem2);
       assertEquals(csk2.getEstimate(), uskEst);
@@ -399,6 +424,9 @@
       assertEquals(csk3.isEmpty(), true);
       assertEquals(csk3.isEstimationMode(), false);
       assertEquals(csk3.getClass().getSimpleName(), "DirectCompactSketch");
+    } catch (final Exception e) {
+      //if (e instanceof SketchesArgumentException) {}
+      throw new RuntimeException(e); 
     }
   }
 
@@ -407,8 +435,8 @@
     int k = 4096;
     int u = 2*k;
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -418,6 +446,8 @@
       for (int i = 0; i< u; i++) { usk.update(i); }
 
       assertTrue(sk1.getRetainedEntries(false) > k);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -426,8 +456,8 @@
     int k = 4096;
     float p = (float)0.5;
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -444,14 +474,16 @@
       assertTrue(ub > est);
       double lb = usk.getLowerBound(1);
       assertTrue(lb < est);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
   @Test
   public void checkErrorBounds() {
     int k = 512;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -475,6 +507,8 @@
       ub = usk.getUpperBound(2);
       assertTrue(est <= ub);
       assertTrue(est >= lb);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -484,8 +518,8 @@
     //virgin, p = 1.0
     int k = 1024;
     float p = (float)1.0;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -498,7 +532,7 @@
       //virgin, p = .001
       p = (float)0.001;
       byte[] memArr2 = new byte[(int) mem.getCapacity()];
-      WritableMemory mem2 = WritableMemory.wrap(memArr2);
+      WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
       UpdateSketch usk2 = UpdateSketch.builder().setP(p).setNominalEntries(k).build(mem2);
       sk1 = (DirectQuickSelectSketch)usk2;
 
@@ -515,6 +549,8 @@
       double lb = usk2.getLowerBound(2);
       assertTrue(lb <= est);
       //println("LB: "+lb);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -522,8 +558,8 @@
   public void checkUpperAndLowerBounds() {
     int k = 512;
     int u = 2*k;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
 
@@ -534,6 +570,8 @@
       double lb = usk.getLowerBound(1);
       assertTrue(ub > est);
       assertTrue(lb < est);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -541,8 +579,8 @@
   public void checkRebuild() {
     int k = 512;
     int u = 4*k;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -561,6 +599,8 @@
       sk1.rebuild();
       assertEquals(sk1.getRetainedEntries(false), k);
       assertEquals(sk1.getRetainedEntries(true), k);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -568,8 +608,8 @@
   public void checkResetAndStartingSubMultiple() {
     int k = 512;
     int u = 4*k;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -590,6 +630,8 @@
 
       assertNotNull(sk1.getMemory());
       assertFalse(sk1.isOrdered());
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -597,8 +639,8 @@
   public void checkExactModeMemoryArr() {
     int k = 4096;
     int u = 4096;
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -608,6 +650,8 @@
 
       assertEquals(usk.getEstimate(), u, 0.0);
       assertEquals(sk1.getRetainedEntries(false), u);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -616,8 +660,8 @@
     int k = 4096;
     int u = 2*k;
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      WritableMemory mem = h.get();
+    try (WritableHandle h = makeNativeMemory(k)) {
+      WritableMemory mem = h.getWritable();
 
       UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(mem);
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
@@ -627,6 +671,8 @@
 
       assertEquals(usk.getEstimate(), u, u*.05);
       assertTrue(sk1.getRetainedEntries(false) > k);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -636,9 +682,9 @@
     int u = 2*k;
     int memCapacity = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
 
-    try(WritableDirectHandle memHandler = WritableMemory.allocateDirect(memCapacity)) {
+    try(WritableHandle memHandler = WritableMemory.allocateDirect(memCapacity)) {
 
-      UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(memHandler.get());
+      UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(memHandler.getWritable());
       DirectQuickSelectSketch sk1 = (DirectQuickSelectSketch)usk; //for internal checks
       assertTrue(usk.isEmpty());
 
@@ -647,6 +693,8 @@
       println(""+est);
       assertEquals(usk.getEstimate(), u, u*.05);
       assertTrue(sk1.getRetainedEntries(false) > k);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -655,8 +703,8 @@
     int k = 4096;
     int u = 2*k;
 
-    try (WritableDirectHandle h = makeNativeMemory(k)) {
-      UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(h.get());
+    try (WritableHandle h = makeNativeMemory(k)) {
+      UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).build(h.getWritable());
       assertTrue(usk.isEmpty());
 
       for (int i = 0; i< u; i++) { usk.update(i); } //force estimation
@@ -672,7 +720,7 @@
 
       serArr = usk.toByteArray();
 
-      WritableMemory mem2 = WritableMemory.wrap(serArr);
+      WritableMemory mem2 = WritableMemory.writableWrap(serArr);
 
       //reconstruct to Native/Direct
       UpdateSketch usk2 = Sketches.wrapUpdateSketch(mem2);
@@ -682,6 +730,8 @@
 
       assertEquals(count2, count1);
       assertEquals(est2, est1, 0.0);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -694,7 +744,7 @@
 
   public void updateAfterWritableWrap() {
     UpdateSketch usk1 = UpdateSketch.builder().build();
-    UpdateSketch usk2 = UpdateSketch.wrap(WritableMemory.wrap(usk1.toByteArray()));
+    UpdateSketch usk2 = UpdateSketch.wrap(WritableMemory.writableWrap(usk1.toByteArray()));
     usk2.update(0);
   }
 
@@ -712,7 +762,7 @@
 
     int bytes = Sketches.getMaxUpdateSketchBytes(k);
     byte[] arr1 = new byte[bytes];
-    WritableMemory mem1 = WritableMemory.wrap(arr1);
+    WritableMemory mem1 = WritableMemory.writableWrap(arr1);
     ResizeFactor rf = ResizeFactor.X1; //0
     UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).setResizeFactor(rf).build(mem1);
     for (int i=0; i<u; i++) { usk1.update(i); }
@@ -764,7 +814,7 @@
     }
 
     byte[] arr2 = Arrays.copyOfRange(arr1, 0, bytes-1); //corrupt length
-    WritableMemory mem2 = WritableMemory.wrap(arr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(arr2);
     try {
       usk2 = DirectQuickSelectSketch.writableWrap(mem2, DEFAULT_UPDATE_SEED);
       fail("Expected SketchesArgumentException");
@@ -779,7 +829,7 @@
 
     int bytes = Sketches.getMaxUpdateSketchBytes(k);
     byte[] arr = new byte[bytes];
-    WritableMemory mem = WritableMemory.wrap(arr);
+    WritableMemory mem = WritableMemory.writableWrap(arr);
     ResizeFactor rf = ResizeFactor.X8; // 3
     UpdateSketch usk = UpdateSketch.builder().setNominalEntries(k).setResizeFactor(rf).build(mem);
     usk.update(0);
@@ -792,7 +842,7 @@
   @Test
   public void checkFamilyAndRF() {
     int k = 16;
-    WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
     UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
     assertEquals(sketch.getFamily(), Family.QUICKSELECT);
     assertEquals(sketch.getResizeFactor(), ResizeFactor.X8);
@@ -803,7 +853,7 @@
   public void checkResizeInBigMem() {
     int k = 1 << 14;
     int u = 1 << 20;
-    WritableMemory mem = WritableMemory.wrap(new byte[(8*k*16) +24]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(8*k*16) +24]);
     UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
     for (int i=0; i<u; i++) { sketch.update(i); }
   }
@@ -811,7 +861,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBadLgNomLongs() {
     int k = 16;
-    WritableMemory mem = WritableMemory.wrap(new byte[(k*16) +24]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) +24]);
     Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
     mem.putByte(LG_NOM_LONGS_BYTE, (byte) 3); //Corrupt LgNomLongs byte
     DirectQuickSelectSketch.writableWrap(mem, DEFAULT_UPDATE_SEED);
@@ -822,12 +872,14 @@
     int k = 1 << 12;
     int u = 2 * k;
     int bytes = Sketches.getMaxUpdateSketchBytes(k);
-      try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
-      WritableMemory wmem = wdh.get();
+      try (WritableHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
+      WritableMemory wmem = wdh.getWritable();
       UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
       assertTrue(sketch.isSameResource(wmem));
       for (int i = 0; i < u; i++) { sketch.update(i); }
       assertFalse(sketch.isSameResource(wmem));
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -836,8 +888,8 @@
     int k = 1 << 12;
     int u = 2 * k;
     int bytes = Sketches.getMaxUpdateSketchBytes(k);
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
-      WritableMemory wmem = wdh.get();
+    try (WritableHandle wdh = WritableMemory.allocateDirect(bytes/2)) { //will request
+      WritableMemory wmem = wdh.getWritable();
       UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
       for (int i = 0; i < u; i++) { sketch.update(i); }
       double est1 = sketch.getEstimate();
@@ -858,6 +910,8 @@
       } catch (SketchesReadOnlyException e) {
         //expected
       }
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
 
   }
@@ -879,7 +933,7 @@
     return (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
   }
 
-  private static WritableDirectHandle makeNativeMemory(int k) {
+  private static WritableHandle makeNativeMemory(int k) {
     return WritableMemory.allocateDirect(getMaxBytes(k));
   }
 
diff --git a/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java b/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
index d92e672..3c21096 100644
--- a/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/DirectUnionTest.java
@@ -62,7 +62,7 @@
 
     assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -87,7 +87,7 @@
       usk2.update(i); //2*k no overlap
     }
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -114,7 +114,7 @@
 
     assertEquals(u, usk1.getEstimate() + usk2.getEstimate()/2, 0.0); //exact, overlapped
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -141,7 +141,7 @@
 
     assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -149,7 +149,7 @@
 
     testAllCompactForms(union, u, 0.0);
 
-    final Union union2 = (Union)SetOperation.heapify(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = (Union)SetOperation.heapify(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.0);
   }
@@ -173,7 +173,7 @@
 
     assertEquals(u, usk1.getEstimate() + usk2.getEstimate(), 0.0); //exact, no overlap
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -181,7 +181,7 @@
 
     testAllCompactForms(union, u, 0.0);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.0);
   }
@@ -202,7 +202,7 @@
       usk2.update(i); //2k no overlap, exact
     }
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //update with heap UpdateSketch
@@ -210,7 +210,7 @@
 
     testAllCompactForms(union, u, 0.05);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.05);
   }
@@ -233,7 +233,7 @@
 
     final CompactSketch cosk2 = usk2.compact(true, null);
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1);  //update with heap UpdateSketch
@@ -246,7 +246,7 @@
 
     testAllCompactForms(union, u, 0.05);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.05);
 
@@ -270,10 +270,10 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     final CompactSketch cosk2 = usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1);      //updates with heap UpdateSketch
@@ -286,7 +286,7 @@
 
     testAllCompactForms(union, u, 0.05);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.05);
 
@@ -310,10 +310,10 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1);        //updates with heap UpdateSketch
@@ -326,7 +326,7 @@
 
     testAllCompactForms(union, u, 0.05);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.05);
 
@@ -350,10 +350,10 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     usk2.compact(false, cskMem2); //unordered, loads the cskMem2 as unordered
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1);        //updates with heap UpdateSketch
@@ -366,7 +366,7 @@
 
     testAllCompactForms(union, u, 0.05);
 
-    final Union union2 = Sketches.wrapUnion(WritableMemory.wrap(union.toByteArray()));
+    final Union union2 = Sketches.wrapUnion(WritableMemory.writableWrap(union.toByteArray()));
 
     testAllCompactForms(union2, u, 0.05);
 
@@ -404,7 +404,7 @@
     }
     v += u;
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(usk1); //updates with heap UpdateSketch
@@ -441,7 +441,7 @@
     final CompactSketch csk1 = (CompactSketch)Sketch.wrap(skMem1);
     final CompactSketch csk2 = (CompactSketch)Sketch.wrap(skMem2);
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(csk1);
@@ -472,7 +472,7 @@
     final Memory v1mem1 = convertSerVer3toSerVer1(usk1.compact(true, null));
     final Memory v1mem2 = convertSerVer3toSerVer1(usk2.compact(true, null));
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(v1mem1);
@@ -503,7 +503,7 @@
     final Memory v2mem1 = convertSerVer3toSerVer2(usk1.compact(true, null), Util.DEFAULT_UPDATE_SEED);
     final Memory v2mem2 = convertSerVer3toSerVer2(usk2.compact(true, null), Util.DEFAULT_UPDATE_SEED);
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(v2mem1);
@@ -520,11 +520,11 @@
 
     final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
     final CompactSketch usk1c = usk1.compact(true, null);
-    WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
 
     final Memory v1mem1 = convertSerVer3toSerVer1(usk1c);
 
-    WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v1mem1);
     CompactSketch cOut = union.getResult(true, null);
@@ -532,19 +532,19 @@
 
     final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
 
-    uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v2mem1);
     cOut = union.getResult(true, null);
     assertEquals(cOut.getEstimate(), 0.0, 0.0);
 
-    uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v3mem1);
     cOut = union.getResult(true, null);
     assertEquals(cOut.getEstimate(), 0.0, 0.0);
 
-    uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     v3mem1 = null;
     union.union(v3mem1);
@@ -564,9 +564,9 @@
       usk1.update(i); //force prelongs to 3
     }
     final CompactSketch usk1c = usk1.compact(true, null);
-    final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v3mem1);
   }
@@ -580,11 +580,11 @@
     usk1.update(1);
     usk1.update(2);
     final CompactSketch usk1c = usk1.compact(true, null);
-    final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
     //corrupt SerVer
     v3mem1.putByte(SER_VER_BYTE, (byte)0);
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.union(v3mem1);
@@ -598,17 +598,17 @@
     final CompactSketch usk1c = usk1.compact(true, null);
     final byte[] skArr = usk1c.toByteArray();
     final byte[] skArr2 = Arrays.copyOf(skArr, skArr.length * 2);
-    final WritableMemory v3mem1 = WritableMemory.wrap(skArr2);
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(skArr2);
 
-    WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v3mem1);
 
     final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
-    final WritableMemory v2mem2 = WritableMemory.wrap(new byte[16]);
+    final WritableMemory v2mem2 = WritableMemory.writableWrap(new byte[16]);
     v2mem1.copyTo(0, v2mem2, 0, 8);
 
-    uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(v2mem2);
   }
@@ -617,7 +617,7 @@
   @Test //Himanshu's issue
   public void checkDirectWrap() {
     final int nomEntries = 16;
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(nomEntries)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(nomEntries)]);
     SetOperation.builder().setNominalEntries(nomEntries).buildUnion(uMem);
 
     final UpdateSketch sk1 = UpdateSketch.builder().setNominalEntries(nomEntries).build();
@@ -642,10 +642,10 @@
   public void checkEmptyUnionCompactResult() {
     final int k = 64;
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
-    final WritableMemory mem = WritableMemory.wrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
     final CompactSketch csk = union.getResult(false, mem); //DirectCompactSketch
     assertTrue(csk.isEmpty());
   }
@@ -654,10 +654,10 @@
   public void checkEmptyUnionCompactOrderedResult() {
     final int k = 64;
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
-    final WritableMemory mem = WritableMemory.wrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[Sketch.getMaxCompactSketchBytes(0)]);
     final CompactSketch csk = union.getResult(true, mem); //DirectCompactSketch
     assertTrue(csk.isEmpty());
   }
@@ -666,7 +666,7 @@
   public void checkUnionMemToString() {
     final int k = 64;
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]); //union memory
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]); //union memory
     SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
   }
 
@@ -677,7 +677,7 @@
 
     final int memBytes = getMaxUnionBytes(k);
     final byte[] memArr = new byte[memBytes];
-    final WritableMemory iMem = WritableMemory.wrap(memArr);
+    final WritableMemory iMem = WritableMemory.writableWrap(memArr);
 
     final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(iMem);
     union.union(sk);
@@ -688,7 +688,7 @@
   @Test
   public void checkPrimitiveUpdates() {
     final int k = 32;
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
 
     union.update(1L);
@@ -729,7 +729,7 @@
   @Test
   public void checkGetFamily() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]);
     final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
     assertEquals(setOp.getFamily(), Family.UNION);
   }
@@ -737,7 +737,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkPreambleLongsCorruption() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]);
 
     final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
     println(setOp.toString());
@@ -752,10 +752,10 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkSizeTooSmall() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*16 +32]); //initialized
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*16 +32]); //initialized
     final SetOperation setOp = new SetOperationBuilder().setNominalEntries(k).build(Family.UNION, mem);
     println(setOp.toString());
-    final WritableMemory mem2 = WritableMemory.wrap(new byte[32]); //for just preamble
+    final WritableMemory mem2 = WritableMemory.writableWrap(new byte[32]); //for just preamble
     mem.copyTo(0, mem2, 0, 32); //too small
     DirectQuickSelectSketch.writableWrap(mem2, Util.DEFAULT_UPDATE_SEED);
   }
@@ -772,7 +772,7 @@
     final Sketch s = usk.compact();
 
     //create empty target union in off-heap mem
-    final WritableMemory mem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union1 = SetOperation.builder().setNominalEntries(k).buildUnion(mem);
 
     union1.union(s);
@@ -798,7 +798,7 @@
     usk.compact(true, memIn); //side effect of loading the memIn
 
     //create empty target union in off-heap mem
-    final WritableMemory mem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union1 = SetOperation.builder().setNominalEntries(k).buildUnion(mem);
 
     union1.union(memIn);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java b/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
index 68133fd..157731a 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapAlphaSketchTest.java
@@ -73,7 +73,7 @@
     assertEquals(sk1.getRetainedEntries(false), u);
 
     byte[] byteArray = usk.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
 
     Sketch.heapify(mem, seed);
@@ -87,7 +87,7 @@
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkAlphaIncompatibleWithMem() {
-    WritableMemory mem = WritableMemory.wrap(new byte[(512*16)+24]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(512*16)+24]);
     UpdateSketch.builder().setFamily(Family.ALPHA).setNominalEntries(512).build(mem);
   }
 
@@ -109,7 +109,7 @@
     assertEquals(usk.getEstimate(), u, 0.0);
     assertEquals(sk1.getRetainedEntries(false), u);
     byte[] byteArray = usk.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
 
     //try to heapify the corruped mem
@@ -269,7 +269,7 @@
     int alphaBytes = sk1.getRetainedEntries(true) * 8;
     assertEquals(bytes, alphaBytes + (Family.COMPACT.getMaxPreLongs() << 3));
     byte[] memArr2 = new byte[bytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
     comp3 = usk.compact(false, mem2);
 
@@ -313,7 +313,7 @@
     int bytes = usk.getCompactBytes();
     assertEquals(bytes, 8); //compact, empty and theta = 1.0
     byte[] memArr2 = new byte[bytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);
 
     CompactSketch csk2 = usk.compact(false,  mem2);
     assertEquals(csk2.getEstimate(), uskEst);
@@ -575,7 +575,7 @@
     int k = 512;
     Sketch alpha = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
     byte[] byteArray = alpha.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 4);
     Sketch.heapify(mem);
@@ -594,7 +594,7 @@
     UpdateSketch sk1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
     sk1.update(1L); //forces preLongs to 3
     byte[] bytearray1 = sk1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(bytearray1);
+    WritableMemory mem = WritableMemory.writableWrap(bytearray1);
     long pre0 = mem.getLong(0);
 
     tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt PreLongs
@@ -619,7 +619,7 @@
     }
     mem.putLong(THETA_LONG, origThetaLong); //restore theta
     byte[] byteArray2 = new byte[bytearray1.length -1];
-    WritableMemory mem2 = WritableMemory.wrap(byteArray2);
+    WritableMemory mem2 = WritableMemory.writableWrap(byteArray2);
     mem.copyTo(0, mem2, 0, mem2.getCapacity());
     try {
       HeapAlphaSketch.heapifyInstance(mem2, DEFAULT_UPDATE_SEED);
@@ -678,7 +678,7 @@
         .setFamily(ALPHA).build();
     for (int i = 0; i < k; i++) { sketch.update(i); }
     byte[] byteArr = sketch.toByteArray();
-    WritableMemory wmem = WritableMemory.wrap(byteArr);
+    WritableMemory wmem = WritableMemory.writableWrap(byteArr);
     wmem.putByte(LG_NOM_LONGS_BYTE, (byte) 8); //corrupt LgNomLongs
     UpdateSketch sk = Sketches.heapifyUpdateSketch(wmem);
   }
diff --git a/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java b/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
index 736b1e5..894864f 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapIntersectionTest.java
@@ -74,7 +74,7 @@
 
     final int bytes = rsk1.getCompactBytes();
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
 
     rsk1 = inter.getResult(!ordered, mem);
     assertEquals(rsk1.getEstimate(), 0.0);
@@ -116,7 +116,7 @@
 
     final int bytes = rsk1.getCompactBytes();
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
 
     rsk1 = inter.getResult(!ordered, mem); //executed twice to fully exercise the internal state machine
     assertEquals(rsk1.getEstimate(), k);
@@ -356,7 +356,7 @@
 
     //Put the intersection into memory
     final byte[] byteArray = inter.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //Heapify
     final Intersection inter2 = (Intersection) SetOperation.heapify(mem);
     final CompactSketch heapifiedSk = inter2.getResult(false, null);
@@ -428,7 +428,7 @@
   public void checkBadPreambleLongs() {
     final Intersection inter1 = SetOperation.builder().buildIntersection(); //virgin
     final byte[] byteArray = inter1.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putByte(PREAMBLE_LONGS_BYTE, (byte) 2); //RF not used = 0
     SetOperation.heapify(mem);
@@ -438,7 +438,7 @@
   public void checkBadSerVer() {
     final Intersection inter1 = SetOperation.builder().buildIntersection(); //virgin
     final byte[] byteArray = inter1.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putByte(SER_VER_BYTE, (byte) 2);
     SetOperation.heapify(mem);
@@ -462,7 +462,7 @@
     final UpdateSketch sk = Sketches.updateSketchBuilder().build();
     inter1.intersect(sk); //initializes to a true empty intersection.
     final byte[] byteArray = inter1.toByteArray();
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.putInt(RETAINED_ENTRIES_INT, 1);
     SetOperation.heapify(mem);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
index 7001649..155cb12 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapQuickSelectSketchTest.java
@@ -73,7 +73,7 @@
     assertEquals(sk1.getRetainedEntries(false), u);
 
     byte[] byteArray = usk.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(SER_VER_BYTE, (byte) 0); //corrupt the SerVer byte
 
     Sketch.heapify(mem, seed);
@@ -96,7 +96,7 @@
     assertEquals(usk.getEstimate(), u, 0.0);
     assertEquals(sk1.getRetainedEntries(false), u);
     byte[] byteArray = usk.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     mem.putByte(FAMILY_BYTE, (byte) 0); //corrupt the Sketch ID byte
 
     //try to heapify the corruped mem
@@ -117,7 +117,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkHeapifyCorruptLgNomLongs() {
     UpdateSketch usk = UpdateSketch.builder().setNominalEntries(16).build();
-    WritableMemory srcMem = WritableMemory.wrap(usk.toByteArray());
+    WritableMemory srcMem = WritableMemory.writableWrap(usk.toByteArray());
     srcMem.putByte(LG_NOM_LONGS_BYTE, (byte)2); //corrupt
     Sketch.heapify(srcMem, DEFAULT_UPDATE_SEED);
   }
@@ -264,7 +264,7 @@
     assertEquals(comp2.getClass().getSimpleName(), "HeapCompactSketch");
 
     byte[] memArr2 = new byte[uskCompBytes];
-    WritableMemory mem2 = WritableMemory.wrap(memArr2);  //allocate mem for compact form
+    WritableMemory mem2 = WritableMemory.writableWrap(memArr2);  //allocate mem for compact form
 
     comp3 = usk.compact(false,  mem2);  //load the mem2
 
@@ -310,7 +310,7 @@
     assertEquals(usk.isEstimationMode(), estimating);
 
     byte[] arr2 = new byte[compBytes];
-    WritableMemory mem2 = WritableMemory.wrap(arr2);
+    WritableMemory mem2 = WritableMemory.writableWrap(arr2);
 
     CompactSketch csk2 = usk.compact(false,  mem2);
     assertEquals(csk2.getEstimate(), uskEst);
@@ -558,7 +558,7 @@
     UpdateSketch s1 = Sketches.updateSketchBuilder().setNominalEntries(k).build();
     for (int i = 0; i < k; i++) { s1.update(i); }
     byte[] badArray = s1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(badArray);
+    WritableMemory mem = WritableMemory.writableWrap(badArray);
     PreambleUtil.insertLgArrLongs(mem, 4);
     PreambleUtil.insertThetaLong(mem, Long.MAX_VALUE / 2);
     Sketch.heapify(mem);
@@ -576,7 +576,7 @@
     UpdateSketch sk1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
     sk1.update(1L); //forces preLongs to 3
     byte[] bytearray1 = sk1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(bytearray1);
+    WritableMemory mem = WritableMemory.writableWrap(bytearray1);
     long pre0 = mem.getLong(0);
 
     tryBadMem(mem, PREAMBLE_LONGS_BYTE, 2); //Corrupt PreLongs
@@ -604,7 +604,7 @@
     }
     mem.putLong(THETA_LONG, origThetaLong); //restore theta
     byte[] byteArray2 = new byte[bytearray1.length -1];
-    WritableMemory mem2 = WritableMemory.wrap(byteArray2);
+    WritableMemory mem2 = WritableMemory.writableWrap(byteArray2);
     mem.copyTo(0, mem2, 0, mem2.getCapacity());
     try {
       HeapQuickSelectSketch.heapifyInstance(mem2, DEFAULT_UPDATE_SEED);
diff --git a/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java b/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
index 6c1240a..7aead0e 100644
--- a/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
+++ b/src/test/java/org/apache/datasketches/theta/HeapUnionTest.java
@@ -229,7 +229,7 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     final CompactSketch cosk2 = usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
 
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -268,7 +268,7 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     usk2.compact(true, cskMem2); //ordered, loads the cskMem2 as ordered
 
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -307,7 +307,7 @@
       usk2.update(i);  //2k no overlap, exact, will force early stop
     }
 
-    final WritableMemory cskMem2 = WritableMemory.wrap(new byte[usk2.getCompactBytes()]);
+    final WritableMemory cskMem2 = WritableMemory.writableWrap(new byte[usk2.getCompactBytes()]);
     usk2.compact(false, cskMem2); //unordered, loads the cskMem2 as unordered
 
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
@@ -390,8 +390,8 @@
       usk2.update(i); //2*k + 1024 no overlap
     }
 
-    final WritableMemory skMem1 = WritableMemory.wrap(usk1.compact(false, null).toByteArray());
-    final WritableMemory skMem2 = WritableMemory.wrap(usk2.compact(true, null).toByteArray());
+    final WritableMemory skMem1 = WritableMemory.writableWrap(usk1.compact(false, null).toByteArray());
+    final WritableMemory skMem2 = WritableMemory.writableWrap(usk2.compact(true, null).toByteArray());
 
     final CompactSketch csk1 = (CompactSketch)Sketch.wrap(skMem1);
     final CompactSketch csk2 = (CompactSketch)Sketch.wrap(skMem2);
@@ -472,7 +472,7 @@
 
     final UpdateSketch usk1 = UpdateSketch.builder().setNominalEntries(k).build();
     final CompactSketch usk1c = usk1.compact(true, null);
-    WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
 
     final Memory v1mem1 = convertSerVer3toSerVer1(usk1.compact(true, null));
 
@@ -512,7 +512,7 @@
       usk1.update(i); //force prelongs to 3
     }
     final CompactSketch usk1c = usk1.compact(true, null);
-    final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
     //println(PreambleUtil.toString(v3mem1));
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion();
     union.union(v3mem1);
@@ -526,7 +526,7 @@
     usk1.update(1);
     usk1.update(2);
     final CompactSketch usk1c = usk1.compact(true, null);
-    final WritableMemory v3mem1 = WritableMemory.wrap(usk1c.toByteArray());
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(usk1c.toByteArray());
     //corrupt SerVer
     v3mem1.putByte(SER_VER_BYTE, (byte)0);
 
@@ -540,13 +540,13 @@
     final CompactSketch usk1c = usk1.compact(true, null);
     final byte[] skArr = usk1c.toByteArray();
     final byte[] skArr2 = Arrays.copyOf(skArr, skArr.length * 2);
-    final WritableMemory v3mem1 = WritableMemory.wrap(skArr2);
+    final WritableMemory v3mem1 = WritableMemory.writableWrap(skArr2);
 
     Union union = SetOperation.builder().buildUnion();
     union.union(v3mem1);
 
     final Memory v2mem1 = convertSerVer3toSerVer2(usk1c, Util.DEFAULT_UPDATE_SEED);
-    final WritableMemory v2mem2 = WritableMemory.wrap(new byte[16]);
+    final WritableMemory v2mem2 = WritableMemory.writableWrap(new byte[16]);
     v2mem1.copyTo(0, v2mem2, 0, 8);
 
     union = SetOperation.builder().buildUnion();
@@ -625,7 +625,7 @@
     compEst2 = comp2.getEstimate();
     assertEquals(compEst2, compEst1, 0.0);
 
-    final WritableMemory mem = WritableMemory.wrap(new byte[comp2.getCurrentBytes()]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[comp2.getCurrentBytes()]);
 
     compEst2 = union.getResult(false, mem).getEstimate(); //not ordered, mem
     assertEquals(compEst2, compEst1, 0.0);
diff --git a/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java b/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
index 5088510..38bcc16 100644
--- a/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
+++ b/src/test/java/org/apache/datasketches/theta/PreambleUtilTest.java
@@ -74,7 +74,7 @@
     final int u = 2*k;
     final int bytes = (k << 4) + (Family.QUICKSELECT.getMinPreLongs() << 3);
     final byte[] byteArray = new byte[bytes];
-    final WritableMemory mem = WritableMemory.wrap(byteArray);
+    final WritableMemory mem = WritableMemory.writableWrap(byteArray);
 
     final UpdateSketch quick1 = UpdateSketch.builder().setNominalEntries(k).build(mem);
     println(Sketch.toString(byteArray));
@@ -91,7 +91,7 @@
     println(quick1.toString());
     println(PreambleUtil.preambleToString(mem));
 
-    final WritableMemory uMem = WritableMemory.wrap(new byte[getMaxUnionBytes(k)]);
+    final WritableMemory uMem = WritableMemory.writableWrap(new byte[getMaxUnionBytes(k)]);
     final Union union = SetOperation.builder().setNominalEntries(k).buildUnion(uMem);
     union.union(quick1);
     println(PreambleUtil.preambleToString(uMem));
@@ -157,7 +157,7 @@
   @Test
   public void checkInsertsAndExtracts() {
     final byte[] arr = new byte[32];
-    final WritableMemory wmem = WritableMemory.wrap(arr);
+    final WritableMemory wmem = WritableMemory.writableWrap(arr);
 
     int v = 0;
     insertPreLongs(wmem, ++v);
diff --git a/src/test/java/org/apache/datasketches/theta/SetOperationTest.java b/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
index 179a0c2..af5fcfb 100644
--- a/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SetOperationTest.java
@@ -133,7 +133,7 @@
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkBuilderAnotB_noMem() {
-    final WritableMemory mem = WritableMemory.wrap(new byte[64]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[64]);
     SetOperation.builder().build(Family.A_NOT_B, mem);
   }
 
@@ -198,7 +198,7 @@
     for (int i=0; i<k; i++) {
       usk1.update(i); //64
     }
-    final WritableMemory wmem = WritableMemory.wrap(usk1.toByteArray());
+    final WritableMemory wmem = WritableMemory.writableWrap(usk1.toByteArray());
     PreambleUtil.insertSerVer(wmem, 2); //corrupt
     final Memory mem = wmem;
     SetOperation.wrap(mem);
@@ -211,7 +211,7 @@
     for (int i=0; i<k; i++) {
       usk1.update(i); //64
     }
-    final WritableMemory wmem = WritableMemory.wrap(usk1.toByteArray());
+    final WritableMemory wmem = WritableMemory.writableWrap(usk1.toByteArray());
     SetOperation.wrap(wmem);
   }
 
@@ -260,7 +260,7 @@
     // However, if you had created this WM object directly in raw, off-heap "native" memory
     // you would have the responsibility to close it when you are done.
     // But, since it was allocated via BB, it closes it for you.
-    final WritableMemory heapMem = WritableMemory.wrap(heapBuf);
+    final WritableMemory heapMem = WritableMemory.writableWrap(heapBuf);
 
     double result = directUnionTrial1(heapMem, heapLayout, sketchNomEntries, unionNomEntries);
     println("1st est: "+result);
@@ -318,7 +318,7 @@
   @Test
   public void checkIsSameResource() {
     final int k = 16;
-    final WritableMemory wmem = WritableMemory.wrap(new byte[k*16 + 32]);
+    final WritableMemory wmem = WritableMemory.writableWrap(new byte[k*16 + 32]);
     final Memory roCompactMem = Memory.wrap(new byte[8]);
     final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(wmem);
     assertTrue(union.isSameResource(wmem));
diff --git a/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java b/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
index 51a60d7..1365160 100644
--- a/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SetOpsCornerCasesTest.java
@@ -482,7 +482,7 @@
         }
         int bytes = Sketch.getMaxCompactSketchBytes(sk.getRetainedEntries(true));
         byte[] byteArr = new byte[bytes];
-        WritableMemory mem = WritableMemory.wrap(byteArr);
+        WritableMemory mem = WritableMemory.writableWrap(byteArr);
         csk = sk.compact(false, mem);
         break;
       }
diff --git a/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java b/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
index ba3c298..bb50617 100644
--- a/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SingleItemSketchTest.java
@@ -194,7 +194,7 @@
 
     //Off-heap
     bytes = Sketches.getMaxUpdateSketchBytes(32);
-    WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
     sk1= Sketches.updateSketchBuilder().setNominalEntries(32).build(wmem);
     sk1.update(1);
     csk = sk1.compact(true, null);
@@ -203,7 +203,7 @@
     assertTrue(csk instanceof SingleItemSketch);
 
     bytes = Sketches.getMaxCompactSketchBytes(1);
-    wmem = WritableMemory.wrap(new byte[bytes]);
+    wmem = WritableMemory.writableWrap(new byte[bytes]);
     csk = sk1.compact(true, wmem);
     assertTrue(csk.isOrdered());
     csk = sk1.compact(false, wmem);
@@ -229,7 +229,7 @@
 
     //Intersection off-heap
     bytes = Sketches.getMaxIntersectionBytes(32);
-    WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
     inter = Sketches.setOperationBuilder().buildIntersection(wmem);
     inter.intersect(sk1);
     inter.intersect(sk2);
@@ -257,7 +257,7 @@
 
     //Union off-heap
     bytes = Sketches.getMaxUnionBytes(32);
-    WritableMemory wmem = WritableMemory.wrap(new byte[bytes]);
+    WritableMemory wmem = WritableMemory.writableWrap(new byte[bytes]);
     union = Sketches.setOperationBuilder().buildUnion(wmem);
     union.update(sk1);
     union.update(sk2);
@@ -292,7 +292,7 @@
     Intersection inter = Sketches.setOperationBuilder().buildIntersection();
     inter.intersect(sk1);
     inter.intersect(sk2);
-    WritableMemory wmem = WritableMemory.wrap(new byte[16]);
+    WritableMemory wmem = WritableMemory.writableWrap(new byte[16]);
     CompactSketch csk = inter.getResult(false, wmem);
     assertTrue(csk.isOrdered());
     Sketch csk2 = Sketches.heapifySketch(wmem);
diff --git a/src/test/java/org/apache/datasketches/theta/SketchTest.java b/src/test/java/org/apache/datasketches/theta/SketchTest.java
index 18c7ed7..9317767 100644
--- a/src/test/java/org/apache/datasketches/theta/SketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SketchTest.java
@@ -200,7 +200,7 @@
     Memory mem = Memory.wrap(sketchArray);
     int serVer = Sketch.getSerializationVersion(mem);
     assertEquals(serVer, 3);
-    WritableMemory wmem = WritableMemory.wrap(sketchArray);
+    WritableMemory wmem = WritableMemory.writableWrap(sketchArray);
     UpdateSketch sk2 = UpdateSketch.wrap(wmem);
     serVer = sk2.getSerializationVersion(wmem);
     assertEquals(serVer, 3);
@@ -211,7 +211,7 @@
     int k = 512;
     Sketch sketch1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
     byte[] byteArray = sketch1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
     Sketch.heapify(mem);
@@ -222,7 +222,7 @@
     int k = 512;
     Sketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
     byte[] byteArray = sketch1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
     Sketch.heapify(mem);
@@ -234,7 +234,7 @@
     UpdateSketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
     int bytes = Sketch.getMaxCompactSketchBytes(0);
     byte[] byteArray = new byte[bytes];
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     sketch1.compact(false, mem);
     //corrupt:
     mem.clearBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
@@ -256,7 +256,7 @@
     int k = 512;
     Sketch sketch1 = UpdateSketch.builder().setFamily(ALPHA).setNominalEntries(k).build();
     byte[] byteArray = sketch1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
     Sketch.wrap(mem);
@@ -268,7 +268,7 @@
     int k = 512;
     Sketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
     byte[] byteArray = sketch1.toByteArray();
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     //corrupt:
     mem.setBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
     Sketch.wrap(mem);
@@ -280,7 +280,7 @@
     UpdateSketch sketch1 = UpdateSketch.builder().setFamily(QUICKSELECT).setNominalEntries(k).build();
     int bytes = Sketch.getMaxCompactSketchBytes(0);
     byte[] byteArray = new byte[bytes];
-    WritableMemory mem = WritableMemory.wrap(byteArray);
+    WritableMemory mem = WritableMemory.writableWrap(byteArray);
     sketch1.compact(false, mem);
     //corrupt:
     mem.clearBits(FLAGS_BYTE, (byte) COMPACT_FLAG_MASK);
@@ -322,8 +322,8 @@
   @Test
   public void checkIsSameResource() {
     int k = 16;
-    WritableMemory mem = WritableMemory.wrap(new byte[(k*16) + 24]);
-    WritableMemory cmem = WritableMemory.wrap(new byte[32]);
+    WritableMemory mem = WritableMemory.writableWrap(new byte[(k*16) + 24]);
+    WritableMemory cmem = WritableMemory.writableWrap(new byte[32]);
     UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(mem);
     sketch.update(1);
     sketch.update(2);
diff --git a/src/test/java/org/apache/datasketches/theta/SketchesTest.java b/src/test/java/org/apache/datasketches/theta/SketchesTest.java
index 6a92ec0..a498459 100644
--- a/src/test/java/org/apache/datasketches/theta/SketchesTest.java
+++ b/src/test/java/org/apache/datasketches/theta/SketchesTest.java
@@ -107,7 +107,7 @@
     assertEquals((int)cSk.getEstimate(), 3*k/2);
 
     final byte[] ubytes = union.toByteArray();
-    final WritableMemory uMem = WritableMemory.wrap(ubytes);
+    final WritableMemory uMem = WritableMemory.writableWrap(ubytes);
 
     Union union2 = (Union)heapifySetOperation(uMem);
     cSk = union2.getResult(true, null);
diff --git a/src/test/java/org/apache/datasketches/theta/UnionImplTest.java b/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
index 8c87d8e..b4121fc 100644
--- a/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
+++ b/src/test/java/org/apache/datasketches/theta/UnionImplTest.java
@@ -29,7 +29,7 @@
 import org.apache.datasketches.SketchesArgumentException;
 import org.apache.datasketches.Util;
 import org.apache.datasketches.memory.Memory;
-import org.apache.datasketches.memory.WritableDirectHandle;
+import org.apache.datasketches.memory.WritableHandle;
 import org.apache.datasketches.memory.WritableMemory;
 import org.testng.annotations.Test;
 
@@ -39,8 +39,8 @@
   @Test
   public void checkUpdateWithSketch() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
-    final WritableMemory mem2 = WritableMemory.wrap(new byte[k*8 + 24]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
+    final WritableMemory mem2 = WritableMemory.writableWrap(new byte[k*8 + 24]);
     final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
     for (int i=0; i<k; i++) { sketch.update(i); }
     final CompactSketch sketchInDirectOrd = sketch.compact(true, mem);
@@ -57,7 +57,7 @@
   @Test
   public void checkUnorderedAndOrderedMemory() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
     final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
     for (int i = 0; i < k; i++) { sketch.update(i); }
     final CompactSketch sketchInDirectOrd = sketch.compact(false, mem);
@@ -76,9 +76,9 @@
   @Test
   public void checkUpdateWithMem() {
     final int k = 16;
-    final WritableMemory skMem = WritableMemory.wrap(new byte[2*k*8 + 24]);
-    final WritableMemory dirOrdCskMem = WritableMemory.wrap(new byte[k*8 + 24]);
-    final WritableMemory dirUnordCskMem = WritableMemory.wrap(new byte[k*8 + 24]);
+    final WritableMemory skMem = WritableMemory.writableWrap(new byte[2*k*8 + 24]);
+    final WritableMemory dirOrdCskMem = WritableMemory.writableWrap(new byte[k*8 + 24]);
+    final WritableMemory dirUnordCskMem = WritableMemory.writableWrap(new byte[k*8 + 24]);
     final UpdateSketch udSketch = UpdateSketch.builder().setNominalEntries(k).build(skMem);
     for (int i = 0; i < k; i++) { udSketch.update(i); } //exact
     udSketch.compact(true, dirOrdCskMem);
@@ -96,7 +96,7 @@
     final int k = 16;
     final long seed = DEFAULT_UPDATE_SEED;
     final int unionSize = Sketches.getMaxUnionBytes(k);
-    final WritableMemory srcMem = WritableMemory.wrap(new byte[unionSize]);
+    final WritableMemory srcMem = WritableMemory.writableWrap(new byte[unionSize]);
     final Union union = Sketches.setOperationBuilder().setNominalEntries(k).buildUnion(srcMem);
     for (int i = 0; i < k; i++) { union.update(i); } //exact
     assertEquals(union.getResult().getEstimate(), k, 0.0);
@@ -110,7 +110,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void checkCorruptFamilyException() {
     final int k = 16;
-    final WritableMemory mem = WritableMemory.wrap(new byte[k*8 + 24]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[k*8 + 24]);
     final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build();
     for (int i=0; i<k; i++) {
       sketch.update(i);
@@ -169,13 +169,13 @@
     final int k = 1 << 12;
     final int u = 2 * k;
     final int bytes = Sketches.getMaxUpdateSketchBytes(k);
-    try (WritableDirectHandle wdh = WritableMemory.allocateDirect(bytes/2);
-         WritableDirectHandle wdh2 = WritableMemory.allocateDirect(bytes/2) ) {
-      final WritableMemory wmem = wdh.get();
+    try (WritableHandle wh = WritableMemory.allocateDirect(bytes/2);
+        WritableHandle wh2 = WritableMemory.allocateDirect(bytes/2) ) {
+      final WritableMemory wmem = wh.getWritable();
       final UpdateSketch sketch = Sketches.updateSketchBuilder().setNominalEntries(k).build(wmem);
       assertTrue(sketch.isSameResource(wmem));
 
-      final WritableMemory wmem2 = wdh2.get();
+      final WritableMemory wmem2 = wh2.getWritable();
       final Union union = SetOperation.builder().buildUnion(wmem2);
       assertTrue(union.isSameResource(wmem2));
 
@@ -184,6 +184,8 @@
 
       final Union union2 = SetOperation.builder().buildUnion(); //on-heap union
       assertFalse(union2.isSameResource(wmem2));  //obviously not
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
@@ -205,13 +207,15 @@
     final double est1 = sk.getEstimate();
 
     final int bytes = Sketches.getMaxCompactSketchBytes(sk.getRetainedEntries(true));
-    try (WritableDirectHandle h = WritableMemory.allocateDirect(bytes)) {
-      final WritableMemory wmem = h.get();
+    try (WritableHandle h = WritableMemory.allocateDirect(bytes)) {
+      final WritableMemory wmem = h.getWritable();
       final CompactSketch csk = sk.compact(true, wmem); //ordered, direct
       final Union union = Sketches.setOperationBuilder().buildUnion();
       union.union(csk);
       final double est2 = union.getResult().getEstimate();
       assertEquals(est2, est1);
+    } catch (final Exception e) {
+      throw new RuntimeException(e);
     }
   }
 
diff --git a/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java b/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
index 8ee0f2a..115b9ee 100644
--- a/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
+++ b/src/test/java/org/apache/datasketches/theta/UpdateSketchTest.java
@@ -158,7 +158,7 @@
   public void checkIncompatibleFamily() {
     UpdateSketch sk = Sketches.updateSketchBuilder().build();
     sk.update(1);
-    WritableMemory wmem = WritableMemory.wrap(sk.compact().toByteArray());
+    WritableMemory wmem = WritableMemory.writableWrap(sk.compact().toByteArray());
     UpdateSketch.wrap(wmem, DEFAULT_UPDATE_SEED);
   }
 
@@ -166,7 +166,7 @@
   public void checkCorruption() {
     UpdateSketch sk = Sketches.updateSketchBuilder().build();
     sk.update(1);
-    WritableMemory wmem = WritableMemory.wrap(sk.toByteArray());
+    WritableMemory wmem = WritableMemory.writableWrap(sk.toByteArray());
     try {
       wmem.putByte(SER_VER_BYTE, (byte) 2);
       UpdateSketch.wrap(wmem, DEFAULT_UPDATE_SEED);
@@ -212,7 +212,7 @@
     for (int i = 2; i < n; i++) { sk.update(i); }
     int cbytes = sk.getCompactBytes();
     byte[] byteArr = sk.toByteArray();
-    skwmem = WritableMemory.wrap(byteArr);
+    skwmem = WritableMemory.writableWrap(byteArr);
     cskwmem1 = WritableMemory.allocate(cbytes);
     cskwmem2 = WritableMemory.allocate(cbytes);
     cskwmem3 = WritableMemory.allocate(cbytes);
diff --git a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleTest.java b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleTest.java
index fb1d075..8f29284 100644
--- a/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/adouble/AdoubleTest.java
@@ -398,11 +398,11 @@
     final UpdatableSketchBuilder<Double, DoubleSummary> bldr = new UpdatableSketchBuilder<>(dsumFact);
     final UpdatableSketch<Double, DoubleSummary> usk = bldr.build();
     final byte[] byteArr = new byte[0];
-    usk.update(byteArr, new Double(0));
+    usk.update(byteArr, 0.0);
     final int[] intArr = new int[0];
-    usk.update(intArr, new Double(1));
+    usk.update(intArr, 1.0);
     final long[] longArr = new long[0];
-    usk.update(longArr, new Double(2));
+    usk.update(longArr, 2.0);
   }
 
   @Test(expectedExceptions = SketchesArgumentException.class)
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
index a0d2a4f..6d993ad 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesAnotBTest.java
@@ -243,7 +243,7 @@
 
     // same operation, but compact sketches and off-heap result
     aNotB.update(sketchA.compact(), sketchB.compact());
-    result = aNotB.getResult(WritableMemory.wrap(new byte[1000000]));
+    result = aNotB.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertFalse(result.isEmpty());
     Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
     Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
@@ -283,7 +283,7 @@
 
     // same operation, but compact sketches and off-heap result
     aNotB.update(sketchA.compact(), sketchB.compact());
-    result = aNotB.getResult(WritableMemory.wrap(new byte[1000000]));
+    result = aNotB.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertFalse(result.isEmpty());
     Assert.assertEquals(result.getEstimate(), expected, expected * 0.1); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
     Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
index b7287e0..a2e1c56 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesCompactSketchTest.java
@@ -56,7 +56,8 @@
 
   @Test
   public void directToHeapExactTwoDoubles() {
-    ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch sketch1 = 
+        new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build(WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update("a", new double[] {1, 2});
     sketch1.update("b", new double[] {1, 2});
     sketch1.update("c", new double[] {1, 2});
@@ -65,7 +66,8 @@
     sketch1.update("b", new double[] {1, 2});
     sketch1.update("c", new double[] {1, 2});
     sketch1.update("d", new double[] {1, 2});
-    ArrayOfDoublesSketch sketch2 = new HeapArrayOfDoublesCompactSketch(Memory.wrap(sketch1.compact(WritableMemory.wrap(new byte[1000000])).toByteArray()));
+    ArrayOfDoublesSketch sketch2 = 
+        new HeapArrayOfDoublesCompactSketch(Memory.wrap(sketch1.compact(WritableMemory.writableWrap(new byte[1000000])).toByteArray()));
     Assert.assertFalse(sketch2.isEmpty());
     Assert.assertFalse(sketch2.isEstimationMode());
     Assert.assertEquals(sketch2.getEstimate(), 4.0);
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
index 802ee7d..be48409 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesIntersectionTest.java
@@ -103,19 +103,19 @@
   @Test
   public void directExactWithEmpty() {
     final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder()
-        .build(WritableMemory.wrap(new byte[1000000]));
+        .build(WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update(1, new double[] {1});
     sketch1.update(2, new double[] {1});
     sketch1.update(3, new double[] {1});
 
     final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder()
-        .build(WritableMemory.wrap(new byte[1000000]));
+        .build(WritableMemory.writableWrap(new byte[1000000]));
 
     final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
-        buildIntersection(WritableMemory.wrap(new byte[1000000]));
+        buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
     intersection.intersect(sketch1, null);
     intersection.intersect(sketch2, null);
-    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(result.isEmpty());
     Assert.assertEquals(result.getRetainedEntries(), 0);
     Assert.assertEquals(result.getEstimate(), 0.0);
@@ -190,22 +190,22 @@
   public void directDisjointEstimationMode() {
     int key = 0;
     final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch1.update(key++, new double[] {1.0});
     }
 
     final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch2.update(key++, new double[] {1.0});
     }
 
     final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().
-        buildIntersection(WritableMemory.wrap(new byte[1000000]));
+        buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
     intersection.intersect(sketch1, combiner);
     intersection.intersect(sketch2, combiner);
-    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(result.isEmpty());
     Assert.assertEquals(result.getRetainedEntries(), 0);
     Assert.assertEquals(result.getEstimate(), 0.0);
@@ -245,21 +245,21 @@
   @Test
   public void directEstimationMode() {
     int key = 0;
-    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch1.update(key++, new double[] {1.0});
     }
 
     key -= 4096; // overlap half of the entries
-    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch2.update(key++, new double[] {1.0});
     }
 
-    final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesIntersection intersection = new ArrayOfDoublesSetOperationBuilder().buildIntersection(WritableMemory.writableWrap(new byte[1000000]));
     intersection.intersect(sketch1, combiner);
     intersection.intersect(sketch2, combiner);
-    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesCompactSketch result = intersection.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertFalse(result.isEmpty());
     Assert.assertEquals(result.getEstimate(), 4096.0, 4096 * 0.03); // crude estimate of RSE(95%) = 2 / sqrt(result.getRetainedEntries())
     Assert.assertTrue(result.getLowerBound(1) <= result.getEstimate());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
index 84c4d33..d02687b 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketchTest.java
@@ -44,7 +44,7 @@
     sketch1.update("d", valuesArr);
     sketch1.update("a", valuesArr);
     noopUpdates(sketch1, valuesArr);
-    ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+    ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
     sketch2.update("b", valuesArr);
     sketch2.update("c", valuesArr);
     sketch2.update("d", valuesArr);
@@ -75,7 +75,7 @@
     sketch1.update("b", values);
     sketch1.update("c", values);
 
-    ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()), seed);
+    ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()), seed);
     sketch2.update("b", values);
     sketch2.update("c", values);
     sketch2.update("d", values);
@@ -95,7 +95,7 @@
     double[] valuesArr = {1.0, 2.0};
     ArrayOfDoublesUpdatableSketch sketch1 =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        setNumberOfValues(2).build(WritableMemory.wrap(new byte[1000000]));
+        setNumberOfValues(2).build(WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update("a", valuesArr);
     sketch1.update("b", valuesArr);
     sketch1.update("c", valuesArr);
@@ -129,7 +129,7 @@
 
     ArrayOfDoublesUpdatableSketch sketch1 =
         new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build(
-            WritableMemory.wrap(new byte[1000000]));
+            WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update("a", values);
     sketch1.update("b", values);
     sketch1.update("c", values);
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
index 29a2096..0da4c0f 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesUnionTest.java
@@ -61,7 +61,7 @@
     Assert.assertEquals(values[1][0], 3.0);
     Assert.assertEquals(values[2][0], 3.0);
 
-    final WritableMemory wmem = WritableMemory.wrap(union.toByteArray());
+    final WritableMemory wmem = WritableMemory.writableWrap(union.toByteArray());
     final ArrayOfDoublesUnion wrappedUnion = ArrayOfDoublesSketches.wrapUnion(wmem);
     result = wrappedUnion.getResult();
     Assert.assertEquals(result.getEstimate(), 3.0);
@@ -211,7 +211,7 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void noSupportWrapV0_9_1() throws Exception {
     final byte[] bytes = getResourceBytes("ArrayOfDoublesUnion_v0.9.1.sk");
-    ArrayOfDoublesUnion.wrap(WritableMemory.wrap(bytes));
+    ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(bytes));
   }
 
   @Test
@@ -242,25 +242,25 @@
   public void directSerializeDeserialize() {
     int key = 0;
     final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(
-        WritableMemory.wrap(new byte[1000000]));
+        WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch1.update(key++, new double[] {1.0});
     }
 
     key -= 4096; // overlap half of the entries
     final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(
-        WritableMemory.wrap(new byte[1000000]));
+        WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch2.update(key++, new double[] {1.0});
     }
 
     final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion(
-        WritableMemory.wrap(new byte[1000000]));
+        WritableMemory.writableWrap(new byte[1000000]));
     union1.union(sketch1);
     union1.union(sketch2);
 
-    final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()));
-    ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(union1.toByteArray()));
+    ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
 
     union2.reset();
@@ -282,47 +282,47 @@
     final long seed = 1;
     int key = 0;
     final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
-        .build(WritableMemory.wrap(new byte[1000000]));
+        .build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch1.update(key++, new double[] {1.0});
     }
 
     key -= 4096; // overlap half of the entries
     final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
-        .build(WritableMemory.wrap(new byte[1000000]));
+        .build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch2.update(key++, new double[] {1.0});
     }
 
     final ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed)
-        .buildUnion(WritableMemory.wrap(new byte[1000000]));
+        .buildUnion(WritableMemory.writableWrap(new byte[1000000]));
     union1.union(sketch1);
     union1.union(sketch2);
 
-    final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()), seed);
-    final ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(union1.toByteArray()), seed);
+    final ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
   }
 
   @Test
   public void directExactMode() {
-    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update(1, new double[] {1.0});
     sketch1.update(1, new double[] {1.0});
     sketch1.update(1, new double[] {1.0});
     sketch1.update(2, new double[] {1.0});
 
-    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     sketch2.update(2, new double[] {1.0});
     sketch2.update(2, new double[] {1.0});
     sketch2.update(3, new double[] {1.0});
     sketch2.update(3, new double[] {1.0});
     sketch2.update(3, new double[] {1.0});
 
-    final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
     union.union(sketch1);
     union.union(sketch2);
-    ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 3.0);
     final double[][] values = result.getValues();
     Assert.assertEquals(values[0][0], 3.0);
@@ -342,21 +342,21 @@
   @Test
   public void directEstimationMode() {
     int key = 0;
-    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch1.update(key++, new double[] {1.0});
     }
 
     key -= 4096; // overlap half of the entries
-    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       sketch2.update(key++, new double[] {1.0});
     }
 
-    final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
     union.union(sketch1);
     union.union(sketch2);
-    ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
 
     union.reset();
@@ -387,10 +387,10 @@
     final ArrayOfDoublesUnion heapUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion();
     heapUnion.union(sketch1);
 
-    final ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(heapUnion.toByteArray()));
+    final ArrayOfDoublesUnion directUnion = ArrayOfDoublesUnion.wrap(WritableMemory.writableWrap(heapUnion.toByteArray()));
     directUnion.union(sketch2);
 
-    final ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesCompactSketch result = directUnion.getResult(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertFalse(result.isEmpty());
     Assert.assertEquals(result.getEstimate(), 3.0);
     final double[][] values = result.getValues();
@@ -415,7 +415,7 @@
     sketch2.update(3, new double[] {1.0});
     sketch2.update(3, new double[] {1.0});
 
-    final ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
+    final ArrayOfDoublesUnion directUnion = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.writableWrap(new byte[1000000]));
     directUnion.union(sketch1);
 
     final ArrayOfDoublesUnion heapUnion = ArrayOfDoublesUnion.heapify(Memory.wrap(directUnion.toByteArray()));
@@ -454,7 +454,7 @@
 
   @Test
   public void directDruidUsageOneSketch() {
-    final WritableMemory mem = WritableMemory.wrap(new byte[1000000]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[1000000]);
     new ArrayOfDoublesSetOperationBuilder().buildUnion(mem); // just set up memory to wrap later
 
     final int n = 100000; // estimation mode
@@ -465,7 +465,7 @@
     sketch.trim(); // pretend this is a result from a union
 
     // as Druid wraps memory
-    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.wrap(new byte[1000000])));
+    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch.compact(WritableMemory.writableWrap(new byte[1000000])));
 
     final ArrayOfDoublesSketch result = ArrayOfDoublesUnion.wrap(mem).getResult();
     Assert.assertEquals(result.getEstimate(), sketch.getEstimate());
@@ -474,7 +474,7 @@
 
   @Test
   public void directDruidUsageTwoSketches() {
-    final WritableMemory mem = WritableMemory.wrap(new byte[1000000]);
+    final WritableMemory mem = WritableMemory.writableWrap(new byte[1000000]);
     new ArrayOfDoublesSetOperationBuilder().buildUnion(mem); // just set up memory to wrap later
 
     int key = 0;
@@ -485,7 +485,7 @@
       sketch1.update(key++, new double[] {1.0});
     }
     // as Druid wraps memory
-    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch1.compact(WritableMemory.wrap(new byte[1000000])));
+    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch1.compact(WritableMemory.writableWrap(new byte[1000000])));
 
     final int n2 = 1000000; // estimation mode
     final ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
@@ -493,7 +493,7 @@
       sketch2.update(key++, new double[] {1.0});
     }
     // as Druid wraps memory
-    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch2.compact(WritableMemory.wrap(new byte[1000000])));
+    ArrayOfDoublesSketches.wrapUnion(mem).union(sketch2.compact(WritableMemory.writableWrap(new byte[1000000])));
 
     // build one sketch that must be the same as union
     key = 0; // reset to have the same keys
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
index dfedb38..5c7a8ab 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesCompactSketchTest.java
@@ -33,8 +33,8 @@
   @Test
   public void emptyFromQuickSelectSketch() {
     ArrayOfDoublesUpdatableSketch us =
-        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
-    ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.wrap(new byte[1000000]));
+        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
+    ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(sketch.isEmpty());
     Assert.assertFalse(sketch.isEstimationMode());
     Assert.assertEquals(sketch.getEstimate(), 0.0);
@@ -54,14 +54,14 @@
   @Test
   public void exactModeFromQuickSelectSketch() {
     ArrayOfDoublesUpdatableSketch us =
-        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     us.update(1, new double[] {1.0});
     us.update(2, new double[] {1.0});
     us.update(3, new double[] {1.0});
     us.update(1, new double[] {1.0});
     us.update(2, new double[] {1.0});
     us.update(3, new double[] {1.0});
-    ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertFalse(sketch.isEmpty());
     Assert.assertFalse(sketch.isEstimationMode());
     Assert.assertEquals(sketch.getEstimate(), 3.0);
@@ -80,12 +80,12 @@
 
   @Test
   public void serializeDeserializeSmallExact() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     us.update("a", new double[] {1.0});
     us.update("b", new double[] {1.0});
     us.update("c", new double[] {1.0});
-    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
-    ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()));
+    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+    ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()));
     Assert.assertFalse(sketch2.isEmpty());
     Assert.assertFalse(sketch2.isEstimationMode());
     Assert.assertEquals(sketch2.getEstimate(), 3.0);
@@ -103,12 +103,12 @@
 
   @Test
   public void serializeDeserializeEstimation() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       us.update(i, new double[] {1.0});
     }
-    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
-    ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()));
+    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+    ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()));
     Assert.assertFalse(sketch2.isEmpty());
     Assert.assertTrue(sketch2.isEstimationMode());
     Assert.assertEquals(sketch2.getEstimate(), sketch1.getEstimate());
@@ -117,19 +117,19 @@
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void deserializeWithWrongSeed() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < 8192; i++) {
       us.update(i, new double[] {1.0});
     }
-    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
-    ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()), 123);
+    ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.writableWrap(new byte[1000000]));
+    ArrayOfDoublesSketches.wrapSketch(WritableMemory.writableWrap(sketch1.toByteArray()), 123);
   }
 
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void fromQuickSelectSketchNotEnoughMemory() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.writableWrap(new byte[1000000]));
     us.update(1, new double[] {1.0});
-    us.compact(WritableMemory.wrap(new byte[39]));
+    us.compact(WritableMemory.writableWrap(new byte[39]));
   }
 
 }
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
index 1846cc7..c77664c 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/DirectArrayOfDoublesQuickSelectSketchTest.java
@@ -31,7 +31,7 @@
   public void isEmpty() {
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(sketch.isEmpty());
     Assert.assertFalse(sketch.isEstimationMode());
     Assert.assertEquals(sketch.getEstimate(), 0.0);
@@ -51,7 +51,7 @@
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
         setSamplingProbability(samplingProbability).
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(sketch.isEmpty());
     Assert.assertTrue(((DirectArrayOfDoublesQuickSelectSketch)sketch).isInSamplingMode());
     Assert.assertFalse(sketch.isEstimationMode());
@@ -72,7 +72,7 @@
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
         setSamplingProbability(samplingProbability).
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     sketch.update("a", new double[] {1.0});
     Assert.assertFalse(sketch.isEmpty());
     Assert.assertTrue(sketch.isEstimationMode());
@@ -88,7 +88,7 @@
   public void exactMode() {
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     Assert.assertTrue(sketch.isEmpty());
     Assert.assertEquals(sketch.getEstimate(), 0.0);
     for (int i = 0; i < 4096; i++) {
@@ -136,7 +136,7 @@
   public void estimationMode() {
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[4096 * 2 * 16 + 32]));
+        build(WritableMemory.writableWrap(new byte[4096 * 2 * 16 + 32]));
     Assert.assertEquals(sketch.getEstimate(), 0.0);
     for (int i = 1; i <= 8192; i++) {
       sketch.update(i, new double[] {1.0});
@@ -177,7 +177,7 @@
   public void updatesOfAllKeyTypes() {
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     sketch.update(1L, new double[] {1.0});
     sketch.update(2.0, new double[] {1.0});
     sketch.update(new byte[] {3}, new double[] {1.0});
@@ -191,7 +191,7 @@
   public void doubleSum() {
     final ArrayOfDoublesUpdatableSketch sketch =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     sketch.update(1, new double[] {1.0});
     Assert.assertEquals(sketch.getRetainedEntries(), 1);
     Assert.assertEquals(sketch.getValues()[0][0], 1.0);
@@ -207,10 +207,10 @@
   public void serializeDeserializeExact() throws Exception {
     final ArrayOfDoublesUpdatableSketch sketch1 =
         new ArrayOfDoublesUpdatableSketchBuilder().
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     sketch1.update(1, new double[] {1.0});
 
-    final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+    final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
 
     Assert.assertEquals(sketch2.getEstimate(), 1.0);
     final double[][] values = sketch2.getValues();
@@ -229,7 +229,7 @@
   public void serializeDeserializeEstimationNoResize() throws Exception {
     final ArrayOfDoublesUpdatableSketch sketch1 =
         new ArrayOfDoublesUpdatableSketchBuilder().setResizeFactor(ResizeFactor.X1).
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     for (int j = 0; j < 10; j++) {
       for (int i = 0; i < 8192; i++) {
         sketch1.update(i, new double[] {1.0});
@@ -240,7 +240,7 @@
     //for visual testing
     //TestUtil.writeBytesToFile(byteArray, "ArrayOfDoublesQuickSelectSketch4K.data");
 
-    final ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketch.wrap(WritableMemory.wrap(byteArray));
+    final ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketch.wrap(WritableMemory.writableWrap(byteArray));
     Assert.assertTrue(sketch2.isEstimationMode());
     Assert.assertEquals(sketch2.getEstimate(), 8192, 8192 * 0.99);
     Assert.assertEquals(sketch1.getTheta(), sketch2.getTheta());
@@ -258,12 +258,12 @@
     final ArrayOfDoublesUpdatableSketch sketch1 =
         new ArrayOfDoublesUpdatableSketchBuilder().
         setNominalEntries(sketchSize).setSamplingProbability(0.5f).
-        build(WritableMemory.wrap(new byte[1000000]));
+        build(WritableMemory.writableWrap(new byte[1000000]));
     for (int i = 0; i < numberOfUniques; i++) {
       sketch1.update(i, new double[] {1.0});
     }
     final ArrayOfDoublesSketch sketch2 =
-        ArrayOfDoublesSketch.wrap(WritableMemory.wrap(sketch1.toByteArray()));
+        ArrayOfDoublesSketch.wrap(WritableMemory.writableWrap(sketch1.toByteArray()));
     Assert.assertTrue(sketch2.isEstimationMode());
     Assert.assertEquals(sketch2.getEstimate() / numberOfUniques, 1.0, 0.01);
     Assert.assertEquals(sketch2.getRetainedEntries() / (double) numberOfUniques, 0.5, 0.01);
@@ -273,6 +273,6 @@
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void notEnoughMemory() {
     new ArrayOfDoublesUpdatableSketchBuilder().
-    setNominalEntries(32).build(WritableMemory.wrap(new byte[1055]));
+    setNominalEntries(32).build(WritableMemory.writableWrap(new byte[1055]));
   }
 }
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
index d37d5a7..0da7101 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesCompactSketchTest.java
@@ -102,7 +102,7 @@
     for (int i = 0; i < 8192; i++) {
       us.update(i, new double[] {1.0});
     }
-    WritableMemory wmem = WritableMemory.wrap(us.toByteArray());
+    WritableMemory wmem = WritableMemory.writableWrap(us.toByteArray());
     ArrayOfDoublesUpdatableSketch wrappedUS = ArrayOfDoublesSketches.wrapUpdatableSketch(wmem);
     Assert.assertFalse(wrappedUS.isEmpty());
     Assert.assertTrue(wrappedUS.isEstimationMode());
diff --git a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
index 0e691e3..e27cda2 100644
--- a/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketchTest.java
@@ -187,7 +187,7 @@
     final ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
     sketch1.update(1, new double[] {1.0});
 
-    final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.heapify(WritableMemory.wrap(sketch1.toByteArray()));
+    final ArrayOfDoublesUpdatableSketch sketch2 = ArrayOfDoublesUpdatableSketch.heapify(WritableMemory.writableWrap(sketch1.toByteArray()));
 
     Assert.assertEquals(sketch2.getEstimate(), 1.0);
     final double[][] values = sketch2.getValues();
diff --git a/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java b/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
index 43b4034..00e2bd4 100644
--- a/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/tuple/strings/ArrayOfStringsSketchTest.java
@@ -49,7 +49,7 @@
     sketch1.update(strArrArr[0], strArrArr[0]); //insert duplicate
     //printSummaries(sketch1.iterator());
     byte[] array = sketch1.toByteArray();
-    WritableMemory wmem = WritableMemory.wrap(array);
+    WritableMemory wmem = WritableMemory.writableWrap(array);
     ArrayOfStringsSketch sketch2 = new ArrayOfStringsSketch(wmem);
     //printSummaries(sketch2.iterator());
     checkSummaries(sketch2, sketch2);
diff --git a/tools/SketchesCheckstyle.xml b/tools/SketchesCheckstyle.xml
index 5a4c83a..5fe40e5 100644
--- a/tools/SketchesCheckstyle.xml
+++ b/tools/SketchesCheckstyle.xml
@@ -23,17 +23,16 @@
 -->
 
 <!--
-  SketchesCheckstyle.xml
+  DataSketcchesCheckstyle.xml
 
   Checkstyle is very configurable. Be sure to read the documentation at
   http://checkstyle.sourceforge.net (or in your downloaded distribution).
 
-  To completely disable a check, just comment it out or delete it from the file.
-
-  Authors: Max Vetrenko, Ruslan Diachenko, Roman Ivanov.
+  To completely disable a check, comment it out, delete it, or set
+  property name="severity" value="ignore".
 -->
 
-<module name = "Checker">
+<module name="Checker">
   <property name="charset" value="UTF-8"/>
   <property name="severity" value="warning"/>
   <property name="fileExtensions" value="java"/>
@@ -55,7 +54,7 @@
   <!-- Size Violations -->
   <module name="LineLength">
     <property name="severity" value="warning"/>
-    <property name="max" value="110"/>
+    <property name="max" value="120"/>
     <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
     <!-- <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/> -->
   </module>
@@ -94,7 +93,7 @@
       <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/>
     </module>
     
-    <module name="LeftCurly"> 
+    <module name="LeftCurly">
       <!-- doesn't allow for if (n == 0) { return 0.0; }, which is readable and not corruptable -->
       <property name="severity" value="ignore"/>
       <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/>
@@ -184,7 +183,6 @@
     
     <module name="UnusedImports"/>
     
-
     <!-- Filters -->
     <!-- Enable suppression using comments: //CHECKSTYLE.OFF: "RULE" and //CHECKSTYLE.ON: "RULE"
      You must specify the specific rule, as in: //CHECKSTYLE.OFF: LineLength -->
@@ -203,15 +201,13 @@
     
     <module name="JavadocMethod">
       <property name="scope" value="public"/>
-      <property name="allowMissingParamTags" value="false"/>
-      <!-- <property name="allowMissingThrowsTags" value="true"/> now not allowed ?!? -->
-      <property name="allowMissingReturnTag" value="false"/>
+      <property name="allowMissingParamTags" value="false"/> <!-- default -->
+      <property name="allowMissingReturnTag" value="false"/> <!-- default -->
       <property name="allowedAnnotations" value="Override, Test"/>
-      <!-- <property name="allowThrowsTagsForSubclasses" value="true"/> now not allowed ?!? -->
     </module>
     
     <module name="JavadocParagraph"/>
-
+    
     <module name="JavadocTagContinuationIndentation">
       <property name="severity" value="ignore"/>
       <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/>
@@ -241,7 +237,7 @@
       <property name="allowByTailComment" value="true"/>
       <property name="allowNonPrintableEscapes" value="true"/>
       <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/>
-    </module>    
+    </module>
     
     <module name="CommentsIndentation">
       <property name="severity" value="warning"/>
@@ -251,7 +247,7 @@
     <module name="Indentation">
       <property name="severity" value="ignore"/>
       <property name="basicOffset" value="2"/>
-      <property name="braceAdjustment" value="0"/>
+      <property name="braceAdjustment" value="0"/> <!-- default -->
       <property name="caseIndent" value="2"/>
       <property name="throwsIndent" value="4"/>
       <property name="lineWrappingIndentation" value="4"/>
@@ -277,7 +273,7 @@
     <module name="ModifierOrder">
       <property name="severity" value="ignore"/>
       <metadata name="net.sf.eclipsecs.core.lastEnabledSeverity" value="inherit"/>
-    </module>    
+    </module>
     
     <!-- Naming Conventions -->
     <module name="AbbreviationAsWordInName">
@@ -344,7 +340,7 @@
           value="Type name ''{0}'' must match pattern ''{1}''."/>
     </module>
 
-    <!-- Regexp -->    
+    <!-- Regexp -->
     <module name="Regexp">
       <property name="severity" value="ignore"/>
       <property name="format" value="[ \t]+$"/>
@@ -398,4 +394,5 @@
     </module>
 
   </module> <!-- End of TreeWalker -->
+
 </module>