Intermediate Ruby Programming & OOP in East Africa

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this intermediate Ruby programming course, the learner will be able to:
• Explain Ruby’s object model and apply object-oriented programming principles.
• Design classes with clear responsibilities, state and behaviour.
• Create and use constructors, instance methods, class methods and constants.
• Protect object state through encapsulation, validation and method visibility.
• Choose appropriately between composition and inheritance.
• Organise reusable code with modules, namespaces and mixins.
• Use blocks, `yield`, Procs and lambdas to write flexible Ruby code.
• Handle expected failures with built-in and custom exceptions.
• Model real business rules with collaborating Ruby objects.
• Refactor procedural code into clean, maintainable object-oriented Ruby.
• Build and document an intermediate Ruby command-line application for an East African use case.

Modules

1. 1

   Thinking in Ruby Objects

   Reviewing methods, collections and program structure.Understanding that values in Ruby are objects.Classes, instances, messages and method calls.Inspecting object class, identity and behaviour.Identifying objects and responsibilities from a problem statement.Moving from procedural scripts to object-oriented design.
2. 2

   Classes, State and Behaviour

   Defining classes and creating objects.Initialising objects with `initialize`.Instance variables and instance methods.Readers, writers and accessors.Class methods, class-level state and constants.Coding exercise: model a product, customer and order.
3. 3

   Encapsulation and Reliable Business Rules

   Public, private and protected methods.Validating data at object boundaries.Keeping state consistent.Query methods and command methods.Value objects and meaningful domain names.Coding exercise: validate payments, balances or stock movements.
4. 4

   Composition, Inheritance and Polymorphism

   “Has-a” and “is-a” relationships.Building objects through composition.Creating subclasses and using `super`.Method overriding and polymorphic behaviour.Recognising fragile or unnecessary inheritance.Refactoring a class hierarchy toward clearer design.
5. 5

   Modules, Namespaces and Mixins

   Defining and using modules.Organising classes with namespaces.Sharing behaviour through `include`, `extend` and `prepend`.Working with `Enumerable` and `Comparable`.Avoiding naming conflicts.Coding exercise: reusable formatting and validation modules.
6. 6

   Blocks, Procs and Lambdas

   Reviewing blocks and block parameters.Passing behaviour with `yield`.Checking for a block with `block_given?`.Creating and calling Procs and lambdas.Understanding return and argument-handling differences.Using closures in practical programs.Coding exercise: configurable report generation.
7. 7

   Exceptions and Defensive Ruby

   Understanding Ruby’s exception hierarchy.Using `begin`, `rescue`, `else` and `ensure`.Raising meaningful errors.Creating custom exception classes.Recovering from file, input and business-rule failures.Avoiding overly broad exception handling.Producing useful messages for users and developers.
8. 8

   Object-Oriented Ruby Application

   Turning requirements into classes and responsibilities.Separating input/output from business logic.Coordinating multiple objects.Refactoring duplication and long methods.Documenting setup and usage in a README.Capstone options: SACCO member ledger, SME inventory manager, produce-order processor or training-centre records system.