Learning Scala programming : object-oriented programming meets functional reactive to create scalable and concurrent programs / Vikash Sharma.

Format:

Book

Author/Creator:

Sharma, Vikash, author.

Language:

English

Subjects (All):

Scala (Computer program language).

Object-oriented programming (Computer science).

Physical Description:

1 online resource (426 pages)

Edition:

1st edition

Place of Publication:

Birmingham, England ; Mumbai, [India] : Packt, 2018.

System Details:

text file

Summary:

Learn how to write scalable and concurrent programs in Scala, a language that grows with you. About This Book Get a grip on the functional features of the Scala programming language Understand and develop optimal applications using object-oriented and functional Scala constructs Learn reactive principles with Scala and work with the Akka framework Who This Book Is For This book is for programmers who choose to get a grip over Scala to write concurrent, scalable, and reactive programs. No prior experience with any programming language is required to learn the concepts explained in this book. Knowledge of any programming language would help the reader understanding concepts faster though. What You Will Learn Get to know the reasons for choosing Scala: its use and the advantages it provides over other languages Bring together functional and object-oriented programming constructs to make a manageable application Master basic to advanced Scala constructs Test your applications using advanced testing methodologies such as TDD Select preferred language constructs from the wide variety of constructs provided by Scala Make the transition from the object-oriented paradigm to the functional programming paradigm Write clean, concise, and powerful code with a functional mindset Create concurrent, scalable, and reactive applications utilizing the advantages of Scala In Detail 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...

Contents:

Cover

Title Page

Copyright and Credits

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: Getting Started with Scala Programming

Introduction to Scala

A programming paradigm

Object-oriented versus functional paradigms

Scala is multi-paradigm

Scala advantages

Runs on JVM

Super smart syntax

Best of both worlds

Type is the core

Concurrency made easy

Asynchronous code

Asynchronous versus parallel versus concurrent programming

Now available for the frontend

Smart IDEs

Extensive language

Online support

Working with Scala

Java installation

SBT installation

Scala REPL

Scala IDEs

Running our first program

Summary

Chapter 2: Building Blocks of Scala

What is underneath a Scala program?

Vals and vars

Literals

Integer literals

Floating point literals

Boolean literals

Character literals

String literals

Symbol literals

Tuple literals

Function literals

Data types

Scala's class hierarchy

Any

AnyVal and AnyRef

AnyRef

AnyVal

Unit

Boolean

Null and Nothing

Type inference

Operators in Scala

Arithmetic operators

Relational operators

Logical operators

Bitwise operators

Operator precedence

Wrapper classes

String Interpolators

The s interpolator

f Interpolator

The raw interpolator

Chapter 3: Shaping our Scala Program

Looping

The for loop

The while Loop

The do while loop

The for expressions

The for yield expressions

Recursion

Why recursion over iteration?

Limitations of recursion

The ideal way to write recursive functions

Conditional statements

The if else conditional expression

Pattern matching

Chapter 4: Giving Meaning to Programs with Functions

Function syntax

Nesting of functions.

Calling a function

Passing a variable number of arguments

Calling a function with a default parameter value

Calling a function while passing named arguments

Evaluation strategies

Call by name

Call by value

Partial functions

Chapter 5: Getting Familiar with Scala Collections

Motivation

Immutable and mutable collections

Differences between the root and immutable collections

Hierarchy of collections in Scala

Traversable

Iterable

Seq

Sequences

Map

Set

Commonly used collections in Scala

List

SortedSet

Streams

Vector

Immutable stack

Immutable queue

Ranges

ArrayBuffer

ListBuffer

StringBuilder

Array

Rich operations performed on collections

Parallel collections in Scala

ParArray

ParVector

Converting a Java collection into a Scala collection

Choosing a collection

Collection performance

Chapter 6: Object-Oriented Scala Basics

Classes

Abstract classes

Abstract classes and traits

The final classes

Objects as singletons

Companion objects

Case classes

Chapter 7: Next Steps in Object-Oriented Scala

Composition and inheritance

Class inheritance

Extending classes

Subtyping versus subclassing

Overriding data and behavior

Restricting inheritance - final keyword

Dynamic binding in function invocation

Misusing inheritance

Default and parameterized constructors

Traits

Traits as mix-ins

Traits as composable mix-ins

Traits as stackable modifications

Linearization

Packaging and importing

Package statements

Multiple package statements in a file

Nested package statements

Chaining package statements

Importing packages

Visibility rules

Sealed traits

Chapter 8: More on Functions

Function literals.

Methods

Functions versus methods

Methods or functions?

What are closures?

Higher-order functions

Currying

Converting a function with multiple parameters to curried form

Partially applied functions

Chapter 9: Using Powerful Functional Constructs

For expressions

Different ways we can pattern match

Matching a variable

Matching a constant

Matching a constructor

Option type

Lazy declaration

Tail call optimization

Combinators

Type parameterization

Chapter 10: 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

When to use what type of variance relation

Abstract types

Type bounds

Abstract versus parameterized types

Type-classes

Chapter 11: 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!

Chapter 12: 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

Setting up the environment

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

Chapter 13: Concurrent Programming in Scala

Concurrent programming

Building blocks of concurrency

Understanding processes and threads

Locks and synchronization

Executor and ExecutionContext

Asynchronous programming

Working with Futures

What if Future computations go wrong?

Why not compose two or more Futures?

Working with Promises

Parallel collections

Chapter 14: Programming with Reactive Extensions

Reactive programming

Reactive extensions

React to RxScala

Creating Observables

Chapter 15: Testing in Scala

The why and what of TDD

The process of TDD

Step 1 - write a test that will fail

Step 2 - write code to pass the failing test

Step 3 - refactor the code to improve the quality

Step 4 - repeat steps 1 to 3

Scenario

Behavior driven development (BDD)

ScalaTest

Setting up for testing

Testing in style using ScalaTest

Assertions

Matchers

ScalaMock - a native library to mock objects

Other Books You May Enjoy

Index.

Notes:

Includes index.

Description based on online resource; title from PDF title page (EBC, viewed March 6, 2018).

OCLC:

1022789317