[As described below, this is Part C of a 3-part course. Participants should complete Parts A and B first -- Part C "dives right in" and refers often to material from Part A and Part B.] 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.
Summarizing All We Have Learned
Loading...
En provenance du cours de University of Washington
Programming Languages, Part C
237 notes
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
À partir de la leçon
Section 10, Final Exam, and Course Wrap-Up
We have reached the last module of Programming Languages! We first study subtyping, how it relates to static types for object-oriented programming, and how it relates to generics. There is no assignment or quiz devoted only to this last "new material", but there is a "final exam" covering Part B and Part C of the course. Enjoy studying for the exam, and don't miss the final "wrap-up" lesson when you're all done!
Rencontrer les enseignants
Dan GrossmanProfessor
Computer Science & Engineering
[MUSIC]
So, what I'd like to do now is welcome to really the wrap up
to the end of the course.
The idea is that this video and
the next on are situated after all the work in the course, after the final exam.
So, I want to congratulate you just take a few minutes to review where we've been and
what's been special about it.
The way it breaks up is this video is about the actual content of the course and
then the next video is more about MOOC experience.
So it turns out that way back when you were first looking at this course, there
was some information about the course that listed some goals, some learning goals.
So I thought I'd really just put these up there and not the outline of the course,
but they're what I hope you got out of participating and the first is this
accurate understanding of both functional and object-oriented programming.
The sort of thing you'll never forget, because we focused on it so
much all the way through.
I hope you've developed the skills to learn new programming languages quickly
not just because you've done it three times, but because you've learned the key
concepts that underly almost all programming languages.
I hope that you can now master specific language concepts.
Both the ones we've studied, whether it's closures or delaying evaluation or
pattern matching as well as new ones by knowing how to approach something by
trying to understand what it means and how it's commonly used in programs.
I hope you've learned to evaluate the power and
elegance of programming languages, even recognize sort of which tools,
which constructs are appropriate for different tasks you might be using or
at least have additional insight into how to go about doing that.
And I hope that you've not only become a quote, unquote better programmer in ML,
Racket and Ruby, but in every programming language you ever have used or
ever will use.
As I've emphasized over and
over again, programming languages is not about ML Racket and
Ruby, that's just the setting in which we've learned far more universal concepts.
So in terms of the actual outline, if you break things down into ten sections,
this is where you've now been.
It's amazing how much content you can have behind these short phrases that
describe these ideas.
So, you've seen functional programming and pattern matching in ML style type systems.
You've seen the dynamic typing of Ruby.
You've implemented your own programming language.
You compared object to any programming, to functional programming.
You've learned how to decompose programs under both approaches.
You've seen subtyping and advanced type system concept.
So, a whole lot of stuff.
And obviously, this is just a very brief summary.
Let me now for probably the third or fourth time show you this slide,
which is the very simple high-level grid of how we've covered three out of four
possibilities of combining functional or
object-oriented with dynamically typed or statically typed and
that's a good complement to a lot of people's prior knowledge.
Or if not, then future knowledge of a statically typed object-oriented
programming language like Java or C#.
And so that's been our framework is doing three of these four quadrants,
but I want to emphasize that it is not the case that all programming languages can
be described by being in one or even more than one of these quadrants.
There are additional things.
So for example, Haskell is a statically type functional language.
But its laziness, the way it delays evaluation of almost everything
in the language makes it quite different from ML and
then there are additional rows of this grid.
The most commonly known one that's neither functional nor object-oriented,
nor sort of lower-level and procedural like C would be prolog and
related languages, which are logic programming languages.
So we could do more, but I feel that where we are here at the end of part C tells
a complete story that covers a lot of the space of programming languages,
but certainly not all of it.
So I want to emphasize a couple more highlights of
what we've gone through things that I like to emphasize and the first,
perhaps no surprise is emphasizing the benefits of not mutating data.
A programming without side effects and assignments statements, and
imperative updates.
So I thought I'd point out that while that's by no means all of that we covered
in this course, it did come up several times and
I think it's worth pointing that out and I may have missed a few here.
All the way back in the first section of the course,
I pointed out that if you don't update things, then you don't have to worry about
when different references in your program are aliases of each other or not.
This is a huge burden lifted from you when you're trying to write correct,
easy to read, easy to maintain programs.
Then in section four, when we're discussing the equivalents of two
functions or two programs, we saw that if you can assume that both are functional,
both on have side effects, then a lot more things become equivalent.
In section five, we looked at the need to make copies of data if you're
worried that some other part of the program might update that data and
you don't want it updated.
But if you know that the program is not going to update something,
perhaps because the language forbids it, then you have to worry about that.
And so your programs connection should be more efficient, shorter and simpler.
And here near the end of the course when we studied subtyping, I made a big point
that in a mutable setting, depth subtyping is unsound.
It's incorrect.
It's wrong.
But if your data is immutable, then depth subtyping is in fact, not a problem.
Now I want to emphasize all these reasons and more to avoid mutation, but
I also want to emphasize that I understand there are situations where updating in
imperative state does make sense.
When it's the natural thing that you are doing when your program is modeling and
imperative update of the world, then imperative updates can make sense.
It's just not necessary to use them for every little algorithm in your program.
So, that's the last time I'll emphasize a mutation free programming.
Let me hit briefly some other highlights.
Function closures and how powerful, and convenient they are.
We didn't just teach what they are,
we saw idiom after idiom of how they are a powerful programming construct.
Back in part A of the course, I really emphasized datatypes and
pattern matching as a really powerful way
to organize the cases of your program that a lot of languages don't have.
And so, we saw that come back in the last programming assignment of the course where
you had some pretty concise ML code that you then had to port to
ruby in a way that was probably a bit harder to understand.
That's a debatable point and
one where people are allowed to have different opinions.
We talked about static versus dynamic typing.
What static typing can accomplish and what it's not designed to do,
and how it's inherently approximate that
sound static languages always reject programs that are perfectly fine.
And that's considered okay, because they catch so many bugs and enforce so
many invariants, but that's a trade-off we're willing to have.
Here at the end of the course, we saw that subtyping and
generics are a very interesting contrast and it's important not to use one when
the other is the right thing for describing what you're doing.
And if there's one thing I wish we had emphasized more in the course,
it's probably modularity.
We certainly focused on ML's modular system around the middle of the course.
There are approaches to modularity in Racket and
Ruby that would have been worth learning, as well.
But as you write larger and more complex programs, there's no substitute for
modularity.
It's a really valuable concept and programming languages can
be designed to help you write effective, and modular programs.
A few more highlights, I love to think of programs themselves as trees.
Not text in a file, but sort of abstract syntax tree that was essential when we
wrote our own interpreter for the made up programming language we did in part B.
And then going all the way back from the very beginning that you can
think of every language construct is having a syntax, how you write it?
Having typing rules.
What makes a legal program and what doesn't?
And evaluation rules.
What does it mean to evaluate such a language
construct when a program is executing?
And what I find truly awe inspiring,
what makes me happy to be spending my professional career focused on programming
languages is the way a small set of simple language constructs can combine.
Languages like ML, Racket and Ruby are not that large compared to
the amazing variety of software that we as humankind have built.
We take these languages that have a small number of really powerful ideas and
we combine them with human ingenuity, and that's what software is all about.
And I've hoped to have shared some of that passion and
awe with you as we've gone through, and
studied the simple concepts that now we're able to combine to write software.
So, what now?
I mean, we're done with the material.
And so I hope I've provided you with an intellectual framework that will
serve you well, as you continue throughout your life to become a better
software developer who enjoys learning new languages and writing new programs.
And as we all get older, as the years pass ahead, surely there will be new languages.
The details will change.
The terminology may change, but the concepts that we've covered in
this course have been around for a long time, have been very successful and
I believe and hope that they have stood the test of time.
And that there will always be some variant of the concepts we studied
in this course at the core foundation of the languages we use to write
the software that runs our world and that's exciting.
It's been exciting to share it with you and that's why I'm so
passionate about programming languages.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
