So this is definitely feeling like a rite of passage, because I am stuck! I looked at the answer in the back of the book and everything in the code makes COMPLETE sense, except for the very end (the actual recursion). I will copy the entire code for context:

```
`def sort arr`
`rec_sort arr, []`
`end`
`def rec_sort unsorted, sorted`
`if unsorted.length <=0`
`return sorted`
`end`
`smallest = unsorted.pop`
`still_unsorted = []`
`unsorted.each do |x|`
`if x < smallest`
`still_unsorted.push smallest`
`smallest = x`
`else`
`still_unsorted.push x`
`end`
`end`
`sorted.push smallest`
`rec_sort still_unsorted, sorted #I do not understand this`
```

`end`

`puts (sort(['can', 'feel', 'singing', 'like', 'a', 'can']))`

I understand that the method is calling itself, but with the first argument replaced with “still_unsorted”. However, it seems like this would pose a problem once the method is run with this new argument. For example, after the initial “if” statement, it would now look like this:

```
`smallest = still_unsorted.pop`
`still_unsorted = []`
`still_unsorted.each do |x|`
`if x < smallest`
`still_unsorted.push smallest`
`smallest = x`
`else`
`still_unsorted.push x`
`end`
`end`
`sorted.push smallest`
`rec_sort still_unsorted, sorted`
```

Is this how the code reads after the method calls itself? It seems like it wouldn’t work. I just wanted to make sure I’m not missing some key concept here.

Thanks for any help, suggestions!