Index

A

• abstract classes
  • about / Abstract classes
  • traits / Abstract classes and traits
  • final classes / The final classes
• abstract types
  • about / Abstract types
  • versus parameterized type / Abstract versus parameterized types
• Actor
  • ActorRef / Actor references and paths
  • paths / Actor references and paths
  • lifecycle / How the Actor life cycle works
  • writing / Writing our first Actor
  • stopping / Stopping Actors
  • communication, via messages / Actor communication via messages and its semantics
  • semantics / Actor communication via messages and its semantics
  • faults, supervising / Supervising fault in our actors
  • testing / Testing actors
• Actor Model / What's up with the Actor Model?
• actorRefs
  • selecting, via actorSelection / Selecting existing actorRefs via actorSelection
• ActorSystem / Understanding the Actor system
• Akka
  • about / Why do we care about Akka?
  • Hello World / Hello world in Akka
  • environment, setting up / Setting up the environment
  • supervision strategy / Default supervision strategy
  • supervision strategy, applying / Applying the supervision strategy
• AllForOne strategy
  • versus OneForOne / OneForOne versus AllForOne strategy
• arithmetic operators / Arithmetic operators
• array / Array
• ArrayBuffer / ArrayBuffer
• ask method
  • versus forward method / The tell versus ask versus forward method
• assertions / Assertions
• asynchronous programming
  • about / Asynchronous programming
  • Futures, working with / Working with Futures
  • Future computation / What if Future computations go wrong?
  • Future composition / Why not compose two or more Futures?
  • Promises, working with / Working with Promises

B

• behavior-driven development (BDD) / Scenario, Behavior driven development (BDD)
• bitwise operators / Bitwise operators
• boolean literals / Boolean literals
• bottom types / Null and Nothing

C

• case classes / Case classes
• character literals / Character literals
• class Any
  • about / Any
  • AnyRef / AnyVal and AnyRef
  • AnyVal / AnyVal and AnyRef, AnyVal
• classes / Classes
• class inheritance
  • about / Class inheritance
  • classes, extending / Extending classes
  • subtyping, versus subclassing / Subtyping versus subclassing
  • data, overriding / Overriding data and behavior
  • behavior, overriding / Overriding data and behavior
  • inheritance, restricting / Restricting inheritance – final keyword
  • dynamic binding, in function invocation / Dynamic binding in function invocation
  • misusing / Misusing inheritance
• closures / What are closures?
• collection performance
  • about / Collection performance
  • URL / Collection performance
• collections
  • using / Commonly used collections in Scala
  • list / List
  • lists / List
  • map / Map
  • SortedSet / SortedSet
  • streams / Streams
  • vector / Vector
  • immutable stack / Immutable stack
  • immutable queue / Immutable queue
  • ranges / Ranges
  • ArrayBuffer / ArrayBuffer
  • ListBuffer / ListBuffer
  • StringBuilder / StringBuilder
  • Array / Array
  • rich operation, performing / Rich operations performed on collections
  • selecting / Choosing a collection
• collections hierarchy
  • about / Hierarchy of collections in Scala
  • traversable / Traversable
  • iterable / Iterable
• combinators / Combinators
• comma-separated values (CSV) / Type-classes, Type-classes ahead!
• companion objects / Companion objects
• composable mix-ins / Traits as composable mix-ins
• composition / Composition and inheritance
• concurrency
  • concepts / Building blocks of concurrency
  • processes / Understanding processes and threads
  • threads / Understanding processes and threads
  • locks / Locks and synchronization
  • synchronization / Locks and synchronization
  • executor / Executor and ExecutionContext
  • ExecutionContext / Executor and ExecutionContext
• concurrent programming / Concurrent programming
• conditional statements
  • about / Conditional statements
  • if else conditional expression / The if else conditional expression
• container types / Container types
• covariance / Variance under inheritance
• currying
  • about / Currying
  • function, converting with multiple parameters / Converting a function with multiple parameters to curried form

D

• data types
  • about / Data types
  • class hierarchy / Scala's class hierarchy
  • class Any / Any
  • unit / Unit
  • boolean / Boolean
  • null / Null and Nothing
  • nothing / Null and Nothing
• default constructor / Default and parameterized constructors
• domain-specific language (DSL) / Scenario
• do while loop / The do while loop
• dynamic binding
  • in function invocation / Dynamic binding in function invocation

E

• Either type
  • using / Either left or right
• evaluation strategies
  • about / Evaluation strategies
  • call by name / Call by name
  • call by value / Call by value
• exception
  • handling / Exception handling – the old way

F

• final classes / The final classes
• f interpolator / f Interpolator
• floating point literals / Floating point literals
• for expressions
  • about / The for expressions, For expressions
  • for yield expressions / The for yield expressions
• for loop / The for loop
• for yield expressions / The for yield expressions
• function
  • syntax / Function syntax
  • nesting / Nesting of functions
  • calling / Calling a function
  • variable number of arguments, passing / Passing a variable number of arguments
  • calling, with default parameter value / Calling a function with a default parameter value
  • calling, while passing named arguments / Calling a function while passing named arguments
  • about / Functions versus methods
  • versus methods / Functions versus methods
  • usage, determining / Methods or functions?
• function literal / Function literals, Function literals, Function literals

G

• generic classes / Another way around - generic classes and traits

H

• Haskell / What are closures?
• Hello World
  • writing, in Akka / Hello world in Akka
• higher-order functions (HOF) / Higher-order functions

I

• immutable collections
  • about / Immutable and mutable collections
  • versus root / Differences between the root and immutable collections
• immutable queue / Immutable queue
• immutable stack / Immutable stack
• implicit conversion / Implicit conversions
• implicitly method / The implicitly method
• implicit parameters
  • using / Implicit parameters
• implicits
  • about / Implicits - what and why
  • need for / Implicits - what and why
  • viewing / Implicits - what and why, Looking for implicits
  • reference link / Looking for implicits
• importing / Packaging and importing
• inheritance
  • about / Composition and inheritance
  • variance / Variance under inheritance
  • variance relation, using / When to use what type of variance relation
• integer literals / Integer literals
• iterable
  • about / Hierarchy of collections in Scala
  • sub-iterations / Iterable
  • sub-collections / Iterable
  • zipping / Iterable
  • comparisons / Iterable
  • seq / Seq
  • sequences / Sequences
  • map / Map
  • set / Set

J

• Java
  • reference link / Java installation
• Java collection
  • converting, into Scala collection / Converting a Java collection into a Scala collection
• Java Virtual Machine (JVM) / Introduction to Scala, Building blocks of concurrency
• Just in Time (JIT ) / Runs on JVM

L

• lazy declaration / Lazy declaration
• lazy evaluation / Lazy declaration
• linearization / Linearization
• linearized hierarchy / Linearization
• ListBuffer / ListBuffer
• literals
  • about / Literals
  • integer literals / Integer literals
  • floating point literals / Floating point literals
  • boolean literals / Boolean literals
  • character literals / Character literals
  • string literals / String literals
  • symbol literals / Symbol literals
  • tuple literals / Tuple literals
  • function literals / Function literals
• logical operator / Logical operators
• looping
  • about / Looping
  • for loop / The for loop
  • while loop / The while Loop
  • do while loop / The do while loop

M

• matchers / Matchers
• methods
  • about / Methods, Functions versus methods
  • versus functions / Functions versus methods
  • usage, determining / Methods or functions?
• mutable collections / Immutable and mutable collections

N

• non-value types / Methods

O

• objects
  • using, as singletons / Objects as singletons
• Observables
  • hot observables / Reactive extensions
  • cold observables / Reactive extensions
  • creating / Creating Observables
• OneForOne
  • versus AllForOne strategy / OneForOne versus AllForOne strategy
• operators
  • about / Operators in Scala
  • arithmetic operators / Arithmetic operators
  • relational operators / Relational operators
  • logical operators / Logical operators
  • bitwise operators / Bitwise operators
  • operator precedence / Operator precedence
• Option type
  • about / Option type
  • using / Using the Option way

P

• packaging
  • about / Packaging and importing
  • package statements / Package statements
  • multiple package statements / Multiple package statements in a file
  • nested package statements / Nested package statements
  • package statements, chaining / Chaining package statements
  • packages, importing / Importing packages
• parallel collections
  • about / Parallel collections in Scala, Parallel collections
  • URL / Parallel collections in Scala
  • ParArray / ParArray
  • ParVector / ParVector
• parameterized constructor / Default and parameterized constructors
• parameterized type
  • versus abstract type / Abstract versus parameterized types
• parametric polymorphism / Why so serious about types?
• partial functions / Partial functions
• partially applied functions / Partially applied functions
• pattern matching
  • about / Pattern matching, Pattern matching
  • types / Different ways we can pattern match
  • variable, matching / Matching a variable
  • constant, matching / Matching a constant
  • constructor, matching / Matching a constructor
• postStop / The preStart and postStop hooks
• pre-emptive multitasking / Understanding processes and threads
• preStart / The preStart and postStop hooks
• primitive types / Data types
• process identifier (pid) / Understanding processes and threads
• Props / Props

R

• ranges / Ranges
• raw interpolator / The raw interpolator
• reactive extensions / Reactive extensions
• reactive programming / Reactive programming
• ReactiveX
  • URL / Creating Observables
• recursion
  • about / Recursion
  • limitations / Limitations of recursion
  • functions, writing / The ideal way to write recursive functions
• relational operators / Relational operators
• rich methods / Wrapper classes
• root collection
  • versus immutable collection / Differences between the root and immutable collections
• root guardian / Understanding the Actor system
• RxScala
  • about / React to RxScala
  • Observables, creating / Creating Observables

S

• Scala
  • about / Introduction to Scala
  • programming paradigm / A programming paradigm
  • object-oriented, versus functional paradigms / Object-oriented versus functional paradigms 
  • multi-paradigm / Scala is multi-paradigm
  • advantages / Scala advantages
  • executing, on JVM / Runs on JVM
  • URL / Type is the core
  • asynchronous programming, versus parallel programming / Asynchronous versus parallel versus concurrent programming
  • asynchronous programming, versus concurrent programming / Asynchronous versus parallel versus concurrent programming
  • parallel programming, versus concurrent programming / Asynchronous versus parallel versus concurrent programming
  • working with / Working with Scala
  • Java, installing / Java installation
  • SBT, installing / SBT installation
  • REPL / Scala REPL
  • IDEs / Scala IDEs
  • program, executing / Running our first program
• Scala, advantages
  • executing, on JVM / Runs on JVM
  • syntax / Super smart syntax
  • object-oriented programming, using / Best of both worlds
  • functional programming, using / Best of both worlds
  • type, defining / Type is the core
  • concurrency / Concurrency made easy
  • asynchronous code / Asynchronous code
  • designing, for frontend / Now available for the frontend
  • smart IDEs / Smart IDEs
  • extensive language / Extensive language
  • online support / Online support
• Scala.js / Now available for the frontend
• Scala API documentation
  • URL / Option type
• Scala collection
  • used, for problem solving / Motivation
• ScalaMock / ScalaMock – a native library to mock objects
• Scala program
  • exploring / What is underneath a Scala program?
• Scala REPL
  • references / Scala REPL
• ScalaTest
  • about / ScalaTest
  • setting up / Setting up for testing
  • used, for applying style / Testing in style using ScalaTest
  • assertions / Assertions
  • matchers / Matchers
• sealed traits / Sealed traits
• Simple Build Tool (SBT)
  • installation / SBT installation
  • URL / SBT installation
• s interpolator / The s interpolator
• stackable modifications / Traits as stackable modifications
• streams / Streams
• StringBuilder / StringBuilder
• String Interpolators
  • about / String Interpolators
  • s interpolator / The s interpolator
  • f interpolator / f Interpolator
  • raw interpolator / The raw interpolator
• string literals / String literals
• subtypes / Scala's class hierarchy
• symbol literals
  • about / Symbol literals
  • URL / Symbol literals

T

• tail call optimization / Tail call optimization
• tell method
  • versus ask method / The tell versus ask versus forward method
• Test-Driven Development (TDD)
  • about / The why and what of TDD
  • process / The process of TDD, Step 4 - repeat steps 1 to 3
  • scenario / Scenario
  • Behavior driven development (BDD) / Behavior driven development (BDD)
• trait mix-ins
  • about / Traits as mix-ins
  • using, as composable mix-ins / Traits as composable mix-ins
  • as composable mix-ins / Traits as composable mix-ins
  • using, as stackable modifications / Traits as stackable modifications
• traits / Abstract classes and traits, Traits, Another way around - generic classes and traits
• traversable
  • about / Hierarchy of collections in Scala, Traversable
  • additions / Traversable
  • transformations / Traversable
  • conversions / Traversable
  • copying / Traversable
  • information retrievals / Traversable
  • element retrievals / Traversable
  • sub collections / Traversable
  • folding / Traversable
• tuple literals / Tuple literals
• type-classes / Type-classes
  • creating / Type-classes ahead!
• type bounds / Type bounds
• type erasure / Type erasure
• type inference / Super smart syntax, Type inference
• type parameter
  • about / Option type
  • names, using / Type parameter names
• type parameterization / Type parameterization, Here comes type parameterization
• types
  • defining / Why so serious about types?

U

• user guardian / Understanding the Actor system

V

• val keyword
  • using / Vals and vars
• value types / Data types
• variance annotation / Type erasure
• var keyword
  • using / Vals and vars
• vector / Vector
• view / Scala's class hierarchy
• visibility rules / Visibility rules

W

• while loop / The while Loop
• wildcard pattern / Pattern matching
• Wrapper classes / Wrapper classes