Search
RailsConf 2013
Ruby Libraries Important for Rails
Edit
#ruby-standard-library
#ruby-on-rails
#test-driven-development
#documentation
#interactive-coding
#rspec
Summarized using AI

Ruby Libraries Important for Rails

Michael Hartl • June 25, 2013 • Portland, OR • Talk

Introduction

The video titled "Ruby Libraries Important for Rails", presented by Michael Hartl at Rails Conf 2013, aims to educate developers on leveraging Ruby's standard library effectively while working with Ruby on Rails applications. The session emphasizes not just the libraries themselves but teaches attendees how to learn and utilize Ruby documentation in practical scenarios.

Key Points

  • Focus on the Ruby Standard Library: The talk shifts from discussing third-party Ruby libraries to the Ruby standard library, highlighting how the built-in classes and modules are critical for Rails development.
  • Understanding Core Concepts: Hartl encourages participants to become comfortable with reading Ruby documentation, asserting that familiarity with concepts like arrays, hashes, and regular expressions enhances Rails programming.
  • Interactive Learning: The workshop incorporates live coding and encourages attendees to participate actively. Hartl demonstrates various Ruby and Rails concepts through live coding, making the content engaging and hands-on.
  • Examples and Illustrations: Specific examples include:
    • Regular Expressions: Understanding the use of regex within Rails applications.
    • Arrays and Methods: Hartl discusses manipulating arrays using methods like insert and map. He explains advanced Ruby capabilities, like set intersections, showcasing how to implement them using ampersand (&).
    • Testing and Documentation: The last part of the talk focuses on using RSpec for testing. Hartl shows how to write specifications that also function as live documentation for Ruby's standard library methods, demonstrating the expectation syntax for creating precise tests.
  • Motivation for Learning: Hartl emphasizes the importance of continuously updating and refining one’s knowledge of Ruby libraries. He suggests allocating time to read and understand Ruby documentation, noting that even seasoned developers can discover new techniques through exploration.

Conclusion

The overarching takeaway from this video is the encouragement for developers to embrace the depth of Ruby's standard library while developing Rails applications. Hartl's insightful illustrations, combined with interactive participation during the workshop, aim to foster better understanding and utilization of Ruby documentation. Participants are urged to not shy away from occasionally pausing and exploring complex documentation, as many valuable techniques can be learned through this practice, ultimately enhancing their efficiency and expertise as developers.

Ruby Libraries Important for Rails
Michael Hartl • June 25, 2013 • Portland, OR • Talk

This talk+workshop highlights some Ruby libraries that are particularly useful when developing Rails applications. In the talk portion, we'll give an overview of some specific classes and modules, and then in the workshop we'll break into groups to dive deeper into libraries of each participant's choice, with a focus on developing the skills needed to read and understand the Ruby documentation. Time and interest permitting, we'll incorporate test-driven development into our investigations.

RailsConf 2013

00:00:15.890 Alright, so today's session is going to be very light on the slides and heavy on the interactive live coding. In the workshop, we will ask you to actually do something.
00:00:21.830 The title of the talk is 'Ruby Libraries Important for Rails,' but there are a couple of misleading aspects about this. Firstly, it's not just about Ruby libraries; it's actually about the Ruby standard library. I like to think of it as a collection of libraries.
00:00:33.020 For example, Array is a library for creating and manipulating arrays. Secondly, we’re not going to cover libraries that are important specifically for Rails; instead, we will learn how to learn about libraries that are important for Rails.
00:00:39.860 There will be some actual digging into code in this part of the talk. My hope is that by the end, if you’re not already comfortable reading Ruby documentation, you will be. Even for someone experienced in Ruby programming, what we’re going to do will be useful.
00:00:45.980 I learned things while preparing for this talk as I reviewed the documentation. I want to start off by motivating this. I've been influenced by the idea that resetting your attention helps when you show pictures of things related to what you're discussing. So, I’m opting for a recognizable theme of dangerous creatures to give us our motivation, starting with a wolf.
00:01:10.910 Now, why would you want to learn more Ruby if you're working with Rails? I might be preaching to the choir here, but this is a portion of the sample application from the Ruby on Rails tutorial.
00:01:28.340 Let’s take a look at some of the things happening in this application, much of which is specific to Rails. You certainly should not understand this unless you’ve already gone through the tutorial.
00:01:39.879 This is the user model for the Ruby on Rails tutorial sample application, which builds a little Twitter-like platform. How many people here have read most or all of the Ruby on Rails tutorial? That’s a fair number.
00:01:51.549 This is the user model, and I want to look through and identify things that are pure Ruby and not specific to Rails. For instance, there’s a line here with a valid email regular expression. This is kind of a mini-language: the language of regular expressions. Knowing about regular expressions is useful, and as you might expect, there's a regular expression standard library as part of the Ruby standard library.
00:02:10.000 We’ve also got hashes here, so being able to manipulate hashes is quite useful. Let me see if I can demonstrate that. Normally, I would launch key caster, and I try command-space, but it’s not working right now.
00:02:24.760 Alright, so here's another example with the user spec. The reason I did that was to show functionalities, and if I do this, it’s just a reminder of certain concepts.
00:02:32.800 The user spec is an example of an array and iterating through it. Chances are you already know how to iterate through an array, but I want to emphasize that these data structures, classes, and modules come up even in relatively simple Rails application code bases.
00:02:40.230 Next, I want to look at the better controller. Here’s an example of accessing elements in a nested hash. It’s really useful to know how to use the Ruby standard library, and as your applications get more complicated, you're more likely to need something from there.
00:02:56.560 So, it’s amazing how productively you can sit down and read the documentation. Let’s take a look at it now; our next section is about how to use Ruby doc to motivate us to dig into Ruby documentation, specifically in the context of IRB.
00:03:10.130 Alright, here’s that GitHub repository I mentioned earlier. For those of you who came a little late, try to visit this URL and see if there's enough Wi-Fi to clone the repo. You won’t use it until the workshop, but it’s a model.
00:03:21.820 These are the basic notes for this talk. I went through the standard library and using my experience in Rails, I thought about which components are useful within a Rails app. This is what I came up with: links to Ruby doc that provide documentation for the standard library.
00:03:35.750 There's actually a lot of information about arrays in this context. It’s amazing how much you can learn just by going through and reading the documentation.
00:03:46.910 Particularly, reading through this documentation may help you as you write a Rails app when recognizing a pattern that you can implement using the standard library.
00:03:57.450 Anytime you can leverage the standard library, you should, because it’s been well tested and is typically faster than writing custom code. It’s beneficial to regularly build up your knowledge of different pieces of information within Ruby.
00:04:07.960 Memorization is underrated as a learning tool. While it won’t by itself make you a great developer, it is indeed helpful to have certain things stored in your head.
00:04:18.010 Let’s take a look at the documentation that is available on ruby.org for arrays. There’s a simple example where an array equals 1, 2, 3. The documentation showcases what the expected outcomes are.
00:04:27.230 One effective way of learning about a part of the standard library is to open up an IRB session and see what happens when you interact with Ruby.
00:04:35.960 This is an encouraging start, and ordinarily I would place these to allow for side-by-side viewing, but I simply don’t have sufficient horizontal space right now.
00:04:45.430 The standard library documentation generally breaks down into two parts: explanatory sections with examples and systematic listings of all methods that the array responds to.
00:04:56.630 We’re not going to exhaustively cover this right now, but I will show you some approaches for learning about it. Often, some lessons come from just reading through the standard library documentation.
00:05:09.060 As I learned Ruby, I would open the standard library and read through various aspects such as arrays, hashes, strings, and so forth. For example, you may not have known that you can perform an intersection on arrays using the ampersand operator.
00:05:20.450 This operator treats arrays as sets and enables set intersection, which we will discuss in just a moment.
00:05:30.130 There’s also the array constructor with one argument, which creates an array with that many nil elements. If you provide two arguments, it creates an array initialized with that string, which I didn’t realize until I prepared this talk.
00:05:42.440 This discovery is valuable because should I ever need it, I now know how to implement it, whereas I used to think that I would write something more complex.
00:06:03.470 It’s crucial to recognize when to skip learning something; don’t be afraid to move past portions of the documentation that seem confusing, as you can always return to them later with a fresh perspective.
00:06:14.990 There are so many useful features that you can implement, such as inserting into an array, removing elements, or using an array as a stack.
00:06:27.200 Your learning style may affect how you approach documentation—some may prefer a thorough reading while others might favor a systematic exploration.
00:06:42.230 As an illustration, let’s review the map method, which is not actually a method on the array but rather belongs to the Enumerable module.
00:06:51.850 Map is a functional programming method that takes a block and applies it to each element in the array. For example, if you want to square each element, you could write a simple function to handle that.
00:07:07.460 This process reveals how you can access the unique functionality of the methods when you try to access an array’s capabilities in conjunction with the Enumerable module.
00:07:20.310 So, let’s take a look at what map does specifically now and potentially create a function to demonstrate this.
00:07:31.900 The key is that map allows you to take a block and apply it to every element in the array, returning an array of the results.
00:07:45.170 For instance, I can create a squaring function and apply it to all elements or simply use a square method to emphasize how powerful this can be.
00:07:59.760 There is a shorthand for applying a block, thereby enhancing the efficiency of writing this Ruby method.
00:08:12.880 Let’s run this code and observe that it's a simple yet effective way of learning to utilize the available array methods and their various functionalities.
00:08:23.420 With consistent practice, you can become well-versed in layers of Ruby’s functionality and deepen your understanding of its language structures.
00:08:34.780 We can take a look at this documentation available for various public instance methods and understand how they behave and perform under different scenarios.
00:08:48.100 For example, when trying to find the intersection of arrays, it's essential for understanding the Ruby standard library. Just as we instantiate a new array, we can also treat it mathematically and understand intersections.
00:09:09.360 The array data structures allow for various blending operations, which we can review systematically as we compare different implementations.
00:09:19.370 This documentation serves as a guide and reference as you adapt these Ruby functionalities into your own projects.
00:09:31.540 Consider the array concatenation; it’s a straightforward way to merge arrays, though let’s explore alternate approaches to achieve similar results.
00:09:43.300 For many developers, this leads to choosing methods that streamline their code while preventing redundancies, and maximize efficiency and effectiveness in programming.
00:09:59.750 To ensure clarity in our methods, let’s compare examples that demonstrate the nuances of mathematical operations in Ruby, showing how additive versus concatenative behaviors can be crucial for learners.
00:10:13.700 Moving beyond basic implementations, it’s worth acknowledging both the functional and logical objectives as we drive deeper into Ruby’s structures.
00:10:26.500 Our journey through testing Ruby libraries and using RSpec exemplifies the documentation process and will significantly help you grasp key concepts.
00:10:40.360 One of the things I appreciate about testing libraries is that it provides a structured pathway to examine how components work and learn their behavior.
00:10:54.540 In this section, I will show you how we can create tests for the Ruby standard library, effectively serving to document its features while ensuring that everything functions as expected.
00:11:09.320 We’ll start with a few basic examples, where the syntax is clear and similar to plain language—a major selling point for RSpec.
00:11:22.060 Let's describe the array, beginning with the construction of a new instance, and understanding its relationship with Ruby's unique syntax becomes our focus.
00:11:34.839 I may rely on context for certain elements, emphasizing its impact on readability and workflow.
00:11:48.959 Now, we will work through writing tests that confirm our array manipulations perform the necessary tasks based on the intended specifications we outlined.
00:12:03.490 Let’s consider all scenarios: when we call an empty array, when we expect a non-empty array, and further clarifications regarding parameters passed along with constructors.
00:12:16.890 As we progress through these details, keep in mind how best practices support your journey as a developer and how clear assumptions help define the structure of your queries.
00:12:29.310 It's crucial to document our findings as we replicate tests for all variations of expected behaviors and have a fuller understanding of Ruby’s functionalities.
00:12:43.819 Once we've run our tests and examined outputs, we build an executable documentation set that allows us to treat our code as cohesive guidelines for use.
00:12:57.210 The ultimate goal is to formulate an understanding of potential use cases with confined methods, and recognizing areas for growth provides a robust learning environment.
00:13:10.760 Each method reflects practical applications, and this provides context on how to engage with the language resourcefully.
00:13:26.370 With our methodical exploration in mind, let’s return to custom-built examples that highlight the operational capabilities of Ruby across various operations.
00:13:43.960 We’ll finish our session by focusing on the intersections, unions, and other array methods that showcase Ruby’s flexibility and robust design principles. This also underlines how you can adopt these concepts into your applications.
00:13:55.940 As we conclude our discussion, I hope you appreciate how powerful these Ruby functionalities are and feel satisfied with the knowledge gained during our time together.
00:14:04.850 Thank you for participating, and now it's time to move on to the workshop where we will put our learnings into action.
Michael Hartl
@mhartl
Explore all talks recorded at RailsConf 2013
+93