Polished Ruby programming : build better software with more intuitive, maintainable, scalable, and high-performance Ruby code / Jeremy Evans.

Format:

Book

Author/Creator:

Evans, Jeremy, author.

Language:

English

Subjects (All):

Ruby (Computer program language).

Physical Description:

1 online resource (434 pages)

Place of Publication:

Birmingham, England ; Mumbai : Packt, [2021]

Biography/History:

Evans Jeremy: Jeremy Evans is a Ruby committer who focuses on fixing bugs in Ruby, as well as improving the implementation of Ruby. He is the maintainer of many popular Ruby libraries, including the fastest web framework (Roda) and fastest database library (Sequel). His libraries are known not just for their performance, but also for their code quality, understandability, documentation, and how quickly any bugs found are fixed. For his contributions to Ruby and the Ruby community, he has received multiple awards, such as receiving the prestigious RubyPrize in 2020 and being chosen as a Ruby Hero in 2015. He has given presentations at over 20 Ruby conferences. In addition to working on Ruby, he is also a committer for the OpenBSD operating system.

Summary:

Elevate your Ruby skills to an advanced level by deepening your understanding of the design principles, best practices, and trade-offs involved in implementation approaches to future-proof your Ruby applications Key FeaturesLearn Ruby web application design principles and strategies for databases, security, and testing from a Ruby committerUnderstand the design principles behind polished Ruby code and trade-offs between implementation approachesUse metaprogramming and DSLs to reduce the amount of code needed without decreasing maintainabilityBook DescriptionAnyone striving to become an expert Ruby programmer needs to be able to write maintainable applications. Polished Ruby Programming will help you get better at designing scalable and robust Ruby programs, so that no matter how big the codebase grows, maintaining it will be a breeze. This book takes you on a journey through implementation approaches for many common programming situations, the trade-offs inherent in each approach, and why you may choose to use different approaches in different situations. You'll start by refreshing Ruby fundamentals, such as correctly using core classes, class and method design, variable usage, error handling, and code formatting. Then you'll move on to higher-level programming principles, such as library design, use of metaprogramming and domain-specific languages, and refactoring. Finally, you'll learn principles specific to web application development, such as how to choose a database and web framework, and how to use advanced security features. By the end of this Ruby programming book, you’ll be a well rounded web developer with a deep understanding of Ruby. While most code examples and principles discussed in the book apply to all Ruby versions, some examples and principles are specific to Ruby 3.0, the latest release at the time of publication.What you will learnUse Ruby s core classes and design custom classes effectivelyExplore the principles behind variable usage and method argument choiceImplement advanced error handling approaches such as exponential backoffDesign extensible libraries and plugin systems in RubyUse metaprogramming and DSLs to avoid code redundancyImplement different approaches to testing and understand their trade-offsDiscover design patterns, refactoring, and optimization with RubyExplore database design principles and advanced web app securityWho this book is forThis book is for Ruby programmers who are comfortable in coding with Ruby but want to advance their skills by mastering the deeper principles and best practices behind writing maintainable, scalable, optimized, and well-structured Ruby code. This book won’t teach you the basics of Ruby – you’ll need intermediate knowledge and practical experience before you can dive in.

Contents:

Cover

Title Page

Copyright and Credits

Dedicated

Contributors

Table of Contents

Preface

Section 1: Fundamental Ruby Programming Principles

Chapter 1: Getting the Most out of Core Classes

Technical requirements

Learning when to use core classes

Best uses for true, false, and nil objects

Different numeric types for different needs

Understanding how symbols differ from strings

Learning how best to use arrays, hashes, and sets

Implementing an in-memory database

Working with Struct - one of the underappreciated core classes

Summary

Questions

Further reading

Chapter 2: Designing Useful Custom Classes

Learning when to create a custom class

Handling trade-offs in SOLID design

The single-responsibility principle

The open-closed principle

The Liskov substitution principle

The interface segregation principle

The dependency inversion principle

Deciding on larger classes or more classes

Learning when to use custom data structures

Chapter 3: Proper Variable Usage

Using Ruby's favorite variable type - the local variable

Increasing performance by adding local variables

Avoiding unsafe optimizations

Handling scope gate issues

Naming considerations with local variables

Learning how best to use instance variables

Increasing performance with instance variables

Handling scope issues with instance variables

Naming considerations for instance variables

Understanding how constants are just a type of variable

Handling scope issues with constants

Visibility differences between constants and class instance variables

Naming considerations with constants

Replacing class variables

Replacing class variables with constants.

Replacing class variables with class instance variables using the superclass lookup approach

Replacing class variables with class instance variables using the copy to subclass approach

Avoiding global variables, most of the time

Chapter 4: Methods and Their Arguments

Understanding that there are no class methods, only instance methods

Naming methods

Special method names

Using the many types of method arguments

Positional arguments

Optional positional arguments

Rest arguments

Keyword arguments

Block arguments

Learning about the importance of method visibility

Fixing visibility mistakes

Handling delegation

Delegating to other objects

Chapter 5: Handling Errors

Handling errors with return values

Handling errors with exceptions

Considering performance when using exceptions

Retrying transient errors

Understanding more advanced retrying

Breaking circuits

Designing exception class hierarchies

Using core exception classes

Chapter 6: Formatting Code for Easy Reading

Recognizing different perspectives of code formatting

Learning how syntactic consistency affects maintainability

Enforcing consistency with RuboCop

Understanding the consequences of using arbitrary limits

Checking basic code formatting with Ruby

Realizing the actual importance of code formatting

Section 2: Ruby Library Programming Principles

Chapter 7: Designing Your Library

Focusing on the user experience

Library naming

Library first impressions

The simplest possible interface

Determining the appropriate size for your library.

Handling complexity trade-offs during method design

Fewer but more complex methods

Chapter 8: Designing for Extensibility

Using Ruby's extensibility features

Designing plugin systems

Designing a basic plugin system

Handling changes to classes

Plugin modifications to classes

Supporting plugin dependencies

Making plugin loading easier

Handling subclasses in plugin systems

Configuring plugins

Understanding globally frozen, locally mutable design

Chapter 9: Metaprogramming and When to Use It

Learning the pros and cons of abstraction

Eliminating redundancy

Understanding different ways of metaprogramming methods

Using method_missing judiciously

Chapter 10: Designing Useful Domain-Specific Languages

Designing your DSL

Configuration DSLs

DSLs for making specific changes

DSLs for reducing the verbosity of code

Libraries implemented as DSLs

Implementing your DSL

Learning when to use a DSL

Chapter 11: Testing to Ensure Your Code Works

Understanding why testing is so critical in Ruby

Learning different approaches to testing

Considering test complexity

Understanding the many levels of testing

Realizing that 100% coverage means nothing

Chapter 12: Handling Change

Considering reasons to refactor

Learning about the refactoring process

Implementing the most common Ruby refactoring techniques

Extracting a method

Extracting a class

Refactoring to add features

Removing features properly

Removing methods

Removing constants

Chapter 13: Using Common Design Patterns.

Technical requirements

Learning about the many design patterns that are built into Ruby

The object pool design pattern

The prototype design pattern

The private class data design pattern

The proxy design pattern

Handling cases where there can be only one

Dealing with nothing

Visiting objects

Adapting and strategizing

Chapter 14: Optimizing Your Library

Understanding that you probably don't need to optimize code

Profiling first, optimizing second

Understanding that no code is faster than no code

Handling code where everything is slow

Section 3: Ruby Web Programming Principles

Chapter 15: The Database Is Key

Learning why database design is so important

Deciding on a database to use

Understanding the most important database design principles

Considerations when denormalizing your database design

Other database design principles

Treating the database as not just dumb storage

Choosing the model layer

Handling database and model errors

Chapter 16: Web Application Design Principles

Choosing between client-side and server-side design

Deciding on a web framework

Ruby on Rails

Sinatra

Grape

Roda

Designing URL paths

Structuring with monoliths, microservices, and island chains

Chapter 17: Robust Web Application Security

Understanding that most security issues in Ruby web applications are high level

Trusting input never

Performing access control at the highest level possible

Avoiding injection

Script injection

SQL injection

Code injection

Approaching high-security environments

Limiting database access.

Internal firewalling

Randomizing memory layouts

Limiting filesystem access

Limiting system call access

Assessments

About Packt

Other Books You May Enjoy

Index.

Notes:

Includes index.

Description based on print version record.

ISBN:

1-80107-791-6

OCLC:

1263776368