Learning Concurrent Programming in Scala 2nd Edition by Aleksandar Prokopec ISBN 1786462141 9781786462145

Learning Concurrent Programming in Scala 2nd Edition by Aleksandar Prokopec – Ebook PDF Instant Download/Delivery: 1786462141, 9781786462145

Full download Learning Concurrent Programming in Scala 2nd Edition after payment

 

 

Product details:

ISBN 10: 1786462141

ISBN 13: 9781786462145

Author:  Aleksandar Prokopec 

Learning Concurrent Programming in Scala 2nd Edition: Key Features Make the most of Scala by understanding its philosophy and harnessing the power of multicores Get acquainted with cutting-edge technologies in the field of concurrency, through practical, real-world applications Get this step-by-step guide packed with pragmatic examples Book Description Scala is a modern, multiparadigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. Scala smoothly integrates the features of object-oriented and functional languages. In this second edition, you will find updated coverage of the Scala 2.12 platform. The Scala 2.12 series targets Java 8 and requires it for execution. The book starts by introducing you to the foundations of concurrent programming on the JVM, outlining the basics of the Java Memory Model, and then shows some of the classic building blocks of concurrency, such as the atomic variables, thread pools, and concurrent data structures, along with the caveats of traditional concurrency. The book then walks you through different high-level concurrency abstractions, each tailored toward a specific class of programming tasks, while touching on the latest advancements of async programming capabilities of Scala. It also covers some useful patterns and idioms to use with the techniques described. Finally, the book presents an overview of when to use which concurrency library and demonstrates how they all work together, and then presents new exciting approaches to building concurrent and distributed systems. What you will learn Get to grips with the fundamentals of concurrent programming on modern multiprocessor systems Build high-performance concurrent systems from simple, low-level concurrency primitives Express asynchrony in concurrent computations with futures and promises Seamlessly accelerate sequential programs by using data-parallel collections Design safe, scalable, and easy-to-comprehend in-memory.

 

Learning Concurrent Programming in Scala 2nd Edition Table of contents:

Introduction

1. Concurrent programming
2. A brief overview of traditional concurrency
3. Modern concurrency paradigms
4. The advantages of Scala
5. Preliminaries
6. Execution of a Scala program
7. A Scala primer
8. Overview of new features in Scala 2.12
9. Summary
10. Exercises

Concurrency on the JVM and the Java Memory Model

1. Processes and threads
2. Creating and starting threads
3. Atomic execution
4. Reordering
5. Monitors and synchronization
6. Deadlocks
7. Guarded blocks
8. Interrupting threads and the graceful shutdown
9. Volatile variables
10. The Java Memory Model
11. Immutable objects and final fields
12. Summary
13. Exercises

Traditional Building Blocks of Concurrency

1. The Executor and ExecutionContext objects
2. Atomic primitives
3. Atomic variables
4. Lock-free programming
5. Implementing locks explicitly
6. The ABA problem
7. Lazy values
8. Concurrent collections
9. Concurrent queues
10. Concurrent sets and maps
11. Concurrent traversals
12. Custom concurrent data structures
13. Implementing a lock-free concurrent pool
14. Creating and handling processes
15. Summary
16. Exercises

Asynchronous Programming with Futures and Promises

1. Futures
2. Starting future computations
3. Future callbacks
4. Futures and exceptions
5. Using the Try type
6. Fatal exceptions
7. Functional composition on futures
8. Promises
9. Converting callback-based APIs
10. Extending the future API
11. Cancellation of asynchronous computations
12. Futures and blocking
13. Awaiting futures
14. Blocking in asynchronous computations
15. The Scala Async library
16. Alternative future frameworks
17. Summary
18. Exercises

Data-Parallel Collections

1. Scala collections in a nutshell
2. Using parallel collections
3. Parallel collection class hierarchy
4. Configuring the parallelism level
5. Measuring the performance on the JVM
6. Caveats with parallel collections
7. Non-parallelizable collections
8. Non-parallelizable operations
9. Side effects in parallel operations
10. Nondeterministic parallel operations
11. Commutative and associative operators
12. Using parallel and concurrent collections together
13. Weakly consistent iterators
14. Implementing custom parallel collections
15. Splitters
16. Combiners
17. Summary
18. Exercises

Concurrent Programming with Reactive Extensions

1. Creating Observable objects
2. Observables and exceptions
3. The Observable contract
4. Implementing custom Observable objects
5. Creating Observables from futures
6. Subscriptions
7. Composing Observable objects
8. Nested Observables
9. Failure handling in Observables
10. Rx schedulers
11. Using custom schedulers for UI applications
12. Subjects and top-down reactive programming
13. Summary
14. Exercises

Software Transactional Memory

1. The trouble with atomic variables
2. Using Software Transactional Memory
3. Transactional references
4. Using the atomic statement
5. Composing transactions
6. The interaction between transactions and side effects
7. Single-operation transactions
8. Nesting transactions
9. Transactions and exceptions
10. Retry transactions
11. Retry with timeouts
12. Transactional collections
13. Transaction-local variables
14. Transactional arrays
15. Transactional maps
16. Summary
17. Exercises

Actors

1. Working with actors
2. Creating actor systems and actors
3. Managing unhandled messages
4. Actor behavior and state
5. Akka actor hierarchy
6. Identifying actors
7. The actor lifecycle
8. Communication between actors
9. The ask pattern
10. The forward pattern
11. Stopping actors
12. Actor supervision
13. Remote actors
14. Summary
15. Exercises

Concurrency in Practice

1. Choosing the right tools for the job
2. Putting it all together – a remote file browser
3. Modeling the filesystem
4. The server interface
5. Client navigation API
6. The client user interface
7. Implementing the client logic
8. Improving the remote file browser
9. Debugging concurrent programs
10. Deadlocks and lack of progress
11. Debugging incorrect program outputs
12. Performance debugging
13. Summary
14. Exercises

Reactors

1. The need for reactors
2. Getting started with Reactors
3. The “Hello World” program
4. Event streams
5. Lifecycle of an event stream
6. Functional composition of event streams
7. Reactors
8. Defining and configuring reactors
9. Using channels
10. Schedulers
11. Reactor lifecycle
12. Reactor system services
13. The logging service
14. The clock service
15. The channels service
16. Custom services
17. Protocols
18. Custom server-client protocol
19. Standard server-client protocol
20. Using an existing connector
21. Creating a new connector
22. Creating a protocol-specific reactor prototype
23. Spawning a protocol-specific reactor directly
24. Router protocol
25. Two-way protocol

 

People also search for Learning Concurrent Programming in Scala 2nd Edition:

what is concurrent programming language
    
concurrent vs parallel programming
    
learning concurrency in python
    
concurrent learning
    
concurrent programming course

Tags:

Aleksandar Prokopec,Learning,Concurrent Programming,Scala