[As described below, this is Part B of a 3-part course. Participants should complete Part A first -- Part B "dives right in" and refers often to material from Part A.] This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones. This course is neither particularly theoretical nor just about programming specifics -- it will give you a framework for understanding how to use language constructs effectively and how to design correct and elegant programs. By using different languages, you will learn to think more deeply than in terms of the particular syntax of one language. The emphasis on functional programming is essential for learning how to write robust, reusable, composable, and elegant programs. Indeed, many of the most important ideas in modern languages have their roots in functional programming. Get ready to learn a fresh and beautiful way to look at software and how to have fun building it. The course assumes some prior experience with programming, as described in more detail in the first module of Part A. Part B assumes successful completion of Part A. The course is divided into three Coursera courses: Part A, Part B, and Part C. As explained in more detail in the first module of Part A, the overall course is a substantial amount of challenging material, so the three-part format provides two intermediate milestones and opportunities for a pause before continuing. The three parts are designed to be completed in order and set up to motivate you to continue through to the end of Part C. Week 1 of Part A has a more detailed list of topics for all three parts of the course, but it is expected that most course participants will not (yet!) know what all these topics mean.
Part B Wrap-Up and Part C Preview
Loading...
Del curso dictado por University of Washington
Programming Languages, Part B
372 calificaciones
De la lección
Section 7 Including a Quiz
In the last module of Part B we will use our experience programming in ML and Racket to
compare and contrast static typing and dynamic typing. This is not only the most important difference between these two languages, but it is a fundamental topic in the study of programming languages. Learning it can help you program more effectively in both kinds of languages. After completing this week's quiz, don't forget to watch the Part B Wrap-Up and Part C Preview video.
Conoce a los instructores
Dan GrossmanProfessor
Computer Science & Engineering
[MUSIC]
In this last video for Part B, I want to congratulate you on getting to this point
and set the context of where we've been and where Part C will allow us to go.
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.
First, we'll see how you could implement object-oriented programming
on your own in Racket.
At least in a particular way.
It turns out Racket has classes and objects, and
we could have just done Part C in Racket, but
if you had nothing in Racket other than what I've already shown you, it turns out
there are some clever ways to implement object- oriented programming on your own.
And seeing that can explain OOP in a pretty fascinating way.
Second, we'll do, as I mentioned before, this way to think about how functional
programing, FP, and object-oriented programming, OOP, decompose problems in
exactly the opposite way, and how that makes them more similar than different.
And then, the last homework of the course,
Homework 7 in Part C, is again a more challenging one.
Challenging like Homework 5 is.
And what we're going to do is we're going to take some code in ML,
we're going to go back and look at ML, import that code to Ruby, and
as we do it we're not just going to translate it over in the same style.
We're going to convert the style to be a fully
OOP committed to objects way of restructuring the program.
And the program we're going to port is another interpreter.
So you get experience with interpreters again
except instead of focusing on closures, which we already did here in Homework 5,
we're going to do it for a little geometry language.
Which will let you see how the idea of interpreters, is useful for
things other than conventional programming languages.
It'll be about different geometry objects and intersecting them and
things like that.
And then, lastly, we'll be able to look all the way back at ML's type variables
those quote As that we saw and the types of functions like map and filter.
And compare that to how languages like Java and C-sharp do provide an analogous
thing which is generics, but also a very different thing which is sub typing.
So we'll get back to static type systems and
see how they're related to both FP and OOP.
So with all that, congratulations on finishing Part B of the course.
You've done a tremendous amount of work and
I hope to see you at the beginning of Part C very soon.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2018 Coursera Inc. Todos los derechos reservados.
