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: 
It's probably too early to have strict best practices for swift, but here's my opinion. In general implicitly unwrapped optionals should be used for a few cases such as outlets, properties that are nil until initialization and return values from Objective-C functions, otherwise a regular optional should be used. 

If you are creating a function that will return a value or nil, do the other programmers interacting with your code a favor and make the return value an optional.
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.