Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20

Programming Scala

Scalability = Functional Programming + Objects

Paperback Engels 2021 9781492077893
Verkooppositie 8766
Verwachte levertijd ongeveer 8 werkdagen


Get up to speed on Scala-the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You'll learn why Scala is ideal for building today's highly scalable, data-centric applications while maximizing developer productivity.

While Java remains popular and Kotlin has become popular, Scala hasn't been sitting still. This third edition covers the new features in Scala 3 with updates throughout the book. Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala's design philosophy and features with a thoroughly practical focus.

- Program faster with Scala's succinct and flexible syntax
- Dive into basic and advanced functional programming techniques
- Build killer big data and distributed apps using Scala's functional combinators and tools like Spark and Akka
- Create concise solutions to challenging design problems with the sophisticated type system, mixin composition with traits, pattern matching, and more


Aantal pagina's:544
Hoofdrubriek:IT-management / ICT


Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over Dean Wampler

Dean Wampler is a Consultant, Trainer, and Mentor with Object Mentor, Inc. He specializes in Scala, Java, and Ruby. He works with clients on application design strategies that combine object-oriented programming, functional programming, and aspect-oriented programming. He also consults on Agile methods, like Lean and XP. Dean is a frequent speaker at industry and academic conferences on these topics. He has a Ph.D. in Physics from the University of Washington.

Andere boeken door Dean Wampler

Over Alex Payne

Alex Payne is Platform Lead at Twitter, where he develops services that enable programmers to build atop the popular social messaging service. Alex has previously built web applications for political campaigns, non-profits, and early-stage startups, and supported information security efforts for military and intelligence customers. In his free time, Alex studies, speaks, and writes about the history, present use, and evolution of programming languages, as well as minimalist art and design.

Andere boeken door Alex Payne


Foreword, Third Edition
Foreword, First and Second Edition
Welcome to Programming Scala, Third Edition
How to Read This Book
Welcome to Programming Scala, Second Edition
Welcome to Programming Scala, First Edition
Conventions Used in This Book
Using Code Examples
Getting the Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments for the Third Edition
Acknowledgments for the Second Edition
Acknowledgments for the First Edition

1. Zero to Sixty: Introducing Scala
Why Scala?
The Appeal of Scala
Why Scala 3?
Migrating to Scala 3
Installing the Scala Tools You Need
Building the Code Examples
More Tips
Using sbt
Running the Scala Command-Line Tools Using sbt
A Taste of Scala
A Sample Application
Recap and What’s Next

2. Type Less, Do More
New Scala 3 Syntax—Optional Braces
Variable Declarations
Partial Functions
Method Declarations
Method Default and Named Parameters
Methods with Multiple Parameter Lists
Nesting Method Definitions and Recursion
Inferring Type Information
Repeated Parameter Lists
Language Keywords
Literal Values
Numeric Literals
Boolean Literals
Character Literals
String Literals
Symbol Literals
Function Literals
Option, Some, and None: Avoiding Nulls
When You Really Can’t Avoid Nulls
Sealed Class Hierarchies and Enumerations
Organizing Code in Files and Namespaces
Importing Types and Their Members
Package Imports and Package Objects
Parameterized Types Versus Abstract Type Members
Recap and What’s Next

3. Rounding Out the Basics
Defining Operators
Allowed Characters in Identifiers
Methods with Empty Parameter Lists
Operator Precedence Rules
Enumerations and Algebraic Data Types
Interpolated Strings
Scala Conditional Expressions
Conditional and Comparison Operators
for Comprehensions
for Loops
Guards: Filtering Values
Yielding New Values
Expanded Scope and Value Definitions
Scala while Loops
Using try, catch, and finally Clauses
Call by Name, Call by Value
Lazy Values
Traits: Interfaces and Mixins in Scala
When new Is Optional
Recap and What’s Next

4. Pattern Matching
Safer Pattern Matching with Matchable
Values, Variables, and Types in Matches
Matching on Sequences
Pattern Matching on Repeated Parameters
Matching on Tuples
Parameter Untupling
Guards in Case Clauses
Matching on Case Classes and Enums
Matching on Regular Expressions
Matching on Interpolated Strings
Sealed Hierarchies and Exhaustive Matches
Chaining Match Expressions
Pattern Matching Outside Match Expressions
Problems in Pattern Bindings
Pattern Matching as Filtering in for Comprehensions
Pattern Matching and Erasure
unapply Method
Alternatives to Option Return Values
unapplySeq Method
Implementing unapplySeq
Recap and What’s Next

5. Abstracting Over Context: Type Classes and Extension Methods
Four Changes
Extension Methods
Build Your Own String Interpolator
Type Classes
Scala 3 Type Classes
Alias Givens
Scala 2 Type Classes
Scala 3 Implicit Conversions
Type Class Derivation
Givens and Imports
Givens Scoping and Pattern Matching
Resolution Rules for Givens and Extension Methods
The Expression Problem
Recap and What’s Next

6. Abstracting Over Context: Using Clauses
Using Clauses
Context Bounds
Other Context Parameters
Context Functions
Constraining Allowed Instances
Implicit Evidence
Working Around Type Erasure with Using Clauses
Rules for Using Clauses
Improving Error Messages
Recap and What’s Next

7. Functional Programming in Scala
What Is Functional Programming?
Functions in Mathematics
Variables That Aren’t
Functional Programming in Scala
Anonymous Functions, Lambdas, and Closures
Purity Inside Versus Outside
Tail Calls and Tail-Call Optimization
Partially Applied Functions Versus Partial Functions
Currying and Uncurrying Functions
Tupled and Untupled Functions
Partial Functions Versus Functions Returning Options
Functional Data Structures
Traversing, Mapping, Filtering, Folding, and Reducing
Flat Mapping
Folding and Reducing
Left Versus Right Folding
Combinators: Software’s Best Component Abstractions
What About Making Copies?
Recap and What’s Next

8. for Comprehensions in Depth
Recap: The Elements of for Comprehensions
for Comprehensions: Under the Hood
Translation Rules of for Comprehensions
Options and Container Types
Option as a Container?
Either: An Alternative to Option
Try: When There Is No Do
Validated from the Cats Library
Recap and What’s Next

9. Object-Oriented Programming in Scala
Class and Object Basics: Review
Open Versus Closed Types
Classes Open for Extension
Overriding Methods? The Template Method Pattern
Reference Versus Value Types
Opaque Types and Value Classes
Opaque Type Aliases
Value Classes
Constructors in Scala
Calling Supertype Constructors
Export Clauses
Good Object-Oriented Design: A Digression
Fields in Types
The Uniform Access Principle
Unary Methods
Recap and What’s Next

10. Traits
Traits as Mixins
Stackable Traits
Union and Intersection Types
Transparent Traits
Using Commas Instead of with
Trait Parameters
Should That Type Be a Class or Trait?
Recap and What’s Next

11. Variance Behavior and Equality
Parameterized Types: Variance Under Inheritance
Functions Under the Hood
Variance of Mutable Types
Improper Variance of Java Arrays
Equality of Instances
The equals Method
The == and != Methods
The eq and ne Methods
Array Equality and the sameElements Method
Equality and Inheritance
Multiversal Equality
Case Objects and hashCode
Recap and What’s Next

12. Instance Initialization and Method Resolution
Linearization of a Type Hierarchy
Initializing Abstract Fields
Overriding Concrete Fields
Abstract Type Members and Concrete Type Aliases
Recap and What’s Next

13. The Scala Type Hierarchy
Much Ado About Nothing (and Null)
The scala Package
Products, Case Classes, Tuples, and Functions
Tuples and the Tuple Trait
The Predef Object
Implicit Conversions
Type Definitions
Condition Checking Methods
Input and Output Methods
Miscellaneous Methods
Recap and What’s Next

14. The Scala Collections Library
Different Groups of Collections
Abstractions with Multiple Implementations
The scala.collection.immutable Package
The scala.collection.mutable Package
The scala.collection Package
The scala.collection.concurrent Package
The scala.collection.convert Package
The scala.collection.generic Package
Construction of Instances
The Iterable Abstraction
Polymorphic Methods
Equality for Collections
Nonstrict Collections: Views
Recap and What’s Next

15. Visibility Rules
Public Visibility: The Default
Visibility Keywords
Protected Visibility
Private Visibility
Scoped Private and Protected Visibility
Recap and What’s Next

16. Scala’s Type System, Part I
Parameterized Types
Abstract Type Members and Concrete Type Aliases
Comparing Abstract Type Members Versus Parameterized Types
Type Bounds
Upper Type Bounds
Lower Type Bounds
Context Bounds
View Bounds
Intersection and Union Types
Intersection Types
Union Types
Phantom Types
Structural Types
Refined Types
Existential Types (Obsolete)
Recap and What’s Next

17. Scala’s Type System, Part II
Match Types
Dependently Typed Methods
Dependent Method and Dependent Function Types
Dependent Typing
Path-Dependent Types
Using this
Using super
Stable Paths
Self-Type Declarations
Type Projections
More on Singleton Types
Self-Recursive Types: F-Bounded Polymorphism
Higher-Kinded Types
Type Lambdas
Polymorphic Functions
Type Wildcard Versus Placeholder
Recap and What’s Next

18. Advanced Functional Programming
Algebraic Data Types
Sum Types Versus Product Types
Properties of Algebraic Data Types
Final Thoughts on Algebraic Data Types
Category Theory
What Is a Category?
The Monad Endofunctor
The Semigroup and Monoid Categories
Recap and What’s Next

19. Tools for Concurrency
The scala.sys.process Package
Robust, Scalable Concurrency with Actors
Akka: Actors for Scala
Actors: Final Thoughts
Stream Processing
Recap and What’s Next

20. Dynamic Invocation in Scala
Structural Types Revisited
A Motivating Example: ActiveRecord in Ruby on Rails
Dynamic Invocation with the Dynamic Trait
DSL Considerations
Recap and What’s Next

21. Domain-Specific Languages in Scala
Internal DSLs
External DSLs with Parser Combinators
About Parser Combinators
A Payroll External DSL
Internal Versus External DSLs: Final Thoughts
Recap and What’s Next

22. Scala Tools and Libraries
Scala 3 Versions
Command-Line Interface Tools
Managing Java JDKs with Coursier
The scalac Command-Line Tool
The scala Command-Line Tool
The scaladoc Command-Line Tool
Other Scala Command-Line Tools
Build Tools
Integration with IDEs and Text Editors
Using Notebook Environments with Scala
Testing Tools
Scala for Big Data: Apache Spark
Typelevel Libraries
Li Haoyi Libraries
Java and Scala Interoperability
Using Java Identifiers in Scala Code
Scala Identifiers in Java Code
Java Generics and Scala Parameterized Types
Conversions Between Scala and Java Collections
Java Lambdas Versus Scala Functions
Annotations for JavaBean Properties and Other Purposes
Recap and What’s Next

23. Application Design
Recap of What We Already Know
Using @main Entry Points
Design Patterns
Creational Patterns
Structural Patterns
Behavioral Patterns
Better Design with Design by Contract
The Parthenon Architecture
Recap and What’s Next

24. Metaprogramming: Macros and Reflection
Scala Compile Time Reflection
Java Runtime Reflection
Scala Reflect API
Type Class Derivation: Implementation Details
Scala 3 Metaprogramming
Wrapping Up and Looking Ahead

A. Significant Indentation Versus Braces Syntax


Managementboek Top 100


Populaire producten



        Programming Scala