Skip Navigation Links

Course Length:
5 Days
Course Description:
This course combines the following courses into a single course:
          Ruby Programming
          Ruby on Rails 3

The description of each course is listed below:

This course covers the fundamental components of the Ruby Programming Language. Emphasis is placed on the object oriented aspects of Ruby. Topics include arrays, hashes, regular expressions, io, exceptions, modules, and applications areas.

This course describes how to write database-backed Web Applications using the Ruby on Rails (also pronounced RoR, or Rails) Framework. Students are taken through the various steps of creating a full-fledged Web Application. Topics include static and dynamic pages, sign up forms, signing in and out, sessions, managing users, and various other Rails topics.
Who Should Attend:
This course combines several courses, the descriptions for who should attend are listed below: This course is intended primarily for those who have programmed in other programming languages such as, but not limited to, C, C++, Java, or Perl. A typical student in this course has either been tasked with writing a Rails application, or has been tasked with evaluating the Rails framework. Thus, this course should be attended by developers and managers alike, and possibly system administrators.
Benefits of Attendance:
Upon completion of this course, students will be able to:
  • Distinguish and use various Ruby datatypes
  • Master the use of arrays and hashes
  • Build home grown classes
  • Use the extensive pre bundled classes
  • Use the I/O facilities of Ruby to read and write binary and text files
  • Master the use of Iterators to loop through various data structures
  • Use Exceptions in handling various run time errors
  • Create Ruby modules
  • Use the wide variety of Ruby Modules that come with the Ruby distribution
  • Install and set up the development environment.
  • Understand and create a basic Rails application.
  • Create static pages.
  • Understand the Ruby language underlying Rails.
  • Create a site layout, user data model, and full registration and authentication system.
  • Add microblogging and social features.
Prerequisites:
Students should have taken the Software Development for Non-Programmers course or have at least six months of programming experience in at least one programming language. Students should have been through a course in the Ruby Programming language. They should also have an understanding of HTML. Students should also have experience with a SQL compliant database such as MySQL.
Course Outline:
  • Chapter 1: An Overview Of Ruby (Part 1)
    1. What is Ruby?
    2. Executing Ruby Code
    3. Getting Input
    4. Comments
    5. Numbers
    6. Strings
    7. The Class Class
    8. Decision Making
    9. The case Construct
    10. Loops
    11. Iterators
    12. Regular Expressions
    13. Functions
    14. Odds and Ends
    15. Time Methods
  • Chapter 2: An Overview of Ruby (Part 2)
    1. Arrays
    2. Array Operator Methods
    3. Array Equality Operator
    4. Arrays as Stacks and Queues
    5. Higher Dimensional Arrays
    6. Other Useful Arrays Methods
    7. Command Line Arguments
    8. Hashes
    9. Common Hash Methods
    10. Sorting Hashes
    11. Iterators with Arrays and Hashes
    12. Arrays and Functions
    13. Hashes and Functions
    14. Named Parameters
    15. Symbols
    16. Procs
    17. Closures
  • Chapter 3: Classes
    1. Objects
    2. Brief History of OOP
    3. OOP Vocabulary
    4. Creating a New Class
    5. Using Objects
    6. Defining Operator Methods
    7. Inheritance
    8. Ancestors
    9. self
    10. Access Levels - public
    11. Access Levels – private
    12. Access Levels - protected
    13. Access Levels - Specification
    14. Class Data and Class Methods
    15. Adding Methods to Classes and Objects
    16. Special Global Variables
    17. Scope of Variables
    18. Built-in Classes
    19. The Math Class
    20. The NilClass Class
    21. TrueClass and FalseClass
    22. Built-in Class Hierarchy
  • Chapter 4: Input and Output
    1. Introduction
    2. Reading from the Standard Input
    3. Reading a Character at a Time
    4. Writing to the Standard Output
    5. Reading and Writing Disk Files
    6. Reading Files Using Iterators
    7. I/O With Command Line Commands
    8. Seeking About Files
    9. tell
    10. Capturing Data About Files
    11. Processing Directories
  • Chapter 5: Exceptions
    1. Introduction
    2. Exceptions
    3. Handling Exceptions
    4. Multiple Rescue Clauses
    5. Exceptions are Classes
    6. ensure
    7. retry
    8. raise
    9. Creating Your Own Exceptions
    10. catch and throw
  • Chapter 6: Modules
    1. Introduction
    2. Using Core Ruby Classes
    3. Ruby Standard Library
    4. require
    5. Search Path
    6. File Organization
    7. Load
    8. Modules
    9. include
    10. Mixins
    11. Using the Comparable Module
    12. Collection Classes
    13. yield
    14. Using the Enumerable Module
  • Chapter 7: Odds and Ends
    1. Ruby Conventions
    2. Strings Are References
    3. The Selection Operator, [ ]
    4. Index Methods
    5. Stripping Whitespace Characters
    6. Bit Manipulation
    7. The upto Method
    8. Substituting
    9. Processing a Line at a Time
    10. Marshalling
    11. Reflection
    12. grep
    13. Classes are Objects
    14. Aliasing
    15. Testing
    16. Test::Unit
    17. Testing Your Own Classes
    18. Freezing Objects
  • From Zero to Deploy
    1. Introduction
    2. Up and Running
    3. Version Control with Git
    4. Deploying
  • A Demo App
    1. Planning the Application
    2. The Users Resource
    3. A Microposts Resource
  • Mostly Static Pages
    1. Static Pages
    2. Our First Tests
    3. Slightly Dynamic Pages
    4. Exercises
  • Rails Flavored Ruby
    1. Motivation
    2. Strings and Methods
    3. Other Data Structures
    4. Ruby Classes
    5. Exercises
  • Filling in the Layout
    1. Adding Some Structure
    2. Layout Links
    3. User Signup: A first Step
    4. Exercises
  • Modeling and Viewing Users
    1. User Model
    2. User Validations
    3. Viewing Users
    4. Exercises
    5. Insecure Passwords
    6. Secure Passwords
    7. Better User Views
    8. Exercises
  • Sign Up
    1. Signup Form
    2. Signup Failure
    3. Signup Success
    4. RSpec Integration Tests
    5. Exercises
  • Sign In, Sign Out
    1. Sessions
    2. Signin Failure
    3. Signin Success
    4. Signing Out
    5. Exercises
  • Updating, Showing, and Deleting Users
    1. Updating Users
    2. Protecting Pages
    3. Showing Users
    4. Destroying Users
    5. Exercises
  • User Microposts
    1. A Micropost Model
    2. Showing Microposts
    3. Manipulating Microposts
    4. Exercises
  • Following Users
    1. A Relationship Model
    2. A Web Interface for Following and Followers
    3. The Status Feed
    4. Exercises