By Aleksandar Prokopec
Research the artwork of establishing complicated, glossy, scalable concurrent functions utilizing Scala
About This Book
layout and enforce scalable and easy-to-understand concurrent applications
utilize Scala by way of realizing its philosophy and harnessing the facility of multicores
Get familiar with state-of-the-art applied sciences within the box of concurrency, with a specific emphasis on functional, real-world applications
step by step educational advisor, that is jam-packed with pragmatic examples
Who This booklet Is For
This ebook is a must have educational for software program builders aiming to write down concurrent courses in Scala, or develop their latest wisdom of concurrency.
This booklet is meant for Scala programmers that experience no past wisdom approximately concurrent programming, in addition to these trying to expand their current wisdom approximately concurrency. easy wisdom of the Scala programming language might be useful. Readers with an outstanding wisdom in one other programming language, similar to Java, may still locate this booklet simply accessible.
What you are going to Learn
familiarize yourself with the basics of concurrent programming on smooth multiprocessor platforms, with a specific concentrate on the JVM concurrency model
construct high-performance concurrent structures from uncomplicated, low-level concurrency primitives
show asynchrony in concurrent computations with futures and promises
Seamlessly speed up sequential courses through the use of data-parallel collections
enforce reactive and event-based courses declaratively with Rx-style occasion streams
layout secure, scalable, and easy-to-comprehend in-memory transactional info models
Transparently create allotted functions that scale throughout a number of machines
decide upon the right kind concurrency abstraction and combine varied concurrency frameworks jointly in huge applications
This ebook provide you with an perception into the simplest practices essential to construct concurrent courses in Scala utilizing glossy, high-level concurrency libraries. It starts off by way of introducing you to the rules of concurrent programming at the JVM, outlining the fundamentals of the Java reminiscence version, after which indicates many of the vintage development blocks of concurrency, similar to the atomic variables, thread swimming pools, and concurrent information buildings, in addition to the caveats of conventional concurrency. It then walks you thru diversified high-level concurrency abstractions, each one adapted towards a particular category of programming initiatives. eventually, the publication provides an outline of whilst to exploit which concurrency library and demonstrates how all of them paintings together.
Read or Download Learning Concurrent Programming in Scala PDF
Similar programming books
Scala intensive is a distinct new publication designed that can assist you combine Scala successfully into your improvement technique. through providing the rising most sensible practices and designs from the Scala group, it courses you thru dozens of strong recommendations instance by means of example.
concerning the Book
Scala is a strong JVM language that blends the useful and OO programming versions. You'll haven't any hassle getting introductions to Scala in books or on-line, yet it's difficult to discover nice examples and insights from skilled practitioners. You'll locate them in Scala in Depth.
There's little heavy-handed thought here—just dozens of crisp, useful concepts for coding in Scala. Written for readers who recognize Java, Scala, or one other OO language.
Purchase comprises unfastened PDF, ePub, and Kindle eBooks downloadable at manning. com.
What's within* Concise, expressive, and readable code type
* the best way to combine Scala into your present Java tasks
* Scala's 2. eight. zero collections API
* tips to use actors for concurrent programming
* getting to know the Scala variety process
* Scala's OO features—type member inheritance, a number of inheritance, and composition
* sensible techniques and patterns—immutability, applicative functors, and monads
desk of Contents<ol>* Scala—a combined language
* The middle ideas
* Modicum of style—coding conventions
* using item orientation
* utilizing implicits to put in writing expressive code
* the kind approach
* utilizing implicits and kinds jointly
* utilizing definitely the right assortment
* Integrating Scala with Java
* styles in useful programming
Completely rewritten for Apple’s rapid programming language, this up to date cookbook is helping you conquer the vexing matters you’re more likely to face whilst growing apps for iOS devices.
You’ll locate hundreds of thousands of recent and revised recipes for utilizing the iOS eight SDK, together with concepts for operating with future health info and HomeKit add-ons, improving and animating photographs, storing and holding information, sending and receiving notifications, and coping with records and folders between them. every one recipe comprises pattern code on GitHub that you should use straight away.
All smooth industries depend on huge and intricate software program platforms. to be able to build such huge structures in a scientific demeanour, the point of interest of the advance methodologies has switched within the final twenty years from sensible to structural concerns. Formal tools were utilized effectively to the verification of medium-sized courses in protocol and layout.
- Intra-enterprise business process management
- El C++ por la práctica. El lenguaje y su filosofía
- Elements of Programming Interviews: The Insiders' Guide
- Mastering Swift 2
- Concurrent Programming on Windows
Additional resources for Learning Concurrent Programming in Scala
The advantages of Scala Although Scala is still a language on the rise that has yet to receive the wide-scale adoption of a language such as Java, its support for concurrent programming is rich and powerful. Concurrency frameworks for nearly all the different styles of concurrent programming exist in the Scala ecosystem, and are being actively developed. Throughout its development, Scala has pushed the boundaries when it comes to providing modern, high-level application programming interfaces or APIs for concurrent programming.
Here, the crucial difference lies in the fact that a high-level concurrency framework expresses which goal to achieve, rather than how to achieve that goal. In practice, the difference between low-level and high-level concurrency is less clear, and different concurrency frameworks form a continuum rather than two distinct groups. Still, recent developments in concurrent programming show a bias towards declarative and functional programming styles. As we will see in Chapter 2, Concurrency on the JVM and the Java Memory Model, computing a value concurrently requires creating a thread with a custom run method, invoking the start method, waiting until the thread completes, and then inspecting specific memory locations to read the result.
They cover the content presented in this chapter, along with some additional Scala features. The last two exercises contrast the difference between concurrent and distributed programming, as defined in this chapter. You should solve them by sketching out a pseudocode solution, rather than a complete Scala program. 1. Implement a compose method with the following signature: def compose[A, B, C](g: B => C, f: A => B): A => C = ??? This method must return a function h, which is the composition of the functions f and g.