Book Image

Learning Scala Programming

By : Vikash Sharma
Book Image

Learning Scala Programming

By: Vikash Sharma

Overview of this book

Scala is a general-purpose programming language that supports both functional and object-oriented programming paradigms. Due to its concise design and versatility, Scala's applications have been extended to a wide variety of fields such as data science and cluster computing. You will learn to write highly scalable, concurrent, and testable programs to meet everyday software requirements. We will begin by understanding the language basics, syntax, core data types, literals, variables, and more. From here you will be introduced to data structures with Scala and you will learn to work with higher-order functions. Scala's powerful collections framework will help you get the best out of immutable data structures and utilize them effectively. You will then be introduced to concepts such as pattern matching, case classes, and functional programming features. From here, you will learn to work with Scala's object-oriented features. Going forward, you will learn about asynchronous and reactive programming with Scala, where you will be introduced to the Akka framework. Finally, you will learn the interoperability of Scala and Java. After reading this book, you'll be well versed with this language and its features, and you will be able to write scalable, concurrent, and reactive programs in Scala.

Related Content you might be interested in

Current Title:

Small book image
Learning Scala Programming
Vikash Sharma
Jan, 2018 | 426 pages
Small book image
Professional Scala
Ruslan Shevchenko | Mads Hartmann
Jul, 2018 | 186 pages
Small book image
Learn Scala Programming
Slava Schmidt
Oct, 2018 | 498 pages
Small book image
Learning Concurrent Programming in Scala.
Aleksandar Prokopec
Feb, 2017 | 434 pages
Table of Contents (21 chapters)
Title Page
Title Page
Packt Upsell
Packt Upsell
Contributors
Contributors
Preface
Preface
Free Chapter
1
Getting Started with Scala Programming
Getting Started with Scala Programming
Introduction to Scala
Scala advantages
Working with Scala
Running our first program
Summary
2
Building Blocks of Scala
Building Blocks of Scala
What is underneath a Scala program?
Vals and vars
Literals
Data types
Type inference
Operators in Scala
Wrapper classes
String Interpolators
Summary
3
Shaping our Scala Program
Shaping our Scala Program
Looping
The for expressions
Recursion
Conditional statements
Pattern matching
Summary
4
Giving Meaning to Programs with Functions
Giving Meaning to Programs with Functions
Function syntax
Calling a function
Function literals
Evaluation strategies
Partial functions
Summary
5
Getting Familiar with Scala Collections
Getting Familiar with Scala Collections
Motivation
Immutable and mutable collections
Hierarchy of collections in Scala
Commonly used collections in Scala
Rich operations performed on collections
Parallel collections in Scala
Converting a Java collection into a Scala collection
Choosing a collection
Collection performance
Summary
6
Object-Oriented Scala Basics
Object-Oriented Scala Basics
Classes
Abstract classes
Objects as singletons
Companion objects
Case classes
Summary
7
Next Steps in Object-Oriented Scala
Next Steps in Object-Oriented Scala
Composition and inheritance
Class inheritance
Default and parameterized constructors
Traits
Traits as mix-ins
Linearization
Packaging and importing
Visibility rules
Sealed traits
Summary
8
More on Functions
More on Functions
Function literals
Methods
Functions versus methods
What are closures?
Higher-order functions
Currying
Partially applied functions
Summary
9
Using Powerful Functional Constructs
Using Powerful Functional Constructs
For expressions
Pattern matching
Different ways we can pattern match
Option type
Lazy declaration
Tail call optimization
Combinators
Type parameterization
Summary
10
Advanced Functional Programming
Advanced Functional Programming
Why so serious about types?
Here comes type parameterization
Another way around - generic classes and traits
Type parameter names
Container types
Type erasure
Variance under inheritance
Abstract types
Type bounds
Abstract versus parameterized types
Type-classes
Summary
11
Working with Implicits and Exceptions
Working with Implicits and Exceptions
Exception handling – the old way
Using the Option way
Either left or right
Implicits - what and why
Implicit parameters
The implicitly method
Implicit conversions
Looking for implicits
Type-classes ahead!
Summary
12
Introduction to Akka
Introduction to Akka
Why do we care about Akka?
What's up with the Actor Model?
Understanding the Actor system
Props
Actor references and paths
Selecting existing actorRefs via actorSelection
How the Actor life cycle works
Hello world in Akka
Writing our first Actor
The tell versus ask versus forward method
Stopping Actors
The preStart and postStop hooks
Actor communication via messages and its semantics
Supervising fault in our actors
OneForOne versus AllForOne strategy
Default supervision strategy
Applying the supervision strategy
Testing actors
Summary
13
Concurrent Programming in Scala
Concurrent Programming in Scala
Concurrent programming
Building blocks of concurrency
Asynchronous programming
Parallel collections
Summary
14
Programming with Reactive Extensions
Programming with Reactive Extensions
Reactive programming
Reactive extensions
React to RxScala
Summary
15
Testing in Scala
Testing in Scala
The why and what of TDD
ScalaTest
ScalaMock – a native library to mock objects
Summary
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

OneForOne versus AllForOne strategy

Take the scenario where we have SimpleActor and AnotherSimpleActor actors. There's one child actor for SimpleActor named SimplerrrActor:

  • SimpleActor: /user/topLevelActor/simpleActor
  • AnotherSimpleActor: /user/topLevelActor/anotherSimpleActor
  • SimplerrrActor: /user/topLevelActor/simpleActor/simplerrrActor

In such cases, the user guardian is going to take care of topLevelActor and topLevelActor is going to supervise SimpleActor and AnotherSimpleActor. If something goes wrong in SimpleActor and we want all the actors to resume/restart/stop, we can define an AllForOneStrategy. If we want to perform such actions only on the failed SimpleActor and its subsequent children, we can opt for OneForOneStrategy.

These two are defined as case classes in Scala, which takes a few parameters in the form of maxNrOfRetries, withinTimeRange, and loggingEnabled:

case class OneForOneStrategy( 
  maxNrOfRetries:              Int      = -1, 
  withinTimeRange:             Duration =...
Previous Section
End of Section 16
Next Section