diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index 342ea99..cf114f8 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -9,6 +9,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <initializer_list>
+#include <utility>
 #include <iostream>
 #include "access.hpp"
 #include "vector.hpp"
@@ -16,6 +17,10 @@
 #include "exception.hpp"
 #include "swap.hpp"
 
+extern "C" {
+#include <bflibc/bfmath.h>
+}
+
 namespace BF {
 
 /**
@@ -26,8 +31,14 @@ namespace BF {
  *
  * Objects stored in array are assumed to be owned by owner of array 
  * object
+ *
+ * blockSize:
+ * block size of memory allocation
+ *
+ * each reallocation where count > capacity, will always
+ * allocate memory in blocks of blockSize
  */
-template <typename T, typename S = long>
+template <typename T, typename S = long, S blockSize = 2 << 3>
 class Array : public Vector<T,S> {
 public:
 	virtual const char * className() const {
@@ -39,6 +50,9 @@ class Array : public Vector<T,S> {
 		this->_count = 0;
 		this->_callback = Array::comparisonDefault;
 		this->_releasecb = NULL;
+		
+		this->_capacity = 0;
+		this->allocate(*this, blockSize);
 	}
 
 	/**
@@ -75,7 +89,8 @@ class Array : public Vector<T,S> {
 			}
 		}
 		
-		this->deallocate(this->_address);
+		//this->deallocate(this->_address);
+		this->deallocate(*this);
 		this->_address = 0;
 		this->_count = 0;
 	}
@@ -180,7 +195,6 @@ class Array : public Vector<T,S> {
 		return res;
 	}
 
-
 	/**
 	 * Prints the array from the first element to the last
 	 */
@@ -210,9 +224,9 @@ class Array : public Vector<T,S> {
 	/**
 	 * Copies content from arr to us
 	 */
-	void copyFromArray(const Array<T,S> * arr) {
+	void copyFromArray(const Array<T,S,blockSize> * arr) {
 		this->removeAll();
-		this->_address = (T *) this->allocate(arr->count());
+		this->allocate(*this, arr->count());
 		this->_count = arr->count();
 		memcpy(this->_address, arr->address(), this->_count);
 	}
@@ -220,9 +234,8 @@ class Array : public Vector<T,S> {
 	/**
 	 * copies content of arr to the end of ours
 	 */
-	void append(const Array<T,S> & arr) {
-		this->_address = this->reallocate(this->_address, this->_count + arr._count);
-		//memcpy(&this->_address[this->_count], &arr._address[0], arr._count);
+	void append(const Array<T,S,blockSize> & arr) {
+		this->reallocate(*this, this->_count, this->_count + arr._count);
 		for (int i = this->_count; i < this->_count + arr._count; i++) {
 			this->_address[i] = arr._address[i - this->_count];
 		}
@@ -233,7 +246,7 @@ class Array : public Vector<T,S> {
 	 * Adds object at the end of the array
 	 */
 	int add(T obj) {
-		this->_address = this->reallocate(this->_address, this->_count + 1);
+		this->reallocate(*this, this->_count, this->_count + 1);
 		if (this->_address == NULL) {
 			this->_count = 0;
 			return -3;
@@ -290,37 +303,52 @@ class Array : public Vector<T,S> {
 	 * adjusts address memory to size
 	 */
 	void adjustMemorySize(S size) {
+		this->reallocate(*this, this->_count, size);
 		this->_count = size;
-		this->_address = this->reallocate(this->_address, this->_count);
 	}
 
 	/**
 	 * Returns address of array
 	 */
-	T * address() const { return this->_address; }
+	T * address() const {
+		// capacity may be > 0 and _address may be allocated
+		if (this->_count == 0) return NULL;
+		return this->_address;
+	}
 	
 private:
 
-	/**
-	 * uses malloc to allocate mem
-	 */
-	static T * allocate(S size) {
-		return (T *) malloc(sizeof(T) * size);
+	static void allocate(Array<T,S,blockSize> & array, S size) {
+		if (size > array._capacity) {
+			array._capacity = size;
+			array._address = (T *) new T[size];
+		}
 	}
 
-	/**
-	 * returns modified `addr` with `newsize`
-	 */
-	static T * reallocate(T * addr, S newsize) {
-		return (T *) realloc(addr, sizeof(T) * newsize);
+	static void reallocate(Array<T,S,blockSize> & array, S oldsize, S newsize) {
+		if (newsize < array._capacity) {
+			return;
+		}
+
+		S adjustedNewSize = (((newsize / blockSize) + 1) * blockSize);
+		array._capacity = adjustedNewSize;
+		T * res = new T[adjustedNewSize];
+		memcpy(res, array._address, sizeof(T) * oldsize);
+		memset(array._address, 0, sizeof(T) * oldsize);
+
+		delete[] array._address;
+		array._address = res;
+
+		return;
 	}
 
 	/**
 	 * Derived must make sure this follows the standard established
 	 * by allocate()
 	 */
-	static void deallocate(T * value) {
-		free((void *) value);
+	static void deallocate(Array<T,S,blockSize> & array) {
+		delete[] array._address;
+		array._capacity = 0;
 	}
 
 	/**
@@ -328,7 +356,7 @@ class Array : public Vector<T,S> {
 	 */
 	void saveArray(const T * array, S size) {
 		this->removeAll();
-		this->_address = (T *) this->allocate(size);
+		this->allocate(*this, size);
 		this->_count = size;
 
 		if (this->_address) {
@@ -347,7 +375,7 @@ class Array : public Vector<T,S> {
 		typename std::initializer_list<T>::iterator itr;
 
 		this->_count = list.size();
-		this->_address = (T *) this->allocate(this->_count);
+		this->allocate(*this, this->_count);
 
 		if (this->_address) {
 			S i = 0;
@@ -368,6 +396,12 @@ class Array : public Vector<T,S> {
 	/// Holds size of _address
 	S _count;
 
+	/**
+	 * will hold a certain amount of reserved space for the
+	 * array elements. we will ask for more memory when _count > _capacity
+	 */
+	S _capacity;
+
 	/**
 	 * How we compare each item in the array
 	 */
@@ -390,7 +424,7 @@ class Array : public Vector<T,S> {
 	/**
 	 * Copies the string content from arr to us
 	 */
-	virtual Array<T,S> & operator=(const Array<T,S> & arr) {
+	virtual Array<T,S,blockSize> & operator=(const Array<T,S,blockSize> & arr) {
 		this->copyFromArray(&arr);
 		return *this;
 	}
diff --git a/bflibcpp/src/data.cpp b/bflibcpp/src/data.cpp
index c87434f..443f611 100644
--- a/bflibcpp/src/data.cpp
+++ b/bflibcpp/src/data.cpp
@@ -64,7 +64,7 @@ Data::Data(const Data & in) : Data(in.size(), (unsigned char *) in.buffer()) { }
 
 Data::~Data() { }
 
-Data::Data(const size_t size, const unsigned char * data) : Array<unsigned char, size_t>() {
+Data::Data(const size_t size, const unsigned char * data) : Array<unsigned char, size_t, 2<<5>() {
 	this->alloc(size, data);
 }
 
diff --git a/bflibcpp/src/data.hpp b/bflibcpp/src/data.hpp
index 0ad530a..4315933 100644
--- a/bflibcpp/src/data.hpp
+++ b/bflibcpp/src/data.hpp
@@ -14,7 +14,7 @@ namespace BF {
 class String;
 class URL;
 
-class Data : public Array<unsigned char, size_t> {
+class Data : public Array<unsigned char, size_t, 2<<5> {
 public:
 	virtual const char * className() const;
 
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 541d5f7..31ebcfb 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -15,7 +15,7 @@
 
 namespace BF {
 
-template<template <typename...> class T> struct Sort;
+template<typename T> struct Sort;
 
 /**
  * Linked List implementation
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
index abdf8d4..aa1ea19 100644
--- a/bflibcpp/src/sort.hpp
+++ b/bflibcpp/src/sort.hpp
@@ -8,40 +8,37 @@
 
 #include "array.hpp"
 #include "list.hpp"
-//#include "typesortstrategy.hpp"
 
 namespace BF {
 
-template<template <typename...> class T> struct Sort;
+template <typename T> struct Sort;
 
-// Generic sort function
-template <template <typename...> class ContainerTemplate, typename... Args>
-int sort(ContainerTemplate<Args...>& v) {
-    Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
+template <typename T>
+int sort(T & v) {
+    Sort<T> sorter;
     return sorter(v);
 }
 
-template <> struct Sort<List> {
-	template <typename L, typename S = size_t> 
+template <typename L, typename S> 
+struct Sort<List<L,S>> {
 	int operator()(List<L,S> & list, SortStrategy strategy = kSortStrategyMerge) {
 		switch (strategy) {
 			case kSortStrategyBubble:
-				return Sort::sortBubble<L,S>(list);
+				return Sort::sortBubble(list);
 			case kSortStrategyInsertion:
-				return Sort::sortInsertion<L,S>(list);
+				return Sort::sortInsertion(list);
 			case kSortStrategySelection:
-				return Sort::sortSelection<L,S>(list);
+				return Sort::sortSelection(list);
 			case kSortStrategyQuick:
-				return Sort::sortQuick<L,S>(list);
+				return Sort::sortQuick(list);
 			case kSortStrategyMerge:
 			default:
-				return Sort::sortMerge<L,S>(list);
+				return Sort::sortMerge(list);
 		}
 	}
 
 	/** BUBBLE SORT - START **/
 
-	template <typename L, typename S = size_t> 
 	static int sortBubble(List<L,S> & c) {
 		typename List<L,S>::Node * head = c.first();
 		S len = c.size();
@@ -89,7 +86,6 @@ template <> struct Sort<List> {
 	/** BUBBLE SORT - END **/
 	/** INSERTION SORT - START **/
 
-	template <typename L, typename S = size_t> 
 	static typename List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
 		if (!sorted || sorted->object() >= newNode->object()) {
 			newNode->right = sorted;
@@ -107,7 +103,6 @@ template <> struct Sort<List> {
 		return sorted;
 	}
 
-	template <typename L, typename S = size_t> 
 	static int sortInsertion(List<L,S> & c) {
 		typename List<L,S>::Node * head = c.first();
 		typename List<L,S>::Node * sorted = NULL;
@@ -115,7 +110,7 @@ template <> struct Sort<List> {
 
 		while (curr) {
 			typename List<L,S>::Node * next = curr->next();
-			sorted = sortInsertion<L,S>(curr, sorted);
+			sorted = sortInsertion(curr, sorted);
 			curr = next;
 		}
 
@@ -127,7 +122,6 @@ template <> struct Sort<List> {
 	/** INSERTION SORT - END **/
 	/** SELECTION SORT - START **/
 
-	template <typename L, typename S = size_t> 
 	static int sortSelection(List<L,S> & c) {
 		typename List<L,S>::Node * head = c.first();
 		for (typename List<L,S>::Node * start = head; start; start = start->next()) {
@@ -152,30 +146,27 @@ template <> struct Sort<List> {
 	/** SELECTION SORT - END **/
 	/** QUICK SORT - START **/
 
-	template <typename L, typename S = size_t> 
 	static int sortQuick(List<L,S> & c) {
 		typename List<L,S>::Node * head = c.first();
 		typename List<L,S>::Node * tail = c.last();
 
-		sortQuick<L,S>(head, tail);
+		sortQuick(head, tail);
 
 		c._head = head;
 		return 0;
 	}
 	
-	template <typename L, typename S = size_t> 
 	static void sortQuick(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
 		if (!head || head == tail) {
 			return;
 		}
 
-		typename List<L,S>::Node * pivot = sortQuickGetPivot<L,S>(head, tail);
+		typename List<L,S>::Node * pivot = sortQuickGetPivot(head, tail);
 
-		sortQuick<L,S>(head, pivot);
-		sortQuick<L,S>(pivot->next(), tail);
+		sortQuick(head, pivot);
+		sortQuick(pivot->next(), tail);
 	}
 	
-	template <typename L, typename S = size_t> 
 	static typename List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
 		typename List<L,S>::Node * pivot = head;
 
@@ -199,40 +190,36 @@ template <> struct Sort<List> {
 	/** QUICK SORT - END **/
 	/** MERGE SORT - START **/
 
-	template <typename L, typename S = size_t> 
 	static int sortMerge(List<L,S> & c) {
-		c._head = sortMerge<L,S>(c._head);
+		c._head = sortMerge(c._head);
 		return 0;
 	}
 
-	template <typename L, typename S = size_t> 
 	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
 		if (!head || !head->next()) {
 			return head;
 		}
 
-		typename List<L,S>::Node * second = sortMergeSplit<L,S>(head);
-		head = sortMerge<L,S>(head);
-		second = sortMerge<L,S>(second);
+		typename List<L,S>::Node * second = sortMergeSplit(head);
+		head = sortMerge(head);
+		second = sortMerge(second);
 
-		return sortMerge<L,S>(head, second);
+		return sortMerge(head, second);
 	}
 	
-	template <typename L, typename S = size_t> 
 	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
 		if (!first) return second;
 		if (!second) return first;
 
 		if (first->object() < second->object()) {
-			first->right = sortMerge<L,S>(first->next(), second);
+			first->right = sortMerge(first->next(), second);
 			return first;
 		} else {
-			second->right = sortMerge<L,S>(first, second->next());
+			second->right = sortMerge(first, second->next());
 			return second;
 		}
 	}
 
-	template <typename L, typename S = size_t> 
 	static typename List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
 		typename List<L,S>::Node * fast = head;
 		typename List<L,S>::Node * slow = head;
@@ -252,28 +239,27 @@ template <> struct Sort<List> {
 	/** MERGE SORT - END **/
 };
 
-template <> struct Sort<Array> {
-	template <typename T, typename S = size_t> 
-	int operator()(Array<T,S> & array, SortStrategy strategy = kSortStrategyMerge) {
+template <typename T, typename S, S B>
+struct Sort<Array<T,S,B>> {
+	int operator()(Array<T,S,B> & array, SortStrategy strategy = kSortStrategyMerge) {
 		switch (strategy) {
 			case kSortStrategyBubble:
-				return Sort::sortBubble<T,S>(array);
+				return Sort::sortBubble(array);
 			case kSortStrategyInsertion:
-				return Sort::sortInsertion<T,S>(array);
+				return Sort::sortInsertion(array);
 			case kSortStrategySelection:
-				return Sort::sortSelection<T,S>(array);
+				return Sort::sortSelection(array);
 			case kSortStrategyQuick:
-				return Sort::sortQuick<T,S>(array);
+				return Sort::sortQuick(array);
 			case kSortStrategyMerge:
 			default:
-				return Sort::sortMerge<T,S>(array);
+				return Sort::sortMerge(array);
 		}
 	}
 
 	/** BUBBLE SORT - START **/
 
-	template <typename T, typename S = size_t> 
-	static int sortBubble(Array<T,S> & c) {
+	static int sortBubble(Array<T,S,B> & c) {
 		S n = c.size();
 		bool swapped = false;
 
@@ -296,8 +282,7 @@ template <> struct Sort<Array> {
 	/** BUBBLE SORT - END **/
 	/** INSERTION SORT - START **/
 
-	template <typename T, typename S = size_t> 
-	static int sortInsertion(Array<T,S> & c) {
+	static int sortInsertion(Array<T,S,B> & c) {
 		S i, j;
 		T key;
 		S n = c.size();
@@ -321,8 +306,7 @@ template <> struct Sort<Array> {
 	/** INSERTION SORT - END **/
 	/** SELECTION SORT - START **/
 
-	template <typename T, typename S = size_t> 
-	static int sortSelection(Array<T,S> & c) {
+	static int sortSelection(Array<T,S,B> & c) {
 		S i, j, min_idx;
 		S n = c.size();
 
@@ -348,28 +332,25 @@ template <> struct Sort<Array> {
 	/** SELECTION SORT - END **/
 	/** QUICK SORT - START **/
 
-	template <typename T, typename S = size_t> 
-	static int sortQuick(Array<T,S> & c) {
-		return sortQuick<T,S>(c, 0, c.size() - 1);
+	static int sortQuick(Array<T,S,B> & c) {
+		return sortQuick(c, 0, c.size() - 1);
 	}
 
-	template <typename T, typename S = size_t> 
-	static int sortQuick(Array<T,S> & c, S low, S high) {
+	static int sortQuick(Array<T,S,B> & c, S low, S high) {
 		if (low < high) {
 			// pi is the partition return index of pivot
-			S pi = sortQuickPartition<T,S>(c, low, high);
+			S pi = sortQuickPartition(c, low, high);
 
 			// Recursion calls for smaller elements
 			// and greater or equals elements
-			sortQuick<T,S>(c, low, pi - 1);
-			sortQuick<T,S>(c, pi + 1, high);
+			sortQuick(c, low, pi - 1);
+			sortQuick(c, pi + 1, high);
 		}
 
 		return 0;
 	}
 
-	template <typename T, typename S = size_t> 
-	static int sortQuickPartition(Array<T,S> & c, S low, S high) {
+	static int sortQuickPartition(Array<T,S,B> & c, S low, S high) {
 		// Choose the pivot
 		T pivot = c[high];
 	  
@@ -400,25 +381,22 @@ template <> struct Sort<Array> {
 	/** QUICK SORT - END **/
 	/** MERGE SORT - START **/
 
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c) {
-		return sortMerge<T,S>(c, 0, c.size() - 1);
+	static int sortMerge(Array<T,S,B> & c) {
+		return sortMerge(c, 0, c.size() - 1);
 	}
 
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c, S left, S right) {
+	static int sortMerge(Array<T,S,B> & c, S left, S right) {
 		if (left >= right)
 			return 0;
 
 		S mid = left + (right - left) / 2;
-		sortMerge<T,S>(c, left, mid);
-		sortMerge<T,S>(c, mid + 1, right);
-		sortMerge<T,S>(c, left, mid, right);
+		sortMerge(c, left, mid);
+		sortMerge(c, mid + 1, right);
+		sortMerge(c, left, mid, right);
 		return 0;
 	}
 
-	template <typename T, typename S = size_t> 
-	static int sortMerge(Array<T,S> & c, S left, S mid, S right) {
+	static int sortMerge(Array<T,S,B> & c, S left, S mid, S right) {
 		S n1 = mid - left + 1;
 		S n2 = right - mid;
 
diff --git a/bflibcpp/src/string.cpp b/bflibcpp/src/string.cpp
index 45c58b0..d83cc77 100644
--- a/bflibcpp/src/string.cpp
+++ b/bflibcpp/src/string.cpp
@@ -24,7 +24,7 @@ String:: String() : String("") {}
 
 String::String(const std::string & str) : String(str.c_str()) { }
 
-String::String(char * str) : Array<char, size_t>() {
+String::String(char * str) : Array<char, size_t, 2<<4>() {
 	this->set(str, strlen(str) + 1);
 }
 
@@ -36,7 +36,7 @@ String::String(int nullstr) {
 	this->set((char *) "", 1);
 }
 
-String::String(const Data & data) : Array<char, size_t>() {
+String::String(const Data & data) : Array<char, size_t, 2<<4>() {
 	this->set((const char *) data.buffer(), data.size());
 
 	/**
@@ -50,13 +50,13 @@ String::String(const Data & data) : Array<char, size_t>() {
 	}
 }
 
-String::String(const char * format, va_list valist) : Array<char, size_t>() {
+String::String(const char * format, va_list valist) : Array<char, size_t, 2<<4>() {
 	char * str = BFStringCreateFormatArgListString(format, valist);
 	this->set(str, strlen(str) + 1);
 	BFFree(str);
 }
 
-String::String(const char * format, ...) : Array<char, size_t>() {
+String::String(const char * format, ...) : Array<char, size_t, 2<<4>() {
 	va_list valist;
 	va_start(valist, format);
 	char * str = BFStringCreateFormatArgListString(format, valist);
diff --git a/bflibcpp/src/string.hpp b/bflibcpp/src/string.hpp
index 3f5689d..3b1f7d1 100644
--- a/bflibcpp/src/string.hpp
+++ b/bflibcpp/src/string.hpp
@@ -15,7 +15,7 @@ namespace BF {
 	
 class Data;
 
-class String : public Array<char, size_t> {
+class String : public Array<char, size_t, 2<<4> {
 public:
 
 	const char * className() const;
diff --git a/bflibcpp/testbench/array_tests.hpp b/bflibcpp/testbench/array_tests.hpp
index b779305..e71feda 100644
--- a/bflibcpp/testbench/array_tests.hpp
+++ b/bflibcpp/testbench/array_tests.hpp
@@ -69,7 +69,6 @@ BFTEST_UNIT_FUNC(test_Contains, 1,  {
 	}
 })
 
-//int test_ObjectAtIndex() {
 BFTEST_UNIT_FUNC(test_ObjectAtIndex, 1,  {
 	Array<double> d({1.1, 2.2, 3.3, 4.4, 5.5});
 
@@ -88,7 +87,6 @@ BFTEST_UNIT_FUNC(test_ObjectAtIndex, 1,  {
 	}
 })
 
-//int test_indexForObject() {
 BFTEST_UNIT_FUNC(test_indexForObject, 2<<10,  {
 	Array<int> arr({1, 2, 3, 4});
 
@@ -120,7 +118,6 @@ BFTEST_UNIT_FUNC(test_indexForObject, 2<<10,  {
 	}
 })
 
-//int test_Count() {
 BFTEST_UNIT_FUNC(test_Count, 1,  {
 	Array<int> a({1, 2, 3, 4, 5});
 
@@ -130,7 +127,6 @@ BFTEST_UNIT_FUNC(test_Count, 1,  {
 	}
 })
 
-//int test_Setter() {
 BFTEST_UNIT_FUNC(test_Setter, 1,  {
 	Array<int> a;
 
@@ -277,13 +273,6 @@ BFTEST_UNIT_FUNC(test_arrayOfCStrings, 2<<8, {
 	BF_ASSERT(b.contains(word));
 })
 
-BFTEST_UNIT_FUNC(test_arrayOfBFStrings, 2<<8, {
-	Array<BF::String> a({"hello", "world"});
-	Array<BF::String> b;
-	b.add("hello");
-	b.add("world");
-})
-
 BFTEST_UNIT_FUNC(test_appendingArrays, 2 << 10, {
 	int max_size = 2 << 10;
 	Array<int> c;
@@ -299,6 +288,13 @@ BFTEST_UNIT_FUNC(test_appendingArrays, 2 << 10, {
 	}
 })
 
+BFTEST_UNIT_FUNC(test_arrayOfBFStrings, 1, {
+	Array<BF::String> a({"hello", "world"});
+	Array<BF::String> b;
+	b.add("hello");
+	b.add("world");
+})
+
 BFTEST_COVERAGE_FUNC(array_tests, {
 	BFTEST_LAUNCH(test_Initializer);
 	BFTEST_LAUNCH(test_Contains);
@@ -310,10 +306,9 @@ BFTEST_COVERAGE_FUNC(array_tests, {
 	BFTEST_LAUNCH(test_insertingAtRandomIndex);
 	BFTEST_LAUNCH(test_releasecallback);
 	BFTEST_LAUNCH(test_addanddelete);
-	//BFTEST_LAUNCH(test_arrayOfBFStrings); // FIXME: this should work if we change how array's allocate memory
 	BFTEST_LAUNCH(test_arrayOfCStrings);
 	BFTEST_LAUNCH(test_appendingArrays);
-
+	BFTEST_LAUNCH(test_arrayOfBFStrings); // FIXME: this should work if we change how array's allocate memory
 })
 
 #endif // ARRAY_TESTS_HPP
diff --git a/bflibcpp/testbench/data_tests.hpp b/bflibcpp/testbench/data_tests.hpp
index a8bbcb3..2b20277 100644
--- a/bflibcpp/testbench/data_tests.hpp
+++ b/bflibcpp/testbench/data_tests.hpp
@@ -20,7 +20,7 @@ using namespace BF;
 BFTEST_UNIT_FUNC(test_datainit, 1,  {
 	Data buf0;
 	BF_ASSERT(buf0.size() == 0);
-	BF_ASSERT(buf0.buffer() != NULL);
+	BF_ASSERT(buf0.buffer() == NULL);
 
 	unsigned char bytes[10];
 	Data buf1(sizeof(bytes), bytes);
@@ -36,7 +36,7 @@ BFTEST_UNIT_FUNC(test_datainit, 1,  {
 
 	Data * buf5 = new Data;
 	BF_ASSERT(buf5->size() == 0);
-	BF_ASSERT(buf5->buffer() != NULL);
+	BF_ASSERT(buf5->buffer() == NULL);
 	BFRelease(buf5);
 })
 
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index c905e56..62bee82 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -63,7 +63,7 @@ int run_vectorSortDefault(SortStrategy type, size_t listsize, int reps) {
 	return result;
 }
 
-template <template <typename...> class ContainerTemplate, typename... Args>
+template <typename T>
 int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 	int result = 0;
 	int max = reps;
@@ -71,8 +71,8 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 		usleep(50);
 		size_t maxsize = listsize;
 		srand(time(0));
-		ContainerTemplate<Args...> l;
-		ContainerTemplate<Args...> b;
+		T l;
+		T b;
 		for (size_t i = 0; i < maxsize; i++) {
 			usleep(50);
 			int val = rand();
@@ -80,7 +80,7 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 			l.add(val);
 		}
 
-		Sort<ContainerTemplate> sorter;
+		Sort<T> sorter;
 		result = sorter(l, type);
 
 		if (!result) {
@@ -110,52 +110,52 @@ int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
 }
 
 BFTEST_UNIT_FUNC(test_vectorListSortBubble, 1,  {
-	int err = run_vectorSort<List, int>(kSortStrategyBubble, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyBubble, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortInsertion, 1,  {
-	int err = run_vectorSort<List, int>(kSortStrategyInsertion, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyInsertion, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortSelection, 1,  {
-	int err = run_vectorSort<List, int>(kSortStrategySelection, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategySelection, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortQuick, 1,  {
-	int err = run_vectorSort<List, int>(kSortStrategyQuick, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyQuick, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortMerge, 1, {
-	int err = run_vectorSort<List, int>(kSortStrategyMerge, 2 << 9, 1);
+	int err = run_vectorSort<List<int>>(kSortStrategyMerge, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortBubble, 1,  {
-	int err = run_vectorSort<Array, int>(kSortStrategyBubble, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyBubble, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortInsertion, 1,  {
-	int err = run_vectorSort<Array, int>(kSortStrategyInsertion, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyInsertion, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortSelection, 1,  {
-	int err = run_vectorSort<Array, int>(kSortStrategySelection, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategySelection, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortQuick, 1,  {
-	int err = run_vectorSort<Array, int>(kSortStrategyQuick, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyQuick, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
-	int err = run_vectorSort<Array, int>(kSortStrategyMerge, 2 << 9, 4);
+	int err = run_vectorSort<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index 0c65fcc..13691c3 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -15,10 +15,11 @@
 - [ ] tuple
 - [x] address compiler warning regarding ambiguous operations
 - [ ] String to integer 
-- [ ] array memory optimization, improving virtual memory usage
-	- [ ] BF::Array to use new/delete for memory allocation
-	- [ ] optimize String
-		- [ ] when appending to string, grab more memory so we don't have keep calling realloc all the time
+- [x] array memory optimization, improving virtual memory usage
+	- [x] BF::Array to use new/delete for memory allocation
+	- [x] optimize String
+		- [x] when appending to string, grab more memory so we don't have keep calling realloc all the time
+    - [x] benchmark test run
 - [x] collection sorting algorithm
 - [x] make sure there are no Delete() calls and must use BFRelease instead
 - [x] throw compiler warnings when using delete
diff --git a/bfnet/makefile b/bfnet/makefile
index 3f17673..6969ef9 100644
--- a/bfnet/makefile
+++ b/bfnet/makefile
@@ -47,9 +47,9 @@ MAIN_FILE = testbench/tests.cpp
 endif # ($(CONFIG),...)
 
 dependencies:
+	cd ../bftest/ && make clean && make build CONFIG=release && make build CONFIG=debug
 	cd ../bflibc/ && make clean && make build CONFIG=release && make build CONFIG=debug
 	cd ../bflibcpp/ && make clean && make build CONFIG=release && make build CONFIG=debug
-	cd ../bftest/ && make clean && make build CONFIG=release && make build CONFIG=debug
 
 include makefiles/lib.mk 
 LIBS_MAKEFILES_PATH:=$(shell dirname $(CURDIR))/makefiles