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.