[MUSIC]

While Ruby Core contains modules and classes,

the Ruby Standard library contains larger pieces of functionality and

must be specifically imported into your programs.

Some examples of standard library are utility classes for working with dates and

times, serialization, network access, and more.

We could do a whole course on every piece of the standard library.

However, we're just going to look at some of the different pieces of functionality

available today.

What we see here is the Ruby Standard Library Documentation.

Now, the main panel says just a little bit about how the documentation was generated.

And gives thanks to the people who helped make it happen.

On the left side of the main documentation,

you'll find the table of contents.

This lists every available package in the standard library and is sorted by letter.

If we click into a package, we'll get the documentation format that we're used to

for other classes and modules.

Most documentation for items in the standard library will be split up

among different classes and modules.

This naming scheme is common in Ruby and encourages separation of concerns when

coding projects larger than just a few methods or files.

Right now, I've loaded up the documentation for CSV, which stands for

comma separated values.

This is a common format which seems easy to implement programmatically, but

is actually quite involved, which is why there's a library for it.

Now that we click into the standard library for

CSV, we'll see a bunch of different classes.

Most commonly, the documentation for

what we want will have the same name as the package.

In the CSV example, I'm gonna click on the top level CSV class again.

When I do that, we get a description of what the package does,

followed by some code examples of how it can work.

We can generally use these code examples

as a guide to accomplish what we want to in our programs.

On the left side, we have the usual method list that the class supports.

In larger packages, like we find in the standard library, we'll also see a name

space section which will show any other sub classes that this library has.

Finally, if we scroll down we can see any modules that are included with this class,

and also included in the library.

Some packages like this one for CSV may also have notes,

gotchas, warnings or other things to keep in mind when coding.

This one contains notes on how different character and codings are handled.

And also a note that we may find bugs in the code,

as well as where to report the issue.

When we get a little further into the documentation, we'll also see a list of

constants in the class before the rest of the methods are listed.

One thing that's interesting to note about packages in the standard library,

is that they have to be explicitly required.

For example, if I open up irb and try to access the CSV class,

I'll get an error saying that there's an uninitialized constant.

In order to use it, I'll have to explicitly require CSV.

Once I do that, I'll have access to the CSV class.

If I click back into the rest of the standard library documentation,

we can see that there's a wealth of functionality available to us.

The Benchmark module for

example, will allow us to measure the time it takes our code to run.

This can help us if we're trying to optimize different pieces of code, and

get an idea of where the bottlenecks might be in our programs.

The CGI library is larger library for working with low level web requests and

has several sub classes inside of it.

If we go back even further, the FileUtils module

gives us a platform agnostic way to work with files and directories.

We can do things like change and list directories, copy, move files, and more.

As we keep scrolling through the documentation for

the standard library, we'll see different sections.

For example, Net/HTTP,

the Net HTTP module can be used to consume APIs, and

also fetch and work with webpages programatically.

It's a good idea to read over the classes and libraries in the standard library.

By being familiar with the standard library,

you'll have a leg up on programming, and

not be tempted to re-implement these pieces of functionality on your own.

Some classes to be familiar with are forwardable,

observer, prettyprint, optparse, and more.

Using the documentation link below,

try reading through some of the standard library documentation now, and

practice with some of these classes on your own using workspaces.