Ruby on Rails 2：敏捷web开发经典指南

需积分: 1 159 浏览量更新于2024-07-26 收藏 9.07MB PDF 举报

"《敏捷Web开发与Rails 2》是一本专为Ruby on Rails新手设计的专业指南，由Ruby on Rails社区的重要人物撰写。该书第一版就因其对Rails框架的全面介绍和对新开发者职业生涯的有力推动而受到欢迎。最新版本延续了这一传统，仍然是向新Rails开发者推荐的第一本书。书中作者以一种轻松愉快的方式让读者熟悉Rails环境，特别是通过清晰地解释模型-视图-控制器（Model-View-Controller，MVC）模式，这在许多其他教程中往往显得复杂难懂。作者采用循序渐进的方法，通过实例彻底消除初学者对这种架构模式的困惑，使学习过程变得直观且易于理解。评论者Mikel Lindsaar，Rails Core团队成员，Ruby Mail库的创建者，以及Ruby X的负责人，高度赞扬了该书对于Rails环境的易用性和对MVC模式的深入讲解。他认为这本书不仅适合入门者，也满足了经验丰富的开发者对深度理解和实践指导的需求。另一评论者Ken Coar，一位开源软件倡导者和Apache开发者，提到《敏捷Web开发与Rails》成功地保持了教学内容的趣味性，同时又不失专业性，确保了读者既能享受阅读，又能获得实用的技能。因此，这本书不仅提供了对Ruby on Rails 2版本的全面覆盖，而且是每个希望进入或提升其Web开发技能的开发者不可或缺的参考资料。"

Introduction

Ruby on Rails is a framework that makes it easier to develop, deploy, and

maintain web applications. During the months that followed its initial release,

Rails went from being an unknown toy to being a worldwide phenomenon,

and more important, it has become the framework of choice for the implemen-

tation of a wide range of so-called Web 2.0 applications.

Why is that?

Rails Simply Feels Right

First, a large number of developers were frustrated with the technologies they

were using to create web applications. It didn’t seem to matter whether they

were using Java, PHP, or .NET—there was a growing sense that their job was

just too damn hard. And then, suddenly, along came Rails, and Rails was

easier.

But easy on its own doesn’t cut it. We’re talking about professional developers

writing real-world websites. They wanted to feel that the applications they

were developing would stand the test of time—that they were designed and

implemented using modern, professional techniques. So, these developers

dug into Rails and discovered it wasn’t just a tool for hacking out sites.

For example, all Rails applications are implemented using the Model-View-

Controller (MVC) architecture. Java developers are used to frameworks such

as Tapestry and Struts, which are based on MVC. But Rails takes MVC further:

when you develop in Rails, you start with a working application, there’s a

place for each piece of code, and all the pieces of your application interact in

a standard way.

Professional programmers write tests. And again, Rails delivers. All Rails

applications have testing support baked right in. As you add functionality to

the code, Rails automatically creates test stubs for that functionality. The

framework makes it easy to test applications, and as a result, Rails applica-

tions tend to get tested.

report erratum • discuss

Prepared exclusively for suling zhang

Rails applications are written in Ruby, a modern, object-oriented scripting

language. Ruby is concise without being unintelligibly terse—you can express

ideas naturally and cleanly in Ruby code. This leads to programs that are

easy to write and (just as important) are easy to read months later.

Rails takes Ruby to the limit, extending it in novel ways that make a program-

mer’s life easier. This makes our programs shorter and more readable. It also

allows us to perform tasks that would normally be done in external configu-

ration files inside the codebase instead. This makes it far easier to see what’s

happening. The following code defines the model class for a project. Don’t

worry about the details for now. Instead, just think about how much informa-

tion is being expressed in a few lines of code.

class Project < ActiveRecord::Base

belongs_to :portfolio

has_one :project_manager

has_many :milestones

has_many :deliverables, through: milestones

validates :name, :description, presence: true

validates :non_disclosure_agreement, acceptance: true

validates :short_name, uniqueness: true

end

Two other philosophical underpinnings keep Rails code short and readable:

DRY and convention over configuration. DRY stands for don’t repeat yourself:

every piece of knowledge in a system should be expressed in just one place.

Rails uses the power of Ruby to bring that to life. You’ll find very little dupli-

cation in a Rails application; you say what you need to say in one place—a

place often suggested by the conventions of the MVC architecture—and then

move on. For programmers used to other web frameworks, where a simple

change to the schema could involve them in half a dozen or more code

changes, this was a revelation.

Convention over configuration is crucial, too. It means that Rails has sensible

defaults for just about every aspect of knitting together your application.

Follow the conventions, and you can write a Rails application using less code

than a typical Java web application uses in XML configuration. If you need

to override the conventions, Rails makes that easy, too.

Developers coming to Rails found something else, too. Rails isn’t playing

catch-up with the new de facto web standards; it’s helping define them. And

Rails makes it easy for developers to integrate features such as Ajax and

RESTful interfaces into their code, because support is built in. (And if you’re

xviii • Introduction

report erratum • discuss

Prepared exclusively for suling zhang

not familiar with Ajax and REST interfaces, never fear—we’ll explain them

later in the book.)

Developers are worried about deployment too. They found that with Rails you

can deploy successive releases of your application to any number of servers

with a single command (and roll them back equally easily should the release

prove to be somewhat less than perfect).

Rails was extracted from a real-world, commercial application. It turns out

that the best way to create a framework is to find the central themes in a

specific application and then bottle them up in a generic foundation of code.

When you’re developing your Rails application, you’re starting with half of a

really good application already in place.

But there’s something else to Rails—something that’s hard to describe.

Somehow, it just feels right. Of course, you’ll have to take our word for that

until you write some Rails applications for yourself (which should be in the

next forty-five minutes or so…). That’s what this book is all about.

Rails Is Agile

The title of this book is Agile Web Development with Rails. You may be sur-

prised to discover that we don’t have explicit sections on applying agile

practices X, Y, and Z to Rails coding.

The reason is both simple and subtle. Agility is part of the fabric of Rails.

Let’s look at the values expressed in the Agile Manifesto as a set of four

preferences:

• Individuals and interactions over processes and tools

• Working software over comprehensive documentation

• Customer collaboration over contract negotiation

• Responding to change over following a plan

Rails is all about individuals and interactions. There are no heavy toolsets,

no complex configurations, and no elaborate processes. There are just small

groups of developers, their favorite editors, and chunks of Ruby code. This

leads to transparency; what the developers do is reflected immediately in

what the customer sees. It’s an intrinsically interactive process.

Rails doesn’t denounce documentation. Rails makes it trivially easy to create

HTML documentation for your entire codebase. But the Rails development

1. http://agilemanifesto.org/. Dave Thomas was one of the seventeen authors of this

document.

report erratum • discuss

Introduction • xix

Prepared exclusively for suling zhang

process isn’t driven by documents. You won’t find 500-page specifications at

the heart of a Rails project. Instead, you’ll find a group of users and developers

jointly exploring their need and the possible ways of answering that need.

You’ll find solutions that change as both the developers and the users become

more experienced with the problems they’re trying to solve. You’ll find a

framework that delivers working software early in the development cycle. This

software may be rough around the edges, but it lets the users start to get a

glimpse of what you’ll be delivering.

In this way, Rails encourages customer collaboration. When customers see

just how quickly a Rails project can respond to change, they start to trust

that the team can deliver what’s required, not just what has been requested.

Confrontations are replaced by “What if?” sessions.

That’s all tied to the idea of being able to respond to change. The strong, almost

obsessive, way that Rails honors the DRY principle means that changes to

Rails applications impact a lot less code than the same changes would in

other frameworks. And since Rails applications are written in Ruby, where

concepts can be expressed accurately and concisely, changes tend to be local-

ized and easy to write. The deep emphasis on both unit and functional testing,

along with support for test fixtures and stubs during testing, gives developers

the safety net they need when making those changes. With a good set of tests

in place, changes are less nerve-racking.

Rather than constantly trying to tie Rails processes to the agile principles,

we’ve decided to let the framework speak for itself. As you read through the

tutorial chapters, try to imagine yourself developing web applications this

way: working alongside your customers and jointly determining priorities and

solutions to problems. Then, as you read the more advanced concepts that

follow in Part III, see how the underlying structure of Rails can enable you to

meet your customers’ needs faster and with less ceremony.

One last point about agility and Rails: although it’s probably unprofessional

to mention this, think how much fun the coding will be.

Who This Book Is For

This book is for programmers looking to build and deploy web-based applica-

tions. This includes application programmers who are new to Rails (and

perhaps even new to Ruby) and ones who are familiar with the basics but

want a more in-depth understanding of Rails.

We presume some familiarity with HTML, Cascading Style Sheets (CSS), and

JavaScript, in other words, the ability to view source on web pages. You need

xx • Introduction

report erratum • discuss

Prepared exclusively for suling zhang

not be an expert on these subjects; the most you will be expected to do is to

copy and paste material from the book, all of which can be downloaded.

How To Read This Book

The first part of this book makes sure you are ready. By the time you are

done with it, you will have been introduced to Ruby (the language), you will

have been exposed to an overview of Rails itself, you will have Ruby and Rails

installed, and you will have verified the installation with a simple example.

The next part takes you through the concepts behind Rails via an extended

example; we build a simple online store. It doesn’t take you one by one through

each component of Rails (“here is a chapter on models, here is a chapter on

views,” and so forth). These components are designed to work together, and

each chapter in this section tackles a specific set of related tasks that involve

a number of these components working together.

Most folks seem to enjoy building the application along with the book. If you

don’t want to do all that typing, you can cheat and download the source code

(a compressed tar archive or a zip file).

This download contains separate sets

of source code for Rails 3.0 Rails 3.1, and Rails 3.2. The files you will want

will be in a

rails32

directory. See the

README-FIRST

file for more details.

Part III, Rails in Depth, on page 253 surveys the entire Rails ecosystem. This

starts with the functions and facilities of Rails that you will now be familiar

with. It then covers a number of key dependencies that the Rails framework

makes use of that contribute directly to the overall functionality that the Rails

framework delivers. Finally, there is a survey of a number of popular plugins

that augment the Rails framework and make Rails an open ecosystem rather

than merely a framework.

Along the way, you’ll see various conventions we’ve adopted.

Ruby Tips

Although you need to know Ruby to write Rails applications, we realize

that many folks reading this book will be learning both Ruby and Rails

at the same time. You will find a (very) brief introduction to the Ruby

language in Chapter 4, Introduction to Ruby, on page 37. When we use a

Ruby-specific construct for the first time, we’ll cross-reference it to that

:name

↪

on page 38

chapter. For example, this paragraph contains a gratuitous use of

:name

a Ruby symbol. In formats that support margins, you’ll see a reference

to where symbols are explained.

2. http://pragprog.com/titles/rails4/source_code has the links for the downloads.

report erratum • discuss

Introduction • xxi

Prepared exclusively for suling zhang

剩余475页未读，继续阅读

susiezhang192

粉丝: 0
资源: 1

Ruby on Rails 2：敏捷web开发经典指南

agile_web_development_with_rails_3rd_edition.9994652073.pdf

Agile Controller-Campus 下载

docker部署AGliegt

agile controller

agile controller-campus

agile_modbus

agile_modbusrtu

agile.net_obfuscator_6.6.0.11_downloadly

rtt agile_modbus

最新资源