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

Learning Scala programming object-oriented programming meets functional reactive to create scalable and concurrent programs

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 princ...

Descripción completa

Detalles Bibliográficos
Otros Autores: Sharma, Vikash, author (author)
Formato: Libro electrónico
Idioma:Inglés
Publicado: Birmingham, England ; Mumbai, [India] : Packt 2018.
Edición:1st edition
Materias:
Scala (Computer program language)
Object-oriented programming (Computer science)
Ver en Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631620506719
Tabla de Contenidos:
  • 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
  • Summary
  • 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
  • Summary
  • 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
  • Function literals
  • Evaluation strategies
  • Call by name
  • Call by value
  • Partial functions
  • Summary
  • 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
  • Map
  • 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
  • Summary
  • Chapter 6: Object-Oriented Scala Basics
  • Classes
  • Abstract classes
  • Abstract classes and traits
  • The final classes
  • Objects as singletons
  • Companion objects
  • Case classes
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • Chapter 9: Using Powerful Functional Constructs
  • For expressions
  • Pattern matching
  • 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
  • Summary
  • 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
  • Summary
  • 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!
  • Summary
  • 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
  • Summary
  • 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
  • Summary
  • Chapter 14: Programming with Reactive Extensions
  • Reactive programming
  • Reactive extensions
  • React to RxScala
  • Creating Observables
  • Summary
  • 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
  • Summary
  • Other Books You May Enjoy
  • Index.

Ejemplares similares