diff --git a/README.md b/README.md
index 2f40357..a41bddc 100644
--- a/README.md
+++ b/README.md
@@ -92,9 +92,9 @@ touch main.c
 #include "libcproject/libcproject.h"
 
 int main() {
-  string_t string_value = "Hello, world!"; // `string_t` is a typedef from `libcproject`
-  printf("%s\n", string_value);
-  printf("string_length = %ld\n", string_get_length(string_value)); // `string_get_length` is a function from `libcproject`
+  string_t string = "Hello, world!"; // `string_t` is a typedef from `libcproject`
+  printf("%s\n", string);
+  printf("string_length = %ld\n", string_get_length(string)); // `string_get_length` is a function from `libcproject`
   return EXIT_SUCCESS;
 }
 ```
diff --git a/lib/character.c b/lib/character.c
index aa53ea1..737f917 100644
--- a/lib/character.c
+++ b/lib/character.c
@@ -1,17 +1,17 @@
 #include "character.h"
 
-void character_append(string_t string_value, const char character) {
-  size_t length = string_get_length(string_value);
-  character_append_at(string_value, character, length);
+void character_append(string_t string, const char character) {
+  size_t length = string_get_length(string);
+  character_append_at(string, character, length);
 }
 
-void character_append_at(string_t string_value, const char character, const size_t index) {
-  size_t length = string_get_length(string_value);
+void character_append_at(string_t string, const char character, const size_t index) {
+  size_t length = string_get_length(string);
   for (size_t index_string = length; index_string > index; index_string--) {
-    string_value[index_string] = string_value[index_string - 1];
+    string[index_string] = string[index_string - 1];
   }
-  string_value[index] = character;
-  string_value[length + 1] = '\0';
+  string[index] = character;
+  string[length + 1] = '\0';
 }
 
 char character_to_upper(const char character) {
diff --git a/lib/character.h b/lib/character.h
index 4a02587..527d24f 100644
--- a/lib/character.h
+++ b/lib/character.h
@@ -11,21 +11,21 @@
  * @brief Append a character to a string, assuming string points to an array
  * with enough space.
  *
- * @param string_value
+ * @p
  * @param character
  * @since v1.0.0
  */
-void character_append(string_t string_value, char character);
+void character_append(string_t string, char character);
 
 /**
  * @brief Append a character to a string at a specific index, assuming string points to an array with enough space.
  *
- * @param string_value
+ * @param string
  * @param character
  * @param index
  * @since v1.0.0
  */
-void character_append_at(string_t string_value, const char character, const size_t index);
+void character_append_at(string_t string, const char character, const size_t index);
 
 /**
  * @brief Converts the character to uppercase.
diff --git a/lib/convert.c b/lib/convert.c
index 3ef577c..b084127 100644
--- a/lib/convert.c
+++ b/lib/convert.c
@@ -18,12 +18,12 @@ char convert_digit_to_character(const char digit) {
   return digit + '0';
 }
 
-long long convert_string_to_number(const string_t string_value) {
-  bool is_negative = string_value[0] == '-';
+long long convert_string_to_number(const string_t string) {
+  bool is_negative = string[0] == '-';
   long long integer = 0;
-  size_t length = string_get_length(string_value);
+  size_t length = string_get_length(string);
   for (size_t index = is_negative ? 1 : 0; index < length; index++) {
-    integer = integer * 10 + convert_character_to_digit(string_value[index]);
+    integer = integer * 10 + convert_character_to_digit(string[index]);
   }
   return is_negative ? integer * -1 : integer;
 }
@@ -42,23 +42,22 @@ string_t convert_number_to_string(const long long integer) {
   if (is_negative) {
     length++;
   }
-  string_t string_value = malloc(sizeof(char) * length);
-  if (string_value == NULL) {
+  string_t string = malloc(sizeof(char) * length);
+  if (string == NULL) {
     exit(EXIT_FAILURE);
   }
   current = mathematics_absolute_value(integer);
   size_t index = 0;
   while (current != 0) {
-    string_value[index++] = convert_digit_to_character(current % 10);
+    string[index++] = convert_digit_to_character(current % 10);
     current = current / 10;
   }
   if (is_negative) {
-    string_value[index++] = '-';
+    string[index++] = '-';
   }
-  string_value[index] = '\0';
-  char* result = string_reverse(string_value);
-  free(string_value);
-  return result;
+  string[index] = '\0';
+  string_reverse(string);
+  return string;
 }
 
 string_t convert_number_from_base_10_to_base(unsigned long long number, unsigned int base) {
diff --git a/lib/convert.h b/lib/convert.h
index aaac456..9fb1cb1 100644
--- a/lib/convert.h
+++ b/lib/convert.h
@@ -37,10 +37,10 @@ char convert_digit_to_character(const char digit);
 /**
  * @brief Convert a string to a number.
  *
- * @param string_value
+ * @param string
  * @since v1.0.0
  */
-long long convert_string_to_number(const string_t string_value);
+long long convert_string_to_number(const string_t string);
 
 /**
  * @brief Convert a number to a string.
diff --git a/lib/string.c b/lib/string.c
index 4699606..5ca2ef1 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -1,135 +1,95 @@
 #include "string.h"
 
-size_t string_get_length(const string_t string_value) {
+size_t string_get_length(const string_t string) {
   size_t length = 0;
-  while (string_value[length] != '\0') {
+  while (string[length] != '\0') {
     length++;
   }
   return length;
 }
 
-string_t string_to_uppercase(string_t string_value) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
+void string_to_uppercase(string_t string) {
+  size_t string_length = string_get_length(string);
   for (size_t index = 0; index < string_length; index++) {
-    result[index] = character_to_upper(string_value[index]);
+    string[index] = character_to_upper(string[index]);
   }
-  result[string_length] = '\0';
-  return result;
+  string[string_length] = '\0';
 }
 
-string_t string_to_lowercase(string_t string_value) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
+void string_to_lowercase(string_t string) {
+  size_t string_length = string_get_length(string);
   for (size_t index = 0; index < string_length; index++) {
-    result[index] = character_to_lower(string_value[index]);
+    string[index] = character_to_lower(string[index]);
   }
-  result[string_length] = '\0';
-  return result;
+  string[string_length] = '\0';
 }
 
-string_t string_replace(string_t string_value, char search, char replace) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
+void string_replace(string_t string, char search, char replace) {
+  size_t string_length = string_get_length(string);
   for (size_t index = 0; index < string_length; index++) {
-    bool is_search_value = search == string_value[index];
+    bool is_search_value = search == string[index];
     if (is_search_value) {
-      result[index] = replace;
+      string[index] = replace;
     } else {
-      result[index] = string_value[index];
+      string[index] = string[index];
     }
   }
-  result[string_length] = '\0';
-  return result;
+  string[string_length] = '\0';
 }
 
-string_t string_trim_start(string_t string_value, char character) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
+void string_trim_start(string_t string, char character) {
+  size_t string_length = string_get_length(string);
   size_t index_space = 0;
-  while (string_value[index_space] == character) {
+  while (string[index_space] == character) {
     index_space++;
   }
-  for (size_t index = index_space; index < string_length; index++) {
-    result[index - index_space] = string_value[index];
+  for (size_t index = 0; index < string_length - index_space; index++) {
+    string[index] = string[index + index_space];
   }
-  result[string_length - index_space] = '\0';
-  return result;
+  string[string_length - index_space] = '\0';
 }
 
-string_t string_trim_end(string_t string_value, char character) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
-  }
+void string_trim_end(string_t string, char character) {
+  size_t string_length = string_get_length(string);
   size_t index_space = string_length - 1;
-  while (string_value[index_space] == character) {
+  while (string[index_space] == character) {
     index_space--;
   }
-  for (size_t index = 0; index < index_space + 1; index++) {
-    result[index] = string_value[index];
-  }
-  result[index_space + 1] = '\0';
-  return result;
+  string[index_space + 1] = '\0';
 }
 
-string_t string_trim(string_t string_value, char character) {
-  string_t result_start = string_trim_start(string_value, character);
-  string_t result = string_trim_end(result_start, character);
-  free(result_start);
-  return result;
+void string_trim(string_t string, char character) {
+  string_trim_start(string, character);
+  string_trim_end(string, character);
 }
 
-string_t string_copy(const string_t source) {
-  size_t source_length = string_get_length(source);
+string_t string_copy(const string_t string) {
+  size_t source_length = string_get_length(string);
   string_t copy = malloc(sizeof(char) * (source_length + 1));
   if (copy == NULL) {
     exit(EXIT_FAILURE);
   }
   size_t index;
   for (index = 0; index < source_length; index++) {
-    copy[index] = source[index];
+    copy[index] = string[index];
   }
   copy[index] = '\0';
   return copy;
 }
 
-string_t string_capitalize(string_t string_value) {
-  size_t string_length = string_get_length(string_value);
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
+void string_capitalize(string_t string) {
+  size_t string_length = string_get_length(string);
+  if (string_length == 0) {
+    return;
   }
-  for (size_t index = 0; index < string_length; index++) {
-    bool is_first_character = index == 0;
-    if (is_first_character) {
-      result[index] = character_to_upper(string_value[index]);
-    } else {
-      result[index] = string_value[index];
-    }
-  }
-  result[string_length] = '\0';
-  return result;
+  string[0] = character_to_upper(string[0]);
 }
 
-size_t string_total_occurrences_of_character(string_t string_value, char character) {
+size_t string_total_occurrences_of_character(string_t string, char character) {
   size_t result = 0;
-  size_t string_length = string_get_length(string_value);
+  size_t string_length = string_get_length(string);
   for (size_t index = 0; index < string_length; index++) {
-    char current_character = string_value[index];
+    char current_character = string[index];
     if (current_character == character) {
       result += 1;
     }
@@ -137,21 +97,17 @@ size_t string_total_occurrences_of_character(string_t string_value, char charact
   return result;
 }
 
-string_t string_reverse(const string_t string_value) {
-  size_t string_length = string_get_length(string_value);
-  size_t index = 0;
-  string_t result = malloc(sizeof(char) * (string_length + 1));
-  if (result == NULL) {
-    exit(EXIT_FAILURE);
+void string_reverse(const string_t string) {
+  size_t string_length = string_get_length(string);
+  size_t index_start = 0;
+  size_t index_end = string_length - 1;
+  while (index_start < index_end) {
+    char temporary = string[index_start];
+    string[index_start] = string[index_end];
+    string[index_end] = temporary;
+    index_start++;
+    index_end--;
   }
-  size_t result_index = 0;
-  for (index = string_length - 1; index > 0; index--) {
-    result[result_index] = string_value[index];
-    result_index++;
-  }
-  result[result_index] = string_value[index];
-  result[string_length] = '\0';
-  return result;
 }
 
 bool string_equals(const string_t string1, const string_t string2) {
@@ -166,11 +122,11 @@ bool string_equals(const string_t string1, const string_t string2) {
   return is_equal;
 }
 
-bool string_get_is_integer(const string_t string_value) {
+bool string_get_is_integer(const string_t string) {
   size_t index = 0;
-  size_t string_length = string_get_length(string_value);
+  size_t string_length = string_get_length(string);
   bool is_integer = string_length >= 1;
-  if (is_integer && string_value[0] == '-') {
+  if (is_integer && string[0] == '-') {
     if (string_length == 1) {
       is_integer = false;
     } else {
@@ -178,7 +134,7 @@ bool string_get_is_integer(const string_t string_value) {
     }
   }
   while (index < string_length && is_integer) {
-    if (!character_get_is_digit(string_value[index])) {
+    if (!character_get_is_digit(string[index])) {
       is_integer = false;
     }
     index++;
@@ -186,8 +142,8 @@ bool string_get_is_integer(const string_t string_value) {
   return is_integer;
 }
 
-string_t* string_split(const string_t string_value, char separator, size_t* result_size) {
-  size_t string_length = string_get_length(string_value);
+string_t* string_split(const string_t string, char separator, size_t* result_size) {
+  size_t string_length = string_get_length(string);
   size_t index_string = 0;
   size_t index_current = 0;
   size_t index_result = 0;
@@ -197,7 +153,7 @@ string_t* string_split(const string_t string_value, char separator, size_t* resu
     exit(EXIT_FAILURE);
   }
   while (index_string < string_length) {
-    if (string_value[index_string] == separator) {
+    if (string[index_string] == separator) {
       current[index_current] = '\0';
       result = realloc(result, sizeof(string_t) * (index_result + 1));
       if (result == NULL) {
@@ -207,7 +163,7 @@ string_t* string_split(const string_t string_value, char separator, size_t* resu
       index_result++;
       index_current = 0;
     } else {
-      current[index_current] = string_value[index_string];
+      current[index_current] = string[index_string];
       index_current++;
     }
     index_string++;
@@ -230,8 +186,8 @@ string_t string_join(string_t* array, const char separator, size_t array_length)
     total_length += string_get_length(array[index_array]);
   }
   size_t string_length = total_length + (array_length - 1);
-  string_t string_value = malloc(sizeof(char) * (string_length + 1));
-  if (string_value == NULL) {
+  string_t string = malloc(sizeof(char) * (string_length + 1));
+  if (string == NULL) {
     exit(EXIT_FAILURE);
   }
   size_t current_index = 0;
@@ -239,17 +195,17 @@ string_t string_join(string_t* array, const char separator, size_t array_length)
     string_t substring = array[index_array];
     size_t substring_length = string_get_length(substring);
     for (size_t index_substring = 0; index_substring < substring_length; index_substring++) {
-      string_value[current_index] = substring[index_substring];
+      string[current_index] = substring[index_substring];
       current_index++;
     }
     bool is_last_character = index_array == (array_length - 1);
     if (!is_last_character) {
-      string_value[current_index] = separator;
+      string[current_index] = separator;
       current_index++;
     }
   }
-  string_value[string_length] = '\0';
-  return string_value;
+  string[string_length] = '\0';
+  return string;
 }
 
 string_t string_concatenate(string_t string1, string_t string2) {
@@ -271,16 +227,16 @@ string_t string_concatenate(string_t string1, string_t string2) {
   return result;
 }
 
-bool string_get_has_unique_characters(const string_t string_value) {
+bool string_get_has_unique_characters(const string_t string) {
   bool has_unique = true;
-  size_t string_length = string_get_length(string_value);
+  size_t string_length = string_get_length(string);
   struct hash_map* characters_already_seen = hash_map_initialization();
   string_t* keys = malloc(sizeof(string_t) * string_length);
   for (size_t index = 0; index < string_length; index++) {
     keys[index] = NULL;
   }
   for (size_t index = 0; index < string_length && has_unique; index++) {
-    char character = string_value[index];
+    char character = string[index];
     keys[index] = convert_character_to_string(character);
     string_t key = keys[index];
     if (hash_map_contains_key(characters_already_seen, key)) {
@@ -299,24 +255,24 @@ bool string_get_has_unique_characters(const string_t string_value) {
   return has_unique;
 }
 
-string_t string_substring(const string_t string_value, size_t index_start, size_t index_end) {
+string_t string_substring(const string_t string, size_t index_start, size_t index_end) {
   size_t substring_length = index_end - index_start + 1;
   string_t result = malloc(sizeof(char) * (substring_length + 1));
   for (size_t index = 0; index < substring_length; index++) {
-    result[index] = string_value[index_start + index];
+    result[index] = string[index_start + index];
   }
   result[substring_length] = '\0';
   return result;
 }
 
-bool string_get_is_substring(const string_t string_value, const string_t substring) {
+bool string_get_is_substring(const string_t string, const string_t substring) {
   bool is_substring = false;
-  size_t string_length = string_get_length(string_value);
+  size_t string_length = string_get_length(string);
   size_t substring_length = string_get_length(substring);
   for (size_t index_string = 0; index_string < string_length && !is_substring; index_string++) {
     size_t index_substring = 0;
     size_t index_considered = index_string;
-    while (index_substring < substring_length && string_value[index_considered] == substring[index_substring]) {
+    while (index_substring < substring_length && string[index_considered] == substring[index_substring]) {
       index_substring++;
       index_considered++;
     }
@@ -356,23 +312,22 @@ string_t string_get_formatted_number(const long long number, string_t separator)
   }
   free(number_string);
   result[formatted_length] = '\0';
-  string_t new_result = string_reverse(result);
-  free(result);
+  string_reverse(result);
   if (is_negative) {
     string_t dash = convert_character_to_string('-');
-    string_t negative_result = string_concatenate(dash, new_result);
-    free(new_result);
+    string_t negative_result = string_concatenate(dash, result);
+    free(result);
     free(dash);
     return negative_result;
   }
-  return new_result;
+  return result;
 }
 
-string_t string_get_last_occurence_of_character(const string_t string_value, char character) {
-  size_t string_length = string_get_length(string_value);
+string_t string_get_last_occurence_of_character(const string_t string, char character) {
+  size_t string_length = string_get_length(string);
   size_t index_last_occurrence = SIZE_MAX;
   for (size_t index = 0; index < string_length; index++) {
-    if (string_value[index] == character) {
+    if (string[index] == character) {
       index_last_occurrence = index;
     }
   }
@@ -385,29 +340,29 @@ string_t string_get_last_occurence_of_character(const string_t string_value, cha
   }
   size_t index_result = 0;
   for (size_t index = index_last_occurrence; index < string_length; index++) {
-    result[index_result++] = string_value[index];
+    result[index_result++] = string[index];
   }
   result[index_result] = '\0';
   return result;
 }
 
-bool string_starts_with(const string_t string_value, const string_t prefix) {
+bool string_starts_with(const string_t string, const string_t prefix) {
   bool starts_with = true;
   size_t prefix_length = string_get_length(prefix);
   for (size_t index = 0; index < prefix_length && starts_with; index++) {
-    starts_with = string_value[index] == prefix[index];
+    starts_with = string[index] == prefix[index];
   }
   return starts_with;
 }
 
-bool string_ends_with(const string_t string_value, const string_t prefix) {
+bool string_ends_with(const string_t string, const string_t prefix) {
   bool ends_with = true;
-  size_t string_length = string_get_length(string_value);
+  size_t string_length = string_get_length(string);
   size_t prefix_length = string_get_length(prefix);
   size_t index_string = string_length - 1;
   size_t index_prefix = prefix_length - 1;
   while (index_prefix > 0 && ends_with) {
-    ends_with = string_value[index_string] == prefix[index_prefix];
+    ends_with = string[index_string] == prefix[index_prefix];
     index_string--;
     index_prefix--;
   }
diff --git a/lib/string.h b/lib/string.h
index 8373983..e596c03 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -13,93 +13,109 @@
 /**
  * @brief Return the length of a string (excluding '\0').
  *
- * @param string_value
+ * @param string
  * @since v1.0.0
  */
-size_t string_get_length(const string_t string_value);
+size_t string_get_length(const string_t string);
 
 /**
  * @brief Converts all the alphabetic characters in a string to uppercase.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_to_uppercase(string_t string_value);
+void string_to_uppercase(string_t string);
 
 /**
  * @brief Converts all the alphabetic characters in a string to lowercase.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_to_lowercase(string_t string_value);
+void string_to_lowercase(string_t string);
 
 /**
  * @brief Replace all the occurrences of search value into replace value in the string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @param search A character search value.
  * @param replace A character containing the text to replace for match.
  * @since v1.0.0
  */
-string_t string_replace(string_t string_value, char search, char replace);
+void string_replace(string_t string, char search, char replace);
 
 /**
  * @brief Removes all `character` from the start of a string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_trim_start(string_t string_value, char character);
+void string_trim_start(string_t string, char character);
 
 /**
  * @brief Removes all `character` from the end of a string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_trim_end(string_t string_value, char character);
+void string_trim_end(string_t string, char character);
 
 /**
  * @brief Removes all `character` from the start and end of a string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_trim(string_t string_value, char character);
+void string_trim(string_t string, char character);
 
 /**
  * @brief Return the copy of a string.
  *
- * @param string_value
+ * @param string
  * @since v1.0.0
  */
-string_t string_copy(const string_t string_value);
+string_t string_copy(const string_t string);
 
 /**
  * @brief Capitalizes the string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_capitalize(string_t string_value);
+void string_capitalize(string_t string);
 
 /**
  * @brief Returns the total number of occurrences of the given character in the string.
  *
- * @param string_value
+ * @param string
  * @param character
  * @since v1.0.0
  */
-size_t string_total_occurrences_of_character(string_t string_value, char character);
+size_t string_total_occurrences_of_character(string_t string, char character);
 
 /**
- * @brief Reverse the characters in an array.
+ * @brief Reverse the characters in a string.
  *
- * @param string_value
+ * NOTE: Mutates the string.
+ *
+ * @param string
  * @since v1.0.0
  */
-string_t string_reverse(const string_t string_value);
+void string_reverse(const string_t string);
 
 /**
  * @brief Check if two strings are equals.
@@ -114,21 +130,21 @@ bool string_equals(const string_t string1, const string_t string2);
 /**
  * @brief Check if the string is a integer.
  *
- * @param string_value
+ * @param string
  * @return true if the string is a integer, false otherwise.
  * @since v1.0.0
  */
-bool string_get_is_integer(const string_t string_value);
+bool string_get_is_integer(const string_t string);
 
 /**
  * @brief Split a string into substrings using the specified separator and return them as an array and update the pointer `result_size` to the resulting size of the created array.
  *
- * @param string_value
+ * @param string
  * @param separator
  * @param result_size
  * @since v1.0.0
  */
-string_t* string_split(const string_t string_value, char separator, size_t* result_size);
+string_t* string_split(const string_t string, char separator, size_t* result_size);
 
 /**
  * @brief Adds all the elements of an array into a string, separated by the specified separator string.
@@ -161,22 +177,22 @@ bool string_get_has_unique_characters(const string_t string);
 /**
  * @brief Returns the part of the string between the start and end indexes (both included).
  *
- * @param string_value
+ * @param string
  * @param index_start
  * @param index_end
  * @since v1.0.0
  */
-string_t string_substring(const string_t string_value, size_t index_start, size_t index_end);
+string_t string_substring(const string_t string, size_t index_start, size_t index_end);
 
 /**
  * @brief Check if a string contains a substring.
  *
- * @param string_value
+ * @param string
  * @param substring
  * @return true if the string contains the substring, false otherwise.
  * @since v1.0.0
  */
-bool string_get_is_substring(const string_t string_value, const string_t substring);
+bool string_get_is_substring(const string_t string, const string_t substring);
 
 /**
  * @brief Format a number to a string with specified separator.
@@ -194,30 +210,30 @@ string_t string_get_formatted_number(const long long number, string_t separator)
 /**
  * @brief Returns a pointer to the last occurrence of character in the string.
  *
- * @param string_value
+ * @param string
  * @param character
  * @since v1.0.0
  */
-string_t string_get_last_occurence_of_character(const string_t string_value, char character);
+string_t string_get_last_occurence_of_character(const string_t string, char character);
 
 /**
  * @brief Check if a string starts with a substring.
  *
- * @param string_value
+ * @param string
  * @param prefix
  * @return true if the string starts with the substring, false otherwise.
  * @since v1.0.0
  */
-bool string_starts_with(const string_t string_value, const string_t prefix);
+bool string_starts_with(const string_t string, const string_t prefix);
 
 /**
  * @brief Check if a string ends with a substring.
  *
- * @param string_value
+ * @param string
  * @param prefix
  * @return true if the string ends with the substring, false otherwise.
  * @since v1.0.0
  */
-bool string_ends_with(const string_t string_value, const string_t prefix);
+bool string_ends_with(const string_t string, const string_t prefix);
 
 #endif
diff --git a/lib/terminal.c b/lib/terminal.c
index d352c52..58c3915 100644
--- a/lib/terminal.c
+++ b/lib/terminal.c
@@ -3,20 +3,20 @@
 string_t terminal_input() {
   char character;
   size_t length = 1;
-  string_t string_value = malloc(length * sizeof(char));
-  if (string_value == NULL) {
+  string_t string = malloc(length * sizeof(char));
+  if (string == NULL) {
     exit(EXIT_FAILURE);
   }
-  *string_value = '\0';
+  *string = '\0';
   while ((character = getchar()) != '\n' && character != EOF) {
     length++;
-    string_value = realloc(string_value, length * sizeof(char));
-    if (string_value == NULL) {
+    string = realloc(string, length * sizeof(char));
+    if (string == NULL) {
       exit(EXIT_FAILURE);
     }
-    character_append(string_value, character);
+    character_append(string, character);
   }
-  return string_value;
+  return string;
 }
 
 void terminal_print_array(void* array, size_t array_size, size_t element_size, void (*print_element)(void*)) {
diff --git a/main.c b/main.c
index b2092b3..e21d9d4 100644
--- a/main.c
+++ b/main.c
@@ -4,8 +4,8 @@
 #include "libcproject.h"
 
 int main() {
-  string_t string_value = "Hello, world!";
-  printf("%s\n", string_value);
-  printf("string_length = %ld\n", string_get_length(string_value));
+  string_t string = "Hello, world!";
+  printf("%s\n", string);
+  printf("string_length = %ld\n", string_get_length(string));
   return EXIT_SUCCESS;
 }
diff --git a/test/string_test.c b/test/string_test.c
index 7f1e7c4..da54507 100644
--- a/test/string_test.c
+++ b/test/string_test.c
@@ -30,46 +30,47 @@ void string_get_length_test() {
   string_t string = "Hello World!";
   size_t string_length = string_get_length(string);
   assert(string_length == 12);
+  assert(strlen(string) == string_length);
 }
 
 void string_to_uppercase_test() {
-  string_t string = "heLlO world";
-  string = string_to_uppercase(string);
+  string_t string = string_copy("heLlO world");
+  string_to_uppercase(string);
   assert(assert_string_equal(string, "HELLO WORLD"));
   free(string);
 }
 
 void string_to_lowercase_test() {
-  string_t string = "HellO WoRLd";
-  string = string_to_lowercase(string);
+  string_t string = string_copy("HellO WoRLd");
+  string_to_lowercase(string);
   assert(assert_string_equal(string, "hello world"));
   free(string);
 }
 
 void string_replace_test() {
-  string_t string = "hello world";
-  string = string_replace(string, 'l', 'z');
+  string_t string = string_copy("hello world");
+  string_replace(string, 'l', 'z');
   assert(assert_string_equal(string, "hezzo worzd"));
   free(string);
 }
 
 void string_trim_start_test() {
-  string_t string = "      hello world      ";
-  string = string_trim_start(string, ' ');
+  string_t string = string_copy("      hello world      ");
+  string_trim_start(string, ' ');
   assert(assert_string_equal(string, "hello world      "));
   free(string);
 }
 
 void string_trim_end_test() {
-  string_t string = "      hello world      ";
-  string = string_trim_end(string, ' ');
+  string_t string = string_copy("      hello world      ");
+  string_trim_end(string, ' ');
   assert(assert_string_equal(string, "      hello world"));
   free(string);
 }
 
 void string_trim_test() {
-  string_t string = "      hello world      ";
-  string = string_trim(string, ' ');
+  string_t string = string_copy("      hello world      ");
+  string_trim(string, ' ');
   assert(assert_string_equal(string, "hello world"));
   free(string);
 }
@@ -86,8 +87,8 @@ void string_copy_test() {
 }
 
 void string_capitalize_test() {
-  string_t string = "hello world";
-  string = string_capitalize(string);
+  string_t string = string_copy("hello world");
+  string_capitalize(string);
   assert(assert_string_equal(string, "Hello world"));
   free(string);
 }
@@ -98,8 +99,8 @@ void string_total_occurrences_of_character_test() {
 }
 
 void string_reverse_test() {
-  string_t string = "hello world";
-  string = string_reverse(string);
+  string_t string = string_copy("hello world");
+  string_reverse(string);
   assert(assert_string_equal(string, "dlrow olleh"));
   free(string);
 }