I have a singleton collection that will very rarely change, but is not static data. Let's say that it's a list of possible shapes that objects can have:

```
var Shape = Backbone.Model.extend({});
var Shapes = new Backbone.Collection.extend({
  url: "/mydata"
});
Shapes.fetch()

```

I have a model and associated collection which is for the models that my views will interact with. We'll call them structures:

```
var Structure = Backbone.Model.extend({
  initialize: function(options) {
    this.vecs = some_utility_function(options.shape);
  }
});

var Structures = Backbone.Collection.extend({
  model: Structure,
  create: function(options) {
    var shape = options.shape || Shapes.get("weird_square");
    return new Structure(Shapes.get("weird_square"));
  }
});

```

The problem is in the collection's `create` function: the call to `Shapes.get()` won't work until the Shapes collection has fired `sync` at least once.

So there's already a complexity issue: now my views need to know that they need to wait for a `sync` event from the `Shapes` collection before they can call `create()` on the Structures collection to get a new model instances.

Even worse: my views might never even **see** the sync, because it'll get a response pretty quickly and a lot of other stuff needs to happen before these views are created.

The only solutions I can think of are:

* a monstrous higher-level view or model that knows everything that needs to be ready before my views and models can talk to each other, and somehow resolves those dependencies before doing anything. That's achievable, but it's difficult to maintain and any structure I give it will seem arbitrary
* changing the code in the collection's `create` so that it's really just giving out a stub instance of the model, and only once the Shapes collection is ready does it fill fire a callback to fill that object in and call `sync` on the model instance. This sucks a bit, because now `sync` on the model could mean "the object has actually been created for real now" as well as its usual meaning of being synced with the server.

Is there a better way?