00:00:25.519
Good afternoon, everyone! I am Michael Hartl, the author of the Ruby on Rails tutorial. I'm going to be talking about Rails-flavored Ruby and take a little tour through some aspects of Ruby that are important for developing Rails applications.
00:00:38.200
First, I'd like to get a quick survey of how many people here have actually read at least some of the Rails tutorial. If you have read Chapter 4, you're going to get a review of some subset of that chapter.
00:00:51.760
I only have three slides for this talk, and as you've seen in the screencast, my style is more oriented towards a practical approach. So, we’re going to discuss Rails-flavored Ruby, focusing particularly on the command line and, more specifically, on the Rails console.
00:01:02.960
Some of you probably know that there’s an interactive Ruby program called IRB, which stands for Interactive Ruby. The Rails console is basically the same, but it loads the full Rails environment, giving you access to Rails-specific extensions.
00:01:22.799
We’re going to start today by jumping right in and discussing different kinds of objects in Ruby. In particular, we’ll focus on some data structures that are important when making Rails applications. You'll find that if you take a computer science course, you spend a lot of time implementing data structures like lists or arrays. However, in real life, you almost never have to do that because mature languages, including Ruby, provide a lot of built-in data structures.
00:01:50.960
We’ll start with one of the most important kinds of objects in Ruby from the perspective of Rails development: strings. Web applications essentially return a string of characters to the browser, which is then rendered as a webpage. A lot of what happens in Rails involves manipulating strings, so let’s assign a string to a variable called 's'.
00:02:38.040
This string is a Ruby object, meaning it will respond to methods. Methods, in this context, are actions that you call on an object using the dot operator. For example, you can ask the string object to reverse itself. When we reverse the string, Ruby returns a result but does not change the original string. To mutate the string, we need to use a bang modifier.
00:03:02.920
Next, let’s look at a string with some whitespace and see how we can manipulate it. This string is designed to be split based on whitespace. Using this function allows us to convert the string into an array, which is an ordered list of elements. When we convert the string into an array, we can ask about its properties, like the class of the object, which we expect to be an array.
00:03:49.160
We can do many amazing things with arrays, and there's plenty of documentation available to help us understand Ruby objects. Learning about Ruby data structures is efficient; rather than implementing everything from scratch, you can utilize predefined methods. For example, if you want to shuffle the elements of an array, Ruby provides a 'shuffle' method, which you can use to pick a random element. This is significantly easier than implementing your own shuffle algorithm.
00:04:35.000
Sorting is another common task. In Ruby, you can ask the array to sort itself, leveraging the built-in functionality rather than manually sorting the elements. Additionally, the array can be mutated in place, and using a bang operator typically signifies that the method will change the object.
00:05:10.480
An important concept to understand is that certain methods, like map, are common across various Ruby objects. These methods belong to a category known as 'enumerable'. Let’s see how the map method works—this method takes a block as its argument and iterates through the elements. For instance, if we want to convert all strings in an array to uppercase, we can apply the upcase method in a block.
00:05:34.360
When creating blocks, you will find that the syntax can be a little complex initially. Blocks are a fundamental aspect of Ruby and are essential for manipulating data structures effectively. Moreover, you can access elements in an array using their indices, starting with 0 for the first element. Ruby also allows you to have nil values, which signify 'nothing'.
00:06:00.800
Another significant data structure in Ruby is the hash, which is a generalization of arrays where the index can be any object, not just an integer. Many of you are likely familiar with hashes. They utilize key-value pairs, and it’s crucial to note that using symbols as keys is more idiomatic in Ruby than using strings.
00:06:48.560
For example, instead of using strings like 'f' or 'b', it’s recommended to define keys with symbols (e.g., :f and :b). There are newer syntactical forms in Ruby 1.9 that simplify defining hashes, such as placing the colon after the key instead of before it, which is a more modern practice.
00:08:03.760
A notable feature of Ruby data structures in general is their dynamic nature, which allows you to mix different types within the same array or hash. This flexibility can be surprising to programmers from statically typed languages.
00:09:18.480
Now, as we transition into defining classes, it’s interesting to note that in Rails applications, it’s rare to define your own classes. Nonetheless, to understand classes better, let’s define a simple class. We’ll call it 'Word', and this class will inherit from String, adding an additional method to check if a string is a palindrome.
00:10:43.840
In Ruby, method names can convey intent, so it’s good practice to append a question mark to methods that return boolean values. Let’s define a method to determine if the word is a palindrome by checking if it equals its reverse, taking care to use a double equals sign for comparison.
00:11:30.640
Once the method is defined, it becomes significantly more straightforward to instantiate our Word class and call this method. As we work through this, we understand more about Ruby's object model and how inheritance operates.
00:12:23.920
It's also essential to understand that Ruby permits the manipulation of existing classes. For instance, you can open the String class and add methods, which is generally useful, but caution is required because modifying built-in classes can lead to unexpected behavior if other developers rely on that same structure.
00:13:25.440
Throughout this talk, we've learned about various Ruby data structures and their powerful applications in Rails. This knowledge is pivotal when developing software, as it allows for efficient data handling and class organization within applications.
00:14:31.119
As we wrap up this session, I’d like to give you one last example from the Rails tutorial. The Static Pages controller, for example, has a method named 'about' that typically renders the corresponding web page.
00:15:12.720
However, in a classroom context, this method does not output anything visible directly because the controller acts as a Ruby class with minimal implementation. In full Rails applications, these controllers respond dynamically to user input and interactions.
00:16:06.560
This highlights an essential distinction: the behavior of Rails and general Ruby interactions can differ significantly. Therefore, I advise those interested in web applications to focus on learning Rails without spending extensive time learning Ruby in its entirety beforehand.
00:17:00.240
For anyone who wants to delve further into Ruby coding and Rails development, there are numerous resources available online, including the Ruby on Rails Tutorial book, which is available for free online.
00:17:48.560
If you're interested, I recently started releasing screencasts for the second edition of the tutorial, and the first two lessons are already out. I plan to publish Lesson 3 soon, along with some special discounts on the materials.
00:18:35.760
PDF versions and screencasts are excellent resources for those who prefer offline content. Overall, I encourage you to explore both the free and paid formats to enhance your experience learning Ruby and Rails.
00:19:26.400
Thank you all very much for your attention—I hope you found this talk valuable, and I look forward to your questions and further discussions!