Programming in Scala is the definitive book on Scala, the popular language for the Java platform that blends object-oriented and functional programming concepts into a unique and powerful tool for developers.Coauthored by the designer of the Scala language, this authoritative book will teach you, one step at a time, the Scala language and the ideas behind it. The book is carefully crafted to help you learn. The first few chapters will give you enough of the basics that you can already start using Scala for simple tasks. The entire book is organized so that each new concept builds on concepts that came before--a series of steps that promises to help you master the Scala language and the important ideas about programming that Scala embodies.A comprehensive tutorial and reference for Scala, this book covers the entire language and important libraries.This fourth edition brings the entire book up to date, adding new material to cover changes in Scala 2.13, in particular the overhaul of collections. This edition covers these changes in detail, including: · The new collections type hierarchy · New concrete collection types · New methods added to collections · The new ways to define your own collection types· The new, simplified views

SummaryFunctional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.About the TechnologyFunctional programming (FP) is a style of software development emphasizing functions that don't depend on program state. Functional code is easier to test and reuse, simpler to parallelize, and less prone to bugs than other code. Scala is an emerging JVM language that offers strong support for FP. Its familiar syntax and transparent interoperability with Java make Scala a great place to start learning FP. About the BookFunctional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to their everyday work. The book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples and exercises that open up the world of functional programming.This book assumes no prior experience with functional programming. Some prior exposure to Scala or Java is helpful. What's Inside\nFunctional programming concepts\nThe whys and hows of FP\nHow to write multicore programs\nExercises and checks for understanding\n\nAbout the AuthorsPaul Chiusano and Rúnar Bjarnason are recognized experts in functional programming with Scala and are core contributors to the Scalaz library.Table of ContentsPART 1 INTRODUCTION TO FUNCTIONAL PROGRAMMINGWhat is functional programming? \nGetting started with functional programming in Scala\nFunctional data structures\nHandling errors without exceptions\nStrictness and laziness\nPurely functional state PART 2 FUNCTIONAL DESIGN AND COMBINATOR LIBRARIESPurely functional parallelism\nProperty-based testing\nParser combinatorsPART 3 COMMON STRUCTURES IN FUNCTIONAL DESIGNMonoids\nMonads\nApplicative and traversable functorsPART 4 EFFECTS AND I/OExternal effects and I/O\nLocal effects and mutable state\nStream processing and incremental I/O\n

If you’ve had trouble trying to learn Functional Programming (FP), you’re not alone. In this best-selling, highly-rated book, Alvin Alexander — author of the Scala Cookbook for O’Reilly, the Scala Book for the official Scala website, and former teacher of Java and Object-Oriented Programming (OOP) classes — writes about his own problems in trying to understand FP, how he finally conquered it, and how he teaches others.In this classic book — one of the highest-selling FP books of all time — he teaches FP in a simple style, without worrying about abstract concepts like functors, monads, and category theory. Instead, he explains FP through a series of small, pragmatic lessons and examples.The Motivation Behind Functional ProgrammingFor instance, the first thing he learned is that experienced FP developers (FPers) are driven by two goals: to use only immutable values and write only pure functions. But then later he learned the REAL truth: FPers have these goals because their true desire — or mental model — is that they want all of their code to look and work just like algebra.While that sounds simple, it turns out that these goals require them to use some advanced Scala features — which they often use all at the same time. As a result, their code can look completely foreign to novice FP developers. As Mr. Alexander writes, “When you first see their code it’s easy to ask, ‘Why would you write code like this?’”But then Mr. Alexander answers that “Why?” question by explaining the benefits of writing pure functional code.Five Rules for Functional ProgrammingOnce you understand those benefits — your motivation for learning FP — he shares five rules for programming in the book: All fields must be immutable (‘val’ fields). All functions must be pure functions. Null values are not allowed. Whenever you use an ‘if’ you must also use an ‘else’. You won’t create OOP classes that encapsulate data and behavior; instead you’ll design data structures using Scala ‘case’ classes, and write pure functions that operate on those data structures.In the book you’ll see how those five, simple rules naturally lead you to write pure, functional code that reads like algebra. He also shares one more Golden Rule for learning: Always ask “Why”?LessonsLessons in the book include: How and why to write only pure functions Why pure function signatures are much more important than OOP method signatures Why recursion is a natural tool for functional programming, and how to write recursive algorithms Because the Scala ‘for’ expression is so important to FP, dozens of pages explain the details of how it works In the end you’ll see that monads aren’t that difficult because they’re a natural extension of the Five Rules The book finishes with lessons on FP data modeling, and two main approaches for organizing your pure functionsAs Mr. Alexander writes, “In this book I take the time to explain all of the concepts that are used to write FP code in Scala. As I learned from my own experience, once you understand the Five Rules and the small concepts, you can understand Scala/FP.”Bonus: More Free Content OnlinePlease note that because of the limits on how large a printed book can be, the paperback version does not include all of the chapters that are in the Kindle eBook. The following lessons are not in the paperback version: Grandma’s Cookies (a story about pure functions) The ScalaCheck lessons The Type Classes lessons The appendicesBecause those lessons didn’t fit in the print version, they have been made freely available online.

With its flexibility for programming both small and large projects, Scala is an ideal language for teaching beginning programming. Yet there are no textbooks on Scala currently available for the CS1/CS2 levels. Introduction to the Art of Programming Using Scala presents many concepts from CS1 and CS2 using a modern, JVM-based language that works well for both programming in the small and programming in the large. The book progresses from true programming in the small to more significant projects later, leveraging the full benefits of object orientation. It first focuses on fundamental problem solving and programming in the small using the REPL and scripting environments. It covers basic logic and problem decomposition and explains how to use GUIs and graphics in programs. The text then illustrates the benefits of object-oriented design and presents a large collection of basic data structures showing different implementations of key ADTs along with more atypical data structures. It also introduces multithreading and networking to provide further motivating examples. By using Scala as the language for both CS1 and CS2 topics, this textbook gives students an easy entry into programming small projects as well as a firm foundation for taking on larger-scale projects. Many student and instructor resources are available at www.programmingusingscala.net

This book is the authoritative tutorial on the Scala programming language, co\-written by the language\x27s designer, Martin Odersky. This fifth edition is a major rewrite of the entire book, adding new material to cover the many changes in Scala 3.0. In fact we have added so much new material that we split the book into two volumes. This volume is a tutorial of Scala and functional programming.

In this practical book, four Cloudera data scientists present a set of self-contained patterns for performing large-scale data analysis with Spark. The authors bring Spark, statistical methods, and real-world data sets together to teach you how to approach analytics problems by example.You’ll start with an introduction to Spark and its ecosystem, and then dive into patterns that apply common techniques―classification, collaborative filtering, and anomaly detection among others―to fields such as genomics, security, and finance. If you have an entry-level understanding of machine learning and statistics, and you program in Java, Python, or Scala, you’ll find these patterns useful for working on your own data applications.Patterns include: Recommending music and the Audioscrobbler data set Predicting forest cover with decision trees Anomaly detection in network traffic with K-means clustering Understanding Wikipedia with Latent Semantic Analysis Analyzing co-occurrence networks with GraphX Geospatial and temporal data analysis on the New York City Taxi Trips data Estimating financial risk through Monte Carlo simulation Analyzing genomics data and the BDG project Analyzing neuroimaging data with PySpark and Thunder

Why learn Scala? You don’t need to be a data scientist or distributed computing expert to appreciate this object-oriented functional programming language. This practical book provides a comprehensive yet approachable introduction to the language, complete with syntax diagrams, examples, and exercises. You’ll start with Scala's core types and syntax before diving into higher-order functions and immutable data structures.\nAuthor Jason Swartz demonstrates why Scala’s concise and expressive syntax make it an ideal language for Ruby or Python developers who want to improve their craft, while its type safety and performance ensures that it’s stable and fast enough for any application.\n\nLearn about the core data types, literals, values, and variables\nDiscover how to think and write in expressions, the foundation for Scala's syntax\nWrite higher-order functions that accept or return other functions\nBecome familiar with immutable data structures and easily transform them with type-safe and declarative operations\nCreate custom infix operators to simplify existing operations or even to start your own domain-specific language\nBuild classes that compose one or more traits for full reusability, or create new functionality by mixing them in at instantiation\n

Interest in the Scala programming language continues to grow for many reasons. Scala embraces the functional programming style without abandoning the object-oriented paradigm, and it allows you to write programs more concisely than in Java. Because Scala runs on the JVM, it can access any Java library and is interoperable with familiar Java frameworks. Scala also makes it easier to leverage the full power of concurrency. Written for experienced Java, C++, or C# programmers who are new to Scala or functional programming, Scala for the Impatient, Second Edition, introduces the key Scala concepts and techniques you need in order to be productive quickly. It is the perfect introduction to the language, particularly for impatient readers who want to learn the fundamentals of Scala so they can start coding quickly. It doesn’t attempt to exhaustively list all the features of the language or make you suffer through long and contrived examples. Instead, carefully crafted examples and hands-on activities guide you through well-defined stages of competency, from basic to expert. This revised edition has been thoroughly updated for Scala 2.12 and reflects current Scala usage. It includes added coverage of recent Scala features, including string interpolation, dynamic invocation, implicit classes, and futures. Scala is a big language, but you can use it effectively without knowing all of its details intimately. This title provides precisely the information that you need to get started in compact, easy-to-understand chunks. \nGet started quickly with Scala’s interpreter, syntax, tools, and unique idioms Master core language features: functions, arrays, maps, tuples, packages, imports, exception handling, and more Become familiar with object-oriented programming in Scala: classes, inheritance, and traits Use Scala for real-world programming tasks: working with files, regular expressions, and XML Work with higher-order functions and the powerful Scala collections library Leverage Scala’s powerful pattern matching and case classes Create concurrent programs with Scala futures Implement domain-specific languages Understand the Scala type system Apply advanced “power tools,” such as annotations, implicits, and type classes \n Register your product at informit.com/register for convenient access to downloads, updates, and corrections as they become available.

Scala Puzzlers is a collection of enigmatic Scala code examples that behave highly contrary to expectations and will entertain and enlighten even the most accomplished Scala developer. Challenge your Scala intuition, then treat yourself to a revealing explanation of the reasons underlying the code's actual behavior that will provide important and often fundamental insights into Scala. Get ready for a fun journey that will take you further down the road to Scala mastery!

SummaryScala in Action is a comprehensive tutorial that introduces Scala through clear explanations and numerous hands-on examples. Because Scala is a rich and deep language, it can be daunting to absorb all the new concepts at once. This book takes a "how-to" approach, explaining language concepts as you explore familiar programming challenges that you face in your day-to-day work.About the TechnologyScala runs on the JVM and combines object-orientation with functional programming. It's designed to produce succinct, type-safe code, which is crucial for enterprise applications. Scala implements Actor-based concurrency through the amazing Akka framework, so you can avoid Java's messy threading while interacting seamlessly with Java.About this BookScala in Action is a comprehensive tutorial that introduces the language through clear explanations and numerous hands-on examples. It takes a "how to" approach, explaining language concepts as you explore familiar programming tasks. You'll tackle concurrent programming in Akka, learn to work with Scala and Spring, and learn how to build DSLs and other productivity tools. You'll learn both the language and how to use it.Experience with Java is helpful but not required. Ruby and Python programmers will also find this book accessible.What's Inside\nA Scala tutorial\nHow to use Java and Scala open source libraries\nHow to use SBT\nTest-driven development\nDebugging\nUpdated for Scala 2.10\n\nPurchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.About the AuthorNilanjan Raychaudhuri is a skilled developer, speaker, and an avid polyglot programmer who works with Scala on production systems.Table of ContentsPART 1 SCALA: THE BASICSWhy Scala?\nGetting started\nOOP in Scala\nHaving fun with functional data structures\nFunctional programmingPART 2 WORKING WITH SCALABuilding web applications in functional style\nConnecting to a database\nBuilding scalable and extensible components\nConcurrency programming in Scala\nBuilding confidence with testingPART 3 ADVANCED STEPSInteroperability between Scala and Java\nScalable and distributed applications using Akka\n