Top 9 Recommended Rails Self-Study Materials! [November 2024]

Rails is Server side Web Application Development framework, written in Ruby.

Rails makes it easier to create dynamic web sites using Ruby.

Rails follows the MVC Architectural Design Pattern (Model View Controller). Rails  was designed to help developers take applications from concept to completion as quickly as possible.

With Rails, you can take web applications from concept to launch in a matter of hours. Rails takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel.

Rails follows the principle of reducing repetition of information or code, promoting efficient development.

Rails introduces the Active Record framework, which allows developers to design interactive database queries.

This course provides developers with a thorough knowledge in developing Web Applications using Rails MVC architectural Pattern.

In this course by development expert Kameswara Sarma Uppuluri, you'll learn all, essential concepts that you need to know to build Modern Web Applications using Rails 7.0.

This course provides step-by-step walk-throughs and coding demos that you're encouraged to code along with to enhance the learning process.

This course is broken down into 36 Modules with each module providing source code so that you can follow along with Kameswara Sarma Uppuluri.

1. Ruby On Rails - The Big Picture
2. Course Introduction
3. Course Support for Learners
4. Introduction To Rails Full-Stack Web Framework
5. Installing Ruby
6. What is GEM?
7. Installing Rails
8. Installing Ruby 3.3.5
9. Installing Rails 7.2.1
10. Installing an Editor
11. Understanding MVC Architecture
12. Complete Course Exercise Files
13. Rails Application Request Response Life Cycle
14. Understanding Rails Request Response Life Cycle
15. Getting Ready with Rails Sample Application
16. Creating Rails Application
17. Creating Rails 7.2.1 Application
18. Creating a New Controller with Actions
19. Accessing Request QueryString Parameters
20. Accessing Controller's Variables in Views
21. Displaying Current Date and Time in View
22. Working with built-in Helper Methods
23. Passing a Hash To View
24. Working with IF In View
25. Looping through with .each Method
26. Debugging Rails Application
27. Using ViewHelper Methods to inspect variables
28. Working with Debug Gem
29. Working with web-console Gem
30. Understanding Logging Mechanism
31. Logging Messages with various Log Levels
32. Consuming RESTAPI
33. Consume RESTAPI and Render Data
34. Consume RESTAPI and Render Data using Bootstrap Card Component
35. Working with redirect_to, link_to
36. Handling CheckBox Events using jquery-rails
37. Setting Up SQLite3 Database for Rails Application
38. Configuring SQLite3 Database Adapter
39. Setting Up SQL Server Database for Rails Application
40. Installing SQL Server 2022
41. Installing SQL Server Management Studio
42. Configuring SQL Db Adapter in Rails App
43. Performing CRUD Operations using Rails ORM - ActiveRecord
44. Creating Models and Applying Migrations
45. Performing CRUD Operations from Rails Console
46. Displaying List Of All Employees
47. Displaying Details of an Individual Employee
48. Editing Details of an Employee
49. Updating Data To Database Table
50. Deleting an Employee
51. Inserting a New Employee
52. Working with Action Text Gem
53. Installing and Configuring ActionText Gem and Using a Rich Text Editor
54. Performing Joins using Rails ORM
55. Creating Master Models and Applying Migrations
56. Seeding Master Tables with Essential Data
57. Adding Foreign Keys through Migrations
58. Inserting Data along with Foreign Keys Data
59. Displaying All Records along with Foreign Keys Data
60. Implementing Details,Edit and Delete Operations
61. Implementing Validations
62. Setting Up Validations Demo Application
63. Creating Actions and Views
64. Implementing Model Level Validations
65. Displaying All Error Messages at Form Level
66. Displaying Error Message at Field Level
67. Writing Custom Validators
68. Active Record Migrations - InDepth
69. Creating Migrations to Add, Remove, Change Columns & Foreign Keys - Part 1
70. Creating Migrations to Add, Remove, Change Columns & Foreign Keys - Part 2
71. Performing Bulk Delete Operations
72. Deleting a Single Record Using RadioButton as a Row Selector
73. Deleting Bulk Records Using CheckBoxes
74. Creating Stimulus Controller to handle Client Side Events
75. Performing Bulk Update Operations
76. Rendering Rows into TextBoxes
77. Handling Edit Button Event using Stimulus
78. Updating Bulk Records
79. Performing Bulk Insert Operations
80. Creating Partial View
81. Rendering Partial View From Main View
82. Inserting Bulk Records
83. Implementing Cascading DropDown Lists
84. Getting ready with Models, Foreign Keys, Migrations, Relationships
85. Seeding Master Tables
86. Implementing Actions for Controllers
87. Creating Views
88. Using Rails.ajax in Stimulus Controller
89. Rendering Partial Views Using AJAX - Shopping Cart Single Page Application (SPA)
90. Understanding REST API End Points
91. Filling Dropdown List with Categories
92. Rendering Products of a Category inside a Partial View using AJAX
93. Rendering Shopping Cart
94. Implementing Add To Cart Functionality
95. Increasing and Decreasing Product Quantity using Buttons
96. Implementing Remove From Cart Functionality
97. Implementing Pagination, Search Functionalities
98. Configuring Kaminari Paginator
99. Implementing Pagination
100. Implementing Dynamic Page Sizing
101. Implementing Search Functionality
102. Working with Radio Buttons
103. Getting Ready with Models, Foreign Keys, Migrations, Relationships
104. Seeding Tables
105. Rendering Radio Buttons Dynamically
106. Handling Radio Button Events using Stimulus Controller
107. Saving Data To Multiple Tables upon Submission of Form
108. Working with CheckBoxes
109. Rendering Checkboxes Dynamically
110. Handling Checkbox Events using Stimulus Controller
111. Saving Data To Multiple Tables upon Submission of Form
112. Working with ListBoxes
113. Rendering Items into ListBoxes Dynamically
114. Moving Items From One List Box To Another ListBox Using Buttons
115. Handing Button Click Events using Stimulus Controller
116. Saving Data To Multiple Tables upon Submission of Form
117. Filtering Records Using Active Record Query Interface
118. Using Where Clause - Part 1
119. Using Where Clause - Part 2
120. Working with find,findby,take,order,select,limit,count,joins,find_by_sql Methods
121. Working with Active Record Callbacks
122. Implementing Before Save,Update,Delete and After Save,Update,Delete Callbacks
123. Using Rails Transaction Support
124. Getting Ready with Models
125. Creating Controller's Index Action
126. Inserting Data Into Multiple Tables with Transaction Support
127. Export Data To Various Formats
128. Installing Required GEMS
129. Implementing Controller Actions
130. Exporting Data To PDF
131. Exporting Data To CSV
132. Exporting Data To TXT
133. Exporting Data To XLS
134. Exporting Data To DOCX
135. Uploading Files using Active Storage
136. Getting ready with Active Storage Tables
137. Implementing Index Action
138. Implementing New Action
139. Using jQuery Rails to handle events
140. Implementing Create Action
141. Implementing Show Action
142. Charts
143. Rendering Graph Types in a DropDown List
144. Drawing Bar, Line,Area,Pie,Doughnut,Radar,PolarArea Graphs on Canvas
145. Sessions - State Management Technique
146. Storing Data Into Session and Reading Data From Session
147. Storing Session Data Into A Database Table
148. Cookies - State Management Technique
149. Creating Plain Text Cookies, Signed Cookies and Encrypted Cookies
150. Authentication
151. Configuring Devise Gem For Authentication Functionality
152. Creating Roles
153. Creating Devise Model, Controllers and Views
154. Configuring Associations between Models
155. Configuring Routes
156. Customizing Layout Page
157. Implementing SignUp Functionality
158. Implementing Change Passwsord, Delete Account Functionality
159. Implementing Change Profile Functionality
160. Displaying List Of Roles for SuperUser
161. Creating New Roles By SuperUser
162. Editing Roles By SuperUser
163. Deleting Roles By SuperUser
164. Displaying List Of Staff Users
165. Creating a New Staff User
166. Editing Staff User Details
167. Deleting a Staff User
168. Creating Permission Model and Permission_Role Model
169. Assigning Permissions To Roles
170. Authorization
171. Configuring Pundit Gem
172. Creating Policy
173. Attaching Policy for Controller's CRUD Operations
174. Locking and Unlocking Users
175. Configuring Devise Model with Trackable and Lockable Modules
176. Configuring Sessions Controller For Consecutive Failed Login Attempts
177. Displaying List Of Locked Users
178. Working with Active Jobs
179. Installing Essential Gems for Active Jobs Scheduling
180. Getting ready with Models
181. Seeding Tables with Sample Rows
182. Creating a New Job and Implementing Perform Function
183. Creating a Second Job
184. Configuring application.rb,routes.rb,redis.rb,sidekiq.rb
185. Installing WSL (Windows Sub System for Linux) and Redis Server Locally
186. Run Redis Server, Sidekiq and Rails Application To Test Jobs
187. Creating Rest API using Rails
188. Creating New Rails REST API Project and Models,Foreign Keys, Migrations
189. Seeding Master Tables
190. Creating RESTAPI Controllers
191. Configuring CORS
192. Implementing Get All Records
193. Implementing Get By Id
194. Implementing Put
195. Implementing Delete
196. Implementing Post
197. Implementing Nested Serializers using Active Model Serializers
198. Consuming Rails Rest API from Rails Web Application
199. Making HTTP GET Request to retrieve List Of Records
200. Making HTTP GET Request to retrieve a Single Record

At first let's speak money...

Ruby on Rails Web Developer average salaries by city as of January 2020 (according to Glassdoor):

New York - $95,000/yr, Boston - $97,000/yr, San Francisco - $100,719/yr

So, Need more reasons on "why Ruby on Rails?"

You'll learn how to build your own Instagram or any social media web application using one of the most powerful and easy frameworks available... Ruby on Rails <3.

We will use the following during our journey:

• Ruby on Rails Framework

• Bootstrap Library for Styling

• Fontawesome Library for Icons

• FileBond Library for Uploading images

• Active Storage for Image Uploading

• Devise Gem for Authentication

What are the requirements?

• Basic understanding of the Ruby on Rails framework

• Basic knowledge of HTML & CSS

• Have Ruby on Rails Installed on your machine

What am I going to get from this course?

• Building a complete Instagram clone using Ruby on Rails 7

• Practice working with Bootstrap components and classes

• Installing Devise

• Adding Users with Devise

• Implementing authentication easily with Devise gem

• Solve Devise integration problems with Ruby on Rails 7

• Handling Authorization

• Work with font-awesome to add icons

• Handle complex database relationships

• Build Like Functionality

• Build Commenting System

• Build Follow System for any Social Media Application

• Suggesting users follow based on specific metrics

• Listing posts as feeds list in the home page

• Uploading images with preview and Drag-Drop using FileBond Javascript library

• Building Real-Time searching functionality

• Creating a User Dashboard

• Creating a Scaffold

• Resources in Rails

• Forcing People to Log In

1. Introduction
2. Introduction
3. Final Instagram Clone Application Preview
4. Github Repository
5. Project Setup
6. Creating our Application and add database configurations
7. Adding Bootstrap and solving integration problems with Rails 7
8. User Accounts & Authentication
9. Designing Instagram Login Page
10. Adding Users and Authentication Using Devise Gem
11. Adding Devise Login Functionality to our Home Page
12. Designing The Signup Page
13. Instagram Posts
14. Posts Overview
15. Creating Posts Model, View, and Controller using Scaffold
16. Styling The Post Card
17. User's Home Page
18. Styling The Navigation Bar
19. Adding The Stories Partial
20. Adding The Suggestions Partial
21. Organizing The Home Page
22. Creating New Posts
23. Adding New Post Modal
24. Adding Preview and Drag-Drop Using FilePond Library
25. Adding Post Validations
26. Likes
27. Likes Model And Controller Logic
28. Adding Like Functionality To Posts' Views
29. Who Liked The Post Modal
30. Comments
31. Comments Model And Controller Logic
32. Adding Creating New Comment Functionality To Posts
33. Listing All The Comments And Deleting Comments
34. User Profile Page
35. Designing User's Profile Header
36. Designing User's Profile Post Listing
37. Designing User's Updating Profile Information Page
38. Enhancing The Application
39. Enhancing The User Experience
40. Handling Post Deletion
41. Instagram's Follow System
42. Follow System Model
43. Testing Follow System Models and Adding Helping Functions
44. Follow System Controller's Logic
45. Integrating Sending Follow Requests To Other Users
46. Integrating Listing, Accepting, And Rejecting Follow Requests
47. Follow System User Experience Enhancements
48. Users Suggestions System
49. Users Suggestions System
50. Post Feeds
51. Post Feeds
52. Searching Users System
53. Searching Users System
54. Thank you
55. What's Next?
56. Thank you

Now featuring Rails 6 - the latest version of the Ruby on Rails framework.

Ruby on Rails Web Developer average salaries by city as of January 2020 (according to Glassdoor):

New York - $95,000/yr, Boston - $97,000/yr, San Francisco - $100,719/yr

Need more reasons on "why Ruby on Rails?"

Since its introduction, Ruby on Rails has rapidly become one of the most popular and powerful web application development tools for both startups and mature software companies. Some of the top sites in the world started with Ruby on Rails such as Basecamp, Twitter, Shopify, Github, LivingSocial, Groupon, Hulu, Airbnb, Yellow Pages and many more! Even after immense scaling, most of them continue to use Rails! Ruby on Rails developers routinely command the highest salaries in the tech industry!

The Complete Ruby on Rails Developer is:

#1 Web development course with Ruby on Rails on Udemy. 64,000+ students, 9500+ ratings, 57% of them are 5-star!

#1 Best-seller in Ruby on Rails since it's launch

This is the only course you'll need where you learn how to build everything from simple to complex, deployable, production-ready web applications

This course currently features the Ruby programming language, 5 total apps -- Alpha-blog and Finance Tracker featuring Rails 6, MessageMe and University app featuring Rails 5 and a SAAS app upgrade to Rails 6 underway!

The Complete Ruby on Rails Developer Course provides a thorough introduction to Web Applications Development using the wildly popular Ruby on Rails framework. With 40+ hours of engaging video lectures and text follow-up lectures with directions, references and code, this course is designed to:

- Take students with no prior programming or web application development experience to accomplished web application developers specializing in Ruby on Rails.

- Give students with prior experience in Ruby on Rails or web development a leg up in the industry by helping them learn the ins and outs of back-end development with Rails and building complex apps at will.

- Give professionals and students alike the avenue by which they can switch to Ruby on Rails as the back-end development framework of choice so they can build robust web apps in very quick time and bring their ideas to life.

Current web apps built in the course (6):

Sections 4 - 7: Alpha blog - CRUD functions, multiple resources, authentication system built from scratch, front-end using Bootstrap, one-to-many and many-to-many associations at DB layer, production deployment! Compatible with both Rails 4 and 5 (with repositories on each version). Built using Rails 6 (compatible with 4, 5, 6)

Section 8: MessageMe real-time messaging app featuring ActionCable, use of WebSocket protocol and Semantic-UI front-end. Built using Rails 5!

Section 9: Finance Tracker social media app - Learning to use Devise for authentication, generators, search forms, Ajax, JavaScript, search functionality, external API usage, secure credentials management, rapid prototyping. Built using Rails 6.

Section 10: Photo App - Production email confirmation functionality, extending devise basic functionality, payment using Stripe API, file storage with AWS S3 bucket.

Section 11: SaaS Project Management App - Multi-tenancy, extending devise and incorporating payment functionality with Stripe, multi-tiered teams, email invitations within teams, restrictions based on payment tiers and more!

Section 12: University App (bonus) - Introductory Rails app (optional as beginner app for the course) - beginner friendly, along the lines of Alpha blog, but uses MaterializeCSS front-end framework instead of Bootstrap and walks through how to customize features in it. Built using Rails 5.

Ruby on Rails - introduced 15 years ago - continues to be the cool but stable framework of choice for startups since it allows for rapid development - while maintaining structure and security - as complex and disruptive business ideas are brought to life in record time.

This course takes a very structured approach of teaching Rails starting with Ruby - the programming language behind Rails. Everything from "Hello World" to Object Oriented Programming is covered. Students acquire skills rapidly; utilizing homework assignments, quizzes, coding exercises and free web based resources to go with the video lectures. The text lectures also provide reference material after each video, it's like having multiple books in addition to the videos to guide students through the course.

At first all the code is done from scratch limiting the use of shortcuts and generators so students can understand what's really going on under the hood of Rails applications and can design them the way they want. Then with solid knowledge and understanding already in place, rapid prototyping methods are introduced in later parts of the course, showing use of generators and scaffolding, finishing with a complete Software as a Service Application that can be used to launch a startup!

Some key features of this course are:

- 250+ lectures and 40+ hours of video content

- Ruby programming from scratch; writing your first program to say "Hello World" to Object Oriented Programming while building multiple mini-projects along the way

- Local installation and development options made available for both Macs and Windows machines (that's right, Windows as well!)

- Git for version control, Github as code repository, Heroku for production deployment

- Working with Amazon Web Services S3 bucket for storage, Sendgrid for production email functionality, Multi-Tenancy using Milia

- Custom credit card form creation and working with Stripe API to implement payment processing functionality

- Rails MVC structure in-depth - Models, Views, Controllers

- FREE live support

- Design and conceptualization using wire-framing tools

- Building authentication systems from scratch at first using the default Rails stack, including admin feature, log in/logout and signup. Then learning how to use Devise and extend the basic functionality provided by Devise to customize it and speed up authentication systems

- Ajax, Jquery, plain JavaScript - all 3 used in different parts of the course!

- Bootstrap, Semantic-UI and MaterializeCSS (using material design concepts) for UI styling

- Fully automated test suites using Unit, Functional and Integration tests

- Database associations: One-to-many, many-to-many, self-referential using ActiveRecord

- much, much more!

Join today and I'll see you in the course.

1. Introduction and Setup
2. Introduction
3. Welcome quiz: Let's get our logic-based thinking warmed up
4. Let's code the quiz!
5. Course Structure, Overview and best way to use the course
6. Ruby on Rails Development Environment overview
7. [IMPORTANT] Development Environment Update - Please don't skip this text lecture
8. Web apps built in the course - Preview series kickoff
9. Preview: SaaS - Project Management App built in section 11
10. Preview of MessageMe chat application showcasing real-time Rails - Section 8
11. Preview of Finance Tracker App built in section 9, rapid prototyping
12. Preview of Univ App using material design for front-end (Section 12)
13. Preview of Alpha Blog App built from section 4 through 7
14. The Ruby Programming Language
15. How to get Free Live Help!
16. Introduction to Section 2 and Ruby
17. Introduction to Ruby - Text with directions, references and code
18. Working with Strings part 1
19. Working with Strings part 2: Getting input from user
20. Working with Strings - Text with directions, references and code
21. Homework Solution: Analyzer program code
22. Working with numbers
23. Working with numbers - Text with directions, references and code
24. Homework Solution: Working with numbers - Analyzer
25. Brief look at comparison operators
26. Methods
27. Branching if/elsif/else/end
28. Methods and Branching - Text with directions, references and code
29. Arrays and Iterators
30. Arrays and Iterators - Text with directions, references and code
31. Hashes
32. Hashes - Text with directions, references and code
33. Homework Project: Authenticator
34. Authenticator project implementation
35. Text lecture: Authenticator project code
36. Ruby Style Guide
37. Ruby Style Guide - Text with directions and references
38. Homework Assignment: Area code dictionary
39. Homework Assignment: Area code dictionary - Text directions
40. Solution: Area code dictionary
41. Solution: Area code dictionary
42. Practice what you have learnt
43. Introduction to Object Oriented Programming
44. Introduction to Object Oriented Programming - Text directions, refs and code
45. Attributes, getters and setters
46. Attributes, getters, setters - Text directions, references and code
47. Final Ruby project: Classes, Modules, Mixins - 1 - bcrypt
48. Final Ruby project 1 - Text follow-up
49. Final Ruby project: Classes, Modules, Mixins - 2 - methods
50. Final Ruby project 2 - Text follow-up
51. Final Ruby project: Classes, Modules, Mixins - 3 - modules
52. Final Ruby project 3 - Text follow-up
53. 'self' notation for method names
54. Final Ruby project: Classes, Modules, Mixins - 4 - include
55. Final Ruby project 4 - Text follow-up
56. Ruby Quiz
57. Introduction to Ruby on Rails
58. Introduction to Section 3 and Ruby on Rails kickoff
59. Ruby on Rails kickoff - Text directions and references
60. Model, View, Controller and Rails App Structure
61. Model, View, Controller and Rails App Structure - Text references
62. Required: Ruby on Rails installation (local or cloud-IDE)
63. Root route, controller, more MVC and say 'Hello World!'
64. Root route, controller and more MVC - Text directions and references
65. Structure of a Rails application
66. Structure of a Rails application - Text references
67. Version control with Git
68. Version control with Git - text references
69. Setup online code repository with GitHub
70. Setup online code repo with Github - Text directions and references
71. Front-end: Learn and practice HTML and CSS
72. Learn and practice HTML and CSS references
73. Create an HTML paragraph element
74. Create an unordered list
75. Add About page and homework assignment
76. Add About page and homework assignment - Text reference and code
77. Production Deploy!
78. Production Deploy - Text directions, references and code
79. The back-end: Database and tables in Rails
80. The back-end: CRUD, scaffold and wrap-up section 3
81. CRUD and scaffold generators - Text directions, references and code
82. Rails basics
83. CRUD Operations in Ruby on Rails
84. Preview of Alpha Blog App and Information
85. Introduction to Section 4: Tables, migrations and naming conventions
86. Intro to tables, migrations, rails conventions - text references
87. Models and rails console
88. Models and rails console - text references
89. CRUD operations from rails console
90. CRUD ops from rails console - text directions and code
91. Validations
92. Validations - text references
93. Show articles (route, action and view)
94. Show articles feature - text references and code
95. Articles index
96. Articles index - text references and code
97. Forms - build a new article creation form
98. Forms - new article form text reference
99. Create action - save newly created articles
100. Create action - text references
101. Messaging - validation and flash messages
102. Messaging - validation and flash messages - text references
103. Edit and update: update existing articles
104. Edit and update - text references and code
105. Delete: delete articles
106. Delete articles - text references
107. User Interface - add layout links
108. Layout links: text references
109. DRY (Don't Repeat Yourself) code - refactoring and partials
110. DRY code - text references
111. Production deploy and wrap up section 4
112. Production deploy - text follow-up
113. Rails UI
114. Define a style to set the font color
115. Define a style to remove underlines from all hyperlinks
116. Styling for your Rails Application
117. Introduction to Section 5 and styling
118. Learn to use Bootstrap
119. Install Bootstrap, asset pipeline, JavaScript, webpack - Rails 6 vs 5
120. Install Bootstrap, asset pipeline - text directions, references and code
121. Install Bootstrap in Rails 5 (or earlier versions)
122. Install Bootstrap in Rails 5 - text references
123. Build homepage
124. Build homepage - text follow-up
125. Layout links using Bootstrap classes
126. Layout links - text follow-up
127. Style articles index page
128. Style index view - text references
129. Style form partial
130. Style form - text references and code
131. Style validation and flash messages
132. Style messages - text references
133. Style show view
134. Style show view - text references
135. Cleanup layout, production deploy and wrap up section 5
136. Cleanup layout - text references
137. Rails front-end styling
138. Associations and Authentication Systems
139. Introduction to section 6: users, associations, ERD and more
140. One-to-many associations demo with the rails console
141. Create users
142. Create users - text directions and code
143. Add user validations
144. Add user validations - text directions and code
145. One to many association
146. One to many association - text directions and code
147. Show user info in articles
148. Show user info in articles - text directions and code
149. Alter object state before_save
150. Alter object state before_save - text directions
151. Add secure password
152. Add secure password - text directions and code
153. New user signup form
154. New User Signup - text directions and code
155. Create new users (back-end)
156. Create new users - text directions and references
157. Edit users
158. Edit users - text directions and code
159. Show user and profile image
160. Show user and profile image - text directions and code
161. Add users index
162. Add users index - text directions
163. Cleanup layout
164. Cleanup layout - text reference
165. Add pagination to views
166. Add pagination to views - text references
167. Add login form
168. Add login form - text references
169. Create and destroy user sessions
170. Create and destroy sessions for users - text directions and code
171. Authentication helper methods
172. Authentication helper methods - text reference and code
173. Controller methods as helper methods
174. Controller methods as helper methods - text references
175. Restrict actions from UI
176. Restrict actions from UI - text references
177. Modify navigation based on helpers
178. Modify navigation - text references
179. Restrict actions at controller level - articles
180. Restrict actions for articles controller - text references
181. Restrict actions in controller level - users
182. Restrict actions for users controller - text references
183. Delete user
184. Delete user - text references
185. Add admin user functionality - intro
186. Admin user intro - text references
187. Add admin user access through views and controllers
188. Add admin user access - text references
189. Assignment - alert message color based on type
190. Assignment solution - text references
191. Production deploy and wrap up section 6
192. Rails actions, authentication and associations
193. Many-To-Many Associations and Automated Testing - Integration, Functional, Unit
194. Introduction to Section 7
195. Category model and testing
196. Category model and testing - text references and code
197. Validations using unit tests
198. Validations using unit tests - text references
199. Categories controller and tests
200. Categories controller and tests - text references and code

If you're tired of long courses and just want to learn basic web development this course is for you. This course was built with the goal of teaching the students how to use Ruby on Rails and SolidJs. It focuses heavily on designing a backend RESTful Web Service with CRUD functionality that sends data to a SolidJs Front End Application.  This is an entry-level course that focuses on building and reinforcing some of the techniques used by developers to build a full-stack application.

In this course, we start by learning what tools you need to create a full-stack Before taking this course, it is recommended that you have an understanding of skills such as Javascript, Ruby, Basic SQL, or ORM development. If not we'll touch on some of those topics early in the course but it is still recommended to have a better understanding.

When going through this course you may come across subjects that you are familiar with as well as those that are completely new to you.

Some of the topics touched upon include

• SolidJs Hooks

• SolidJs Functional Components

• HTTP Requests with Fetch

• CRUD Methods

• Ruby on Rails

• Database Migrations

• ORMs

When taking this course, please know that you can take your time because you will get access to support along the way. By the time you finish this course, you should feel comfortable creating a full-stack web application with SolidJs and Ruby on Rails.

1. Introduction
2. Introduction
3. Create Rails API
4. Install Ruby
5. Create Rails Project
6. Create Rails Models
7. Create Todo Rails Controller
8. Create a Todo Rails
9. Show Todos Rails
10. Update Todos API Ruby on Rails
11. Delete Todos API Ruby on Rails
12. Create SolidJS Todo List
13. Install SolidJS
14. TodoList Service
15. TodoList UI Componenets
16. Todo List Item Component
17. Todo List Methods
18. Todo List Component UI
19. Create Todos
20. Delete Todos

Content updated in 2022 to reflect latest versions of Ruby, Rails and GraphQL!

This course teaches the basics of using GraphQL in a Rails application. GraphQL is a query language invented by Facebook in 2012, and made open source in 2015. While it has certain clear advantages over REST, it also has a somewhat steeper learning curve.

Structured in a simple and accessible manner, these lectures will help you get on your way to using GraphQL to circulate data between back-end and front-end applications.

In the first section we will learn about reading data. The second section will be focused on changing data, and the slightly more advanced third section is about protecting data, using techniques both implemented in the GraphQL library or suggested by myself.

GraphQL has a number of features that make it an advantageous change for REST adopters, like the ability to only get what you ask for, or having instant API documentation available after every change. After completing this course, you'll be in a position to implement GraphQL in a new or existing Rails application with basic features all the way up to authorisation and access control. This should definitely get you started on your way!

1. Introduction
2. Introduction
3. What is GraphQL?
4. GraphQL versus REST
5. Getting Started
6. GraphiQL
7. The Default Query
8. Reading Data
9. What we'll do
10. JSON
11. Introduction to queries
12. Query arguments
13. Query context
14. ActiveRecord queries
15. Scalar field types
16. Nullability
17. ActiveRecord fields
18. Custom types
19. Arrays
20. Start the back-end of a blog app
21. Changing Data
22. What we'll do
23. Creating records
24. Query variables
25. Input types
26. Updating records
27. Deleting records
28. Handling validation errors
29. Continue the blog back-end by adding create, update and delete capabilities
30. Authentication, Authorisation, and Access Control
31. What we'll do
32. How authentication and authorisation work
33. Login (authentication)
34. Authorisation
35. Logout
36. Access control
37. Visibility and Authorisation
38. Conclusion
39. Conclusion