Advice on


Our group (team of 4) have done a few small-scale Rails applications.
They've been successful enough that we're contemplating a much larger
scale development.

By scale I don't mean the number of users or hits/second or volumes of
data handled. That really isn't an issue for us, and even if it
happens we're confident we can deal with it.

What we're most concerned about is scaling to a large number of models
and controllers. We estimate about 100+ "entities" that we'll need to
manage, and that doesn't include M:M join tables or general lookup
tables. Also, some of the tables (thankfully only a few) have more
than 40 columns.

Most of the open-source projects we initially looked at for learning
and guidance are quite small (e.g. Insoshi has < 20 models).

Are there any tips for programming in the large?

Any pointers would be appreciated.


Are you mostly worried about the "soft" side of this (ie how will
developers get their heads around a large app like this) or have I
misinterpreted your question ?


Hi Cameron,

One idea is to build a bunch of little applications instead of just
one and making them all connect with each other over REST. Having many
apps would make it simpler to change their implementations and also to
get people around it, as there would be less objects and things to
worry about each of them. It's also easier to scale, as each app can
run in it's own server, with it's own database without having to worry
about the other ones.

The downside of having many micro-apps is that you end up with a lot
of "moving parts" in your system, as an application needs to talk to
other application to perform it's job.

And one consideration, 40 columns in one table doesn't seem to be a
good idea, maybe you could try to normalize it a litle bit more :slight_smile:


The largest projects (in Rails) that I've worked on have been in the
range of ~150 models. The only major difference between a smaller 20
model project and one with 150... is the amount of overhead there is
in thinking about changes. Good spec coverage (rspec!) is going to
help you out in the long run. The general best practices that Rails
community encourages you to follow works just as well with a large
project as it does with a small project.

Remember: A large project is just a collection of smaller ones. Break it down...

Good luck!