Programming Scala

by Dean Wampler

Overview

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

Product Details

ISBN-13:	9781492077848
Publisher:	O'Reilly Media, Incorporated
Publication date:	05/26/2021
Sold by:	Barnes & Noble
Format:	eBook
Pages:	556
File size:	3 MB

About the Author

Dean Wampler is an expert in data engineering for scalable streaming data systems and applications of machine learning and artificial intelligence. He is a principal software engineer at Domino Data Lab. Previously he worked at Anyscale and Lightbend, where he worked on scalable machine learning with Ray and distributed streaming data systems with Apache Spark, Apache Kafka, Kubernetes, and other tools. Besides Programming Scala, Dean is also the author of What Is Ray?, Distributed Computing Made Simple, Fast Data Architectures for Streaming Applications, and Functional Programming for Java Developers, as well as the coauthor of Programming Hive, all from O’Reilly. He is a contributor to several open source projects and a frequent conference speaker, and he co-organizes several conferences around the world and several user groups in Chicago. Dean has a PhD in physics from the University of Washington. Find Dean on Twitter: @deanwampler.

Table of Contents

Dedication;
Foreword;
Preface;
Welcome to Programming Scala;
Conventions Used in This Book;
Using Code Examples;
Safari® Books Online;
How to Contact Us;
Acknowledgments;
Chapter 1: Zero to Sixty: Introducing Scala;
1.1 Why Scala?;
1.2 Installing Scala;
1.3 For More Information;
1.4 A Taste of Scala;
1.5 A Taste of Concurrency;
1.6 Recap and What’s Next;
Chapter 2: Type Less, Do More;
2.1 In This Chapter;
2.2 Semicolons;
2.3 Variable Declarations;
2.4 Method Declarations;
2.5 Inferring Type Information;
2.6 Literals;
2.7 Tuples;
2.8 Option, Some, and None: Avoiding nulls;
2.9 Organizing Code in Files and Namespaces;
2.10 Importing Types and Their Members;
2.11 Abstract Types And Parameterized Types;
2.12 Reserved Words;
2.13 Recap and What’s Next;
Chapter 3: Rounding Out the Essentials;
3.1 Operator? Operator?;
3.2 Methods Without Parentheses and Dots;
3.3 Domain-Specific Languages;
3.4 Scala if Statements;
3.5 Scala for Comprehensions;
3.6 Other Looping Constructs;
3.7 Conditional Operators;
3.8 Pattern Matching;
3.9 Enumerations;
3.10 Recap and What’s Next;
Chapter 4: Traits;
4.1 Introducing Traits;
4.2 Stackable Traits;
4.3 Constructing Traits;
4.4 Recap and What’s Next;
Chapter 5: Basic Object-Oriented Programming in Scala;
5.1 Class and Object Basics;
5.2 Parent Classes;
5.3 Constructors in Scala;
5.4 Nested Classes;
5.5 Visibility Rules;
5.6 Recap and What’s Next;
Chapter 6: Advanced Object-Oriented Programming In Scala;
6.1 Overriding Members of Classes and Traits;
6.2 Companion Objects;
6.3 Case Classes;
6.4 Equality of Objects;
6.5 Recap and What’s Next;
Chapter 7: The Scala Object System;
7.1 The Predef Object;
7.2 Classes and Objects: Where Are the Statics?;
7.3 Sealed Class Hierarchies;
7.4 The Scala Type Hierarchy;
7.5 Linearization of an Object’s Hierarchy;
7.6 Recap and What’s Next;
Chapter 8: Functional Programming in Scala;
8.1 What Is Functional Programming?;
8.2 Functional Programming in Scala;
8.3 Recursion;
8.4 Tail Calls and Tail-Call Optimization;
8.5 Functional Data Structures;
8.6 Traversing, Mapping, Filtering, Folding, and Reducing;
8.7 Pattern Matching;
8.8 Partial Functions;
8.9 Currying;
8.10 Implicits;
8.11 Implicit Function Parameters;
8.12 Call by Name, Call by Value;
8.13 Lazy Vals;
8.14 Recap: Functional Component Abstractions;
Chapter 9: Robust, Scalable Concurrency with Actors;
9.1 The Problems of Shared, Synchronized State;
9.2 Actors;
9.3 Actors in Scala;
9.4 Traditional Concurrency in Scala: Threading and Events;
9.5 Recap and What’s Next;
Chapter 10: Herding XML in Scala;
10.1 Reading XML;
10.2 Writing XML;
10.3 Recap and What’s Next;
Chapter 11: Domain-Specific Languages in Scala;
11.1 Internal DSLs;
11.2 External DSLs with Parser Combinators;
11.3 Recap and What’s Next;
Chapter 12: The Scala Type System;
12.1 Reflecting on Types;
12.2 Understanding Parameterized Types;
12.3 Variance Under Inheritance;
12.4 Type Bounds;
12.5 Nothing and Null;
12.6 Understanding Abstract Types;
12.7 Path-Dependent Types;
12.8 Value Types;
12.9 Self-Type Annotations;
12.10 Structural Types;
12.11 Existential Types;
12.12 Infinite Data Structures and Laziness;
12.13 Recap and What’s Next;
Chapter 13: Application Design;
13.1 Annotations;
13.2 Enumerations Versus Pattern Matching;
13.3 Thoughts On Annotations and Enumerations;
13.4 Using Nulls Versus Options;
13.5 Exceptions and the Alternatives;
13.6 Scalable Abstractions;
13.7 Effective Design of Traits;
13.8 Design Patterns;
13.9 Better Design with Design By Contract;
13.10 Recap and What’s Next;
Chapter 14: Scala Tools, Libraries, and IDE Support;
14.1 Command-Line Tools;
14.2 Build Tools;
14.3 Integration with IDEs;
14.4 Test-Driven Development in Scala;
14.5 Other Notable Scala Libraries and Tools;
14.6 Java Interoperability;
14.7 Java Library Interoperability;
14.8 Recap and What’s Next;
References;
Glossary;
Colophon;