I’ve been mucking a bit with go recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with go recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with go recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with go recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn’t use all the inodes. Why not?
Let’s add some debug:
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
Ahh there we go, we are running out of open file descriptors. Of course.
So the final code becomes:
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````
Ahh there we go, we are running out of open file descriptors. Of course.
So the final code becomes:
and we can compile it like so:
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````
Ahh there we go, we are running out of open file descriptors. Of course.
So the final code becomes:
`````I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`I’ve been mucking a bit with [go][1] recently. Nothing special, just doing some small problems that I needed to solve.
At work, I have built up a challenge for new candidates. One of them is the old trick of using all the inodes on a file-system. This is a quick one to rule out the ones who have real world experience.
So I wrote some code:
`
``
But this wouldn't use all the inodes. Why not?
Let's add some debug:
```
````
Ahh there we go, we are running out of open file descriptors. Of course.
So the final code becomes:
`````
and we can compile it like so: