diff --git a/include/avian/util/assert.h b/include/avian/util/assert.h
new file mode 100644
index 0000000000..ab6cee63ed
--- /dev/null
+++ b/include/avian/util/assert.h
@@ -0,0 +1,32 @@
+/* Copyright (c) 2008-2013, Avian Contributors
+
+   Permission to use, copy, modify, and/or distribute this software
+   for any purpose with or without fee is hereby granted, provided
+   that the above copyright notice and this permission notice appear
+   in all copies.
+
+   There is NO WARRANTY for this software.  See license.txt for
+   details. */
+
+#ifndef AVIAN_UTIL_ASSERT_H
+#define AVIAN_UTIL_ASSERT_H
+
+#include <stdlib.h>
+
+namespace avian {
+namespace util {
+
+#define UNREACHABLE_ ::abort()
+
+// TODO: print msg in debug mode
+#define UNREACHABLE(msg) ::abort()
+
+#define ASSERT(that)    \
+  if (!(that)) {        \
+    UNREACHABLE(#that); \
+  }
+
+}  // namespace util
+}  // namespace avian
+
+#endif  // AVIAN_UTIL_ASSERT_H
diff --git a/include/avian/util/slice.h b/include/avian/util/slice.h
index b4936e0a06..51b1ad918e 100644
--- a/include/avian/util/slice.h
+++ b/include/avian/util/slice.h
@@ -13,6 +13,7 @@
 
 #include "allocator.h"
 #include "math.h"
+#include "assert.h"
 
 namespace avian {
 namespace util {
@@ -33,6 +34,7 @@ class Slice {
 
   inline T& operator[](size_t index)
   {
+    ASSERT(index < count);
     return items[index];
   }
 
@@ -51,20 +53,36 @@ class Slice {
     return Slice<T>((T*)a->allocate(sizeof(T) * count), count);
   }
 
-  Slice<T> clone(Allocator* a)
+  static Slice<T> allocAndSet(Allocator* a, size_t count, const T& item)
   {
-    Slice<T> ret((T*)a->allocate(count * sizeof(T)), count);
-    memcpy(ret.items, items, count * sizeof(T));
-    return ret;
+    Slice<T> slice(alloc(a, count));
+    for (size_t i = 0; i < count; i++) {
+      slice[i] = item;
+    }
+    return slice;
+  }
+
+  Slice<T> clone(Allocator* a, size_t newCount)
+  {
+    T* newItems = (T*)a->allocate(newCount * sizeof(T));
+    memcpy(newItems, items, min(count, newCount) * sizeof(T));
+    return Slice<T>(newItems, newCount);
+  }
+
+  Slice<T> cloneAndSet(Allocator* a, size_t newCount, const T& item)
+  {
+    Slice<T> slice(clone(a, newCount));
+    for (size_t i = count; i < newCount; i++) {
+      slice[i] = item;
+    }
+    return slice;
   }
 
   void resize(Allocator* a, size_t newCount)
   {
-    T* newItems = (T*)a->allocate(newCount * sizeof(T));
-    memcpy(newItems, items, min(count, newCount));
+    Slice<T> slice(clone(a, newCount));
     a->free(items, count);
-    items = newItems;
-    count = newCount;
+    *this = slice;
   }
 };