book

Polished Ruby Programming

Name: Polished Ruby Programming
Author: Jeremy Evans
ISBN: 9781801072724

by Jeremy Evans

July 2021

Intermediate to advanced

434 pages

8h 36m

English

Packt Publishing

Read now

Unlock full access

Polished Ruby Programming
ContributorsAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchReviews
Section 1: Fundamental Ruby Programming Principles
Chapter 1: Getting the Most out of Core Classes
Technical requirementsLearning when to use core classesBest uses for true, false, and nil objectsDifferent numeric types for different needsUnderstanding how symbols differ from stringsLearning how best to use arrays, hashes, and setsImplementing an in-memory databaseWorking with Struct – one of the underappreciated core classes SummaryQuestionsFurther reading
Chapter 2: Designing Useful Custom Classes
Technical requirementsLearning when to create a custom classHandling trade-offs in SOLID designThe single-responsibility principleThe open-closed principleThe Liskov substitution principleThe interface segregation principleThe dependency inversion principleDeciding on larger classes or more classesLearning when to use custom data structuresSummaryQuestions
Chapter 3: Proper Variable Usage
Technical requirementsUsing Ruby's favorite variable type – the local variableIncreasing performance by adding local variablesAvoiding unsafe optimizationsHandling scope gate issuesNaming considerations with local variablesLearning how best to use instance variablesIncreasing performance with instance variablesHandling scope issues with instance variablesNaming considerations for instance variablesUnderstanding how constants are just a type of variableHandling scope issues with constantsVisibility differences between constants and class instance variablesNaming considerations with constantsReplacing class variablesReplacing class variables with constantsReplacing class variables with class instance variables using the superclass lookup approachReplacing class variables with class instance variables using the copy to subclass approachAvoiding global variables, most of the timeSummaryQuestionsFurther reading
Chapter 4: Methods and Their Arguments
Technical requirementsUnderstanding that there are no class methods, only instance methodsNaming methodsSpecial method namesUsing the many types of method argumentsPositional argumentsOptional positional argumentsRest argumentsKeyword argumentsBlock argumentsLearning about the importance of method visibilityFixing visibility mistakesHandling delegationDelegating to other objectsSummaryQuestions
Chapter 5: Handling Errors
Technical requirementsHandling errors with return valuesHandling errors with exceptionsConsidering performance when using exceptionsRetrying transient errorsUnderstanding more advanced retryingBreaking circuitsDesigning exception class hierarchiesUsing core exception classesSummaryQuestions
Chapter 6: Formatting Code for Easy Reading
Technical requirementsRecognizing different perspectives of code formattingLearning how syntactic consistency affects maintainabilityEnforcing consistency with RuboCopUnderstanding the consequences of using arbitrary limitsChecking basic code formatting with RubyRealizing the actual importance of code formattingSummaryQuestions
Section 2: Ruby Library Programming Principles

Chapter 7: Designing Your Library
Technical requirementsFocusing on the user experienceLibrary namingLibrary first impressionsThe simplest possible interfaceDetermining the appropriate size for your libraryHandling complexity trade-offs during method designFewer but more complex methodsSummaryQuestions
Chapter 8: Designing for Extensibility
Technical requirementsUsing Ruby's extensibility featuresDesigning plugin systemsDesigning a basic plugin systemHandling changes to classesPlugin modifications to classesSupporting plugin dependenciesMaking plugin loading easierHandling subclasses in plugin systemsConfiguring pluginsUnderstanding globally frozen, locally mutable designSummaryQuestions
Chapter 9: Metaprogramming and When to Use It
Technical requirementsLearning the pros and cons of abstractionEliminating redundancyUnderstanding different ways of metaprogramming methodsUsing method_missing judiciouslySummaryQuestions
Chapter 10: Designing Useful Domain-Specific Languages
Technical requirementsDesigning your DSLConfiguration DSLsDSLs for making specific changesDSLs for reducing the verbosity of codeLibraries implemented as DSLsImplementing your DSLLearning when to use a DSLSummaryQuestions
Chapter 11: Testing to Ensure Your Code Works
Technical requirementsUnderstanding why testing is so critical in RubyLearning different approaches to testingConsidering test complexityUnderstanding the many levels of testingRealizing that 100% coverage means nothingSummaryQuestions
Chapter 12: Handling Change
Technical requirementsConsidering reasons to refactorLearning about the refactoring processImplementing the most common Ruby refactoring techniquesExtracting a methodExtracting a classRefactoring to add featuresRemoving features properlyRemoving methodsRemoving constantsSummaryQuestions
Chapter 13: Using Common Design Patterns
Technical requirementsLearning about the many design patterns that are built into RubyThe object pool design patternThe prototype design patternThe private class data design patternThe proxy design patternHandling cases where there can be only oneDealing with nothingVisiting objectsAdapting and strategizingSummaryQuestions
Chapter 14: Optimizing Your Library
Technical requirementsUnderstanding that you probably don't need to optimize codeProfiling first, optimizing secondUnderstanding that no code is faster than no codeHandling code where everything is slowSummaryQuestions
Section 3: Ruby Web Programming Principles
Chapter 15: The Database Is Key
Technical requirementsLearning why database design is so importantDeciding on a database to useUnderstanding the most important database design principlesConsiderations when denormalizing your database designOther database design principlesTreating the database as not just dumb storageChoosing the model layerHandling database and model errorsSummaryFurther readingQuestions
Chapter 16: Web Application Design Principles
Technical requirementsChoosing between client-side and server-side designDeciding on a web frameworkRuby on RailsSinatraGrapeRodaDesigning URL pathsStructuring with monoliths, microservices, and island chainsSummaryQuestions
Chapter 17: Robust Web Application Security
Technical requirementsUnderstanding that most security issues in Ruby web applications are high levelNever trust inputPerforming access control at the highest level possibleAvoiding injectionScript injectionSQL injectionCode injectionApproaching high-security environmentsLimiting database accessInternal firewallingRandomizing memory layoutsLimiting filesystem accessLimiting system call accessSummaryQuestions
Assessments
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12Chapter 13Chapter 14Chapter 15Chapter 16Chapter 17
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youLeave a review - let other readers know what you think

Content preview from Polished Ruby Programming

Chapter 15: The Database Is Key

The database is the backbone and most important part of almost all web applications, regardless of the programming language used. This is because the database is where all of an application's data is stored, and in most cases, an application's data is more important than the application itself. In this chapter, you'll learn why proper database design is so important, some important database design principles, and why it is best to use the database's full capabilities. You'll also learn how to choose a model layer for your application, and how to handle database errors when using that model layer.

We will cover the following topics:

Learning why database design is so important
Understanding the most important ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781801072724

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Polished Ruby Programming

by Jeremy Evans

Chapter 15: The Database Is Key

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.