Question: I am watching a tutorial on 2d arrays and I can't seem to understand where the values for 
states.length and states[i].length are coming from. How does it know the outer loop deals with the size 3 array and the inner is the size 2 array?

```
public class Test3 {
public static void main(String[] args) {

    String [][] states = new String[3][2];

    states[0][0] = "California";
    states[0][1] = "Sacremento";

    states[1][0] = "Oregon";
    states[1][1] = "Salem";

    states[2][0] = "Washington";
    states[2][1] = "Olympia";

    for (int i = 0; i < states.length; i++) {

        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < states[i].length; j++) {

            sb.append(states[i][j]);
        }
        System.out.println(sb);
    }

}
}

```

Answer: 
I feel like Swift is a bit too young at the moment for this kind of advice, so take any with a grain of salt. And in the future who knows, maybe a new feature will come to Swift that changes how everyone writes Swift code.

That being said, here are my thoughts on this topic:

In native Swift code you should stay away from implicitly unwrapped optionals as much as you can. If your function may return `nil` for any reason, then the return type should be Optional, which tells the receiver that they can expect `nil` to be returned. 

Returning an implicitly unwrapped optional from a native Swift function currently doesn't give you much information. To me it says "This return value should never be `nil`". But in that case, why does it need to be an Optional at all? 

**Edit:**
Regarding your posted code, the only reason that code returns implicitly unwrapped optionals is because it is translated from ObjC.
In my opinion, for old framework the reason apple using implicitly unwrapped optionals is to provide almost the same usage and behaviours as Obj-C.