Okay so I've been working on writing an insertion sort function in MIPS assembly for a while now..I'm at the point where I really just don't know what to do.
I think I'm getting held back trying to get an individual character from a given string at a given location in an array.
Also, as far as I know, the print_array method and the str_lt methods are both working, the final insertionSort method isn't though.

This is what I have written so far
Code:
# Data/declarations
.data
	# For main function
	initStr: 	 	.asciiz "The initial array is:\n"
	endStr:		 	.asciiz "Insertion sort is finished!\n"

	# For print_array
	arrPrintStart:	.asciiz "["
	arrPrintEnd:	.asciiz " ]\n"
	spc:			.asciiz " "
	size: 		 	.word 16
	
	# For str_lt
	nullChar:		.asciiz "\0"
	charX:			.asciiz ""
	charY:			.asciiz ""
	xCounter:		.word 0
	yCounter:		.word 0

	# For insertSort
	value:			.asciiz ""
	space:			.align 5

	# General
	iCounter:    	.word 0
	jCounter:    	.word 0

    arr: 	.align 5
         	.asciiz "Joe"
		 	.align 5
            .asciiz "Jenny"
			.align 5
            .asciiz "Jill"
			.align 5
            .asciiz "John"
			.align 5
            .asciiz "Jeff"
			.align 5
            .asciiz "Joyce"
			.align 5
            .asciiz "Jerry"
			.align 5
            .asciiz "Janice"
			.align 5
            .asciiz "Jake"
			.align 5
            .asciiz "Jonna"
			.align 5
            .asciiz "Jack"
			.align 5
            .asciiz "Jocelyn"
			.align 5
            .asciiz "Jessie"
			.align 5
            .asciiz "Jess"
			.align 5
            .asciiz "Janet"
			.align 5
            .asciiz "Jane"
			.align 5

.text

.globl main

# Main method
main:
	la $a0, initStr		# 
	li $v0, 4			# Load and print the initial string
    syscall				#

	jal print_array		# Call print_array

	jal insertSort		# Call insertSort

	la $a0, endStr		# 
	li $v0, 4			# Load and print the initial string
    syscall				#

	jal print_array		# Call print_array

	li $v0, 10			# Exit (system call code for exit is 10)
	syscall				# Make the syscall



print_array:
	addi $sp, $sp, -8			# Adjust the stack for 2 more items
	sw $ra, 4($sp)				# Save the return address
	sw $a0, 0($sp)				# Save the user input (size)

	la $s0, arr					# Store array address in s0

	la $a0, arrPrintStart		#
	li $v0, 4					# Print arrPrintStart (in $v0)
	syscall						#

	startLoop:
		lw $a0, size				# Load the array size to a0

		blt $a1, $a0, loopNotDone	# If a1<a0, goto loopNotDone
	
		# Here the loop is done, so we want to print arrPrintEnd and exit
		la $a0, arrPrintEnd			#
		li $v0, 4					# Print arrPrintEnd (in $v0)
		syscall						#

		lw $ra, 4($sp)				# Load the return address
    	addi $sp, $sp, 8			# Remove 2 items off the stack
		jr $ra						# Return to the caller


		loopNotDone:
			addi $a1, $a1, 1		# Add 1 to i
			
			la $a0, spc				# 
			li $v0, 4				# Print a space
			syscall					# 
			la $a0, 0($s0)			# 
			li $v0, 4				# Print the current array item
			syscall					# 

			addi $s0, $s0, 32		# Add 32 to s0
	
			jal startLoop			# Call startLoop (recursive)
		
			lw $ra, 4($sp)			# Load the return address
			addi $sp, $sp, 8		# Remove 2 items off the stack
			jr $ra					# Return to caller



str_lt:
	# $a1 will point to xChar
	# $a2 will point to yChar
	addi $sp, $sp, -4			# Adjust the stack for 1 more item
	sw $ra, 0($sp)				# Save the return address
	
	startCharLoop:
		bgtz $a1, exit				# If xChar is '\0', exit
		bgtz $a2, exit				# If yChar is '\0', exit

		blt $a1, $a2, return1		# If xChar<yChar, return 1
		blt $a2, $a1, return0		# If yChar<xChar, return 0

		add $a1, $a1, 1				# Increment pointer to xChar
		add $a2, $a2, 1				# Increment pointer to yChar

		j startLoop					# Start the loop again

	return0:
		add $v0, $zero, $zero		# Set our result to 0

		lw $ra, 0($sp)				# Load the return address
    	addi $sp, $sp, 4			# Remove 1 item off the stack
		jr $ra						# Return to the caller

	return1:
		add $v0, $zero, 1			# Set our result to 1

		lw $ra, 0($sp)				# Load the return address
    	addi $sp, $sp, 4			# Remove 1 item off the stack
		jr $ra						# Return to the caller

	exit:
		beqz $a2, return0			# If yChar='\0', return 0
		j return1					# Else return 1
		


insertSort:
	# Adjust the stack for 1 more item
	addi $sp, $sp, -4
	# Save the return address		
	sw $ra, 0($sp)

	lw $t6, size						# Set $t6 to the array size
	lw $t0, iCounter					# Load iCounter to t0 - for individual chars
	lw $t1, jCounter					# Load jCounter to t1 - for individual chars
	la $s1, arr							# Load array to s1 - will act as iCounter for full strings
	la $s2, arr							# Load array to s2 - will act as jCounter for full strings
	la $t2, arr							# Load the array as a pointer to t2

	addi $t0, $zero, 1					# Set $t0 to 1 (the first loop counter)

	startFirstForLoop:

		beq $t0, $t6, end					# If i=size of array, exit
		j startSecondForLoop				# Else goto startSecondForLoop

		startSecondForLoop:
			add $t3, $s1, $t0				# Set *value to the correct item

			sub $t1, $t0, 1					# Set $t1 to t0-1 (jCounter = iCounter - 1)	

			la $t7, 32						# 
			mult $t7, $t0					# Set s1 pointer to t0*32
			add $s1, $t2, $t7				# 		

			la $t7, 32						# 
			mult $t7, $t1					# Set s2 pointer to t1*32
			add $s2, $t2, $t7				#


			la $a0, 0($t3)			# 
			li $v0, 4				# Print the current array item
			syscall					# 


			bge $t1, $zero, firstCondMet	# Branch to firstCondMet if t1 >= 0
			j startFirstForLoop				# Else goto startFirstForLoop
			
				firstCondMet:
					### Making sure our registers used in str_lt are assigned correctly ###
					add $s1, $s1, $t0			# Point to the i char of this word
					add $s2, $s2, $t1			# Point to the i char of this word
					lb $a0, ($s1)				# Load the pointer to arr[t0] to a0 (our first str_lt parameter)
					lb $a1, ($s2)				# Load the pointer to arr[t1] to a1 (our first str_lt parameter)

					jal str_lt					# Goto str_lt (result will be saved to $v0)

					sub $s1, $s1, $t0			# Reset $s1 to a multiple of 32
					sub $s2, $s2, $t1			# Reset $s2 to a multiple of 32

					beq $v0, $zero, startFirstForLoop	# Branch to startFirstForLoop if v0=0
					j secondCondMet						# Else goto secondCondMet
					
					secondCondMet:
						addi $t4, $t1, 1			# Set t1+1 to t4
						la $t4, ($t1)				# Set t4 (t1+1) to t1 (a[j+1] = a[j])
						
						subi $t1, $t1, 1			# t1 = t1-1 
						jal startSecondForLoop		# Recurse back to the start of the second for loop


			addi $t4, $t1, 1						# Set t1+1 to t4
			la $t4, ($t3)							# Set t4 (t1+1) to t3 (a[j+1] = value)

			addi $t0, $t0, 1						# Increment the iCounter

			jal startFirstForLoop					# Recurse back to the start of the first for loop


	end:
		lw $ra, 0($sp)					# Load the return address
		addi $sp, $sp, 4				# Remove 1 item off the stack
		jr $ra							# Return to caller
Here is the C code I am translating from
Code:
int main(void)
{
  char * data[] = {"Joe", "Jenny", "Jill", "John", "Jeff", "Joyce",
		"Jerry", "Janice", "Jake", "Jonna", "Jack", "Jocelyn",
		"Jessie", "Jess", "Janet", "Jane"};
  int size = 16;

  printf("Initial array is:\n");
  print_array(data, size);
  insertSort(data, size);
  printf("Insertion sort is finished!\n");
  print_array(data, size);
  exit(0);
}


int str_lt (char *x, char *y) {
  for (; *x!='\0' && *y!='\0'; x++, y++) {
    if ( *x < *y ) return 1;
    if ( *y < *x ) return 0;
  }
  if ( *y == '\0' ) return 0;
  else return 1;
}

void insertSort(char *a[], size_t length) {
     // WAS: size_t i, j;
     // size_t can be 'unsigned int';  When j decrements from 0 to -1,
     // this causes an underflow problem that is not caught by gcc-3.2.
     int i, j;
 
     for(i = 1; i < length; i++) {
         char *value = a[i];
         for (j = i-1; j >= 0 && str_lt(value, a[j]); j--) {
             a[j+1] = a[j];
         }
         a[j+1] = value;
     }
 }

void print_array(char * a[], const int size)
{
  int i=0;
  printf("[");
  while(i < size) printf("  %s", a[i++]);
  printf(" ]\n");
}

Any help is greatly appreciated, I'm pretty stuck here.