Learning concurrent programming in Scala : learn the art of building intricate, modern, scalable concurrent applications using Scala / Aleksandar Prokopec.

Format:

Book

Author/Creator:

Prokofʹev, Aleksandr Andreevich, 1900-1971, author.

Contributor:

Odersky, Martin, writer of introduction.

Series:

Community experience distilled.

Community Experience Distilled

Language:

English

Subjects (All):

Scala (Computer program language).

Physical Description:

1 online resource (366 p.)

Edition:

1st edition

Other Title:

Learn the art of building intricate, modern, scalable concurrent applications using Scala

Place of Publication:

Birmingham, England : Packt Publishing, 2014.

Language Note:

English

System Details:

text file

Biography/History:

Prokopec Aleksandar: Aleksandar Prokopec, who also authored the first edition of this book, is a concurrent and distributed programming researcher. He holds a PhD in computer science from the cole Polytechnique Fdrale de Lausanne, Switzerland. He has worked at Google and is currently a principal researcher at Oracle Labs. As a member of the Scala team at EPFL, Aleksandar actively contributed to the Scala programming language, and he has worked on programming abstractions for concurrency, data-parallel programming support, and concurrent data structures for Scala. He created the Scala Parallel Collections framework, which is a library for high-level data-parallel programming in Scala, and participated in working groups for Scala concurrency libraries, such as Futures, Promises, and ScalaSTM. Aleksandar is the primary author of the reactor programming model for distributed computing.

Summary:

This book is a must-have tutorial for software developers aiming to write concurrent programs in Scala, or broaden their existing knowledge of concurrency.This book is intended for Scala programmers that have no prior knowledge about concurrent programming, as well as those seeking to broaden their existing knowledge about concurrency. Basic knowledge of the Scala programming language will be helpful. Readers with a solid knowledge in another programming language, such as Java, should find this book easily accessible.

Contents:

Cover; Copyright; Credits; Foreword; About the Author; Acknowledgments; About the Reviewers; www.PacktPub.com; Table of Contents; Preface; Chapter 1: Introduction; Concurrent programming; A brief overview of traditional concurrency; Modern concurrency paradigms; The advantages of Scala; Preliminaries; Execution of a Scala program; A Scala primer; Summary; Exercises; Chapter 2: Concurrency on the JVM and the Java Memory Model; Processes and Threads; Creating and starting threads; Atomic execution; Reordering; Monitors and synchronization; Deadlocks; Guarded blocks

Interrupting threads and the graceful shutdownVolatile variables; The Java Memory Model; Immutable objects and final fields; Summary; Exercises; Chapter 3: Traditional Building Blocks of Concurrency; The Executor and ExecutionContext objects; Atomic primitives; Atomic variables; Lock-free programming; Implementing locks explicitly; The ABA problem; Lazy values; Concurrent collections; Concurrent queues; Concurrent sets and maps; Concurrent traversals; Creating and handling processes; Summary; Exercises; Chapter 4: Asynchronous Programming with Futures and Promises; Futures

Starting future computationsFuture callbacks; Futures and exceptions; Using the Try type; Fatal exceptions; Functional composition on futures; Promises; Converting callback-based APIs; Extending the future API; Cancellation of asynchronous computations; Futures and blocking; Awaiting futures; Blocking in asynchronous computations; The Scala Async library; Alternative Future frameworks; Summary; Exercises; Chapter 5: Data-Parallel Collections; Scala collections in a nutshell; Using parallel collections; Parallel collection class hierarchy; Configuring the parallelism level

Measuring the performance on the JVMCaveats of parallel collections; Non-parallelizable collections; Non-parallelizable operations; Side effects in parallel operations; Nondeterministic parallel operations; Commutative and associative operators; Using parallel and concurrent collections together; Weakly consistent iterators; Implementing custom parallel collections; Splitters; Combiners; Alternative data-parallel frameworks; Collections hierarchy in ScalaBlitz; Summary; Exercises; Chapter 6: Concurrent Programming with Reactive Extensions; Creating Observable objects

Observables and exceptionsThe Observable contract; Implementing custom Observable objects; Creating Observables from futures; Subscriptions; Composing Observable objects; Nested observables; Failure handling in observables; Rx schedulers; Using custom schedulers for UI applications; Subjects and top-down reactive programming; Summary; Exercises; Chapter 7: Software Transactional Memory; The trouble with atomic variables; Using Software Transactional Memory; Transactional references; Using the atomic statement; Composing transactions; The interaction between transactions and side effects

Single-operation transactions

Notes:

Includes index.

Description based on online resource; title from PDF title page (ebrary, viewed December 17, 2014).

ISBN:

9781783281428

1783281421

OCLC:

899245781