Dissecting Ruby on Rails 5 - Become a Professional Developer

In this first guide, we're going to walk through how to download and install virtualbox on your local machine.

Now that we have virtual box installed on our system it is time to download and install Ubuntu. So this is going to be the version of Linux that we'll be using throughout the rest of this course. It is one of the most popular versions of Linux that's out there so I think it's a good choice for us.

In this guide, we're going to walk through how you can reboot your virtual box.

In this configuration lesson, we're going to walk through how we can install desktop applications inside of our Linux virtual machine.

This is going to be a quick lesson where I show you how to sign up for a GitHub account.

In this lesson, we're going to walk through how we can configure git on our virtual machine and also connect it with github. As you go through any of the courses that you're going to follow along with you will discover that you need to use version control.

In this lesson we're going to walk through how to install and configure node and the node package manager also called NPM on our Linux machine.

In this configuration lesson we are going to walk through how to install Heroku on our local machines.

This guide walks through how to fix the 'role does not exist' error that you may run into when creating databases.

In this section we will walk through how to setup a project management dashboard and how to build out the Rails application. Additionally we will analyze how Rails works from the inside out so that it's easier to understand how to extend functionality later on.

In this guide we'll walk through how to sign up for a project management account using Pivotal Tracker. This will help us to track our progress and ensure that we list out all of the requirements for the Rails application that we'll be building.

In this guide I walk through how to work with the Pivotal Tracker project management dashboard, including how to create a set of requirements, add todo items, and how to start a project.

In this guide I walk through how you can upload the attached project management tasks into Pivotal Tracker so that you can follow along.

In this guide we'll walk through how to create a Rails application completely from scratch and we will also analyze how to look at the web server to perform debugging.

In this guide we walk through how to utilize the Rails scaffold system in order to create the blog for our portfolio application, including how to update the Postgres database.

In this guide we take a step back and analyze how the Rails system works. To begin we walk through the basic App directory and then walk through how to work with the Index and Show methods provided in the Rails Controllers.

In this guide I walk through how to properly understand the Rails process, specifically as it relates to the: New, Create, Update, Edit, and Destroy actions.

In this guide you'll learn how the Resource system works with Rails in relation to routes.

In this guide I walk through the remaining file system components and explain how they work and how you can use them to build Rails applications.

In this guide we'll update the Pivotal Tracker project management dashboard to complete the tasks listed for this module.

In this lesson we'll walk through the full Rails application generation process. This will include a comprehensive analysis of the options that can be used when creating a new Rails app. We'll walk through:

• How to customize the database used in a Rails app
• What is needed to build a Rails API only app and how it affects the app structure
• What Rails templates are
• How to skip the bundle process for faster app generation
• And much more!

This is part 1 of 2

In this lesson we'll walk through the full Rails application generation process. This will include a comprehensive analysis of the options that can be used when creating a new Rails app. We'll walk through:

• How to customize the database used in a Rails app
• What is needed to build a Rails API only app and how it affects the app structure
• What Rails templates are
• How to skip the bundle process for faster app generation
• And much more!

This is part 2 of 2

After this section of the course you will know how to implement version control into a Rails application. This will include: configuring your system with GitHub and pushing your repo to the web.

Learn how to create a GitHub account and navigate through the GitHub dashboard.

Learn how to generate SSH keys from your local system and add them to GitHub. This will allow for you to push securely to remote GitHub repositories.

In this guide you'll learn how to: create a new git repository, how to push to GitHub, and how to work with different versions of your application.

In this guide we'll walk through how to edit a .gitignore file so that our application can securely store secret API keys and various credentials. We'll also examine how to clear our local Git cache to properly update the .gitignore file.

This guide examines how to work with the markdown syntax. Learning markdown will allow you to style Readme files, add items such as syntax highlighting to GitHub comments, and much more.

In this short guide we'll update the Git sprint feature in the Pivotal Tracker dashboard.

In this deep dive, we'll walk through the finer points of Git. Specifically, we'll analyze: what git is, how it can be used in day to day development, how to work with git branches and much more. Part 1 of 2.

In this deep dive, we'll walk through the finer points of Git. Specifically, we'll analyze: what git is, how it can be used in day to day development, how to work with git branches and much more. Part 2 of 2.

This section of the course will teach you how to work with Rails generators, including the controller, model, and resource generators. We'll also analyze how to customize generators.

This guide walks through how to work with the Rails controller generator in order to create static pages in a Ruby on Rails application. We'll also walk through how to pass data between the model, view, and controller files. This is a part 1 of 2.

This guide walks through how to work with the Rails controller generator in order to create static pages in a Ruby on Rails application. We'll also walk through how to pass data between the model, view, and controller files. This is a part 1 of 2.

This guide explains how to work with the Rails model generator, specifically it shows how you can generate models and use the model to query the database and render data onto the view.

This guide examines how to run the Rails Resource generators, and specifically compares the Resource generator with the: model, controller, and scaffold generators.

In this deep dive guide we'll examine how generators work in Rails. Additionally, we'll walk through how to create a custom generator in Rails. Part 1 of 2.

In this deep dive guide we'll examine how generators work in Rails. Additionally, we'll walk through how to create a custom generator in Rails. Part 2 of 2.

This section of the course explains how data flow works in Rails, focusing on how the MVC structure allows for an organized process of data management.

In this guide you'll learn how to create a seeds file. This file will allow you to dynamically generate sample data to use in the application.

This guide walks through a step by step process for building out an index action from scratch to list out all of the portfolio items from the database.

This guide gives a step by step guide for how to implement the new and create functionality in a Rails application.

This lesson walks through how to build out the ability to edit database records in Rails, completely from scratch.

This tutorial will walk through how to implement the link_to method in Rails in order to dynamically generate links to other pages of an application.

This guide will walk you through how to create the show action in Rails, completely from scratch, including how to implement show page links from other pages.

This guide gives a step by step guide for how to delete items in a Ruby on Rails application. We'll also walk through the differences between delete and destroy in Rails.

This guide gives step by step instructions for how to customize routes in Rails, including how to set the homepage route for an entire application.

This guide examines how to override the default route path for the resources method in a Ruby on Rails application for the show action.

This tutorial walks through how to implement permalinks into a Ruby on Rails application by integrating the friendly_id gem. This is part 1 of 2.

This tutorial walks through how to implement permalinks into a Ruby on Rails application by integrating the friendly_id gem. This is part 2 of 2.

This guide walks through how to integrate enums into a Ruby on Rails application, which will allow for our application's blog posts to have a published or draft status. This will enable a number of key features, such as: creating scopes, automatically generating methods for updating the blog post's draft or published status, and much more.

This lesson provides a step by step guide for how to implement a custom method in Rails that can be activated via clicking a link. This implementation will cover each stage of the data flow process and show how to properly toggle the blog post's status via the view. Part 1 of 2.

This lesson provides a step by step guide for how to implement a custom method in Rails that can be activated via clicking a link. This implementation will cover each stage of the data flow process and show how to properly toggle the blog post's status via the view. Part 2 of 2.

In this guide we finish up the data flow set of features, update the project management dashboard and merge the feature branch into the master branch on GitHub.

In this deep dive we're going to examine how to work with the Ruby on Rails routing system. This will include creating custom routes, using namespaces for nested routes, working with dynamic values in routes, and much more. Part 1 of 3.

In this deep dive we're going to examine how to work with the Ruby on Rails routing system. This will include creating custom routes, using namespaces for nested routes, working with dynamic values in routes, and much more. Part 2 of 3.

In this deep dive we're going to examine how to work with the Ruby on Rails routing system. This will include creating custom routes, using namespaces for nested routes, working with dynamic values in routes, and much more. Part 3 of 3.

This section of the course walks through how to manage data in a Rails application. This includes working with: validations, concerns, data relationships, and much more.

This guide walks through how to implement data validations in Rails 5, specifically it explains how to require data to be entered in order to create or edit records in the database.

In this guide you'll learn the basics of how data relationships work in Rails. Additionally, we'll walk through a system for determining how to decide on foreign key placement.

This guide gives a step by step set of instructions for building custom database scopes in a Rails 5 application, including both of the syntax options available in Rails.

This guide walks through multiple ways that you can set defaults in a Rails 5 application, including a discussion on when to use the various options and the various stages of callbacks.

This lesson explains how to properly utilize concerns in the Rails framework. Additionally, it discusses when concerns should be utilized.

In this guide we'll prepare for implementing complex forms in Rails by building an additional parent/child database relationship, connecting the Portfolio model with a new model called Technology.

In this guide we'll continue to walk through complex forms in Rails 5, specifically we'll analyze how to configure the model file so that it can accept nested attributes for a child model.

In this guide we're going to finish up the complex Rails 5 form feature. Specifically, we will walk through how to configure the form, controller, and view files to work with nested attributes.

In this deep dive we're going to walk through a wide range of ways that Rails allows developers to communicate with databases. Specifically we're going to analyze SQL and ActiveRecord to learn how to query data in an application. Part 1 of 3.

In this deep dive we're going to walk through a wide range of ways that Rails allows developers to communicate with databases. Specifically we're going to analyze SQL and ActiveRecord to learn how to query data in an application. Part 2 of 3.

In this deep dive we're going to walk through a wide range of ways that Rails allows developers to communicate with databases. Specifically we're going to analyze SQL and ActiveRecord to learn how to query data in an application. Part 3 of 3.

In this section you'll learn how to integrate authentication into your application, allowing users to register, sign in, and sign out. We will implement the Devise RubyGem to build out this feature.

This guide walks through how to install the Devise Gem in a Ruby on Rails 5 application, including how to find the Devise Gem page.

This guide gives step by step instructions for how to install the Devise gem and configure it to allow users to register, login, and logout of a Ruby on Rails 5 application.

Learn how to implement custom routes for Devise based authentication pages, including new methods that have changed in Rails 5.

This guide examines how to implement the ability for users to be able to logout of a Rails 5 application. Additionally this lesson shows how to dynamically show and hide the authentication links based on whether a user is signed in or out.

Learn how to customize the Devise authentication system by adding new User attributes that can be added during the sign up process.

In this Ruby on Rails 5 guide we'll walk through how to refactor the Devise strong parameter list and integrate it into a controller concern.

This guide explains how to implement virtual attributes in Rails 5. Specifically we'll walk through the steps needed to add first and last name attributes without having to add new columns to the database.

This deep dive focuses on how to implement encryption in Ruby. Specifically we'll analyze how to leverage the BCrypt RubyGem in order to securely encrypt and perform comparisons with data.

This section explains how you can work with controllers in a Rails 5 application, including: how to work with sessions in Rails, understanding params, and reviewing data flow.

This guide walks through how to work with the params hash in a Rails 5 application, including how to access params from the controller and view.

This guide explains how you can work with sessions in Rails 5 to share data between pages, and how to pull data from the params hash.

This guide walks through how to refactor the session tracking system into its own controller concern to improve the code organization in the Rails 5 application.

Strong parameters can help to protect your site from malicious hacking attempts. In this guide we'll walk through what strong params are, how to make them optional, and how to build a strong param method from scratch.

The null object pattern is a helpful design pattern that enables methods to be called with more confidence. In this deep dive we'll walk through how to implement the null object pattern in a Rails application to override the Devise current_user method to enable a guest user feature. Part 1 of 2.

The null object pattern is a helpful design pattern that enables methods to be called with more confidence. In this deep dive we'll walk through how to implement the null object pattern in a Rails application to override the Devise current_user method to enable a guest user feature. Part 2 of 2.

In this section you'll learn how to work with Views in Rails, including: using custom layout files, working with partials, using Rails view helpers, and how to dynamically generate HTML code.

Rails provides a master layout file that allows programs to have a single file that can share components such as: a navigation bar, login links, and other items that are required on multiple pages. In this guide we'll walk through the Rails master layout file and examine how we can customize it and therefore add elements that are shared across the application. Part 1 of 2.

Rails provides a master layout file that allows programs to have a single file that can share components such as: a navigation bar, login links, and other items that are required on multiple pages. In this guide we'll walk through the Rails master layout file and examine how we can customize it and therefore add elements that are shared across the application. Part 2 of 2.

As helpful as the master application layout file is in Rails, we also have the ability to implement custom layout files in an application. This guide walks through how to build two custom layout files, one for our blog, and another for the portfolio pages.

Partials in Rails are a great way to share view components across multiple pages. Additionally, partials help make it possible to limit duplicate view code in an application. In this guide we'll walk through an introduction to Rails partials and refactor our navigation bar so that it can be shared across multiple layouts.

In addition to partials allowing applications to share view code, Rails also makes it possible to send data to partials in order to give them custom behavior. In this guide we'll examine how we can use locals in partials to refactor the Portfolio form and to add dynamic styles to the navigation bar.

View helpers are a great way to store view logic in a Rails application. In this guide we'll walk through: what view helpers are, how they can be used, how they are different from partials, and how to implement them in order to store the logic for our application's auth links.

So far we've covered the ability to hard code HTML code into a Rails view helper method. In this guide we'll walk through how to leverage the content_tag helper method to auto generate HTML code in a Rails 5 application.

This introductory guide walks through how to leverage partials to automatically render collections of data. We'll also walk through when this approach works and when you will need to manually configure the process.

In the last guide we implemented an automated way to render collections in a Rails view template. In this guide we'll examine how we can manually configure collections to work with partials.

This guide walks through how to implement powerful ActionView helper methods in a Rails application to perform tasks such as rendering how long ago a blog post was created, how auto render currency, and much more.

This deep dive examines various processes associated with ActionView. Specifically, we'll walk through: what ActionView is, how to manage views in a Rails application, how to work with partials, and much more. Part 1 of 2.

This deep dive examines various processes associated with ActionView. Specifically, we'll walk through: what ActionView is, how to manage views in a Rails application, how to work with partials, and much more. Part 2 of 2.