Index: uspace/app/bithenge/blob.c
===================================================================
--- uspace/app/bithenge/blob.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/blob.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -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)
Index: uspace/app/bithenge/blob.h
===================================================================
--- uspace/app/bithenge/blob.h	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/blob.h	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -52,12 +52,11 @@
 typedef struct bithenge_random_access_blob_ops_t {
 	/** @copydoc bithenge_blob_t::bithenge_blob_size */
-	int (*size)(bithenge_blob_t *blob, aoff64_t *size);
+	int (*size)(bithenge_blob_t *self, aoff64_t *size);
 	/** @copydoc bithenge_blob_t::bithenge_blob_read */
-	int (*read)(bithenge_blob_t *blob, aoff64_t offset, char *buffer,
+	int (*read)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
 	    aoff64_t *size);
 	/** Destroy the blob.
-	 * @param blob The blob.
-	 * @return EOK on success or an error code from errno.h. */
-	int (*destroy)(bithenge_blob_t *blob);
+	 * @param blob The blob. */
+	void (*destroy)(bithenge_blob_t *self);
 } bithenge_random_access_blob_ops_t;
 
@@ -87,9 +86,9 @@
 	 *
 	 * @memberof bithenge_blob_t
-	 * @param blob The blob.
+	 * @param self The blob.
 	 * @param[out] size Total size of the blob.
 	 * @return EOK on success or an error code from errno.h.
 	 */
-	int (*size)(bithenge_sequential_blob_t *blob, aoff64_t *size);
+	int (*size)(bithenge_sequential_blob_t *self, aoff64_t *size);
 
 	/** Read the next part of the blob. If the requested data extends
@@ -97,5 +96,5 @@
 	 * will be read.
 	 *
-	 * @param blob The blob.
+	 * @param self The blob.
 	 * @param[out] buffer Buffer to read into. If an error occurs, the contents are
 	 * undefined.
@@ -105,11 +104,10 @@
 	 * @return EOK on success or an error code from errno.h.
 	 */
-	int (*read)(bithenge_sequential_blob_t *blob, char *buffer,
+	int (*read)(bithenge_sequential_blob_t *self, char *buffer,
 	    aoff64_t *size);
 
 	/** Destroy the blob.
-	 * @param blob The blob.
-	 * @return EOK on success or an error code from errno.h. */
-	int (*destroy)(bithenge_sequential_blob_t *blob);
+	 * @param self The blob. */
+	void (*destroy)(bithenge_sequential_blob_t *self);
 } bithenge_sequential_blob_ops_t;
 
@@ -117,13 +115,13 @@
  *
  * @memberof bithenge_blob_t
- * @param blob The blob.
+ * @param self The blob.
  * @param[out] size Total size of the blob.
  * @return EOK on success or an error code from errno.h.
  */
-static inline int bithenge_blob_size(bithenge_blob_t *blob, aoff64_t *size)
-{
-	assert(blob);
-	assert(blob->base.blob_ops);
-	return blob->base.blob_ops->size(blob, size);
+static inline int bithenge_blob_size(bithenge_blob_t *self, aoff64_t *size)
+{
+	assert(self);
+	assert(self->base.blob_ops);
+	return self->base.blob_ops->size(self, size);
 }
 
@@ -134,5 +132,5 @@
  *
  * @memberof bithenge_blob_t
- * @param blob The blob.
+ * @param self The blob.
  * @param offset Byte offset within the blob.
  * @param[out] buffer Buffer to read into. If an error occurs, the contents are
@@ -143,10 +141,10 @@
  * @return EOK on success or an error code from errno.h.
  */
-static inline int bithenge_blob_read(bithenge_blob_t *blob, aoff64_t offset,
+static inline int bithenge_blob_read(bithenge_blob_t *self, aoff64_t offset,
     char *buffer, aoff64_t *size)
 {
-	assert(blob);
-	assert(blob->base.blob_ops);
-	return blob->base.blob_ops->read(blob, offset, buffer, size);
+	assert(self);
+	assert(self->base.blob_ops);
+	return self->base.blob_ops->read(self, offset, buffer, size);
 }
 
@@ -170,35 +168,30 @@
 }
 
-static inline int bithenge_blob_inc_ref(bithenge_blob_t *blob)
-{
-	return bithenge_node_inc_ref(bithenge_blob_as_node(blob));
-}
-
-static inline int bithenge_blob_dec_ref(bithenge_blob_t *blob)
-{
-	if (!blob)
-		return EOK;
-	return bithenge_node_dec_ref(bithenge_blob_as_node(blob));
-}
-
-int bithenge_new_random_access_blob(bithenge_blob_t *blob,
-    const bithenge_random_access_blob_ops_t *ops);
-
-int bithenge_new_sequential_blob(bithenge_sequential_blob_t *blob,
-    const bithenge_sequential_blob_ops_t *ops);
-
-int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
-    size_t len);
-
-int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
-    size_t len, bool needs_free);
-
-int bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *blob,
-    aoff64_t offset);
-
-int bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *blob,
-    aoff64_t offset, aoff64_t size);
-
-bool bithenge_blob_equal(bithenge_blob_t *a, bithenge_blob_t *b);
+/** Increment a blob's reference count.
+ * @param blob The blob to reference. */
+static inline void bithenge_blob_inc_ref(bithenge_blob_t *blob)
+{
+	bithenge_node_inc_ref(bithenge_blob_as_node(blob));
+}
+
+/** Decrement a blob's reference count.
+ * @param blob The blob to dereference, or NULL. */
+static inline void bithenge_blob_dec_ref(bithenge_blob_t *blob)
+{
+	if (blob)
+		bithenge_node_dec_ref(bithenge_blob_as_node(blob));
+}
+
+int bithenge_init_random_access_blob(bithenge_blob_t *,
+    const bithenge_random_access_blob_ops_t *);
+int bithenge_init_sequential_blob(bithenge_sequential_blob_t *,
+    const bithenge_sequential_blob_ops_t *);
+int bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t);
+int bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t,
+    bool);
+int bithenge_new_offset_blob(bithenge_node_t **, bithenge_blob_t *, aoff64_t);
+int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
+    aoff64_t);
+bool bithenge_blob_equal(bithenge_blob_t *, bithenge_blob_t *);
 
 #endif
Index: uspace/app/bithenge/file.c
===================================================================
--- uspace/app/bithenge/file.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/file.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -55,10 +55,10 @@
 } file_blob_t;
 
-static inline file_blob_t *file_from_blob(bithenge_blob_t *base)
+static inline file_blob_t *blob_as_file(bithenge_blob_t *base)
 {
 	return (file_blob_t *)base;
 }
 
-static inline bithenge_blob_t *blob_from_file(file_blob_t *blob)
+static inline bithenge_blob_t *file_as_blob(file_blob_t *blob)
 {
 	return &blob->base;
@@ -67,5 +67,5 @@
 static int file_size(bithenge_blob_t *base, aoff64_t *size)
 {
-	file_blob_t *blob = file_from_blob(base);
+	file_blob_t *blob = blob_as_file(base);
 	*size = blob->size;
 	return EOK;
@@ -75,5 +75,5 @@
     aoff64_t *size)
 {
-	file_blob_t *blob = file_from_blob(base);
+	file_blob_t *blob = blob_as_file(base);
 	if (offset > blob->size)
 		return ELIMIT;
@@ -95,10 +95,9 @@
 }
 
-static int file_destroy(bithenge_blob_t *base)
+static void file_destroy(bithenge_blob_t *base)
 {
-	file_blob_t *blob = file_from_blob(base);
+	file_blob_t *blob = blob_as_file(base);
 	close(blob->fd);
 	free(blob);
-	return EOK;
 }
 
@@ -128,6 +127,5 @@
 		return ENOMEM;
 	}
-	rc = bithenge_new_random_access_blob(blob_from_file(blob),
-	    &file_ops);
+	rc = bithenge_init_random_access_blob(file_as_blob(blob), &file_ops);
 	if (rc != EOK) {
 		free(blob);
@@ -143,5 +141,5 @@
 #endif
 	blob->needs_close = needs_close;
-	*out = bithenge_blob_as_node(blob_from_file(blob));
+	*out = bithenge_blob_as_node(file_as_blob(blob));
 
 	return EOK;
Index: uspace/app/bithenge/helenos/block.c
===================================================================
--- uspace/app/bithenge/helenos/block.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/helenos/block.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -51,10 +51,10 @@
 } block_blob_t;
 
-static inline block_blob_t *block_from_blob(bithenge_blob_t *base)
+static inline block_blob_t *blob_as_block(bithenge_blob_t *base)
 {
 	return (block_blob_t *)base;
 }
 
-static inline bithenge_blob_t *blob_from_block(block_blob_t *blob)
+static inline bithenge_blob_t *block_as_blob(block_blob_t *blob)
 {
 	return &blob->base;
@@ -63,6 +63,6 @@
 static int block_size(bithenge_blob_t *base, aoff64_t *size)
 {
-	block_blob_t *blob = block_from_blob(base);
-	*size = blob->size;
+	block_blob_t *self = blob_as_block(base);
+	*size = self->size;
 	return EOK;
 }
@@ -71,17 +71,16 @@
     aoff64_t *size)
 {
-	block_blob_t *blob = block_from_blob(base);
-	if (offset > blob->size)
+	block_blob_t *self = blob_as_block(base);
+	if (offset > self->size)
 		return ELIMIT;
-	*size = min(*size, blob->size - offset);
-	return block_read_bytes_direct(blob->service_id, offset, *size, buffer);
+	*size = min(*size, self->size - offset);
+	return block_read_bytes_direct(self->service_id, offset, *size, buffer);
 }
 
-static int block_destroy(bithenge_blob_t *base)
+static void block_destroy(bithenge_blob_t *base)
 {
-	block_blob_t *blob = block_from_blob(base);
-	block_fini(blob->service_id);
-	free(blob);
-	return EOK;
+	block_blob_t *self = blob_as_block(base);
+	block_fini(self->service_id);
+	free(self);
 }
 
@@ -129,5 +128,5 @@
 		return ENOMEM;
 	}
-	rc = bithenge_new_random_access_blob(blob_from_block(blob),
+	rc = bithenge_init_random_access_blob(block_as_blob(blob),
 	    &block_ops);
 	if (rc != EOK) {
@@ -138,5 +137,5 @@
 	blob->service_id = service_id;
 	blob->size = size;
-	*out = bithenge_blob_as_node(blob_from_block(blob));
+	*out = bithenge_blob_as_node(block_as_blob(blob));
 
 	return EOK;
Index: uspace/app/bithenge/script.c
===================================================================
--- uspace/app/bithenge/script.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/script.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -121,5 +121,5 @@
 static void syntax_error(state_t *state, const char *message)
 {
-	// Multiple errors are confusing.
+	// Printing multiple errors is confusing.
 	if (state->error == EOK) {
 		size_t start_char = state->old_buffer_pos + state->line_offset;
@@ -423,2 +423,5 @@
 	return rc;
 }
+
+/** @}
+ */
Index: uspace/app/bithenge/script.h
===================================================================
--- uspace/app/bithenge/script.h	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/script.h	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -40,8 +40,8 @@
 #include "transform.h"
 
-int bithenge_parse_script(const char *filename, bithenge_transform_t **out);
+int bithenge_parse_script(const char *, bithenge_transform_t **);
 
 #endif
 
-/** @/
+/** @}
  */
Index: uspace/app/bithenge/source.c
===================================================================
--- uspace/app/bithenge/source.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/source.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -78,4 +78,10 @@
 }
 
+/** Create a node from a source described with a string. For instance,
+ * "hex:55aa" will result in a blob node. If there is no colon in the string,
+ * it is assumed to be a filename.
+ * @param[out] out Stores the created node.
+ * @param source Specifies the node to be created.
+ * @return EOK on success or an error code from errno.h. */
 int bithenge_node_from_source(bithenge_node_t **out, const char *source)
 {
Index: uspace/app/bithenge/source.h
===================================================================
--- uspace/app/bithenge/source.h	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/source.h	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -40,5 +40,5 @@
 #include "tree.h"
 
-int bithenge_node_from_source(bithenge_node_t **out, const char *source);
+int bithenge_node_from_source(bithenge_node_t **, const char *);
 
 #endif
Index: uspace/app/bithenge/transform.c
===================================================================
--- uspace/app/bithenge/transform.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/transform.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -42,8 +42,8 @@
 
 /** Initialize a new transform.
- * @param[out] xform Transform to initialize.
+ * @param[out] self Transform to initialize.
  * @param[in] ops Operations provided by the transform.
  * @return EOK or an error code from errno.h. */
-int bithenge_new_transform(bithenge_transform_t *xform,
+int bithenge_init_transform(bithenge_transform_t *self,
     const bithenge_transform_ops_t *ops)
 {
@@ -51,16 +51,15 @@
 	assert(ops->apply);
 	assert(ops->destroy);
-	xform->ops = ops;
-	xform->refs = 1;
-	return EOK;
-}
-
-static int transform_indestructible(bithenge_transform_t *xform)
+	self->ops = ops;
+	self->refs = 1;
+	return EOK;
+}
+
+static void transform_indestructible(bithenge_transform_t *self)
 {
 	assert(false);
-	return EOK;
-}
-
-static int uint32le_apply(bithenge_transform_t *xform, bithenge_node_t *in,
+}
+
+static int uint32le_apply(bithenge_transform_t *self, bithenge_node_t *in,
     bithenge_node_t **out)
 {
@@ -82,5 +81,5 @@
 }
 
-static int uint32be_apply(bithenge_transform_t *xform, bithenge_node_t *in,
+static int uint32be_apply(bithenge_transform_t *self, bithenge_node_t *in,
     bithenge_node_t **out)
 {
@@ -102,5 +101,5 @@
 }
 
-static int prefix_length_4(bithenge_transform_t *xform, bithenge_blob_t *blob,
+static int prefix_length_4(bithenge_transform_t *self, bithenge_blob_t *blob,
     aoff64_t *out)
 {
@@ -266,5 +265,5 @@
 }
 
-static int struct_node_destroy(bithenge_node_t *base)
+static void struct_node_destroy(bithenge_node_t *base)
 {
 	struct_node_t *node = node_as_struct(base);
@@ -272,5 +271,4 @@
 	bithenge_blob_dec_ref(node->blob);
 	free(node);
-	return EOK;
 }
 
@@ -280,8 +278,8 @@
 };
 
-static int struct_transform_apply(bithenge_transform_t *xform,
+static int struct_transform_apply(bithenge_transform_t *base,
     bithenge_node_t *in, bithenge_node_t **out)
 {
-	struct_transform_t *struct_transform = transform_as_struct(xform);
+	struct_transform_t *self = transform_as_struct(base);
 	if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
 		return EINVAL;
@@ -295,6 +293,6 @@
 		return rc;
 	}
-	bithenge_transform_inc_ref(xform);
-	node->transform = struct_transform;
+	bithenge_transform_inc_ref(base);
+	node->transform = self;
 	bithenge_node_inc_ref(in);
 	node->blob = bithenge_node_as_blob(in);
@@ -303,8 +301,8 @@
 }
 
-static int struct_transform_prefix_length(bithenge_transform_t *xform,
+static int struct_transform_prefix_length(bithenge_transform_t *base,
     bithenge_blob_t *blob, aoff64_t *out)
 {
-	struct_transform_t *struct_transform = transform_as_struct(xform);
+	struct_transform_t *self = transform_as_struct(base);
 	int rc = EOK;
 	bithenge_node_t *node;
@@ -316,7 +314,7 @@
 	blob = bithenge_node_as_blob(node);
 	*out = 0;
-	for (size_t i = 0; struct_transform->subtransforms[i].transform; i++) {
+	for (size_t i = 0; self->subtransforms[i].transform; i++) {
 		bithenge_transform_t *subxform =
-		    struct_transform->subtransforms[i].transform;
+		    self->subtransforms[i].transform;
 		aoff64_t sub_size;
 		rc = bithenge_transform_prefix_length(subxform, blob, &sub_size);
@@ -344,10 +342,9 @@
 }
 
-static int struct_transform_destroy(bithenge_transform_t *xform)
-{
-	struct_transform_t *struct_transform = transform_as_struct(xform);
-	free_subtransforms(struct_transform->subtransforms);
-	free(struct_transform);
-	return EOK;
+static void struct_transform_destroy(bithenge_transform_t *base)
+{
+	struct_transform_t *self = transform_as_struct(base);
+	free_subtransforms(self->subtransforms);
+	free(self);
 }
 
@@ -370,20 +367,20 @@
 {
 	int rc;
-	struct_transform_t *struct_transform =
-	    malloc(sizeof(*struct_transform));
-	if (!struct_transform) {
+	struct_transform_t *self =
+	    malloc(sizeof(*self));
+	if (!self) {
 		rc = ENOMEM;
 		goto error;
 	}
-	rc = bithenge_new_transform(struct_as_transform(struct_transform),
+	rc = bithenge_init_transform(struct_as_transform(self),
 	    &struct_transform_ops);
 	if (rc != EOK)
 		goto error;
-	struct_transform->subtransforms = subtransforms;
-	*out = struct_as_transform(struct_transform);
+	self->subtransforms = subtransforms;
+	*out = struct_as_transform(self);
 	return EOK;
 error:
 	free_subtransforms(subtransforms);
-	free(struct_transform);
+	free(self);
 	return rc;
 }
Index: uspace/app/bithenge/transform.h
===================================================================
--- uspace/app/bithenge/transform.h	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/transform.h	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -51,25 +51,24 @@
 typedef struct bithenge_transform_ops {
 	/** @copydoc bithenge_transform_t::bithenge_transform_apply */
-	int (*apply)(bithenge_transform_t *xform, bithenge_node_t *in, bithenge_node_t **out);
+	int (*apply)(bithenge_transform_t *self, bithenge_node_t *in, bithenge_node_t **out);
 	/** @copydoc bithenge_transform_t::bithenge_transform_prefix_length */
-	int (*prefix_length)(bithenge_transform_t *xform, bithenge_blob_t *blob, aoff64_t *out);
+	int (*prefix_length)(bithenge_transform_t *self, bithenge_blob_t *blob, aoff64_t *out);
 	/** Destroy the transform.
-	 * @param xform The transform.
-	 * @return EOK on success or an error code from errno.h. */
-	int (*destroy)(bithenge_transform_t *xform);
+	 * @param self The transform. */
+	void (*destroy)(bithenge_transform_t *self);
 } bithenge_transform_ops_t;
 
 /** Apply a transform.
  * @memberof bithenge_transform_t
- * @param xform The transform.
+ * @param self The transform.
  * @param in The input tree.
  * @param[out] out Where the output tree will be stored.
  * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_transform_apply(bithenge_transform_t *xform,
+static inline int bithenge_transform_apply(bithenge_transform_t *self,
     bithenge_node_t *in, bithenge_node_t **out)
 {
-	assert(xform);
-	assert(xform->ops);
-	return xform->ops->apply(xform, in, out);
+	assert(self);
+	assert(self->ops);
+	return self->ops->apply(self, in, out);
 }
 
@@ -79,40 +78,36 @@
  * subtransforms.
  * @memberof bithenge_transform_t
- * @param xform The transform.
+ * @param self The transform.
  * @param blob The blob.
  * @param[out] out Where the prefix length will be stored.
  * @return EOK on success, ENOTSUP if not supported, or another error code from
  * errno.h. */
-static inline int bithenge_transform_prefix_length(bithenge_transform_t *xform,
+static inline int bithenge_transform_prefix_length(bithenge_transform_t *self,
     bithenge_blob_t *blob, aoff64_t *out)
 {
-	assert(xform);
-	assert(xform->ops);
-	if (!xform->ops->prefix_length)
+	assert(self);
+	assert(self->ops);
+	if (!self->ops->prefix_length)
 		return ENOTSUP;
-	return xform->ops->prefix_length(xform, blob, out);
+	return self->ops->prefix_length(self, blob, out);
 }
 
 /** Increment a transform's reference count.
- * @param xform The transform to reference.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_transform_inc_ref(bithenge_transform_t *xform)
+ * @param self The transform to reference. */
+static inline void bithenge_transform_inc_ref(bithenge_transform_t *self)
 {
-	assert(xform);
-	xform->refs++;
-	return EOK;
+	assert(self);
+	self->refs++;
 }
 
 /** Decrement a transform's reference count and free it if appropriate.
- * @param xform The transform to dereference, or NULL.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_transform_dec_ref(bithenge_transform_t *xform)
+ * @param self The transform to dereference, or NULL. */
+static inline void bithenge_transform_dec_ref(bithenge_transform_t *self)
 {
-	if (!xform)
-		return EOK;
-	assert(xform->ops);
-	if (--xform->refs == 0)
-		return xform->ops->destroy(xform);
-	return EOK;
+	if (!self)
+		return;
+	assert(self->ops);
+	if (--self->refs == 0)
+		self->ops->destroy(self);
 }
 
@@ -127,5 +122,5 @@
 extern bithenge_named_transform_t *bithenge_primitive_transforms;
 
-int bithenge_new_transform(bithenge_transform_t *xform,
+int bithenge_init_transform(bithenge_transform_t *self,
     const bithenge_transform_ops_t *ops);
 
Index: uspace/app/bithenge/tree.c
===================================================================
--- uspace/app/bithenge/tree.c	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/tree.c	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -41,42 +41,41 @@
 #include "tree.h"
 
-static int blob_destroy(bithenge_node_t *base)
-{
-	bithenge_blob_t *blob = bithenge_node_as_blob(base);
-	assert(blob->base.blob_ops);
-	return blob->base.blob_ops->destroy(blob);
-}
-
-static int node_destroy(bithenge_node_t *node)
-{
-	switch (bithenge_node_type(node)) {
+static void blob_destroy(bithenge_node_t *base)
+{
+	bithenge_blob_t *self = bithenge_node_as_blob(base);
+	assert(self->base.blob_ops);
+	self->base.blob_ops->destroy(self);
+}
+
+static void node_destroy(bithenge_node_t *self)
+{
+	switch (bithenge_node_type(self)) {
 	case BITHENGE_NODE_BLOB:
-		return blob_destroy(node);
+		blob_destroy(self);
+		return;
 	case BITHENGE_NODE_STRING:
-		if (node->string_value.needs_free)
-			free((void *)node->string_value.ptr);
+		if (self->string_value.needs_free)
+			free((void *)self->string_value.ptr);
 		break;
 	case BITHENGE_NODE_INTERNAL:
-		return node->internal_ops->destroy(node);
+		self->internal_ops->destroy(self);
+		return;
 	case BITHENGE_NODE_BOOLEAN:
-		return EOK; // the boolean nodes are allocated statically below
+		return; /* The boolean nodes are allocated statically below. */
 	case BITHENGE_NODE_INTEGER: /* pass-through */
 		break;
 	}
-	free(node);
-	return EOK;
+	free(self);
 }
 
 /** Decrement a node's reference count and free it if appropriate.
  * @memberof bithenge_node_t
- * @param node The node to dereference, or NULL.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_node_dec_ref(bithenge_node_t *node)
+ * @param node The node to dereference, or NULL. */
+void bithenge_node_dec_ref(bithenge_node_t *node)
 {
 	if (!node)
-		return EOK;
+		return;
 	if (--node->refs == 0)
-		return node_destroy(node);
-	return EOK;
+		node_destroy(node);
 }
 
@@ -103,9 +102,9 @@
 {
 	int rc;
-	simple_internal_node_t *node = node_as_simple(base);
-	for (bithenge_int_t i = 0; i < node->len; i++) {
-		bithenge_node_inc_ref(node->nodes[2*i+0]);
-		bithenge_node_inc_ref(node->nodes[2*i+1]);
-		rc = func(node->nodes[2*i+0], node->nodes[2*i+1], data);
+	simple_internal_node_t *self = node_as_simple(base);
+	for (bithenge_int_t i = 0; i < self->len; i++) {
+		bithenge_node_inc_ref(self->nodes[2*i+0]);
+		bithenge_node_inc_ref(self->nodes[2*i+1]);
+		rc = func(self->nodes[2*i+0], self->nodes[2*i+1], data);
 		if (rc != EOK)
 			return rc;
@@ -114,17 +113,12 @@
 }
 
-static int simple_internal_node_destroy(bithenge_node_t *base)
-{
-	int rc;
-	simple_internal_node_t *node = node_as_simple(base);
-	for (bithenge_int_t i = 0; i < 2 * node->len; i++) {
-		rc = bithenge_node_dec_ref(node->nodes[i]);
-		if (rc != EOK)
-			return rc;
-	}
-	if (node->needs_free)
-		free(node->nodes);
-	free(node);
-	return EOK;
+static void simple_internal_node_destroy(bithenge_node_t *base)
+{
+	simple_internal_node_t *self = node_as_simple(base);
+	for (bithenge_int_t i = 0; i < 2 * self->len; i++)
+		bithenge_node_dec_ref(self->nodes[i]);
+	if (self->needs_free)
+		free(self->nodes);
+	free(self);
 }
 
@@ -136,13 +130,13 @@
 /** Initialize an internal node.
  * @memberof bithenge_node_t
- * @param[out] node The node.
+ * @param[out] self The node.
  * @param[in] ops The operations provided.
  * @return EOK on success or an error code from errno.h. */
-int bithenge_init_internal_node(bithenge_node_t *node,
+int bithenge_init_internal_node(bithenge_node_t *self,
     const bithenge_internal_node_ops_t *ops)
 {
-	node->type = BITHENGE_NODE_INTERNAL;
-	node->refs = 1;
-	node->internal_ops = ops;
+	self->type = BITHENGE_NODE_INTERNAL;
+	self->refs = 1;
+	self->internal_ops = ops;
 	return EOK;
 }
@@ -164,17 +158,17 @@
 	int rc;
 	assert(out);
-	simple_internal_node_t *node = malloc(sizeof(*node));
-	if (!node) {
+	simple_internal_node_t *self = malloc(sizeof(*self));
+	if (!self) {
 		rc = ENOMEM;
 		goto error;
 	}
-	rc = bithenge_init_internal_node(simple_as_node(node),
+	rc = bithenge_init_internal_node(simple_as_node(self),
 	    &simple_internal_node_ops);
 	if (rc != EOK)
 		goto error;
-	node->nodes = nodes;
-	node->len = len;
-	node->needs_free = needs_free;
-	*out = simple_as_node(node);
+	self->nodes = nodes;
+	self->len = len;
+	self->needs_free = needs_free;
+	*out = simple_as_node(self);
 	return EOK;
 error:
@@ -183,5 +177,5 @@
 	if (needs_free)
 		free(nodes);
-	free(node);
+	free(self);
 	return rc;
 }
@@ -211,11 +205,11 @@
 {
 	assert(out);
-	bithenge_node_t *node = malloc(sizeof(*node));
-	if (!node)
+	bithenge_node_t *self = malloc(sizeof(*self));
+	if (!self)
 		return ENOMEM;
-	node->type = BITHENGE_NODE_INTEGER;
-	node->refs = 1;
-	node->integer_value = value;
-	*out = node;
+	self->type = BITHENGE_NODE_INTEGER;
+	self->refs = 1;
+	self->integer_value = value;
+	*out = self;
 	return EOK;
 }
@@ -231,12 +225,12 @@
 {
 	assert(out);
-	bithenge_node_t *node = malloc(sizeof(*node));
-	if (!node)
+	bithenge_node_t *self = malloc(sizeof(*self));
+	if (!self)
 		return ENOMEM;
-	node->type = BITHENGE_NODE_STRING;
-	node->refs = 1;
-	node->string_value.ptr = value;
-	node->string_value.needs_free = needs_free;
-	*out = node;
+	self->type = BITHENGE_NODE_STRING;
+	self->refs = 1;
+	self->string_value.ptr = value;
+	self->string_value.needs_free = needs_free;
+	*out = self;
 	return EOK;
 }
Index: uspace/app/bithenge/tree.h
===================================================================
--- uspace/app/bithenge/tree.h	(revision 04a7435f4ee13d275f9b652482de1d377eed4a8f)
+++ uspace/app/bithenge/tree.h	(revision 978ccaf1353e6dc7d83c324cc4bfc3d5a951be8c)
@@ -93,7 +93,8 @@
 typedef struct bithenge_internal_node_ops_t {
 	/** @copydoc bithenge_node_t::bithenge_node_for_each */
-	int (*for_each)(bithenge_node_t *node, bithenge_for_each_func_t func, void *data);
-	/** @copydoc bithenge_node_t::bithenge_node_destroy */
-	int (*destroy)(bithenge_node_t *node);
+	int (*for_each)(bithenge_node_t *self, bithenge_for_each_func_t func, void *data);
+	/** Destroys the internal node.
+	 * @param self The node to destroy. */
+	void (*destroy)(bithenge_node_t *self);
 } bithenge_internal_node_ops_t;
 
@@ -109,55 +110,54 @@
 /** Increment a node's reference count.
  * @memberof bithenge_node_t
- * @param node The node to reference.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_node_inc_ref(bithenge_node_t *node)
+ * @param node The node to reference. */
+static inline void bithenge_node_inc_ref(bithenge_node_t *node)
 {
 	assert(node);
 	node->refs++;
-	return EOK;
 }
 
-int bithenge_node_dec_ref(bithenge_node_t *node);
+void bithenge_node_dec_ref(bithenge_node_t *node);
 
 /** Iterate over a node's children.
  * @memberof bithenge_node_t
- * @param node The internal node to iterate over.
+ * @param self The internal node to iterate over.
  * @param func The callback function.
  * @param data Data to provide to the callback function.
  * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_node_for_each(bithenge_node_t *node, bithenge_for_each_func_t func, void *data)
+static inline int bithenge_node_for_each(bithenge_node_t *self,
+    bithenge_for_each_func_t func, void *data)
 {
-	assert(node->type == BITHENGE_NODE_INTERNAL);
-	return node->internal_ops->for_each(node, func, data);
+	assert(self->type == BITHENGE_NODE_INTERNAL);
+	return self->internal_ops->for_each(self, func, data);
 }
 
 /** Get the value of a boolean node.
  * @memberof bithenge_node_t
- * @param node The boolean node.
+ * @param self The boolean node.
  * @return The node's value. */
-static inline bool bithenge_boolean_node_value(bithenge_node_t *node)
+static inline bool bithenge_boolean_node_value(bithenge_node_t *self)
 {
-	assert(node->type == BITHENGE_NODE_BOOLEAN);
-	return node->boolean_value;
+	assert(self->type == BITHENGE_NODE_BOOLEAN);
+	return self->boolean_value;
 }
 
 /** Get the value of an integer node.
  * @memberof bithenge_node_t
- * @param node The integer node.
+ * @param self The integer node.
  * @return The node's value. */
-static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *node)
+static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *self)
 {
-	assert(node->type == BITHENGE_NODE_INTEGER);
-	return node->integer_value;
+	assert(self->type == BITHENGE_NODE_INTEGER);
+	return self->integer_value;
 }
 
 /** Get the value of an string node.
  * @memberof bithenge_node_t
- * @param node The string node.
+ * @param self The string node.
  * @return The node's value. */
-static inline const char *bithenge_string_node_value(bithenge_node_t *node)
+static inline const char *bithenge_string_node_value(bithenge_node_t *self)
 {
-	assert(node->type == BITHENGE_NODE_STRING);
-	return node->string_value.ptr;
+	assert(self->type == BITHENGE_NODE_STRING);
+	return self->string_value.ptr;
 }