The Rontologist

Returning multiple values from a single function is not supported in most programming languages. To get around this limitation some developers have wrapped their return values in an array. This is a bad practice that should not be followed as it leads to fragile and unreadable code.

For example, lets make a function that needs to return a user object and her favourite movie. This can be done by wrapping both pieces of data in an object array like this:

public Object[] getUserInfo(String username) {
    /* code to look up a user */
    return new Object[] {user, favouriteMovie};
}

This is nice, compact, and easy to implement. Unfortunately it is a bit unwieldy trying to use it:

Object[] info = getUserInfo("bob");
String name = (String) info[0];
Movie favouriteMovie = (Movie) info[1];

There is a fair amount of casting going on, and it does add several extra variables. But it does work, and because of time considerations we decide to leave it be until we have time to go back to it (and since this is software that will never happen).

A week down the road the code gets selected for a random code review. The reviewers are feeling the time pressure as well and decide that the only thing that needs changing are the index literals. It would be much better if they were constants. This is a change that can be done quickly with little risk of making a mistake.

public static final int USER_INFO_USER_IDX = 0;
public static final int USER_INFO_FAV_MOVIE_IDX = 1;

public Object[] getUserInfo(String username) {
    /* code to look up a user */
    return new Object[] {user, favouriteMovie};
}

// usage
Object[] info = getUserInfo("bob");
String name = (String) info[USER_INFO_USER_IDX];
Movie favouriteMovie = (Movie) info[USER_INFO_FAV_MOVIE_IDX];

The constants are in place and everyone agrees that it is an improvement.

Another week down the road a new requirement comes down the pipe requesting that the software also tracks the users favourite snack. It is decided that the getUserInfo function should be expanded to return this information as well.

public static final int USER_INFO_USER_IDX = 0;
public static final int USER_INFO_FAV_MOVIE_IDX = 1;
public static final int USER_INFO_FAV_SNACK_IDX = 2;

public Object[] getUserInfo(String username) {
    /* code to look up a user */
    return new Object[] {user, favouriteMovie, favouriteSnack};
}

// usage
Object[] info = getUserInfo("bob");
String name = (String) info[USER_INFO_USER_IDX];
Movie favouriteMovie = (Movie) info[USER_INFO_FAV_MOVIE_IDX];
Snack favouriteSnack = (Snack) info[USER_INFO_FAV_SNACK_IDX];

As you can see it is getting uglier with each iteration. The focus of our business changes and we no longer care about movies, but they are so ingrained in the system that we will need to take an iterative approach in removing them. The first set is to remove it from the getUserInfo function. Doing it for the function is easy.

public static final int USER_INFO_USER_IDX = 0;
public static final int USER_INFO_FAV_MOVIE_IDX = 1;
public static final int USER_INFO_FAV_SNACK_IDX = 1;

public Object[] getUserInfo(String username) {
    /* code to look up a user */
    return new Object[] {user, favouriteMovie,  favouriteSnack};
}

// usage
Object[] info = getUserInfo("bob");
String name = (String) info[USER_INFO_USER_IDX];
Movie favouriteMovie = (Movie) info[USER_INFO_FAV_MOVIE_IDX];
Snack favouriteSnack = (Snack) info[USER_INFO_FAV_SNACK_IDX];

When we try to compile this we will get a warning from every class that used the USER_INFO_FAV_MOVIE_IDX symbol. Once those are fixed up it should be fine, but unfortunately it is not.

When the array is returned there is no way to enforce that the constants are used while accessing it. Any usage of it where developers used literal numbers to access the elements will still compile, and cause runtime errors since info[1] is now returning a Snack instead of a Movie. This can be the source of more bugs than you can shake a stick at, and is precisely the reason why you should never return an array like this.

A better approach would be to create a small object as a container and return that. It is a little more overhead up front but it does pay off during the maintenance cycle. Assume we had implemented getUserInfo loike this prior to the request to remove the favourite movie.

public static class UserInfo {
    private String user;
    private Movie favouriteMovie;
    private Snack favouriteSnack;

   /* getters and setters */
}

public UserInfo getUserInfo(String username) {
    /* code to look up a user */
    return new UserInfo(user, favouriteMovie, favouriteSnack);
}

Not only will the usage of this be nicer (since the casting and temporary variables are no longer needed) but it’ll be easier to maintain to. If we remove the movie property from our object the compiler will let us know every usage of it – not just the ones that people accessed with optional constants.

Arrays as a multiple return mechanism is a bad idea and a horrible code smell.