Syllabus

[KevinMulhern]

Leo made a great point about drafting out a broad syllabus for this course in another issue #2

I think it's a great idea and will hopefully generate a lot of new ideas as well as get us all on the same page as to what we want this course to be and contain.

I'm not sure what format we should go with here so write out your ideas in whatever way you think is best.

I think it would also be good to mention that I think we should take an MVP philosophy with working on and rolling out the new course. We should aim to make the smallest changes that add value and then roll it out to get feedback and to allow users to get value from what we are working on as quickly as possible. We can then iterate from that to polish and 'complete' things.

[KevinMulhern]

Heres my take:

Overall Learning outcomes for a student completing this course.

• They know the basics of programming and how to solve problems programatically
• They have a good grasp of Ruby as a language and specific features to it ie enumerables
• They have a good grasp of OOP and testing
• They know about Files and serialisation
• They know how to model software with OOP and know the best practices with general software and OOP design

Essentially I would like the course to focus only on the pragmatic programming skills a student will need to be a software developer as well as best practices for writing clean and maintainable code. Not many programs I've seen cover the later point in much detail so I think this will give us an edge as well as producing much more skilled students.

The main things I think we should change

• Shorter more focused lessons, take a look at the amount of learning outcomes in some our existing lessons some of the lists have well over 30 items. Smaller more focused lessons will allow us to make better more localised improvements in the future as well as improve the users experience as they will be able to focus on one thing at a time and mark lessons complete much more frequently

• Small exercises on every lesson, having small exercises in each lesson will allow the user to practice concepts they are learning straight away and get them coding more often.

• Remove the computer science section, this section isn't that great and is a bit out of place in this course. Austin outlined the idea of having a language agnostic computer science course so we wouldn't duplicate efforts between the Ruby and Javascript. I think this would be a much better approach with teaching computer science fundamentals. In saying that I do think we should use some of the common staples of computer science data structures and algorithms for the projects in this course. For example, sorting algorithms, linked lists, queues and stacks etc. These are great for getting students thinking in a programatic way so we shouldn't try and reinvent the wheel with the projects.

• Remove the chess final project and replace it with something a bit less intimidating. As the lesson completion data shows a lot of students skip the final chess project after making it all the way through the rest of the course. From feedback in the chatroom and elsewhere I deduce this project is too intimidating to students. They see it as a massive jump in complexity and a huge time commitment to complete and there may be other barriers that put them off it such as not knowing how to play chess. I believe we should replace this project with something that is still significant but isn't as complex and won't take as much time to complete overall.

With all that being said, heres a rough draft of what I think the syllabus should be:

---

Section: Programming Fundamentals

• Lesson: Primitive Data Types
  • Strings, numbers and symbols
• Lesson: Variables
  • What are variables and how to use them. Explain pass by reference.
• Lesson: Input and Output
  • Puts, print and getting input from a user
• Lesson: Conditional Logic
  • If and case statements. Boolean logic
• Lesson: Loops
  • All the different loops in Ruby (Except enumerables)
• Lesson: Collections
  • Arrays and hashes
• Lesson: Basic Enumerables
  • What enumerables are and how they work. Explain each, map, select
• Lesson: Methods
  • How to write your own methods
• Lesson: Problem Solving
  • Approaches to problem solving
• Lesson: Debugging Techniques
  • Some techniques for debugging
• Projects
  • 4 or 5 projects to practice the fundementals

---

Section: Basics of OOP

• Lesson: Why OOP?
  • What OOP is and what problems it solves
• Lesson: Classes and Instances
  • Whats a class and instance and whats the difference between them
• Lesson: Methods in OOP
  • Instance methods, class methods and getter and setter methods
• Lesson: Inheritance
  • What is inheritance, what does it do.
• Lesson: Method scope
  • Public, protected and private methods
• Lesson: Modules
  • Whats a module, whats the difference between them and classes and what to use them for
• Lesson: Working with Collaborator Objects
  • How to get your objects to work together
• Lesson: Intermediate enumerables
  • Intermediate enumerables, inject, max, sort etc
• Projects
  • 4 - 5 projects to practice OOP

---

Section: TDD

• Lesson: Why TDD?
  • The philosophy behind TDD and its process
• Lesson: Introduction to RSpec
  • Install Rspec and its basic syntax
• Lesson: Structuring your tests
  • How to use describe and context in your tests
• Lesson: Mocks, stubs and spies
  • What each of these are and when and how to use them
• Lesson: What to test
  • The rules of what to test
• Projects
  • 1 or 2 projects the user can practice testing on

---

Section: Files and Serialisation

• Lesson: Files basics
  • The basics of using files
• Lesson: Loading files
  • Require, load, require_relative etc
• Lesson: Standard Ruby project set up
  • How to set up your ruby objects, lib and spec folder etc
• Lesson: Serialization
  • Yaml and JSON
• Projects
  • A couple of projects to practice using files

---

Section: Advanced OOP

• Lesson: Ruby Object Model
  • How ruby finds which method to use.
• Lesson: Solid Design Principles
  • Explain all the principles
• Lesson: Basics of Refactoring and code smells
  • Basic code smells and solutions for refactoring them
• Lesson: Composition over Inheritance
  • Why you should use composition over inheritance
• Lesson: Basic Design Patterns
  • Some of the common design patterns the student will come across
• Projects
  • A couple of projects to practice

---

Advanced Ruby

• Lesson: Blocks Procs and lambdas
  • What these are and how to use them
• Lesson: Advanced Enumerable’s
  • How to use enumerable in your own custom class
• Lesson: Meta Programming basics
  • The basics of meta programming
• Projects
  • A couple of projects, one for making your own enumerable methods. The other for meta programming

---

Wrapping up

• Final project
  • Final project for this course
• Lesson: Conclusion
  • Closing thoughts

---

I don't consider this to be complete or the final syllabus. This is very likely to change from feedback we receive and other learnings as we progress with making the new course. But this covers all the stuff I really want to cover in the new course.

[CouchofTomato]

Hi @KevinMulhern. Agree with most of what you say and the draft of the plan looks great.

At this stage I only have two things to add.

1. Although splitting up lessons to make them shorter helps. We need to be careful not to get too carried away. If you look at the FCC roadmap it looks really daunting, even if most of those lessons might only take minutes to learn. It might put people off if the course looks ridiculously long so I'd like to find a good middle ground. I definitely do agree that we need to split out some of the current content though.

2. One big thing in Ruby is that you should aim for composition over inheritance. In what section do you see that being addressed?

[KevinMulhern]

Great points @CouchofTomato, I completely agree with not getting too carried away with the amount of lessons we have. I think having a lot of smaller lessons at the start of the course will make the course more accessible to beginners as it will be holding their hand a lot more with its introduction of new topics coming one lesson at a time. We can tail off this as the course progresses and make longer more 'complete' lessons.

🙈 I completely forgot about composition, do you think it fits better in the Basic OOP section or the Advanced OOP section?

[leosoaivan]

Great job on that syllabus, @KevinMulhern!

It would appear to me that composition would be a great fit in Advanced OOP. It could go after the first bit on Refactoring, sort of like Refactoring pt. 2, I think.

[CouchofTomato]

@KevinMulhern

I agree with @leosoaivan and would aim to put composition in the advanced section.

[KevinMulhern]

👍 sounds good

We planned to add debugging lesson to the fundamentals when we planned that section earlier in the year. I think it would be good to include that as well.

[CouchofTomato]

Oh yeah, debugging is a must. Well remembered.

[mindovermiles262]

https://github.com/TheOdinProject/ruby_course/blob/master/Syllabus.md

[mindovermiles262]

Is it worth it to include some RegEx stuff too? I don't use it ALL that often, but it's nice to know how it works

[KevinMulhern]

We should definitely include that @mindovermiles262 👍 👍 👍
Which section should we put it in?

[mindovermiles262]

Might fit best in the Advance section. Maybe we can make some sort of web scraper as a final project where RegEx would be helpful

[KevinMulhern]

Nice! I really like the idea of building a web scrapper 😄 its practical and can be non trivial.