[MUSIC] So let me now give a brief oral review of what we've covered already in Part A and Part B, and how that relates to what we're going to cover in Part C. So to boil down [LAUGH] probably 100 hours worth of work and ideas into one slide. In Part A, we learned the basics of functional programming. We learned static typing in ML. We learned pattern-matching. We learned first-class functions and closures, and things like type inference, modules, and the idea of two programs being equivalent to each other. Then in part B we were able to complement our experience with ML by using Racket, which is a dynamically typed functional language. And beyond just the basics of dynamic typing and how they relate to static typing, we investigated some key idioms, as well, related to delaying evaluation. As well as to implementing our own languages in terms of an interpreter function, that eval exp that we covered quite a bit in the middle of Part B. So overall, what this gives you is a background in functional programming. Key experiences, both using a static type system and not using one. And getting very familiar with the sort of data structures and recursion and interpreters that are well known in the functional programming community. So now, as we transition over to object-oriented programming, we'll have to learn quite a bit new, but we'll leverage that previous experience. So as we learn the basics of Ruby, we'll identify a number of things that are not that different from in ML and Racket. It turns out Ruby has something called blocks that are almost like closures. We'll also see that Ruby is a very dynamic language. It has some dynamic features that are probably even more dynamic than the way Racket looks at these things. And then we'll focus on the object-oriented piece, classes and methods, and how the data in a Ruby program is always wrapped up in this idea of an object which has state and methods that you can call on those objects. So we'll have methods instead of functions. And if you've seen object-oriented programming before, you may be a little less excited by this first section of Part C. And if you haven't, it's okay, everything should be self contained. But we need to go through everything so that we have that basic piece. And we'll actually see that Ruby is a very pure object-oriented language. As we'll explain in this first week of the course, everything is an object. Then that will set up the second part of the course here in Part C, where we'll be in a good position to understand how to use object-oriented programming to decompose a problem into pieces, and how to use functional programming to decompose a problem into pieces. And we'll see that these approaches to programming are exactly opposite. They're so opposite that they're actually not that different. And this'll be a key aha moment for the course. And then we'll be able to build on that with some advanced related topics such as Ruby's approach to mixins, which it calls modules. And this programming idiom in object-oriented programming known as double dispatch, which will be a key focus of the programming assignment, there in that second week of Part C. And it turns out the second week, as we'll understand more in the next video, is sort of light on videos and heavy on challenging homework. because that's the last programming assignment in the course, where I want to bring a lot of ideas in together. And then in the last week, I want to return to static typing land. So we'll kind of just focus on the key concepts of subtyping, which is really important if you do want static typing for an object-oriented langauge. And contrasting that with the generics, with the polymorphism that we saw in ML. So we have a lot ahead of us, a lot of key opportunities to bring together concepts and contrast them. So even if you find this first week a little bit more basic, and just focused on getting you up to speed in Ruby and with objects. Rest assured, in the two weeks that follow, we'll use that foundation to bring a lot of pieces together and sort of wrap up the course into a coherent presentation of comparing and contrasting key ideas.