I was recently having a decent conversation with some friends online about where scalability should reside or, more importantly, where it shouldn’t.

While scalability in web applications, which is what we were mainly discussing, is something which is typically ignored (except in the largest of applications); it is nonetheless important – especially with the new range of tools like .NET and J2EE which encourage developers to think of web applications as actual applications.

My thoughts could easily be organized into 3 main areas: Development Style, Abstraction and Application Servers.

Development Style

The key part of development style is designing your applications and websites in such a way that if your site got to a certain load you won’t have to rewrite it. Doing this is in the first place is the most obvious solution. The exact specifications for this will likely depend on the environment and language used, but the principles are the same, and tie into my second point.

Abstraction

While too much abstraction can be a hindrance to scalability, too little certainly is. Having at least 3 tiers is incredibly helpful and I’d even say critical for an application to scale properly.

In fact, a properly designed middle tier really does simplify the task of your frontend coding. After all, if there is little or no actual logic (beyond a few quick loops and checks) in the frontend code, there’s nothing that could really be done to make it non scalable (again, big if!).

I’m a firm believer in utilizing your tiers to the maximum not just for scalability but also for project longevity. I believe you honestly need to have priorities for each project. For some, speed will be an issue, for others longevity will and so you may actually have greater levels of abstraction so that you can more easily manage certain aspects of the application over the long term.

Application Servers

While not an area that web developers typically think of, when we begin thinking about websites as simply the frontend to larger applications, the possibility and, in some cases, necessity, of application servers should be readily apparent.

I’d like to take this one step further and say that the farther from your frontend that you implement logic, the better performance (likely, but not always, depends on too many things) but more importantly the all-desired scalability, longevity and cost reductions will be.

If you think about it, nobody is saying “put everything in the PHP or .NET page”, as that’d be silly (except in the cases of tiny sites which wouldn’t benefit from N-Tier at all, but I’m assuming we’re talking about something beyond the norm of what we debate about).

Where to Concentrate Your Efforts

It’s almost like we should ideally be designing all our applications as a reverse funnel. The farther from the user you are, the heavier your logic, fault tolerance, etc, etc, etc should be.

I guess this applies in every area of application design: where the logic sits, what areas you backup (after all, why backup your PHP or .NET or JSP pages nightly?); etc.

The farther from the user you are, the more you concentrate your efforts, right?

Anyways, just jumbled thoughts, perhaps I’ll organize them more later.