So here's kind of the overview of where we are after Part A we had seen the basics
of functional programming and static type language including pattern matching and
function closures and things that are a little more ML
specific in terms of how it does modularity and type inference.
And then, here in Part B,
you've seen the corresponding dynamically typed approach to several things.
We've focused a lot on delayed evaluation and things like streams.
And then, we learned how to write interpreters and
even implement our own language with function closures.
And then, we were able to discuss the difference between static and
dynamic typing.
So are we done?
Well, we certainly done with Part B but what I'd like to do is spend just a couple
minutes explaining how Part C really helps us finish the story.
So Part C has two more modules, section seven and eight and
what they do is focused still on dynamic typing like Racket but
on issues related to object-oriented programming and on comparing and
contrasting that, with functional programming.
So in section seven we'll have to do a bunch of things to get started with Ruby,
but in addition to just the object oriented programming
basics that that will involve, we'll do some other Ruby specific things as well.
Including its approach to things that are very close to closures, the way it treats
arrays in a very flexible manner, and a number of other things.
And then, in section eight, I think a lot of things will really come together.
And we'll learn how an object oriented style and a functional style in fact
are so opposite in the way they decompose large problems that they're really
two elegant ways of looking at the same thing just from, sort of something that
where it's such an opposite perspective, it's more similar than different.
And then, we'll be able to take on some more advanced object-oriented
programming topics.
Things like mixins and double dispatch,
we'll learn what those are when we get there.
And then, be able to compare fancy approaches to more flexible type systems,
kind of coming full circle and going back to the static typing domain with things
like the difference between generics and subtyping.
So let me sort of argue that I hope you continue to Part C to sort of finish
the story of what we're trying to do in this course.
Now, some of you, and somewhat understandably, may say, well,
I already have a lot of experience in OOP and object oriented programming.
I kind of came here for the functional parts, I've learned a lot and
I don't think I'm going to get as much out of Part C.
And I appreciate that perspective but
let me tell you how Part C might not be quite what you expected to be.
First of all, as we approach object-oriented programming,
in some ways like you've never seen it before, we're going to do it in a way
that's deeply analogous to the way we approach functional programming.
And the way I believe studying the material we have so
far in a piece by piece fashion with crisp definitions of what each
component means, I think similarly studying object- oriented programming
in that way will give you a better foundation for how to think about objects,
and classes, and methods, and things you may have seen before.
In particular, we will build up to giving a precise definition of
how you find what code to execute when calling a method on an object and
see that it's actually bit more complicated
than the rules associated with function closures.
Now, I will say that as you get in to the two modules in Part C, a lot of people may
find the second one more compelling and more interesting than the first one.
The first one needs to be self-contained, even for
people who haven't seen objects before.
And if you've already programmed in Ruby or a similar language,
a lot of it might seem old hat.
I should also add that the homework for that section is a little bit different.
What we basically do is make some small modifications to codes that are already
given to you.
What I like to do with that is give you that experience which is a lot
more like programming in industry and our open source projects is often like.
And again, there's kind of a bit of a divide there.
People who have already done a lot of that find it a little less motivated, but
people that don't, often find it really interesting their ability to go into
a language that they may have never used before.
And with a little bit of background namely the material on the section of the course,
are able to go into a full program and
change it in a fundamental ways to make it more flexible and expressive.
As a last thing, this course focuses a lot on functional programming and
therefore it can kind of seem anti object oriented programming.
That's largely not true in Part C.
I like to give OOP.
But we do focus on some things where functional tends to work out a little
better or following an object or in a perspective turns out to be a bit awkward.
And what that's really letting us do,
and what I hope you're excited to see, is actually learn more about functional
programming by being able to contrast it with object-oriented programming.
So let me finish up with some of the things that we're going to see in Part C
that really are about functional programming.