Index

A

• ABA problem
  • about / The ABA problem
• actor
  • state / Actor behavior and state
• actor behavior
  • manipulating / Actor behavior and state
• actor class
  • about / Working with actors
• actor configurations
  • about / Creating actor systems and actors
• actor instance
  • about / Working with actors
• actor path
  • about / Identifying actors
• actor reference
  • about / Working with actors
• actors
  • working with / Working with actors
  • creating / Creating actor systems and actors
  • identifying / Identifying actors
  • life cycle / The actor life cycle
  • communication between / Communication between actors
  • stopping / Stopping actors
• actor supervision
  • about / Actor supervision
• actor system
  • about / Working with actors
• actor systems
  • creating / Creating actor systems and actors
• aggregate operation / Commutative and associative operators
• Akka actor hierarchy
  • about / Akka actor hierarchy
• ArrayBlockingQueue
  • about / Concurrent queues
• ask pattern
  • about / The ask pattern
• associative operators / Commutative and associative operators
• atomic execution
  • about / Atomic execution
• atomic primitives, nonblocking synchronization
  • about / Atomic primitives
  • atomic variables / Atomic variables
  • lock-free programming / Lock-free programming
  • locks, implementing explicitly / Implementing locks explicitly
  • ABA problem / The ABA problem
• atomic statement
  • using / Using the atomic statement
• atomic variables
  • about / Atomic variables, Lock-free programming
  • issues / The trouble with atomic variables
• Await.ready statement / Blocking in asynchronous computations
• Await.result statement / Blocking in asynchronous computations
• awaiting futures / Awaiting futures

B

• behavior / Actor behavior and state

C

• call stack / Execution of a Scala program
• collections hierarchy, ScalaBlitz / Collections hierarchy in ScalaBlitz
• combiners
  • about / Combiners
  • implementing / Combiners
• communication, between actors
  • ask pattern / The ask pattern
  • forward pattern / The forward pattern
• commutative operators / Commutative and associative operators
• compare-and-swap (CAS) / Atomic variables
• concurrency framework
  • concerns, addressing / Choosing the right tools for the job
  • JVM concurrency / Choosing the right tools for the job
  • futures and promises / Choosing the right tools for the job
  • reactive extensions / Choosing the right tools for the job
  • software transactional memory / Choosing the right tools for the job
  • actors / Choosing the right tools for the job
  • execution contexts / Choosing the right tools for the job
  • parallel collections / Choosing the right tools for the job
• concurrency libraries
  • overview / Choosing the right tools for the job
  • benefits / Choosing the right tools for the job
• concurrent.Map trait
  • about / Concurrent sets and maps
• concurrent collections
  • about / Concurrent collections
• concurrent maps
  • about / Concurrent sets and maps
• concurrent programming
  • overview / Concurrent programming
  • traditional concurrency / A brief overview of traditional concurrency
  • modern concurrency paradigms / Modern concurrency paradigms
• concurrent programs
  • debugging / Debugging concurrent programs
• concurrent queues
  • about / Concurrent queues
• concurrent sets
  • about / Concurrent sets and maps
• concurrent traversals
  • about / Concurrent traversals
• connected state / Client navigation API
• connecting state / Client navigation API
• control exceptions
  • about / Transactions and exceptions
• cop operator / Commutative and associative operators
• countdown latch
  • about / Debugging incorrect program outputs
• custom combiner, implementation ways
  • merging / Combiners
  • two-phase evaluation / Combiners
  • concurrent data-structure / Combiners
• custom Observable objects
  • implementing / Implementing custom Observable objects
• custom parallel collections
  • implementing / Implementing custom parallel collections
• custom schedulers
  • creating, from futures / Creating Observables from futures
  • using, for UI applications / Using custom schedulers for UI applications

D

• data-parallel frameworks
  • alternative / Alternative data-parallel frameworks
• data abstractions
  • volatile variables (JDK) / Choosing the right tools for the job
  • atomic variables (JDK) / Choosing the right tools for the job
  • futures and promises (scala.concurrent) / Choosing the right tools for the job
  • observables and subjects (Rx) / Choosing the right tools for the job
  • transactional references (Scala STM) / Choosing the right tools for the job
• data access constructs
  • arbitrary data (JDK) / Choosing the right tools for the job
  • atomic variables and classes (JDK) / Choosing the right tools for the job
  • futures and promises (scala.concurrent) / Choosing the right tools for the job
  • transactional references and classes (Scala STM) / Choosing the right tools for the job
• dataflow graph
  • about / Functional composition on futures
• deadlocks
  • about / Deadlocks
  • preventing, from occurring / Deadlocks
  • overview / Deadlocks and lack of progress
• DeathWatch / Stopping actors
• dispatcher
  • about / Working with actors
• Document Object Model (DOM) / Processes and Threads
• dynamic scope, transaction / The interaction between transactions and side effects

E

• exceptions
  • and futures / Futures and exceptions
  • and observables / Observables and exceptions
  • and transactions / Transactions and exceptions
• ExecutionContext object
  • implementing / The Executor and ExecutionContext objects
• ExecutionContext parameter / Futures
• Executor object
  • about / The Executor and ExecutionContext objects
  • implementing / The Executor and ExecutionContext objects

F

• failure handling, observables / Failure handling in observables
• final fields, Java Memory Model / Immutable objects and final fields
• fire-and-forget pattern
  • about / Communication between actors
• flatMap combinator / Functional composition on futures
• ForkJoinPool class / The Executor and ExecutionContext objects
• forward pattern
  • about / The forward pattern
• functional composition
  • on futures / Functional composition on futures
• future callbacks
  • about / Future callbacks
• future computations
  • starting / Starting future computations
• Future frameworks
  • alternatives / Alternative Future frameworks
• futures
  • about / Futures
  • and exceptions / Futures and exceptions
  • Try type, using / Using the Try type
  • fatal exceptions / Fatal exceptions
  • functional composition / Functional composition on futures
  • blocking with / Futures and blocking
  • awaiting futures / Awaiting futures
  • blocking, in asynchronous computations / Blocking in asynchronous computations
  • observables, creating from / Creating Observables from futures
• Future[String] type
  • about / Futures
• Future[T] type / Futures

G

• Garbage Collection (GC) / Measuring the performance on the JVM
  • about / Performance debugging
• getWebpage method / Futures
• graceful shutdown
  • about / Interrupting threads and the graceful shutdown
• graceful stop pattern / Stopping actors
• guarded blocks
  • about / Guarded blocks
• guardian actor
  • about / Akka actor hierarchy

I

• immutable objects, Java Memory Model / Immutable objects and final fields
• incorrect program outputs
  • debugging / Debugging incorrect program outputs
• intrinsic lock
  • about / Monitors and synchronization

J

• java.lang.Thread class
  • about / Processes and Threads
• Java Memory Model
  • about / The Java Memory Model
  • immutable objects / Immutable objects and final fields
  • final fields / Immutable objects and final fields
• Java Virtual Machine (JVM)
  • about / The advantages of Scala
  / Processes and Threads
• Just-In-Time (JIT) / Measuring the performance on the JVM
• JVM
  • performance, measuring of / Measuring the performance on the JVM

L

• lazy values
  • interaction / Lazy values
• linearization point / The trouble with atomic variables
• LinkedBlockingQueue
  • about / Concurrent queues
• livelock
  • about / Deadlocks and lack of progress
• lock-free programming
  • about / Lock-free programming
• locks
  • implementing, explicitly / Implementing locks explicitly
• logTransfer method / Deadlocks

M

• mailbox
  • about / Working with actors
• maps
  • about / Scala collections in a nutshell
• message
  • about / Working with actors
• modern concurrency paradigms
  • about / Modern concurrency paradigms
• Modified Exclusive Shared Invalid (MESI) / Using parallel collections
• monitors
  • about / Monitors and synchronization
• multitasking
  • about / Processes and Threads

N

• nested observables
  • about / Nested observables
• non-parallelizable collections / Non-parallelizable collections
• non-parallelizable operations / Non-parallelizable operations
• nondeterministic parallel operations / Nondeterministic parallel operations

O

• object heap / Execution of a Scala program
• Observable contract
  • about / The Observable contract
• Observable objects
  • about / Creating Observable objects
  • creating / Creating Observable objects
  • subscriptions / Subscriptions
• observables
  • and exceptions / Observables and exceptions
  • composing / Composing Observable objects
  • nested observables / Nested observables
  • failure handling concept / Failure handling in observables
• OS threads
  • about / Processes and Threads

P

• parallel, and concurrent collections
  • using, simultaneously / Using parallel and concurrent collections together
• parallel collection class hierarchy
  • about / Parallel collection class hierarchy
• parallel collections
  • using / Using parallel collections
  • parallelism level, configuring / Configuring the parallelism level
  • performance, measuring of JVM / Measuring the performance on the JVM
• parallel collections, cautions
  • about / Caveats of parallel collections
  • non-parallelizable collections / Non-parallelizable collections
  • non-parallelizable operations / Non-parallelizable operations
  • nondeterministic parallel operations / Nondeterministic parallel operations
  • associative operators / Commutative and associative operators
  • commutative operators / Commutative and associative operators
• parallel operations
  • drawbacks / Side effects in parallel operations
• path selection
  • about / Identifying actors
• performance debugging
  • about / Performance debugging
• priority queue
  • about / Transactions and exceptions
• processes
  • about / Processes and Threads
  • creating / Creating and handling processes
  • handling / Creating and handling processes
• promises
  • about / Promises
  • callback-based APIs, converting / Converting callback-based APIs
  • future API, extending / Extending the future API
  • asynchronous computations, cancelling / Cancellation of asynchronous computations
• putIfAbsent(k* K, v* V)* Option[V] signature / Concurrent sets and maps

R

• race condition / Atomic execution
• Random Access Memory (RAM) / Using parallel collections
• remote actors
  • about / Remote actors
  • communication, requisites / Remote actors
• remote file browser
  • about / Putting it all together – a remote file browser
  • filesystem, modelling / Modeling the filesystem
  • server interface / The server interface
  • client navigation API / Client navigation API
  • client user interface / The client user interface
  • client logic, implementing / Implementing the client logic
  • improving / Improving the remote file browser
• remove(k* K, v* V)* Boolean signature / Concurrent sets and maps
• reordering
  • about / Reordering
• replace(k* K, ov* V, nv* V)* Boolean signature / Concurrent sets and maps
• replace(k* K, v* V)* Option[V] signature / Concurrent sets and maps
• rules, Java Memory Model
  • program order / The Java Memory Model
  • monitor locking / The Java Memory Model
  • volatile fields / The Java Memory Model
  • thread start / The Java Memory Model
  • thread termination / The Java Memory Model
  • transitivity / The Java Memory Model
• Rx schedulers
  • about / Rx schedulers
  • custom schedulers, using for UI applications / Using custom schedulers for UI applications

S

• Scala
  • advantages / The advantages of Scala
  • about / Processes and Threads
• scala.sys.process API
  • about / Creating and handling processes
• scala.sys.process package / Creating and handling processes
• Scala Async library
  • about / The Scala Async library
• ScalaBlitz
  • about / Alternative data-parallel frameworks
  • collections hierarchy / Collections hierarchy in ScalaBlitz
• Scala collection library / Scala collections in a nutshell
• Scala collections
  • sequences / Scala collections in a nutshell
  • maps / Scala collections in a nutshell
  • sets / Scala collections in a nutshell
• Scala collections module
  • about / Scala collections in a nutshell
• ScalaFTP browser
  • about / Putting it all together – a remote file browser
  • features, implementing / Putting it all together – a remote file browser
• ScalaMeter / Performance debugging
• Scala primer / A Scala primer
• Scala program
  • executing / Execution of a Scala program
• sequences
  • about / Scala collections in a nutshell
• sets
  • about / Scala collections in a nutshell
• Simple Build Tool (SBT) / Execution of a Scala program
• single-operation transactions / Single-operation transactions
• Small Build Tool (SBT) / Creating and starting threads
• Software Transactional Memory (STM)
  • using / Using Software Transactional Memory
  • transactional references, declaring / Transactional references
  • atomic statement, using / Using the atomic statement
• sop operator / Commutative and associative operators
• splitter
  • about / Splitters
  • implementing / Splitters
• starvation
  • about / Deadlocks and lack of progress
• state machines
  • about / Actor behavior and state
• static scope, transaction / The interaction between transactions and side effects
• subjects
  • about / Subjects and top-down reactive programming
• supervision strategy
  • about / Actor supervision
• synchronization
  • about / Monitors and synchronization
• synchronized statement / Reordering

T

• @tailrec annotation
  • about / Atomic variables
• threads
  • about / Processes and Threads, Futures
  • creating / Creating and starting threads
  • starting / Creating and starting threads
  • interrupting / Interrupting threads and the graceful shutdown
• top-down reactive programming
  • about / Subjects and top-down reactive programming
• traditional concurrency
  • overview / A brief overview of traditional concurrency
• transaction-local variable
  • about / Transaction-local variables
• transactional arrays
  • about / Transactional arrays
• transactional collections
  • about / Transactional collections
  • transaction-local variables / Transaction-local variables
  • transactional arrays / Transactional arrays
  • transactional maps / Transactional maps
• transactional conflict
  • about / Using Software Transactional Memory
• transactional maps
  • about / Transactional maps
• transactional reference
  • about / Transactional references
• transactions
  • composing / Composing transactions
  • and side effects / The interaction between transactions and side effects
  • single-operation transactions / Single-operation transactions
  • nesting / Nesting transactions
  • and exceptions / Transactions and exceptions
  • retrying / Retrying transactions
  • retrying, with timeouts / Retrying with timeouts
• Try type
  • using / Using the Try type
• Try[T] objects / Using the Try type
• Try[T] type / Using the Try type

U

• UI applications
  • custom schedulers, using for / Using custom schedulers for UI applications
• unconnected state / Client navigation API
• unhandled messages
  • managing / Managing unhandled messages

V

• Virtual Machine (VM)
  • about / Implementing custom Observable objects
• volatile variables
  • about / Volatile variables

W

• weakly consistent iterators / Weakly consistent iterators