Top 9 Recommended Ruby 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

Welcome to the most comprehensive Ruby course available on Udemy! An in-depth overview of coding with Ruby, a popular programming language renowned for its simplicity and elegance. Whether you've never written a line of code before or are looking to learn a brand new language, this course covers all bases!

Learn to Code with Ruby offers more than 40+ hours of video tutorials, 250+ lectures, and dozens of quizzes and coding exercises to test your knowledge as you proceed through the course.

Lessons include:

• Installation and configuration for both Mac OS and Windows systems

• Common programming concepts (variables, arithmetic, output)

• Objects and methods

• Strings

• Numbers

• Booleans

• Methods and Conditionals

• Ranges

• Arrays

• Hashes

• Blocks, Procs, and Lambdas

• Dates and times

• File Input and Output

• Regular Expression

• Classes, Modules, and Inheritance

and more!

Ruby is a language released by Yukihiro Matsumoto in 1995 that bills itself as "a programmer's best friend". Every aspect of Ruby is designed to make programming easier for the developer. There is no better first language if you're interested in learning how to program.

Ruby also serves as the foundation for Ruby on Rails, a popular web framework that powers over 1.2 million websites worldwide. The course offers an extensive introduction to the base language you'll need to know if you intend to tackle web development in the future.

Check out the sample videos below to get a taste of what the course has to offer!

So if you're ready to commit yourself, if you're eager to expand your knowledge of programming, if you're ready to discover what makes this elegant language so loved by developers, you are ready to Learn to Code with Ruby!

Thanks for checking out the course!

1. Introduction and Installation
2. Welcome to Ruby [SLIDES]
3. Object-Oriented Programming [SLIDES]
4. Ruby Installation Instructions
5. macOS - Access and Work with the Terminal
6. macOS - Install XCode Command Line Tools
7. macOS - Install Homebrew
8. macOS - Install rbenv
9. macOS - Install Ruby
10. macOS - Install VSCode Text Editor
11. Windows - Access and Work with PowerShell
12. Windows - Figure Out if System is 32-bit or 64-bit
13. Windows - Install Ruby
14. Windows - Install VSCode Text Editor
15. Install VSCode Extensions
16. Add VSCode to Your System PATH
17. Download Course Materials
18. Write First Ruby File and Run with Code Runner
19. Write First Ruby File and Run with Terminal or PowerShell
20. Interactive Ruby (IRB)
21. Section Review [SLIDES]
22. Getting Started
23. The puts Method
24. Escape Characters
25. The print Method
26. The p Method
27. Comments
28. Outputting Text
29. Multiline Comments
30. Integers and Floating Point Numbers
31. Basic Arithmetic in Ruby
32. String Concatenation
33. Intro to Exceptions: TypeError
34. Output and Arithmetic
35. Section Review [SLIDES]
36. Variables
37. Variables [SLIDES]
38. Declaring Variables
39. Variable Declaration
40. Coding Exercise Solution: Variable Declaration
41. Exceptions: NameError
42. Parallel Variable Assignment
43. Swapping Variable Values
44. Assignment Shortcuts
45. Constants
46. Section Review [SLIDES]
47. Object Methods
48. Intro to Object Methods
49. Integer Methods
50. Intro to Object Methods
51. Coding Exercise Solution: Intro to Object Methods
52. Exceptions: NoMethodError
53. Method Chaining
54. The inspect Method
55. The nil Object
56. String Interpolation
57. The gets Method
58. The class Method
59. Methods to Convert Objects
60. Section Review [SLIDES]
61. Booleans and Predicate Methods
62. Intro to Booleans
63. The Equality Operator
64. The Inequality Operator
65. Mathematical Comparisons
66. Predicate Methods
67. Methods with Arguments (include?)
68. Methods with Multiple Arguments
69. Arithmetic Methods
70. Float Methods
71. Section Review [SLIDES]
72. Methods
73. Intro to Methods
74. Parameters and Arguments
75. Multiple Method Parameters
76. Manipulating Arguments
77. Local Variables
78. Return Values I
79. Return Values II: Implicit Return Values
80. Methods
81. Coding Exercise Solution: Methods
82. Optional Parameters and Default Arguments
83. Optional Parameters and Default Arguments
84. Coding Exercise Solution: Optional Parameters and Default Arguments
85. Section Review [SLIDES]
86. Blocks
87. Introduction to Blocks with the times Method
88. Intro to Blocks
89. Coding Exercise Solution: Intro to Blocks
90. Block Variables
91. Block Variables
92. Coding Exercise Solution: Block Variables
93. The upto and downto Methods
94. The step Method
95. Section Review [SLIDES]
96. Conditionals
97. The if Statement
98. Predicate Methods in if Statements
99. Truthiness and Falsiness
100. if Statements
101. Coding Exercise Solution: if Statements
102. if and elsif
103. if and else
104. if, else and elsif
105. Coding Exercise Solution: if, else and elsif
106. Multiple Conditions with And Operator (&&)
107. Multiple Conditions with Or Operator (||)
108. Multiple Conditions
109. Coding Exercise Solution: Multiple Conditions
110. Parentheses Precedence
111. Nested if Statements
112. Ternary Operator
113. Call A Method from Another Method
114. The case Statement
115. The unless Keyword
116. Statement Modifiers
117. Conditional Assignment Operator
118. Section Review [SLIDES]
119. Strings I
120. Single Quotes vs Double Quotes
121. Multiline Strings
122. String Comparisons
123. String Concatenation Options
124. The length and size Methods
125. Length and Comparison
126. Coding Exercise Solution: Length and Comparison
127. Intro to Index Positions
128. Index Positions
129. Coding Exercise Solution: Index Positions
130. Extract Multiple Characters from a String
131. String Slicing
132. Coding Exercise Solution: String Slicing
133. Overwrite Characters in String
134. The insert Method
135. The empty? and nil? Methods
136. Case Methods
137. The reverse Method
138. Bang Methods on Strings
139. Section Review [SLIDES]
140. Loops
141. The while Loop
142. The until Loop
143. FizzBuzz Problem
144. FizzBuzz Solution
145. The next Keyword
146. The break keyword
147. Recursion I
148. Recursion II
149. Section Review [SLIDES]
150. Debugging
151. Install debug Gem
152. The debugger and binding.break Methods
153. The step Keyword
154. The info Keyword
155. Section Review [SLIDES]
156. Arrays I: Creation and Access
157. Introduction to Arrays
158. Nested Arrays
159. Shorthand %w Syntax to Create An Array of Strings
160. Creating Arrays
161. Coding Exercise Solution: Creating Arrays
162. Access and Overwrite Array Element by Index Position
163. Access Single Array Element with the fetch Method
164. Indexing into Arrays
165. Coding Exercise Solution: Indexing into Array
166. Access and Overwrite Multiple Array Elements with Bracket Syntax
167. Access Multiple Array Elements with the values_at Method
168. The first and last Methods
169. The length, size, and count Methods
170. Extracting Multiple Array Elements
171. Coding Exercise Solution: Extracting Multiple Array Elements
172. The empty? and nil? Methods
173. Equality and Inequality Operators with Arrays
174. The Spaceship Operator
175. The push Method and Shovel Operator
176. The insert Method
177. The pop Method
178. The shift and unshift Methods
179. Section Review [SLIDES]
180. Ranges
181. Intro to Ranges
182. Alphabetical Ranges
183. The include? and member? Method on Ranges
184. Random Numbers in Ruby (rand Method)
185. Extract Multiple Characters or Elements
186. The case Statement with Ranges
187. Convert Ranges to Arrays with to_a Method
188. Section Review [SLIDES]
189. Arrays II: Iteration and Various Methods
190. The each Method
191. Filtering with the each Method
192. each within each
193. The for Loop
194. each Method
195. Coding Exercise Solution: The each Method
196. The each_with_index Method
197. each_with_index
198. Coding Exercise Solution: each_with_index Method
199. Iteration over Array with while or until Loops
200. The map and collect Methods

Welcome to Testing Ruby with RSpec: The Complete Guide!

This course offers a comprehensive overview of the RSpec testing library for the Ruby programming language. RSpec is the most popular Ruby Gem of all time, with over 300 million downloads to date.

If you're new to the topic, testing is the practice of "writing code that confirms that other code works as expected". Tests control for regressions, which are changes to the code that break the program. Tests give you the confidence to refactor existing code because you know that you will honor the original purpose of the code.

The benefits of testing extend outside of your codebase. In this course, we'll cover test-driven development (TDD), a methodology in which we write our tests first, before the implementation. Test-driven development often leads to simpler, more decoupled code. Thus, testing can make you a better developer. Tests force you to think critically about the program and its features: the classes, the objects, the methods and more.

Testing Ruby with RSpec begins with the RSpec essentials and proceeds to more complex topics including:

• Installation

• Project Initialization

• Test-Driven Development (TDD)

• let variables

• before and after Hooks

• Subjects

• Shared Examples

• Shared Context

• Built-in Matchers

• Mocks and Doubles

• Instance Doubles

• Class Doubles

As a software engineer and consultant who's worked with Ruby for 5+ years, I'm excited to introduce you to the awesome RSpec library, its elegant syntax, and all of its fun quirks.

Thanks for checking out the course!

1. Introduction
2. Welcome to RSpec
3. About Me
4. Unit Tests vs End-to-End (E2E) Tests
5. Setup Ruby on macOS Computers
6. Setup Ruby on Windows Computers
7. Install RSpec
8. Install Visual Studio Code for macOS
9. Start a Project with rspec --init
10. Download Course Files (Optional)
11. Test-Driven Development
12. The describe Method
13. The it Method
14. The expect and eq Methods
15. The describe, it and expect Methods
16. Reading Failures
17. Making the Specs Pass
18. QUIZ: TDD and RSpec Methods
19. Multiple Examples in Example Group
20. Fixing Failing Specs Again
21. Making Specs Pass
22. Reducing Duplication - Before Hooks and Instance Variables
23. Reducing Duplication: Helper Methods
24. Problems With Mutation
25. Reducing Duplication: The let Method
26. Custom Error Messages
27. Removing Duplication
28. The context Method and Nested Describes
29. before and after Hooks
30. Nested Logic: Hooks
31. Single Context Hooks
32. Multi-Context Hooks
33. Nested Logic: Overwriting Let Variables
34. Subjects, Shared Examples, and Shared Context
35. Implicit Subject
36. Implicit Subject
37. Explicit Subject
38. Explicit Subject
39. One-Liner-Example-Syntax
40. described_class
41. Shared Examples with include_examples
42. Shared Context with include_context
43. Subjects, Shared Examples, and Shared Context
44. Built-In Matchers
45. The not_to Method
46. Equality Matchers I (eq and eql)
47. Equality Matchers II (equal and be)
48. Comparison Matchers
49. Equality and Comparison Matchers
50. Predicate Matchers
51. all Matcher
52. be Matcher (Truthy, Falsy and Nil Values)
53. Predicate, all and be Matchers
54. change Matcher
55. contain_exactly Matcher
56. have_attributes Matcher
57. include Matcher
58. start_with and end_with Matchers
59. raise_error Matcher
60. respond_to Matcher
61. satisfy Matcher
62. not_to Method
63. Compound Expectations
64. Compound Expectations
65. Mocks
66. Create a Test Double
67. Doubles
68. Set up Our Test Movie
69. Replacing an Object with a Double
70. Receive Counts
71. The allow Method
72. Matching Arguments
73. Instance Doubles
74. Class Doubles
75. Spies I
76. Spies II
77. Conclusion
78. Conclusion
79. Bonus!

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

In this course we'll learn the Ruby programming language from an absolute Beginner level all the way to Advanced in no time at all!

This course is aimed at the absolute beginner, you don't need any coding experience at all!

We'll start out by setting up a development environment that has all the tools you need to start writing and running Ruby code.

Then, we'll dive into very basic computer science concepts. Things like:

• Printing to the Screen

• String Manipulation

• Variables

• Getting User Input

• Simple Math

• Comparison Operators

• Assignment Operators

After that, we'll move into more intermediate topics like:

• Conditional If/Else Statements

• Arrays

• While Loops

• Each Loops

• Hashes 

• Fizzbuzz

Finally we'll finish up with more advanced topics like:

• Methods

• Classes

Ruby is one of the greatest programming languages to learn, and learning has never been this easy!

I'll see you on the inside!

-John Elder

1. Ruby Programming Basics
2. Introduction
3. First Things First: How To Get Support Fast!
4. Install Sublime and Git Bash
5. Install Ruby
6. Hello World - First Ruby Program
7. Printing To The Screen With Puts and Print
8. String Manipulation
9. Variables
10. Getting User Input With Gets
11. Git Bash Weirdness...
12. Simple Math
13. Converting To An Integer
14. Comparison Operators
15. Assignment Operators
16. If/Else Conditional Statements
17. Intermediate Ruby Programming
18. Arrays
19. While Loops
20. Each Loops
21. Hashes
22. Building FizzBuzz!
23. Methods Part 1
24. Methods Part 2
25. Advanced Ruby Programming
26. Intro To Ruby Classes
27. Ruby Classes Part 1
28. Class Getters
29. Class Setters
30. Adding Perimeter and Area Methods
31. Class Attr Accessor
32. Creating a Draw Method
33. Bonus Lecture