【2015新书】Clojure Reactive Programming

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

【2015新书】    Clojure Reactive Programming

Book 图书名称： Clojure Reactive Programming
Author 作者：Leonardo Borges
Publisher 出版社：Packt Publishing
Page 页数：194
Publishing Date 出版时间：Mar 23, 2015                        
Language 语言：English
Size 大小：  MB
Format 格式：pdf  文字版
ISBN: 1783986662, 9781783986668
Edition: 第1版  搜索过论坛，没有该文档


Design and implement highly reusable reactive applications by integrating different frameworks with Clojure
About This BookLearn how to leverage the features of functional reactive programming using ClojureCreate dataflow-based systems that are the building blocks of reactive programmingLearn different Functional Reactive Programming frameworks and techniques by implementing real-world examplesWho This Book Is For
If you are a Clojure developer who is interested in using Reactive Programming to build asynchronous and concurrent applications, this book is for you. Knowledge of Clojure and Leiningen is required. Basic understanding of ClojureScript will be helpful for the web chapters, although it is not strictly necessary.
In Detail
Reactive Programming (RP) is central to many concurrent systems. It endeavors to make the process of developing highly-concurrent, event-driven, and asynchronous applications simpler and less error-prone. RP comes in many flavors and we will look at some of them in this book.

Clojure Reactive Programming is a practical guide aimed at exploring RP. It starts by describing Functional Reactive Programming (FRP) and its formulations, as well as how it inspired Compositional Event Systems (CES).

It also presents several examples of Reactive applications implemented in different frameworks, allowing you to develop an understanding of the subject as well as learn how to develop your ability to work with time-varying values.

By the end of the book, you will be equipped to solve real-world problems as well as understand the trade-offs between the approaches shown in the book.

== Table of contents ==
N/A


== 回帖见免费下载 ==

本帖隐藏的内容

Clojure Reactive Programming.pdf (2.01 MB)

2015-5-28 06:36:04 上传

声明： 本资源仅供学术研究参考之用，发布者不负任何法律责任，敬请下载者支持购买正版。
提倡免费分享！ 我发全部免费的，分文不收 来看看 ...
你也可关注我  马上加关注

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享1 收藏6 回帖

关键词：Programming Program Clojure Active Ming 西班牙 Leonardo English Design 出版社

Exercise 1.1

Modify the previous example in such a way that the sine wave is drawn using all rainbow colors. The drawing loop should look like the following:

1. (-> (.zip sine-wave rainbow-colours #(vector % %2))
   
2.     (.take 600)
   
3.     (.subscribe (fn [[{:keys [x y]} colour]]
   
4.                   (fill-rect x y colour))))

复制代码

Chapter 1 Summary

Reactive Programming is all about building responsive applications. There are several ways in which we can make our applications reactive. Some are old ideas: dataflow programming, electronic spreadsheets, and the Observer pattern are all examples. But CES in particular has become popular in recent years.

CES aims to bring to Reactive Programming the declarative way of modeling problems that is at the core of Functional Programming. We should worry about what and not about how.

Chapter 2 Summary

In this chapter, we took a deep dive into RxJava, a port form Microsoft's Reactive Extensions from .NET. We learned about its main abstraction, the observable, and how it relates to iterables.

We also learned how to create, manipulate, and combine observables in several ways. The examples shown here were contrived to keep things simple. Nevertheless, all concepts presented are extremely useful in real applications and will come in handy for our next chapter, where we put them to use in a more substantial example.

Finally, we finished by looking at error handling and backpressure, both of which are important characteristics of reliable applications that should always be kept in mind.

Chapter 3 Summary

In this chapter, we simulated a real-world application with our stock market program. We've written it in a somewhat traditional way using thread pools and a custom queue implementation. We then refactored it to a CES style using RxClojure's observable sequences.

The resulting program is shorter, simpler, and easier to read once you get familiar with the core concepts of RxClojure and RxJava.

In the next Chapter we will be introduced to core.async in preparation for implementing our own basic CES framework.

Chapter 4 Summary

By now, I hope to have proved that you can write reactive applications using core.async. It's an extremely powerful and flexible concurrency model with a rich API. If you can design your solution in terms of queues, most likely core.async is the tool you want to reach for.

This version of the stock market application is shorter and simpler than the version using only the standard Java API we developed earlier in this book—for instance, we didn't have to worry about thread pools. On the other hand, it feels like it is a little more complex than the version implemented using Reactive Extensions inChapter 3, Asynchronous Programming and Networking.

This is because core.async operates at a lower level of abstraction when compared to other frameworks. This becomes especially obvious in our application as we had to worry about creating broadcasting channels, go loops, and so on—all of which can be considered incidental complexity, not directly related to the problem at hand.

core.async does, however, provide an excellent foundation for building our own CES abstractions. This is what we will be exploring next.

Chapter 5 Summary

In this chapter, we developed our very own CES framework. By developing our own framework, we have solidified our understanding of both CES and how to effectively use core.async.

The idea that core.async could be used as the foundation of a CES framework isn't mine, however. James Reeves (see https://github.com/weavejester)—creator of the routing library Compojure (see https://github.com/weavejester/compojure) and many other useful Clojure libraries—also saw the same potential and set off to writeReagi (see https://github.com/weavejester/reagi), a CES library built on top of core.async, similar in spirit to the one we developed in this chapter.

He has put a lot more effort into it, making it a more robust option for a pure Clojure framework. We'll be looking at it in the next chapter.

take a look

Thanks for Sharing!