Advanced Rails Development Resources and Books

需积分: 10 36 浏览量更新于2024-07-27 收藏 2.54MB PDF 举报

"Advanced Rails是 Brad Ediger 在2007年出版的一本关于深入学习 Ruby on Rails 框架的书籍。这本书旨在帮助已经熟悉基础 Rails 开发的读者提升到更高级的层次，探索框架的深层机制和最佳实践。在书中，作者可能会涵盖诸如性能优化、复杂的数据库设计、高级测试策略、RESTful API 设计以及如何利用 Ruby 的灵活性来扩展 Rails 应用程序等主题。此外，资源还提到了与这本书相关的其他 O'Reilly 出版的 IT 和编程书籍，如 Ajax on Rails、Learning Ruby、Rails Cookbook、RESTful Web Services、Ruby on Rails: Up and Running 和 Ruby Pocket Reference，这些书都是深入了解 Web 开发相关技术的重要参考资料。" 通过 O'Reilly 网站，读者可以获取到更多关于这些书籍的详细信息，包括新闻、事件、文章、博客、样本章节和代码示例。同时，O'Reilly 还组织了一系列的技术会议，汇聚行业创新者，推动新技术的发展，并提供实用的技能培训。对于需要快速解决问题的专业人士，O'Reilly 的 Safari Bookshelf 在线参考图书馆是一个宝贵的资源，用户可以在超过1000本书籍中进行搜索，迅速找到关键问题的答案，还可以在线阅读这些书籍。 "Advanced Rails" 一书将帮助读者掌握 Rails 的高级特性和最佳实践，包括但不限于以下方面： 1. **性能优化**：探讨如何通过调整代码、数据库查询和缓存策略来提高 Rails 应用的运行速度。 2. **数据库设计**：深入讲解如何设计复杂的数据库模式，使用关联和多表查询来实现高效的数据操作。 3. **高级测试**：介绍 TDD（测试驱动开发）和 BDD（行为驱动开发）的最佳实践，包括使用 RSpec 和 Cucumber 进行自动化测试。 4. **RESTful API 设计**：教授如何构建遵循 REST 架构原则的 API，以实现可伸缩和模块化的服务。 5. **Ruby 语言的运用**：展示如何利用 Ruby 的元编程和模块化特性来增强 Rails 应用的灵活性和可维护性。 6. **插件和 gems**：介绍如何开发和使用 Rails 插件及社区贡献的 gems，以扩展 Rails 的功能。 7. **部署和运维**：讲解如何配置和优化服务器环境，确保应用稳定运行和快速部署。 "Advanced Rails" 是一本面向中级至高级 Rails 开发者的指南，它将帮助读者提升在 Rails 生态系统中的专业技能，实现更高效、更灵活的 Web 应用开发。

Chapter 1

CHAPTER 1

Foundational Techniques1

Simplicity is prerequisite for reliability.

—Edsger W. Dijkstra

Since its initial release in July 2004, the Ruby on Rails web framework has been

steadily growing in popularity. Rails has been converting PHP, Java, and .NET devel-

opers to a simpler way: a model-view-controller (MVC) architecture, sensible

defaults (“convention over configuration”), and the powerful Ruby programming

language.

Rails had somewhat of a bad reputation for a lack of documentation during its first

year or two. This gap has since been filled by the thousands of developers who use,

contribute to, and write about Ruby on Rails, as well as by the Rails Documentation

project (http://railsdocumentation.org/). There are hundreds of blogs that offer tutori-

als and advice for Rails development.

This book’s goal is to collect and distill the best practices and knowledge embodied by

the community of Rails developers and present everything in an easy-to-understand,

compact format for experienced programmers. In addition, I seek to present facets of

web development that are often undertreated or dismissed by the Rails community.

What Is Metaprogramming?

Rails brought metaprogramming to the masses. Although it was certainly not the first

application to use Ruby’s extensive facilities for introspection, it is probably the most

popular. To understand Rails, we must first examine the parts of Ruby that make

Rails possible. This chapter lays the foundation for the techniques discussed in the

remainder of this book.

Metaprogramming is a programming technique in which code writes other code or

introspects upon itself. The prefix meta- (from Greek) refers to abstraction; code that

uses metaprogramming techniques works at two levels of abstraction simultaneously.

Chapter 1: Foundational Techniques

Metaprogramming is used in many languages, but it is most popular in dynamic lan-

guages because they typically have more runtime capabilities for manipulating code as

data. Though reflection is available in more static languages such as C# and Java, it is

not nearly as transparent as in the more dynamic languages such as Ruby because the

code and data are on two separate levels at runtime.

Introspection is typically done on one of two levels. Syntactic introspection is the low-

est level of introspection—direct examination of the program text or token stream.

Template-based and macro-based metaprogramming usually operate at the syntactic

level.

Lisp encourages this style of metaprogramming by using S-expressions (essentially a

direct translation of the program’s abstract syntax tree) for both code and data.

Metaprogramming in Lisp heavily involves macros, which are essentially templates

for code. This offers the advantage of working on one level; code and data are both

represented in the same way, and the only thing that distinguishes code from data is

whether it is evaluated. However, there are some drawbacks to metaprogramming at

the syntactic level. Variable capture and inadvertent multiple evaluation are direct

consequences of having code on two levels of abstraction in the source evaluated in the

same namespace. Although there are standard Lisp idioms for dealing with these prob-

lems, they represent more things the Lisp programmer must learn and think about.

Syntactic introspection for Ruby is available through the ParseTree library, which

translates Ruby source into S-expressions.

An interesting application of this library

is Heckle,

†

a test-testing framework that parses Ruby source code and mutates it,

changing strings and flipping

true to false and vice versa. The idea is that if you have

good test coverage, any mutation of your code should cause your unit tests to fail.

The higher-level alternative to syntactic introspection is semantic introspection,or

examination of a program through the language’s higher-level data structures.

Exactly how this looks differs between languages, but in Ruby it generally means

working at the class and method level: creating, rewriting, and aliasing methods;

intercepting method calls; and manipulating the inheritance chain. These techniques

are usually more orthogonal to existing code than syntactic methods, because they

tend to treat existing methods as black boxes rather than poking around inside their

implementations.

Don’t Repeat Yourself

At a high level, metaprogramming is useful in working toward the DRY principle

(Don’t Repeat Yourself). Also referred to as “Once and Only Once,” the DRY prin-

ciple dictates that you should only need to express a particular piece of informa-

tion once in a system. Duplication is usually unnecessary, especially in dynamic

* http://www.zenspider.com/ZSS/Products/ParseTree/

† http://rubyforge.org/projects/seattlerb

What Is Metaprogramming?

languages like Ruby. Just as functional abstraction allows us to avoid duplicating

code that is the same or nearly the same, metaprogramming allows us to avoid dupli-

cating similar concepts when they recur throughout an application.

Metaprogramming is primarily about simplicity. One of the easiest ways to get a feel

for metaprogramming is to look for repeated code and factor it out. Redundant code

can be factored into functions; redundant functions or patterns can often be fac-

tored out through the use of metaprogramming.

Design patterns cover overlapping territory here; patterns are designed

to minimize the number of times you have to solve the same problem.

In the Ruby community, design patterns have acquired something of a

negative reputation. To some developers, patterns are a common

vocabulary for describing solutions to recurring problems. To others,

they are overengineered.

To be sure, patterns can be overapplied. However, this need not be the

case if they are used judiciously. Design patterns are only useful inso-

far as they reduce cognitive complexity. In Ruby, some of the fine-

grained patterns are so transparent that it would be counterintuitive to

call them “patterns”; they are really idioms, and most programmers

who “think in Ruby” use them without thinking. Patterns should be

thought of as a vocabulary for describing architecture, not as a library

of prepackaged implementation solutions. Good Ruby design patterns

are vastly different from good C++ design patterns in this regard.

In general, metaprogramming should not be used simply to repeat code. You should

always evaluate the options to see if another technique, such as functional abstrac-

tion, would better suit the problem. However, in a few cases, repeating code via

metaprogramming is the best way to solve a problem. For example, when several

very similar methods must be defined on an object, as in ActiveRecord helper meth-

ods, metaprogramming can be used.

Caveats

Code that rewrites itself can be very hard to write and maintain. The programming

devices you choose should always serve your needs—they should make your life eas-

ier, not more difficult. The techniques illustrated here should be more tools in your

toolbox, not the only tools.

Bottom-Up Programming

Bottom-up programming is a concept borrowed from the Lisp world. The primary

concept in bottom-up programming is building abstractions from the lowest level. By

writing the lowest-level constructs first, you are essentially building your program on

top of those abstractions. In a sense, you are writing a domain-specific language in

which you build your programs.

剩余358页未读，继续阅读

dang_jian

粉丝: 0
资源: 1

Advanced Rails Development Resources and Books

Pragmatic.Bookshelf.Advanced.Rails.Recipes.May.2008

Pragmatic.Rails.Recipes.Rails.3.Edition.Mar.2012.pdf

Agile.Web.Development.with.Rails.4(2013.10).Sam.Ruby.文字版.pdf 一书的配套代码

Build.Your.Own.Ruby.on.Rails.Web.Applications.Feb.2007.pdf

Apress.Practical.Rails.Social.Networking.Sites.Jun.2007.eBook-BBL.pdf

Addison.Wesley.Rails.AntiPatterns.Best.Practice.Ruby.on.Rails.Refactoring

Wrox.Professional.Ruby.on.Rails.Feb.2008.pdf

Addison.Wesley.RailsSpace.Building.a.Social.Networking.Website.with.Ruby.on.Rails

RESTful.Rails.Development.2015.10.pdf

Pragmatic - Agile.Web.Development.with.Rails.4.Sep.2013.pdf

最新资源