Growing Rails Applications in Practice Front Cover

Growing Rails Applications in Practice

  • Length: 88 pages
  • Edition: 1
  • Publisher:
  • Publication Date: 2014-06-20
Description
  • “Never has a tech book spoken so clearly and in a timely manner to acute pains I’ve been having at work” — Ethan Garofolo
  • “Nice to witness a new generation of Rails authors” — Obie Fernandez
  • #1 bestselling book on Leanpub during launch week!

How we got here

When you started working with Rails some years ago, it all seemed so easy. You saw the blog-in-ten-minutes video. You reproduced the result. ActiveRecord felt great and everything had its place.

Fast forward two years. Your blog is now a full-blown CMS with a hundred models and controllers. Your team has grown to four developers. Every change to the application is a pain. Your code feels like a house of cards.

You turn to the internet for assistance, and find it filled with silver bullets. You should move away from fat controllers, it says. But do avoid fat models. And use DCI. Or CQRS. Or SOA. As you cycle through patterns, your application is becoming a patchwork of different coding techniques. New team members are having a hard time catching up. And you’re beginning to question if all those new techniques actually help, or if you’re just adding layers of indirection.

You start missing the early days, when everything had seemed so easy and every new piece of code had its place. You actually liked ActiveRecord before it drowned you in a sea of callbacks. If only there was a way to do things “the Rails way” without having it fall apart as your application grows.

The myth of the infinitely scalable architecture

We’d like to show you one path to write Rails apps that are a joy to understand and change, even as your team and codebase grows. This book describes a complete toolbox that has served us well for all requirements that we have encountered.

But before we do that, we need to let you in on an inconvenient secret: Large applications are large. The optimal implementation of a large application will always be more complex than the optimal representation of a smaller app. We cannot make this go away. What we can do is to organize a codebase in a way that “scales logarithmically”. Twice as many models should not mean twice as many problems.

To accomplish this, you don’t necessarily need to change the entire way your application is built. You don’t necessarily need to introduce revolutionary architectures to your code. You can probably make it with the tools built into Rails, if you use them in a smarter way.

Compare this to sorting algorithms. When a sorting function is too slow, our first thought is not “install a Hadoop cluster”. Instead we simply look for an algorithm that scales better. In a similar fashion this book is not about revolutionary design patterns or magic gems that make all your problems go away. Instead we will show how to use discipline, consistency and organization to make your application grow more gently.

Table of Contents

Chapter 1. Introduction

Part 1. New rules for Rails
Chapter 2. Beautiful controllers
Chapter 3. Relearning ActiveRecord
Chapter 4. User interactions without a database

Part 2. Creating a system for growth
Chapter 5. Dealing with fat models
Chapter 6. A home for interaction-specific code
Chapter 7. Extracting service objects
Chapter 8. Organizing large codebases with namespaces
Chapter 9. Taming stylesheets

Part 3. Building applications to last
Chapter 10. On following fashions
Chapter 11. Surviving the upgrade pace of Rails
Chapter 12. Owning your stack
Chapter 13. The value of tests
Chapter 14. Closing thoughts

To access the link, solve the captcha.
Subscribe