Index
A
- abstract class / Abstract class
- abstract member / Abstract class
- actions / Execution model
- Actors
- defining / Actors
- setting up / Setting up
- workflow, illustrating / A diagram of Actors
- ad hoc polymorphism / Understanding type classes
- Akka
- Algebraic Data Type (ADT) / Defining an algebraic data type
- algebraic data type (ADT) / Using Option
- anonymous function / Refactoring the production code
- Apache Spark
- about / Understanding Apache Spark
- RDD / RDD, DataFrame, and Dataset
- Spark SQL / Spark SQL
- execution model / Execution model
- API
- deploying, on Heroku / Deploying on Heroku
- API, online shopping project
- calling / Calling our API
- main method, setting / Setting the main method
- application, running with spark-submit
- about / Running the application with spark-submit
- Apache Spark, installing / Installing Apache Spark
- assembly JAR, packaging / Packaging the assembly JAR
- spark-submit, running / Running spark-submit
- application, Swagger
- login / Login
- list of products / List of products
- cart endpoints / Cart endpoints
- Applicative Functor / cats.Applicative
- attribute / Class
B
- BatchProducerApp
- implementing / Implementing BatchProducerApp
- BatchProducer application / Putting it all together
- Bitstamp
- reference / Calling the Bitstamp REST API
- Bitstamp REST API / Calling the Bitstamp REST API
- broker / Topics, partitions, and offsets, Connecting to Kafka
- BrowserManager
- implementing / Implementing BrowserManager
- build process / Build
- by-name parameter / By-name parameters
C
- cart
- products, listing in / Listing products in cart
- cart panel, online shopping project user interface / Cart panel
- cart test
- about / Cart test
- completing / Completing the cart test
- logging in / Logging in
- unit test / Unit test
- login method, implementing / Implementation
- cookie, passing / Passing the cookie
- case class / Case class
- cats.Applicative
- about / cats.Applicative
- laws / Laws
- usage examples / Usage examples
- cats.Apply
- about / cats.Apply
- laws / Laws
- usage examples / Usage examples
- cats.Functor
- about / cats.Functor
- laws / Laws
- usage example / Usage examples
- cats.Monad
- about / cats.Monad
- laws / Laws
- usage example / Usage examples
- cats.Monoid
- about / cats.Monoid
- laws / Laws
- usage examples / Usage examples
- cats.Semigroup
- about / cats.Semigroup
- laws / Laws
- usage examples / Usage examples
- cats dependency
- adding / Adding the cats dependency
- Circe
- JSON, encoding with / Encoding JSON with Circe
- class / Class
- class hierarchy / Scala class hierarchy
- class inheritance / Class inheritance
- client side, interactive browser
- implementing / Implementing the client side
- web socket, adding / Adding the web socket
- user, notifying / Notifying the user
- companion object / Companion object
- constants / Companion object
- constructor arguments / Class
- consumer group / Consumer group
- consumers / Topics, partitions, and offsets
- contravariance / Covariance and contravariance
- contravariant
- encoder / Contravariant encoder
- in collections / Covariance in collections
- covariance / Covariance and contravariance
- CovariantDecoder / CovariantDecoder
- curried function / Currying
- currying / Currying and partially applied functions, Currying
D
- data
- producing, into Kafka / Producing data into Kafka
- consuming, from Kafka / Consuming data from Kafka
- Data Access Objects (DAO) / Cart test
- database test
- product test / Product test
- cart test / Cart test
- DataFrame, Spark SQL / Dataframe
- Dataset, Spark SQL / Dataset
- derivation / Class inheritance
- Discretized Stream (DStream)
- reference / Introducing Spark Streaming
- Domain-Specific Language (DSL) / Creating the web socket route
E
- Either type
- using / Using Either
- manipulating / Manipulating Either
- environment
- setting up / Setting up your environment
- exceptions
- using / Using exceptions
- throwing / Throwing exceptions
- catching / Catching exceptions
- referential transparency, breaking / Showing how exceptions break referential transparency
- execution context / Execution context
- expressions / Types
F
- field / Class
- finally block
- using / Using the finally block
- Final State Machine (FSM) / Implementing BrowserManager
- for... yield
- transformations, composing / Composing transformations with for... yield
- for comprehension / Implementing another feature
- Frameless
- reference / Transforming rows using select
- function literal / Function value
- functions
- declaring / Declaring and calling functions
- calling / Declaring and calling functions
- side effects / Side effects
- curried function / Currying
- partially applied functions / Partially applied functions
- function value / Function value
- Future
- about / Future
- concrete value, obtaining / Getting a concrete value
- waiting on / Waiting on a Future
- callback / Callback
- composing / Composing Futures
- using, for-comprehension / Using for-comprehension
G
- garbage collector / Class
- generalization / Class inheritance
- Git
- reference / Setup
H
- Heroku
- about / Deploying the application
- configuration / Heroku configuration
- application, deploying on / Deploying on Heroku
- Heroku CLI
- reference / Deploying your application
- higher-kinded types
- about / Higher-kinded types, Higher-kinded types
- arity / Arity
- higher-order function / Higher-order function
- higher order function / Implementing futureCapital
I
- identity element / cats.Monoid
- if ... else expression / If...else expression
- immutable variables
- defining / Declaring variables
- implicit class / Implicit class
- implicit conversion / Implicit conversion
- implicit parameters
- about / Implicit parameters
- usage / Implicit parameter usage
- timeout, passing / Passing a timeout
- application context, passing / Passing an application context
- examples, in SDK / Examples in the SDK
- implicit parameters, Scala Development Kit (SDK)
- breakOut / breakOut
- executionContext / executionContext
- implicit resolution / Implicit parameters
- implicits
- about / Implicits
- resolving / How are implicits resolved?
- impure function
- examples / Defining pure functions
- Integrated Development Environment (IDE) / Setting up your environment
- IntelliJ IDEA
- installing / Installing IntelliJ IDEA
- interactive browser
- server side, implementing / Implementing the server side
- client side, implementing / Implementing the client side
- InvariantDecoder / InvariantDecoder, CovariantDecoder
- isomorphic application / Product list panel
- iterator / Loading the file with Source
J
- Java Development Kit (JDK) / Setting up your environment
- Java SDK
- installing / Installing the Java SDK
- reference / Installing the Java SDK
- Java Virtual Machine (JVM) / Setting up your environment
- Jilen
- reference / Encoding JSON with Circe
- jQuery
- extending, Scala.js used / Extending jQuery
- JSON
- encoding, with Circe / Encoding JSON with Circe
- JSON response, parsing
- about / Parsing the JSON response
- jsonToHttpTransaction, unit testing / Unit testing jsonToHttpTransaction
- jsonToHttpTransaction, implementing / Implementing jsonToHttpTransaction
- httpToDomainTransactions, unit testing / Unit testing httpToDomainTransactions
- httpToDomainTransactions, implementing / Implementing httpToDomainTransactions
- jsonToHttpTransaction
- unit testing / Unit testing jsonToHttpTransaction
K
- Kafka
- about / Introducing Apache Kafka
- topic / Topics, partitions, and offsets
- partitions / Topics, partitions, and offsets
- offset / Topics, partitions, and offsets
- producer / Producing data into Kafka
- data, producing into / Producing data into Kafka
- consumer / Consuming data from Kafka
- data, consuming from / Consuming data from Kafka
- connecting to / Connecting to Kafka
- transactions, streaming to / Streaming transactions to Kafka
- transactions, reading from / Reading transactions from Kafka
L
- layout, online shopping project user interface
- defining / Defining the layout
- creating / Creating the layout
- main layout / Main layout
- lazy data structures / Lazy data structures
- lazy evaluation strategy / Strictness and laziness
- lazy val / lazy val
- live transactions
- deserializing / Deserializing live transactions
M
- Main method
- implementing / Implementing the Main method
- Main object
- creating / Creating the Main object
- methods
- overriding / Overriding methods
- mixin / Trait
- mutable data structure / Loading the file with Source
- mutable variables
- defining / Declaring variables
N
- nondeterministic function / Defining pure functions
- NonEmptyList type / Introducing NonEmptyList
- Notify.js
- about / Notifying the user
- reference / Extending jQuery
O
- objectives, online shopping project user interface / Learning objectives
- offset / Topics, partitions, and offsets
- offset management / Offset management
- online shopping project
- creating / Creating the project
- persistence / Persistence
- deploying / Deploying the application, Deploying your application
- account, setting up / Setting up an account
- jQuery, adding / Adding jQuery to our project
- Option type
- using / Using Option
- instances, manipulating / Manipulating instances of Option
- org.scalactic.Equality / org.scalactic.Equality
P
- page, online shopping project user interface
- building / Building the page
- partially applied functions / Partially applied functions
- partitions / Topics, partitions, and offsets
- pattern matching / Pattern matching
- Paw
- reference / Checking the API
- persistence, online shopping project
- about / Persistence
- Slick, setting up / Setting up Slick
- database, setting up / Setting up the database
- database test / Database test
- Future / Future
- execution context / Execution context
- Futures, rounding up / Rounding up Futures
- database creation / Database creation
- Data Access Object creation / Data Access Object creation
- test, running / Running the test
- pimp my library pattern / Implicit class
- Platform as a Service (PaaS) / Deploying the application
- Postman
- reference / Checking the API
- processOneBatch
- testing / Testing processOneBatch
- implementing / Implementing processOneBatch
- processRepeatedly
- implementing / Implementing processRepeatedly
- product API
- implementing / Implementing the product API
- product list
- implementing / Product list
- product list panel, online shopping project user interface / Product list panel
- products
- adding, to database / Adding a product
- listing, in cart / Listing products in cart
- product tests
- about / Product test
- completing / Completing the product tests
- product type / Writing a failing unit test
- project
- building, ways / Build
- creating / Creating the project
- pure function
- about / Side effects, Ensuring referential transparency
- defining / Defining pure functions
- Pusher
- subscribing with / Subscribing with Pusher
- pusher channels
- reference / Subscribing with Pusher
R
- RDD (Resilient Distributed Dataset)
- about / Understanding Apache Spark
- lazy / RDD, DataFrame, and Dataset
- characteristics / RDD, DataFrame, and Dataset
- distributed / RDD, DataFrame, and Dataset
- Resilient / RDD, DataFrame, and Dataset
- referential transparency
- ensuring / Ensuring referential transparency
- REST API
- about / The REST API
- reference / The REST API
- tests, writing / Writing the tests, Running the test
- routes, defining / Defining the routes
- checking / Checking the API
- implementing, with persistence / Implementing the API with persistence
- REST architecture
- principles / The REST API
- retirement calculator
- overview / Project overview
- future capital, calculating / Calculating the future capital
- unit test, writing for accumulation phase / Writing a unit test for the accumulation phase
- futureCapital, implementing / Implementing futureCapital
- production code, refactoring / Refactoring the production code
- test, writing for decumulation phase / Writing a test for the decumulation phase
- retirement plan, simulating / Simulating a retirement plan
- failing unit test, writing / Writing a failing unit test
- tuples, working with / Working with tuples
- simulatePlan, implementing / Implementing simulatePlan
- retirement age, calculating / Calculating when you can retire
- failing test, writing for nbOfMonthsSaving / Writing a failing test for nbOfMonthsSaving
- function body, writing / Writing the function body
- tail-recursion / Understanding tail-recursion
- termination, ensuring / Ensuring termination
- market rates, using / Using market rates
- algebraic data type, defining / Defining an algebraic data type
- returns, filtering for specific period / Filtering returns for a specific period
- pattern matching / Pattern matching
- simulatePlan, refactoring / Refactoring simulatePlan, Refactoring simulatePlan
- market data, loading / Loading market data
- unit test, writing with column selection mode / Writing the unit test using the column selection mode
- file, loading with source / Loading the file with Source
- inflation data, loading / Loading inflation data
- real returns, computing / Computing real returns
- application, packaging / Packaging the application, Packaging the application
- app object, creating / Creating the App object
- setup, starting / Setup
- refactoring, to use Option / Refactoring the retirement calculator to use Option
- refactoring, to use Either / Refactoring the retirement calculator to use Either
- nbOfMonthsSavings, refactoring / Refactoring nbOfMonthsSavings
- monthlyRate, refactoring / Refactoring monthlyRate
- SimulatePlanApp, refactoring / Refactoring SimulatePlanApp
- refactoring, to use ValidatedNel / Refactoring the retirement calculator to use ValidatedNel
- unit tests, adding / Adding unit tests
- parsing functions, implementing / Implementing parsing functions
- SimulatePlanApp.strSimulatePlan, implementing / Implementing SimulatePlanApp.strSimulatePlan
- SimulatePlanApp.strMain, refactoring / Refactoring SimulatePlanApp.strMain
S
- SBT project
- setting up / Setting up the project
- SBT synchronization / SBT synchronization
- scala.math.Ordering / scala.math.Ordering
- Scala Console
- running / Running the Scala Console
- using / Using the Scala Console
- Scala Development Kit (SDK) / Examples in the SDK
- Scala REPL / Using the Scala Console
- ScalaTest
- reference / Writing the first unit test
- scatter chart
- drawing / Drawing a scatter chart
- server side, interactive browser
- implementing / Implementing the server side
- web socket route, creating / Creating the web socket route
- BrowserManager, implementing / Implementing BrowserManager
- WebSocket, handling / Handling WebSocket
- Actor flow, representing / A diagram of Actors
- Simple Build Tool (SBT) / Setting up your environment, SBT synchronization
- singleton / Companion object
- Spark / Understanding Apache Spark
- Spark API
- exploring, with Scala console / Exploring the Spark API with the Scala console
- rows, transforming with map / Transforming rows using map
- rows, transforming with select / Transforming rows using select
- Spark Engine / Introducing Spark Streaming
- Spark master / Execution model
- Spark SQL
- Spark streaming
- about / Introducing Spark Streaming
- APIs / Introducing Spark Streaming
- Discretized Stream (DStream) / Introducing Spark Streaming
- structured streaming / Introducing Spark Streaming
- Spark streaming process
- input source / Writing to an in-memory sink
- operations / Writing to an in-memory sink
- output sink / Writing to an in-memory sink
- SparkUI web server / Running spark-submit
- specialization / Class inheritance
- stack trace / Throwing exceptions
- statically typed language / Types
- StreamingProducerApp
- running / Running StreamingProducerApp
- streaming transactions
- analyzing, with Zeppelin / Analyzing streaming transactions with Zeppelin
- aggregating / Aggregating streaming transactions
- strict evaluation strategy / Strictness and laziness
- strictVal / Strict val
- strict variable
- declaring / Strict val
- string interpolation / Implementing another feature
- structured streaming
- reference / Introducing Spark Streaming
- subclass / Class inheritance
- subclass assignment / Subclass assignment
- superclass / Class inheritance
- Swagger
- about / Swagger
- installing / Installing Swagger
- endpoints, declaring / Declaring endpoints
- application, running / Running the application
T
- tagless final encoding
- reference / Usage examples
- Test-Driven-Development (TDD) / Implementing the transaction batch producer
- topic / Topics, partitions, and offsets
- trait / Trait
- transaction batch producer
- implementing / Implementing the transaction batch producer, Putting it all together
- Bitstamp REST API, calling / Calling the Bitstamp REST API
- JSON response, parsing / Parsing the JSON response
- transactions, saving / Saving transactions
- processOneBatch, testing / Testing processOneBatch
- processOneBatch, implementing / Implementing processOneBatch
- processRepeatedly, implementing / Implementing processRepeatedly
- BatchProducerApp, implementing / Implementing BatchProducerApp
- transactions
- saving / Saving transactions
- Parquet format / Introducing the Parquet format
- writing, in Parquet / Writing transactions in Parquet
- IO Monad, using / Using the IO Monad
- analyzing, with Zeppelin / Analyzing transactions with Zeppelin
- streaming, to Kafka / Streaming transactions to Kafka
- reading, from Kafka / Reading transactions from Kafka
- transformations
- composing, with for... yield / Composing transformations with for... yield
- about / Execution model
- type class
- about / Understanding type classes, Common type classes
- recipe / Type class recipe
- scala.math.Ordering / scala.math.Ordering
- org.scalactic.Equality / org.scalactic.Equality
- cats.Semigroup / cats.Semigroup
- cats.Monoid / cats.Monoid
- higher-kinded types / Higher-kinded types
- cats.Functor / cats.Functor
- cats.Apply / cats.Apply
- cats.Applicative / cats.Applicative
- cats.Monad / cats.Monad
- Typelevel
- reference / Encoding JSON with Circe
- type parameter / Implementing futureCapital
- types / Types
U
- UI actions, online shopping project
- implementing / Implementing UI actions
- product, adding to cart / Adding a product to the cart
- product, removing from cart / Removing a product from the cart
- product quantity, updating / Updating the quantity
- UI manager
- about / Introducing the UI manager
- jQuery, adding to project / Adding jQuery to our project
- API, calling / Calling our API
- UI actions, implementing / Implementing UI actions
- Uniform Resource Identifier (URI) / The REST API
- unit test
- writing / Writing the first unit test
- user interface, online shopping project
- learning objectives / Learning objectives
- setting up / Setting up
- layout, defining / Defining the layout
- layout, creating / Creating the layout
- page, building / Building the page
- main layout / Main layout
- product list panel / Product list panel
- cart panel / Cart panel
- UI manager / Introducing the UI manager
- initializing / Initializing the user interface
- deploying / Deploying the user interface
- debugging / Debugging the interface
V
- ValidatedNel
- using / Using ValidatedNel
- Validated type / Introducing Validated
- variables
- declaring / Declaring variables
- defining / Declaring variables
- variance / Covariance and contravariance
- InvariantDecoder / InvariantDecoder
- CovariantDecoder / CovariantDecoder
W
- WebSocket
- handling / Handling WebSocket
- web socket route
- creating / Creating the web socket route
- WordSpec
- reference / Writing the first unit test
- worksheet
- using / Using the worksheet
Z
- Zeppelin
- about / Introduction to Zeppelin
- roles / Introduction to Zeppelin
- installing / Installing Zeppelin
- starting / Starting Zeppelin
- testing / Testing Zeppelin
- notebook / Structure of a notebook
- paragraph, adding / Writing a paragraph
- charts, drawing / Drawing charts, Drawing our first chart, Drawing more charts
- transactions, analyzing / Analyzing transactions with Zeppelin
- chart, drawing / Drawing our first chart
- streaming transactions, analyzing with / Analyzing streaming transactions with Zeppelin
- Zookeeper / Connecting to Kafka