Explore
For Enterprise
Join for Free
Log In

Обзор
Поиск
Для организаций
Войти
Присоединиться бесплатно

Conclusion

Loading...

Functional Program Design in Scala

Федеральная политехническая школа Лозанны

4.5 (оценок: 2,706) | Зарегистрировано учащихся: 46K

Курс 2 из 5 — Functional Programming in Scala Специализация

In this course you will learn how to apply the functional programming style in the design of larger applications. You'll get to know important new functional programming concepts, from lazy evaluation to structuring your libraries using monads. We'll work on larger and more involved examples, from state space exploration to random testing to discrete circuit simulators. You’ll also learn some best practices on how to write good Scala code in the real world. Several parts of this course deal with the question how functional programming interacts with mutable state. We will explore the consequences of combining functions and state. We will also look at purely functional alternatives to mutable state, using infinite data structures or functional reactive programming. Learning Outcomes. By the end of this course you will be able to: - recognize and apply design principles of functional programs, - design functional libraries and their APIs, - competently combine functions and state in one program, - understand reasoning techniques for programs that combine functions and state, - write simple functional reactive applications. Recommended background: You should have at least one year programming experience. Proficiency with Java or C# is ideal, but experience with other languages such as C/C++, Python, Javascript or Ruby is also sufficient. You should have some familiarity using the command line. This course is intended to be taken after Functional Programming Principles in Scala: https://www.coursera.org/learn/progfun1.

Просмотреть программу курса

Получаемые навыки

Streams, Functional Design, Reactive Programming, Functional Programming

Рецензии

4.5 (оценок: 2,706)

5 stars
1,762 ratings
4 stars
679 ratings
3 stars
215 ratings
2 stars
42 ratings
1 star
8 ratings

HH

Jul 24, 2016

Really enjoyed doing the course. Learned a ton of Stuff. Functional programming design is amazing. It's like learning Object Oriented programming (with design patterns) for the first time.

MM

Jul 15, 2016

Picks up where the previous course left off... the last assignment is a bit more challenging than the others, well for me it was. Thanks to the people who put the course together.

Из урока

Timely Effects

This week we'll learn a number of important programming patterns via examples, starting with the observer pattern, and then going on to functional reactive programming. We'll learn how latency can be modeled as an effect, and how latency can be handled with Scala's monadic futures. We'll learn the important combinators on futures as well as how they can be composed to build up rich and responsive services.

Lecture 4.1 - Imperative Event Handling: The Observer Pattern12:27

Lecture 4.2 - Functional Reactive Programming20:23

Lecture 4.3 - A Simple FRP Implementation19:32

Lecture 4.4 - Latency as an Effect 17:33

Lecture 4.5 - Latency as an Effect 212:46

Lecture 4.6 - Combinators on Futures 19:20

Lecture 4.7 - Combinators on Futures 27:07

Lecture 4.8 - Composing Futures 14:03

Lecture 4.9 - Implementation of flatMap on Future3:46

Lecture 4.10 - Composing Futures 28:03

Преподаватели

Martin Odersky
Professor

Текст видео

This concludes the course on Functional Program Design. Over the past four weeks, you have learned how to combine the fundamental elements of functional programming in more interesting and advanced higher level combinations, which in turn then are useful tools for the design of more advanced programs and systems. In particular, you have learned about lazy evaluation and how you can use it to define infinite data structure. And you also have learned about the very important distinctions between computations and values, and the fact that computations can themselves be values and function of programming. That manifests itself in many different contexts. For instance, a random value is really a computation that gives you values every time you demand an value, or sigma is really a computation that can be sampled at a particular point in time. An important method to abstract the properties of a computation where monads, and you'll see monads applied in many different contexts from randomness, to delays to general effects. An important strand of many modules in this course was the interaction and relationship of functional programming and mutable state. You have seen what happens when you mix the two. In particular, the substitution model is no longer valid and the question of when two values are equal becomes a lot more subtle then it was before. You've seen some of the powers of mutations in the example of digital circuit simulation. And also how to encapsulate and contain that power using a range of techniques from laziness, for instance, because laziness essentially encapsulates a mutation from undefined to defined. But you can't really use that directly, you use rather the idea of a lazy value indirectly. The second way to encapsulate state mutations was functional reactive programming. There again signals internally are defined by variables which from the outside you can't see that. You just interact with values that are signals that essentially time varying functions. And finally, you have encountered monads. As a useful way to encapsulate state mutations and to define already in the type where you have side effects rather than purely functional programming. So you've seen in the last week of this course, futures from a consumer perspective as essentially events that happen at some later point in time. Of course, the question comes up, well who will actually compute the thing that gets evaluated and sent later in time? And the answer is, invariably, well, it has to be some sort of parallel computation using threads. So, it's important to learn about how these threads work. And also how to abstract over them, because threads by the themselves are a very low-level and dangerous model. Useful abstractions beside futures reactive streams and also actors. The second question then is well, how can we use multithreadedness to gain more efficiency using parallel data structures and parallel algorithms? If you want to scale parallelism further than what a single computer can do, you arrive at distributive programs. A particularly important topic for distributive programs is data analysis and big data, for instance the very popular Spark platform for data analysis is written in Scala and can be programmed in Scala. It actually turns out that our ideas of collections that we have already seen for sequential and then in the future we'll also see that for parallel, Scala bright into distributed collections. So in a sense, Spark can be seen as a framework for distributed Scala collections. You'll find out more about this in future courses of the specializations. And I hope I'll see you back for them in class.

Ознакомьтесь с нашим каталогом

Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.

Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.

Coursera

О проекте
Руководство
Карьера
Каталог
Сертификаты
Сертификаты MasterTrack™
Степени
Для организаций
Для правительственных организаций

Сообщество

Учащиеся
Партнеры
Разработчики
Бета-тестировщики
Переводчики
Блог
Технический блог

Еще

Условия
Конфиденциальность
Помощь
Доступность
Пресса
Контакты
Справочник
Филиалы

© Coursera Inc., 2019 Все права защищены.