Index: uspace/app/bithenge/blob.c
===================================================================
--- uspace/app/bithenge/blob.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/blob.c	(revision 600f5d197151eb0ed71c0ce7e030405f7c2231e1)
@@ -49,5 +49,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-int bithenge_new_random_access_blob(bithenge_blob_t *blob,
+int bithenge_init_random_access_blob(bithenge_blob_t *blob,
     const bithenge_random_access_blob_ops_t *ops)
 {
@@ -85,5 +85,5 @@
 }
 
-static inline bithenge_sequential_blob_t *sequential_from_blob(
+static inline bithenge_sequential_blob_t *blob_as_sequential(
     bithenge_blob_t *base)
 {
@@ -91,5 +91,5 @@
 }
 
-static inline bithenge_blob_t *blob_from_sequential(
+static inline bithenge_blob_t *sequential_as_blob(
     bithenge_sequential_blob_t *blob)
 {
@@ -99,5 +99,5 @@
 static int sequential_size(bithenge_blob_t *base, aoff64_t *size)
 {
-	bithenge_sequential_blob_t *blob = sequential_from_blob(base);
+	bithenge_sequential_blob_t *blob = blob_as_sequential(base);
 	int rc;
 	if (blob->ops->size) {
@@ -121,5 +121,5 @@
     char *buffer, aoff64_t *size)
 {
-	bithenge_sequential_blob_t *blob = sequential_from_blob(base);
+	bithenge_sequential_blob_t *blob = blob_as_sequential(base);
 	aoff64_t end = offset + *size;
 	if (end > blob->data_size) {
@@ -135,9 +135,9 @@
 }
 
-static int sequential_destroy(bithenge_blob_t *base)
-{
-	bithenge_sequential_blob_t *blob = sequential_from_blob(base);
+static void sequential_destroy(bithenge_blob_t *base)
+{
+	bithenge_sequential_blob_t *blob = blob_as_sequential(base);
 	free(blob->buffer);
-	return blob->ops->destroy(blob);
+	blob->ops->destroy(blob);
 }
 
@@ -155,5 +155,5 @@
  * @return EOK on success or an error code from errno.h.
  */
-int bithenge_new_sequential_blob(bithenge_sequential_blob_t *blob,
+int bithenge_init_sequential_blob(bithenge_sequential_blob_t *blob,
     const bithenge_sequential_blob_ops_t *ops)
 {
@@ -164,5 +164,5 @@
 	// ops->size is optional
 
-	int rc = bithenge_new_random_access_blob(blob_from_sequential(blob),
+	int rc = bithenge_init_random_access_blob(sequential_as_blob(blob),
 	    &sequential_ops);
 	if (rc != EOK)
@@ -182,10 +182,10 @@
 } memory_blob_t;
 
-static inline memory_blob_t *memory_from_blob(bithenge_blob_t *base)
+static inline memory_blob_t *blob_as_memory(bithenge_blob_t *base)
 {
 	return (memory_blob_t *)base;
 }
 
-static inline bithenge_blob_t *blob_from_memory(memory_blob_t *blob)
+static inline bithenge_blob_t *memory_as_blob(memory_blob_t *blob)
 {
 	return &blob->base;
@@ -194,5 +194,5 @@
 static int memory_size(bithenge_blob_t *base, aoff64_t *size)
 {
-	memory_blob_t *blob = memory_from_blob(base);
+	memory_blob_t *blob = blob_as_memory(base);
 	*size = blob->size;
 	return EOK;
@@ -202,5 +202,5 @@
     aoff64_t *size)
 {
-	memory_blob_t *blob = memory_from_blob(base);
+	memory_blob_t *blob = blob_as_memory(base);
 	if (offset > blob->size)
 		return ELIMIT;
@@ -210,11 +210,10 @@
 }
 
-static int memory_destroy(bithenge_blob_t *base)
-{
-	memory_blob_t *blob = memory_from_blob(base);
+static void memory_destroy(bithenge_blob_t *base)
+{
+	memory_blob_t *blob = blob_as_memory(base);
 	if (blob->needs_free)
 		free((void *)blob->buffer);
 	free(blob);
-	return EOK;
 }
 
@@ -244,5 +243,5 @@
 	if (!blob)
 		return ENOMEM;
-	rc = bithenge_new_random_access_blob(blob_from_memory(blob),
+	rc = bithenge_init_random_access_blob(memory_as_blob(blob),
 	    &memory_ops);
 	if (rc != EOK) {
@@ -259,5 +258,5 @@
 	blob->size = len;
 	blob->needs_free = true;
-	*out = bithenge_blob_as_node(blob_from_memory(blob));
+	*out = bithenge_blob_as_node(memory_as_blob(blob));
 	return EOK;
 }
@@ -283,5 +282,5 @@
 	if (!blob)
 		return ENOMEM;
-	rc = bithenge_new_random_access_blob(blob_from_memory(blob),
+	rc = bithenge_init_random_access_blob(memory_as_blob(blob),
 	    &memory_ops);
 	if (rc != EOK) {
@@ -292,5 +291,5 @@
 	blob->size = len;
 	blob->needs_free = needs_free;
-	*out = bithenge_blob_as_node(blob_from_memory(blob));
+	*out = bithenge_blob_as_node(memory_as_blob(blob));
 	return EOK;
 }
@@ -340,10 +339,9 @@
 }
 
-static int subblob_destroy(bithenge_blob_t *base)
+static void subblob_destroy(bithenge_blob_t *base)
 {
 	subblob_t *blob = blob_as_subblob(base);
 	bithenge_blob_dec_ref(blob->source);
 	free(blob);
-	return EOK;
 }
 
@@ -404,5 +402,5 @@
 		goto error;
 	}
-	rc = bithenge_new_random_access_blob(subblob_as_blob(blob),
+	rc = bithenge_init_random_access_blob(subblob_as_blob(blob),
 	    &subblob_ops);
 	if (rc != EOK)