We've ranked the best scala books using expert recommendations, sales data, and millions of reader ratings. At Shortform, we know books. Our book guides are the best in the world. Learn why.
Cover unavailable
1
Programming in Scala: Updated for Scala 2.12
Martin Odersky, Lex Spoon, Bill Venners
5.0
Programming in Scala
Recommended by Santiago Basulto.
Santiago Basulto
I love the following books, even though I don’t code in these languages in a daily basis. It’s still interesting to learn the concepts behind them Programming in Scala (Odersky) Learn You a Haskell for Great Good [source]
Cover unavailable
2
Functional Programming in Scala
Paul Chiusano, Rúnar Bjarnason
5.0
Functional programming (FP) is a programming style emphasizing functions that return consistent and predictable results regardless of a program's state. As a result, functional code is easier to test and reuse, simpler to parallelize, and less prone to bugs. Scala is an emerging JVM language that offers strong support for FP. Its familiar syntax and transparent interoperability with existing Java libraries make Scala a great place to start learning FP.
Functional 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, they'll find concrete examples and exercises that open up the world of functional programming.
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
…
Cover unavailable
3
Scala for the Impatient
Cay S. Horstmann
4.8
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. Get 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 Register your product at informit.com/register for convenient access to downloads, updates, and corrections as they become available.
…
Cover unavailable
4
Scala Cookbook
Alvin Alexander
4.8
Save time and trouble when using Scala to build object-oriented, functional, and concurrent applications. With more than 250 ready-to-use recipes and 700 code examples, this comprehensive cookbook covers the most common problems you’ll encounter when using the Scala language, libraries, and tools. It’s ideal not only for experienced Scala developers, but also for programmers learning to use this JVM language.
Author Alvin Alexander (creator of DevDaily.com) provides solutions based on his experience using Scala for highly scalable, component-based applications that support concurrency and distribution. Packed with real-world scenarios, this book provides recipes for:
Strings, numeric types, and control structures Classes, methods, objects, traits, and packaging Functional programming in a variety of situations Collections covering Scala's wealth of classes and methods Concurrency, using the Akka Actors library Using the Scala REPL and the Simple Build Tool (SBT) Web services on both the client and server sides Interacting with SQL and NoSQL databases Best practices in Scala development
…
Cover unavailable
5
Scala in Depth
Joshua D. Suereth and Martin Odersky
4.8
Summary
Scala in Depth is a unique new book designed to help you integrate Scala effectively into your development process. By presenting the emerging best practices and designs from the Scala community, it guides you through dozens of powerful techniques example by example.
About the BookScala is a powerful JVM language that blends the functional and OO programming models. You'll have no trouble getting introductions to Scala in books or online, but it's hard to find great examples and insights from experienced practitioners. You'll find them in Scala in Depth.
There's little heavy-handed theory here—just dozens of crisp, practical techniques for coding in Scala. Written for readers who know Java, Scala, or another OO language.
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
What's Inside Concise, expressive, and readable code style How to integrate Scala into your existing Java projects Scala's 2.8.0 collections API How to use actors for concurrent programming Mastering the Scala type system Scala's OO features—type member inheritance, multiple inheritance, and composition Functional concepts and patterns—immutability, applicative functors, and monads ==================================================
Table of Contents Scala—a blended language The core rules Modicum of style—coding conventions Utilizing object orientation Using implicits to write expressive code The type system Using implicits and types together Using the right collection Actors Integrating Scala with Java Patterns in functional programming
Learn how to be more productive with Scala, a new multi-paradigm language for the Java Virtual Machine (JVM) that integrates features of both object-oriented and functional programming. With this book, you'll discover why Scala is ideal for highly scalable, component-based applications that support concurrency and distribution.
Programming Scala clearly explains the advantages of Scala as a JVM language. You'll learn how to leverage the wealth of Java class libraries to meet the practical needs of enterprise and Internet projects more easily. Packed with code examples, this book provides useful information on Scala's command-line tools, third-party tools, libraries, and available language-aware plugins for editors and IDEs.
Learn how Scala's succinct and flexible code helps you program faster Discover the notable improvements Scala offers over Java's object model Get a concise overview of functional programming, and learn how Scala's support for it offers a better approach to concurrency Know how to use mixin composition with traits, pattern matching, concurrency with Actors, and other essential features Take advantage of Scala's built-in support for XML Learn how to develop domain-specific languages Understand the basics for designing test-driven Scala applications
…
Cover unavailable
7
Designing with Type: The Essential Guide to Typography
James Craig and Irene Korol Scala
4.7
The classic Designing with Type has been completely redesigned, with an updated format and full color throughout. New information and new images make this perennial best-seller an even more valuable tool for anyone interested in learning about typography. The fifth edition has been integrated with a convenient website, www.designingwithtype.com, where students and teachers can examine hundreds of design solutions and explore a world of typographic information. First published more than thirty-five years ago, Designing with Type has sold more than 250,000 copies—and this fully updated edition, with its new online resource, will educate and inspire a new generation of designers.
If you've had trouble trying to learn Functional Programming (FP), you're not alone. In this book, Alvin Alexander -- author of the Scala Cookbook and former teacher of Java and Object-Oriented Programming (OOP) classes -- writes about his own problems in trying to understand FP, and how he finally conquered it.
What he originally learned is that experienced FP developers are driven by two goals: to use only immutable values, and write only pure functions. What he later learned is that they have these goals as the result of another larger goal: 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 many 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 anyone write code like this?'"
Mr. Alexander answers that "Why?" question by explaining the benefits of writing pure functional code. Once 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"? Lessons 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 functions As 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."
(Alvin Alexander (alvinalexander.com) wrote the popular Scala Cookbook for O'Reilly, and also self-published two other books, How I Sold My Business: A Personal Diary, and A Survival Guide for New Consultants.)
…
Cover unavailable
9
Learning Concurrent Programming in Scala, Second Edition
Aleksandar Prokopec
4.7
This book is a must-have tutorial for software developers aiming to write concurrent programs in Scala, or broaden their existing knowledge of concurrency. This book is intended for Scala programmers that have no prior knowledge about concurrent programming, as well as those seeking to broaden their existing knowledge about concurrency. Basic knowledge of the Scala programming language will be helpful. Readers with a solid knowledge in another programming language, such as Java, should find this book easily accessible.
…
Cover unavailable
10
Designing Data-Intensive Applications
Martin Kleppmann
4.7
Many forces affect software today: larger datasets, geographical disparities, complex company structures, and the growing need to be fast and nimble in the face of change.
Proven approaches such as service-oriented and event-driven architectures are joined by newer techniques such as microservices, reactive architectures, DevOps, and stream processing. Many of these patterns are successful by themselves, but as this practical ebook demonstrates, they provide a more holistic and compelling approach when applied together.
Author Ben Stopford explains how service-based architectures and stream processing tools such as Apache Kafka® can help you build business-critical systems.
* Learn why streaming beats request-response based architectures in complex, contemporary use cases * Understand why replayable logs such as Kafka provide a backbone for both service communication and shared datasets * Explore how event collaboration and event sourcing patterns increase safety and recoverability with functional, event-driven approaches * Apply patterns including Event Sourcing and CQRS, and how to build multi-team systems with microservices and SOA using patterns such as “inside out databases” and “event streams as a source of truth” * Build service ecosystems that blend event-driven and request-driven interfaces using a replayable log and Kafka's Streams API * Scale beyond individual teams into larger, department- and company-sized architectures, using event streams as a source of truth
…
Cover unavailable
11
Advanced Scala with Cats
Jesus Labarta
4.7
The main goal of this book is to teach system architecture and design using the techniques of modern functional programming. This means designing systems as small composable units, expressing constraints and interactions via the type system, and using composition to guide the construction of large systems in a way that maintains the original architectural vision.
The book also serves as an introduction to the Cats library. We use abstractions from Cats, and we explain the structure of Cats so you can use it without fear in your own code base. The broad ideas are not specific to Cats, but Cats provides an excellent implementation that is beneficial to learn in its own right.
…
Cover unavailable
12
Learning Scala: Practical Functional Programming for the JVM
Jason Swartz
4.7
Learning Scala is an introduction and a guide to getting started with functional programming (FP) development. Written for programmers who are already familiar with object-oriented (OO) development, the book introduces the reader to the core Scala syntax and its OO models with examples and solutions that build familiarity, experience and confidence with the language.
The more challenging topics of Scala development (immutable data, anonymous functions, strong typing, flexible syntax) are introduced later in the book and build on the earlier problems to assist understanding. New concepts will be demonstrated and explained before being used in coding problems or samples so that readers will be able to progress through the chapters sequentially and not be forced to browse for answers. Scala has a deserved reputation as being difficult to learn, with a steep and extensive learning curve and unfamiliar syntax. This book is designed to address those difficulties.
…
Cover unavailable
13
Modern Systems Programming with Scala Native: Write Lean, High-Performance Code without the JVM
Richard Whaling
4.7
Cover unavailable
14
Scala in Action: Covers Scala 2.10
Nilanjan Raychaudhuri and Chad Fowler
4.7
Summary
Scala 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 Technology
Scala 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 Book
Scala 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
A Scala tutorial How to use Java and Scala open source libraries How to use SBT Test-driven development Debugging Updated for Scala 2.10
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Author
Nilanjan Raychaudhuri is a skilled developer, speaker, and an avid polyglot programmer who works with Scala on production systems.
Table of Contents
PART 1 SCALA: THE BASICS Why Scala? Getting started OOP in Scala Having fun with functional data structures Functional programming PART 2 WORKING WITH SCALA Building web applications in functional style Connecting to a database Building scalable and extensible components Concurrency programming in Scala Building confidence with testing PART 3 ADVANCED STEPS Interoperability between Scala and Java Scalable and distributed applications using Akka
…
Cover unavailable
15
The Type Astronaut's Guide to Shapeless
Dave Gurnell
4.7
The Type Astronaut’s Guide is aimed at experienced Scala hitch hikers with an interest in generic programming and boilerplate elimination. The book walks you through one of the main use cases for shapeless – automatic, boilerplate-free derivation of type class instances.
The book is divided into two parts. Part I introduces the general mechanisms for type class derivation in shapeless. It introduces generic encodings of product and coproduct types (case classes and sealed traits), and shows how to implement type classes by solving problems at the generic level.
In Part II we open the shapeless toolbox and show how to apply the solutions from Part I to a wider range of situations. We introduce polymorphic functions that let us map and flatMap over generic representations, and show how we can count at the type level.
Each chapter of the book is illustrated with worked examples that are also available on Github (https://github.com/underscoreio/shape...).
…
Cover unavailable
16
Seven Languages in Seven Weeks
Bruce Tate
4.7
You should learn a programming language every year, as recommended by The Pragmatic Programmer. But if one per year is good, how about Seven Languages in Seven Weeks? In this book you'll get a hands-on tour of Clojure, Haskell, Io, Prolog, Scala, Erlang, and Ruby. Whether or not your favorite language is on that list, you'll broaden your perspective of programming by examining these languages side-by-side. You'll learn something new from each, and best of all, you'll learn how to learn a language quickly.
Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and beyond the 20-minute tutorial you'll find someplace online. This book has an audacious goal: to present a meaningful exploration of seven languages within a single book. Rather than serve as a complete reference or installation guide, Seven Languages hits what's essential and unique about each language. Moreover, this approach will help teach you how to grok new languages.
For each language, you'll solve a nontrivial problem, using techniques that show off the language's most important features. As the book proceeds, you'll discover the strengths and weaknesses of the languages, while dissecting the process of learning languages quickly--for example, finding the typing and programming models, decision structures, and how you interact with them.
Among this group of seven, you'll explore the most critical programming models of our time. Learn the dynamic typing that makes Ruby, Python, and Perl so flexible and compelling. Understand the underlying prototype system that's at the heart of JavaScript. See how pattern matching in Prolog shaped the development of Scala and Erlang. Discover how pure functional programming in Haskell is different from the Lisp family of languages, including Clojure.
Explore the concurrency techniques that are quickly becoming the backbone of a new generation of Internet applications. Find out how to use Erlang's let-it-crash philosophy for building fault-tolerant systems. Understand the actor model that drives concurrency design in Io and Scala. Learn how Clojure uses versioning to solve some of the most difficult concurrency problems.
It's all here, all in one place. Use the concepts from one language to find creative solutions in another-or discover a language that may become one of your favorites.
…
Cover unavailable
17
Meb For Mortals: Harness the Training Methods of a Champion Marathoner to Achieve Peak Running Performance
Meb Keflezighi, Scott Douglas
4.7
With his historic win at the 2014 Boston Marathon, Meb Keflezighi cemented his legacy as one of the great champions of long-distance running. Runners everywhere wanted to know how someone two weeks away from his 39th birthday, who had only the 15th best time going into the race, could defeat the best field in Boston Marathon history and become the first American man to win the race in 31 years.Meb For Mortals describes in unprecedented detail how three-time Olympian Keflezighi prepares to take on the best runners in the world. More important, the book shows everyday runners how to implement the training, nutritional, and mental principles that have guided him throughout his long career, which in addition to this year’s Boston win includes an Olympic silver medal and the 2009 New York City Marathon title.
…
Cover unavailable
18
The Neophyte's Guide to Scala
Harold D. Underdown
4.7
The Neophyte's Guide to Scala is a book for intermediate Scala developers. If you have made your first steps with Scala and functional programming, for example by participating in Martin Odersky's Coursera course Functional Programming Principles in Scala, and you don't know how to continue, this book is for you.
Originally published as a blog series from November 2012 to April 2013, the Neophyte's Guide to Scala is now available as an ebook, a compilation of all 16 articles.
In this book, you will learn the details of how to employ pattern matching and extractors, working with the omnipresent Option and similar types in an idiomatic way, and leveraging higher-order functions and currying to keep your code DRY. Furthermore, you will gain insight into advanced Scala features like type classes and path-dependent types and about Scala's approach at concurrent programming: Learn about the power of Scala's futures and the actor model, as implemented in the popular Akka toolkit.
…
Cover unavailable
19
Scala for Java Developers
Thomas Alexandre
4.6
This step-by-step guide is full of easy-to-follow code taken from real-world examples explaining the migration and integration of Scala in a Java project. If you are a Java developer or a Java architect, working in Java EE-based solutions and want to start using Scala in your daily programming, this book is ideal for you. This book will get you up and running quickly by adopting a pragmatic approach with real-world code samples. No prior knowledge of Scala is required.
…
Cover unavailable
20
Akka in Action
Raymond Roestenburg, Rob Bakker, Rob Williams
4.6
Akka is a Scala-based toolkit that simplifies developing concurrent distributed applications. Akka uses Actors-independently executing processes that communicate via message passing—as the foundation for fault-tolerant applications where individual actors can fail without crashing everything. Perfect for high-volume applications that need to scale rapidly, Akka is an efficient foundation for event-driven systems that want to scale elastically up and out on demand, both on multi-core processors and across server nodes.
Akka in Action is a comprehensive tutorial on building message-oriented systems using Akka. The book takes a hands-on approach, where each new concept is followed by an example that shows you how it works, how to implement the code, and how to (unit) test it. You'll learn to test and deploy an actor system and scale it up and out, showing off Akka's fault tolerance. As you move along, you'll explore a message-oriented event-driven application in Akka. You'll also tackle key issues like how to model immutable messages and domain models, and apply patterns like Event Sourcing, and CQRS. The book concludes with practical advice on how to tune and customize a system built with Akka.
…
Cover unavailable
21
Scala Puzzlers
Andrew Phillips and Nermin Serifovic
4.6
Cover unavailable
22
Introduction to the Art of Programming Using Scala
Mark C. Lewis
4.6
This text is the first to teach programming with Scala, one of a new generation of languages that combine the best from the procedural, functional, and object-oriented paradigms of programming. The first part of the book covers basic logic and problem decomposition and explains how to use GUIs and graphics in programs. The second part incorporates the core topics of object-orientation with a heavy focus on abstraction for constructing basic data structures, including stacks, queues, linked-lists, trees, and heaps. The text also introduces multithreading and networking.
…
Cover unavailable
23
Pragmatic Scala: Create Expressive, Concise, and Scalable Applications
Venkat Subramaniam
4.6
Our industry is moving toward functional programming, but your object-oriented experience is still valuable. Scala combines the power of OO and functional programming, and Pragmatic Scala shows you how to work effectively with both. Updated to Scala 2.11, with in-depth coverage of new features such as Akka actors, parallel collections, and tail call optimization, this book will show you how to create stellar applications.
The first edition of this book was released as Programming Scala.
Our industry is moving toward functional programming, but your object-oriented experience is still valuable. Scala combines the power of OO and functional programming, and Pragmatic Scala shows you how to work effectively with both. Updated to Scala 2.11, with in-depth coverage of new features such as Akka actors, parallel collections, and tail call optimization, this book will show you how to create stellar applications.
This thorough introduction to Scala will get you coding in this powerful language right away. You'll start from the familiar ground of Java and, with easy-to-follow examples, you'll learn how to create highly concise and expressive applications with Scala. You'll find out when and how to mix both imperative and functional style, and how to use parallel collections and Akka actors to create high-performance concurrent applications that effectively use multicore processors.
Scala has evolved since the first edition of this book, and Pragmatic Scala is a significant update. We've revised each chapter, and added three new chapters and six new sections to explore the new features in Scala. You'll learn how to:
Safely manage concurrency with parallel collections and Akka actors Create expressive readable code with value classes and improved implicit conversions Create strings from data with no sweat using string interpolation Create domain-specific languages Optimize your recursions with tail call optimization Whether you're interested in creating concise, robust single-threaded applications or highly expressive, thread-safe concurrent programs, this book has you covered.
What You Need:
The Scala compiler (2.x) and the JDK are required to make use of the concepts and the examples in this book.
…
Cover unavailable
24
Functional and Reactive Domain Modeling
Debasish Ghosh
4.6
Perhaps the biggest challenge a developer faces is understanding the problems that a software system needs to solve. Domain modeling is a technique for creating a conceptual map of a problem space such as a business system or a scientific application, so that the developer can write the software more efficiently. The domain model doesn't present a solution to the problem, but instead describes the attributes, roles, and relationships of the entities involved, along with the constraints of the system.
Reactive application design, which uses functional programming principles along with asynchronous non-blocking communication, promises to be a potent pattern for developing performant systems that are relatively easy to manage, maintain and evolve. Typically we call such models "reactive" because they are more responsive both to user requests and to system loads. But designing and implementing such models requires a different way of thinking. Because the core behaviors are implemented using pure functions, you can reason about the domain model just like mathematics, so your model becomes verifiable and robust.
Functional and Reactive Domain Modeling teaches you how to think of the domain model in terms of pure functions and how to compose them to build larger abstractions. You will start with the basics of functional programming and gradually progress to the advanced concepts and patterns that you need to know to implement complex domain models. The book demonstrates how advanced FP patterns like algebraic data types, typeclass based design, and isolation of side-effects can make your model compose for readability and verifiability.
On the subject of reactive modeling, the book focuses on higher order concurrency patterns like actors and futures. It uses the Akka framework as the reference implementation and demonstrates how advanced architectural patterns like event sourcing and CQRS can be put to great use in implementing scalable models. You will learn techniques that are radically different from the standard RDBMS based applications that are based on mutation of records. You'll also pick up important patterns like using asynchronous messaging for interaction based on non blocking concurrency and model persistence, which delivers the speed of in-memory processing along with suitable guarantees of reliability.
…
Cover unavailable
25
Frick Collection: Handbook of Paintings
Scala Publishers
4.6
The Frick Collection in New York ranks among the world's most prestigious private art collections. It was founded by Henry Clay Frick, the Pittsburgh industrialist, who bequeathed his New York residence and the most outstanding of his many artworks to establish a public gallery.
Cover unavailable
26
Essential Slick
Denise F. Polit PhDFAAN and Cheryl Tatano Beck DNScCNMFAAN
4.6
Essential Slick is a guide to building application using the Slick database library. It is aimed at Scala developers who need to become productive with Slick quickly.
Cover unavailable
27
Play for Scala
Peter Hilton, Erik Bakker, Francisco Canedo
4.6
Summary
Play for Scala shows you how to build Scala-based web applications using the Play 2 framework. This book starts by introducing Play through a comprehensive overview example. Then, you'll look at each facet of a typical Play application both by exploring simple code snippets and by adding to a larger running example. Along the way, you'll deepen your knowledge of Scala as a programming language and work with tools like Akka.
About this Book
Play is a Scala web framework with built-in advantages: Scala's strong type system helps deliver bug-free code, and the Akka framework helps achieve hassle-free concurrency and peak performance. Play builds on the web's stateless nature for excellent scalability, and because it is event-based and nonblocking, you'll find it to be great for near real-time applications.
Play for Scala teaches you to build Scala-based web applications using Play 2. It gets you going with a comprehensive overview example. It then explores each facet of a typical Play application by walking through sample code snippets and adding features to a running example. Along the way, you'll deepen your knowledge of Scala and learn to work with tools like Akka.
Written for readers familiar with Scala and web-based application architectures. No knowledge of Play is assumed.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
What's Inside
Intro to Play 2 Play's MVC structure Mastering Scala templates and forms Persisting data and using web services Using Play's advanced features
About the Authors
Peter Hiltonv, Erik Bakker, and Francisco Canedo, are engineers at Lunatech, a consultancy with Scala and Play expertise. They are contributors to the Play framework.
Table of Contents
PART 1: GETTING STARTED Introduction to Play Your first Play application
PART 2: CORE FUNCTIONALITY Deconstructing Play application architecture
Defining the application's HTTP interface
Storing data—the persistence layer
Building a user interface with view templates
Validating and processing input with the forms API
PART 3: ADVANCED CONCEPTS Building a single-page JavaScript application with JSON
Play and more Web services, iteratees, and WebSockets
…
Cover unavailable
28
Drakin: The Scala Series Book 1
Noah Hawkes
4.6
Cover unavailable
29
Spark: The Definitive Guide: Big Data Processing Made Simple
Bill Chambers
4.6
Learn how to use, deploy, and maintain Apache Spark with this comprehensive guide, written by the creators of the open-source cluster-computing framework. With an emphasis on improvements and new features in Spark 2.0, authors Bill Chambers and Matei Zaharia break down Spark topics into distinct sections, each with unique goals.
You'll explore the basic operations and common functions of Spark's structured APIs, as well as Structured Streaming, a new high-level API for building end-to-end streaming applications. Developers and system administrators will learn the fundamentals of monitoring, tuning, and debugging Spark, and explore machine learning techniques and scenarios for employing MLlib, Spark's scalable machine-learning library.
Get a gentle overview of big data and Spark Learn about DataFrames, SQL, and Datasets--Spark's core APIs--through worked examples Dive into Spark's low-level APIs, RDDs, and execution of SQL and DataFrames Understand how Spark runs on a cluster Debug, monitor, and tune Spark clusters and applications Learn the power of Structured Streaming, Spark's stream-processing engine Learn how you can apply MLlib to a variety of problems, including classification or recommendation
…
Cover unavailable
30
Learning Spark: Lightning-Fast Big Data Analysis
Holden Karau, Andy Konwinski, et al
4.6
Cover unavailable
31
An Invitation to Applied Category Theory: Seven Sketches in Compositionality
Brendan Fong
4.6
Category theory is unmatched in its ability to organize and layer abstractions and to find commonalities between structures of all sorts. No longer the exclusive preserve of pure mathematicians, it is now proving itself to be a powerful tool in science, informatics, and industry. By facilitating communication between communities and building rigorous bridges between disparate worlds, applied category theory has the potential to be a major organizing force. This book offers a self-contained tour of applied category theory. Each chapter follows a single thread motivated by a real-world application and discussed with category-theoretic tools. We see data migration as an adjoint functor, electrical circuits in terms of monoidal categories and operads, and collaborative design via enriched profunctors. All the relevant category theory, from simple to sophisticated, is introduced in an accessible way with many examples and exercises, making this an ideal guide even for those without experience of university-level mathematics.
…
Cover unavailable
32
Stop Nurse Burnout: What to Do When Working Harder Isn't Working
Elizabeth Scala and Dike Drummond
4.6
Cover unavailable
33
Testing in Scala
Daniel Hinojosa
4.6
If you build your Scala application through Test-Driven Development, you’ll quickly see the advantages of testing before you write production code. This hands-on book shows you how to create tests with ScalaTest and the Specs2—two of the best testing frameworks available—and how to run your tests in the Simple Build Tool (SBT) designed specifically for Scala projects.
By building a sample digital jukebox application, you’ll discover how to isolate your tests from large subsystems and networks with mocking code, and how to use the ScalaCheck library for automated specification-based testing. If you’re familiar with Scala, Ruby, or Python, this book is for you.
Get an overview of Test-Driven Development Start a simple project with SBT and create tests before you write code Dive into SBT’s basic commands, interactive mode, packaging, and history Use ScalaTest both in the command line and with SBT, and learn how to incorporate JUnit and TestNG Work with the Specs2 framework, including Specification styles, matchers DSLs, and Data Tables Understand mocking by using Java frameworks EasyMock and Mockito, and the Scala-only framework ScalaMock Automate testing by using ScalaCheck to generate fake data
…
Cover unavailable
34
Functional Programming Patterns in Scala and Clojure: Write Lean Programs for the JVM
Michael Bevilacqua-Linn
4.6
Functional languages have their own patterns that enable you to solve problems with less code than object-oriented programming alone. This book introduces you, the experienced Java programmer, to Scala and Clojure: practical, production-quality languages that run on the JVM and interoperate with existing Java. By using both the statically typed, type-inferred Scala and the dynamically typed, modern Lisp Clojure, you’ll gain a broad understanding of functional programming.
For each pattern, you’ll first see the traditional object-oriented solution, and then dig into the functional replacements in both Scala and Clojure. These patterns are common in the functional world and deserve to become part of your problem-solving toolkit. On the object-oriented side, you’ll see many common patterns, such as Command, Strategy, and Null Object. On the functional side, you’ll learn core functional patterns such as Memoization, Lazy Sequence, and Tail Recursion.
Each pattern helps you solve a common programming problem. Working through them gives you a set of patterns you can use to solve problems you come across while writing programs. Finally, you’ll learn how to work your existing Java code into new Scala or Clojure projects. You can start off small, adding functional code little by little, so you can complement your existing knowledge with Scala and Clojure as these languages gain popularity on the JVM.
…
Cover unavailable
35
Lift Application Development Cookbook
Gilberto T. Garcia Jr
4.6
Lift Application Development Cookbook contains practical recipes on everything you will need to create secure web applications using this amazing framework.The book first teaches you basic topics such as starting a new application and gradually moves on to teach you advanced topics to achieve a certain task. Then, it explains every step in detail so that you can build your knowledge about how things work.This book is for developers who have at least some basic knowledge about Scala and who are looking for a functional, secure, and modern web framework. Prior experience with HTML and JavaScript is assumed.
…
Cover unavailable
36
Programming Scala
Venkat Subramaniam
4.6
Scala is an exciting, modern, multi-paradigm language for the JVM. You can use it to write traditional, imperative, object-oriented code. But you can also leverage its higher level of abstraction to take full advantage of modern, multicore systems. Programming Scala will show you how to use this powerful functional programming language to create highly scalable, highly concurrent applications on the Java Platform.
The increasing popularity and availability of multicore processors is creating a whole new set of challenges--although you can enjoy true concurrency, you're now faced with higher contention and synchronization issues. Deploying an existing application on a multicore processor may bring out previously hidden concurrency issues. Java's multi-threading facility by itself isn't enough---it's a very low level abstraction. Instead, you need a paradigm that provides a higher level of abstraction to deal with concurrency. It's time to embrace Functional Programming.
Scala is a hybrid Object-Oriented/Functional Programming language on the JVM. Using Scala, you can create traditional imperative programs, intermix them with Java code, and at the same time take advantage of higher levels of abstraction. You can use features that lead to concise, highly expressive code that remove the pain of dealing with concurrency.
Programming Scala will show you the fundamentals of functional programming using Scala. Very quickly, you'll learn how this statically typed language can give you dynamic capabilities to create concise, scalable, highly capable concurrent code.
Pragmatic programmers always use the right tool for the job. For concurrent programming on the Java VM, Scala is the tool, and Programming Scala by award-winning author Venkat Subramaniam is your guide.
…
Cover unavailable
37
Reactive Application Development
Duncan DeVore, Sean Walsh, Brian Hanafee
4.6
Modern distributed applications run in environments that may include thousands of processors, web and mobile clients, hybrid cloud deployments, and petabytes of data. The traditional patterns and practices for enterprise application development simply can't deliver the millisecond response times and near-perfect reliability these systems require. Reactive applications meet these demands by employing a loosely-coupled system of independent, isolated components that communicate via asynchronous message passing. These systems are highly responsive to changes in load, extremely fault tolerant through self-healing, and designed to elastically scale. For developers working in JVM-based systems, the Typesafe stack, anchored by the Java and Scala programming languages and the Akka toolkit and runtime, gives developers the tools to build a production-ready reactive application platform.
Reactive Application Development teaches you how to build reactive applications using the Typesafe stack. The book starts with an architectural overview that teaches you how a reactive application works and shows you where the various technologies you'll use fit into the system. Then you'll tackle the many moving pieces of a reactive application, learning to apply patterns such as CQRS, Event Sourcing, Microservices and more. Along the way, you'll learn how to build distributed domain models for reactive applications and clustered actor systems for elasticity and resilience, as well as how to integrate reactive systems with traditional architectures. You'll also pick up techniques for testing reactive applications, refactoring existing systems, and designing RESTful APIs.
…
Cover unavailable
38
DSLs in Action
Debasish Ghosh
4.6
Your success—and sanity—are closer at hand when you work at a higher level of abstraction, allowing your attention to be on the business problem rather than the details of the programming platform. Domain Specific Languages—"little languages" implemented on top of conventional programming languages—give you a way to do this because they model the domain of your business problem.
DSLs in Action introduces the concepts and definitions a developer needs to build high-quality domain specific languages. It provides a solid foundation to the usage as well as implementation aspects of a DSL, focusing on the necessity of applications speaking the language of the domain. After reading this book, a programmer will be able to design APIs that make better domain models. For experienced developers, the book addresses the intricacies of domain language design without the pain of writing parsers by hand.
The book discusses DSL usage and implementations in the real world based on a suite of JVM languages like Java, Ruby, Scala, and Groovy. It contains code snippets that implement real world DSL designs and discusses the pros and cons of each implementation.
Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.
What's Inside
Tested, real-world examples How to find the right level of abstraction Using language features to build internal DSLs Designing parser/combinator-based little languages
…
Cover unavailable
39
Eating Right for a Bad Gut
James Scala
4.6
"Straightforward recommendations for healthy eating that easy on the gut... Hopeful and helpful."--Publishers Weekly
In this completely revised and updated edition of his classic book on treating "bad gut" diseases, Dr. James Scala presents a new dietary plan that has been proven to help inflammatory bowel disease go into remission. Scala firmly believes that nutrition is preventative medicine and food is the vehicle of its practice. His drug-free food and lifestyle program offers relief from the pain and embarrassment of living with these mysterious and chronic ills while providing reassuring step-by-step guidance on:
- Developing a personal testing program to identify foods that cause, aggravate, or relieve flare-ups - Keeping a food and lifestyle diary - How food allergies affect IBD - What to do if you are lactose, alcohol, or sugar intolerant - Reducing inflammation through complex carbohydrates, proteins, dietary fiber, and the omega-3 oils found in fish and leafy vegetables - The do's and don'ts of food selection - Techniques for stress reduction and overall fitness - Vitamin and mineral supplements, and their recommended dosages - Specific cooking methods that can prevent flare-ups - Medicinal foods that bring flare-ups into remission - The role stress, anger, fear, and other emotions play - The healing power of vitamin E - IBD and children
The New Eating Right for a Bad Gut offers a solid program for health that is uniquely focused on an area of major concern to a wide segment of the population.
…
Cover unavailable
40
Reactive Web Applications: Covers Play, Akka, and Reactive Streams
Manuel Bernhardt
4.6
Summary
Reactive Web Applications teaches web developers how to benefit from the reactive application architecture and presents hands-on examples using the Play framework.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Reactive applications build on top of components that communicate asynchronously as they react to user and system events. As a result, they become scalable, responsive, and fault-tolerant. Java and Scala developers can use the Play Framework and the Akka concurrency toolkit to easily implement reactive applications without building everything from scratch.
About the Book
Reactive Web Applications teaches web developers how to benefit from the reactive application architecture and presents hands-on examples using Play, Akka, Scala, and Reactive Streams. This book starts by laying out the fundamentals required for writing functional and asynchronous applications and quickly introduces Play as a framework to handle the plumbing of your application. The book alternates between chapters that introduce reactive ideas (asynchronous programming with futures and actors, managing distributed state with CQRS) and practical examples that show you how to build these ideas into your applications.
What's Inside
Reactive application architecture Basics of Play and Akka Examples in Scala Functional and asynchronous programming
About Reader Description
For readers comfortable programming with a higher-level language such as Java or C#, and who can read Scala code. No experience with Play or Akka needed.
About the Author
Manuel Bernhardt is a passionate engineer, author, and speaker. As a consultant, he guides companies through the technological and organizational transformation to distributed computing.
Table of Contents
PART 1 GETTING STARTED WITH REACTIVE WEB APPLICATIONS Did you say reactive? Your first reactive web application Functional programming primer Quick introduction to Play PART 2 CORE CONCEPTS Futures Actors Dealing with state Responsive user interfaces PART 3 ADVANCED TOPICS Reactive Streams Deploying reactive Play applications Testing reactive web applications
…
Cover unavailable
41
Akka Concurrency
Derek Wyat
4.6
Writing truly concurrent software on the Java Virtual Machine just got a whole lot easier. The Akka Toolkit takes the sting out of coding for multiple cores, multiple processors, and even multiple machines.
Akka Concurrency will show you what it means to design and write software in the paradigm of Akka. You'll learn how to think about your software in new and exciting ways that will allow you to express your designs naturally, allowing you to focus on the business of your software more than on the concurrency of it. This book picks up where the Akka documentation leaves off, exploring the how and the why of Akka, in a way that will empower you to grow your applications to new levels of scalability, responsiveness, and performance.
…
Cover unavailable
42
Reactive Messaging Patterns with the Actor Model: Applications and Integration in Scala and Akka
Vaughn Vernon
4.6
USE THE ACTOR MODEL TO BUILD SIMPLER SYSTEMS WITH BETTER PERFORMANCE AND SCALABILITY Enterprise software development has been much more difficult and failure-prone than it needs to be. Now, veteran software engineer and author Vaughn Vernon offers an easier and more rewarding method to succeeding with Actor model. Reactive Messaging Patterns with the Actor Model shows how the reactive enterprise approach, Actor model, Scala, and Akka can help you overcome previous limits of performance and scalability, and skillfully address even the most challenging non-functional requirements. Reflecting his own cutting-edge work, Vernon shows architects and developers how to translate the longtime promises of Actor model into practical reality. First, he introduces the tenets of reactive software, and shows how the message-driven Actor model addresses all of them-making it possible to build systems that are more responsive, resilient, and elastic. Next, he presents a practical Scala bootstrap tutorial, a thorough introduction to Akka and Akka Cluster, and a full chapter on maximizing performance and scalability with Scala and Akka. Building on this foundation, you'll learn to apply enterprise application and integration patterns to establish message channels and endpoints; efficiently construct, route, and transform messages; and build robust systems that are simpler and far more successful. Coverage Includes How reactive architecture replaces complexity with simplicity throughout the core, middle, and edges The characteristics of actors and actor systems, and how Akka makes them more powerful Building systems that perform at scale on one or many computing nodes Establishing channel mechanisms, and choosing appropriate channels for each application and integration challenge Constructing messages to clearly convey a sender's intent in communicating with a receiver Implementing a Process Manager for your Domain-Driven Designs Decoupling a message's source and destination, and integrating appropriate business logic into its router Understanding the transformations a message may experience in applications and integrations Implementing persistent actors using Event Sourcing and reactive views using CQRS Find unique online training on Domain-Driven Design, Scala, Akka, and other software craftsmanship topics using the for{comprehension} website at forcomprehension.com.
…
Cover unavailable
43
Practical Apache Spark: Using the Scala API
Subhashini Chellappan and Dharanitharan Ganesan
4.6
Work with Apache Spark using Scala to deploy and set up single-node, multi-node, and high-availability clusters. This book discusses various components of Spark such as Spark Core, DataFrames, Datasets and SQL, Spark Streaming, Spark MLib, and R on Spark with the help of practical code snippets for each topic. Practical Apache Spark also covers the integration of Apache Spark with Kafka with examples. You'll follow a learn-to-do-by-yourself approach to learning - learn the concepts, practice the code snippets in Scala, and complete the assignments given to get an overall exposure. On completion, you'll have knowledge of the functional programming aspects of Scala, and hands-on expertise in various Spark components. You'll also become familiar with machine learning algorithms with real-time usage. What You Will Learn Discover the functional programming features of Scala
Understand the complete architecture of Spark and its components Integrate Apache Spark with Hive and Kafka
Use Spark SQL, DataFrames, and Datasets to process data using traditional SQL queries
Work with different machine learning concepts and libraries using Spark's MLlib packages
Who This Book Is For Developers and professionals who deal with batch and stream data processing.
…
Cover unavailable
44
Baroque: The Visual Encyclopedia of Art
The Scala Group
4.6
The definition of the Baroque age is still subject to debate among critics and historians. In one of its most commonly accepted meanings, Baroque describes some aspects of 17th-century art, with sumptuous Roma at the center, that upset the proportions and static harmony of the Renaissance already undermined by Mannerism during the previous century through the use of curves, strange movements of forms, the daring optics of illusionism, and theatricality. Bernini, Borromini, da Cortona, and Rubens were, among others, decisive examples. In addition to these theatrical expressions, the art of the 17th century also included quite different trends such as the naturalism in the works of Caravaggio, classicism in the works of the Carraccis and of Poussin, the intimacy of Vermeer and the pictorial atmospheres in the works of Rembrandt and Velazquez. The Rococo was born in France at the beginning of the 18th century, characterized by airy forms, arabesques, elegance, and luminous colors in painting as well as sculpture and architecture; instead of heroic or sacred themes, it embodied a more lighthearted glance at aristocratic life, or scenes of daily life that might be gay or frivolous. Watteau, Fragonard, Boucher, Canaletto, and Bellotto were representatives of this style in painting while, in architecture, Neumann and the magnificent Residenz in Wurzburg are particularly worthy of note.
…
Cover unavailable
45
Functional Thinking
Neal Ford
4.6
Learning the syntax of a new language is easy, but learning to think under a different paradigm is difficult. This practical guide from renowned software architect Neal Ford helps you transition from a Java-writing imperative programmer to a functional programmer, using Java, Clojure, and Scala as examples.
Rather than focus on specific language features, Functional Thinking looks at a variety of common practices in OOP languages and then shows you how to solve the same problems with a functional language. For instance, you know how to achieve code-reuse in Java via mechanisms such as inheritance and polymorphism. Code reuse is also possible in functional languages, using high-order functions, composition, and multi-methods.
Ford encourages you to value results over steps, so you can begin to think like a functional programmer. Expect your mind to be bent, but you’ll finish with a much better understanding of both the syntax and semantics of functional languages.
…
Cover unavailable
46
Scala Design Patterns: Design modular, clean, and scalable applications by applying proven design patterns in Scala, 2nd Edition
Ivan Nikolov
4.5
Cover unavailable
47
Creative Scala
Edward Horswell
4.5
Creative Scala is aimed at developers who have no prior experience in Scala. It is designed to give you a fun introduction to functional programming. We assume you have some familiarity with another programming language but little or no experience with Scala or other functional languages.
Our goal is to demonstrate the building blocks that Scala developers use to create programs in a clear, succinct, and declarative manner. Working through the exercises in the book should take a few hours, after which we hope you will have a feel of what Scala can do for your applications.
The exercises in Creative Scala are based on a functional graphics library called Doodle. Although Doodle is primarily designed to make programming fun and creative, it is based on universal concepts that apply to all well-designed software written in a functional style.
…
Cover unavailable
48
The Colmar Treasure: A Medieval Jewish Legacy
Barbara Drake Boehm
4.5
During a 19th century renovation of a confectioner's shop in the town of Colmar, France, workers chanced upon a previous hoard of medieval jewelry and coins hidden in a wall. The cache – known as the Colmar Treasure – is thought to have been concealed by a Jewish family prior to the outbreak of the Plague in 1348, when Jews across the region were tragically scapegoated and put to violent death. This exquisite volume, published to accompany an exhibition at The Met Cloisters, examines their legacy through the lens of the Colmar treasure, shedding light on what it reveals about the work, homes, worship and values of its owners.
…
Cover unavailable
49
Pergamon Museum, Berlin 66 Masterpieces (Scala's Masterpieces)
Scala Publishers
4.5
One of the world's great museums, the Pergamon Museum, lies on Berlin's Museumsinsel (Museum Island) complex, which is located between the Rivers Spree and Kupfergraben. Five museums were built on this site between 1824 and 1930 to house archaeological treasures and art collections. The last of the five to be built was the Pergamon Museum, which was designed by Alfred Messel and houses spectacular works of architectural antiquities, including collections of Assyrian, Far Eastern, Greek and Islamic art. Highlights include the Pergamon Altar, with a 394 foot frieze, the Market Gate of Miletus and the Ishtar Gate from Babylon.
…
Cover unavailable
50
Effective Akka
Jamie Alle
4.5
This book will explain how to create Akka applications using best practices based on several years of experience with Actors. The content will be general enough that it would apply to actor-based and asynchronous applications on the whole, but the examples are shown in Akka using the Scala programming interface. The ideal audience are developers who are building systems with Akka and are looking for guidance with regards to patterns and how best to write code that is correct, debuggable and understandable in production.
…
Cover unavailable
51
Practical FP in Scala: A hands-on approach
Andrew Johnso
4.5
Cover unavailable
52
Beginning Scala
David Pollak
4.5
A curious attribute of the Scala programming language is that it expends a lot of expressive power in order to make the life of casual programmers simpler. For instance, Scala provides sophisticated type parametrization and traits so that more advanced programmers can design libraries which are at the same time general and easy to use. Casual users can profit from these libraries long before they discover the full power of Scala's abstraction constructs. The language design avoids the temptation of simply defining some handy primitives in the syntax, even if these primitives would be useful many times to many users. Instead of fixed primitives, the language design tries very hard to provide general construction principles, with which users can then define their own fundamental constructs, at no loss in syntactic convenience. This idea ranges from simple things, such as being able to define your own numeric data types, to full-blown domain-specific APIs such as Scala's support for concurrent actors. There is hardly a better example of this approach than David Pollak's Lift Web Framework for Scala. It leverages the full expressive power of Scala to provide a framework that's at the same time simple to use, powerful, and secure. David has been one of the earliest adopters of Scala. He has become a crystallization point for many important developments in the Scala community. He fostered the vibrant Lift community, organized the first Scala Lift Off conference in 2008, and promoted the adoption of Scala in many important industrial applications.
…
Cover unavailable
53
Applied Akka Patterns: A Hands-On Guide to Designing Distributed Applications
Michael Nash, Wade Waldron
4.5
When it comes to big data processing, we can no longer ignore concurrency or try to add it in after the fact. Fortunately, the solution is not a new paradigm of development, but rather an old one. With this hands-on guide, Java and Scala developers will learn how to embrace concurrent and distributed applications with the open source Akka toolkit. You'll learn how to put the actor model and its associated patterns to immediate and practical use.
Throughout the book, you'll deal with an analogous workforce problem: how to schedule a group of people across a variety of projects while optimizing their time and skillsets. This example will help you understand how Akka uses actors, streams, and other tools to stitch your application together.
Model software that reflects the real world with domain-driven design Learn principles and practices for implementing individual actors Unlock the real potential of Akka with patterns for combining multiple actors Understand the consistency tradeoffs in a distributed system Use several Akka methods for isolating and dealing with failures Explore ways to build systems that support availability and scalability Tune your Akka application for performance with JVM tools and dispatchers
…
Cover unavailable
54
Scala for Machine Learning
Patrick R. Nicola
4.5
Cover unavailable
55
Reactive Design Patterns
Roland Kuhn Dr., Brian Hanafee, Jamie Allen
4.5
Modern applications present incredible design challenges: we expect near-realtime performance while managing petabyte-scale data and distribution across environments ranging from traditional servers to cloud systems to mobile devices. The Reactive Application model addresses these demands through new patterns designed to "react" effectively to user and system events, changes in load, competition for shared system resources, and unanticipated failures. Although reactive design patterns can be implemented using standard enterprise development tools, you best realize the benefits when you pair them with a functional programming language like Scala and an Actor-based concurrency system like Akka.
Reactive Design Patterns is a clearly-written guide for building event-driven distributed systems that are resilient, responsive, and scalable. Written by the authors of the Reactive Manifesto, this book teaches you to apply reactive design principles to the real problems of distributed application development. You'll discover technologies and paradigms that can be used to build reactive applications including Akka and other actor-based systems, functional programming, replication and distribution, and implementation techniques such as futures, iteratees, and reactive streams. While the book presents concrete examples in Scala, Java, JavaScript, and Erlang, the primary goal is to introduce patterns and best practices that you can use to apply reactive principles to common problems you'll face when building distributed systems.
WHAT'S INSIDE * Discover best practices and patterns for building responsive applications * Build applications that can withstand hardware or software failure at any level * Patterns for fault tolerance, scalability, and responsiveness * Maximize multicore hardware using asynchronous and event-driven solutions * Scale applications under tremendous load
Readers should be familiar with a standard programming language like Java, C++ or C# and be comfortable with the basics of distributed systems. Software engineers and architects will learn how to avoid common pitfalls and apply patterns for solving day-to-day problems in a fault-tolerant and scalable way to maximize their application's responsiveness to users and clients. Project leaders and CTOs will gain a deeper understanding of the philosophy behind resilience and scalability in distributed systems, as well as their limitations, challenges and benefits.
…
Cover unavailable
56
Scala Programming for Big Data Analytics: Get Started with Big Data Analytics Using Apache Spark
Irfan Elahi
4.5
Gain the key language concepts and programming techniques of Scala in the context of big data analytics and Apache Spark. The book begins by introducing you to Scala and establishes a firm contextual understanding of why you should learn this language, how it stands in comparison to Java, and how Scala is related to Apache Spark for big data analytics. Next, you'll set up the Scala environment ready for examining your first Scala programs. This is followed by sections on Scala fundamentals including mutable/immutable variables, the type hierarchy system, control flow expressions and code blocks. The author discusses functions at length and highlights a number of associated concepts such as functional programming and anonymous functions. The book then delves deeper into Scala's powerful collections system because many of Apache Spark's APIs bear a strong resemblance to Scala collections. Along the way you'll see the development life cycle of a Scala program. This involves compiling and building programs using the industry-standard Scala Build Tool (SBT). You'll cover guidelines related to dependency management using SBT as this is critical for building large Apache Spark applications. Scala Programming for Big Data Analytics concludes by demonstrating how you can make use of the concepts to write programs that run on the Apache Spark framework. These programs will provide distributed and parallel computing, which is critical for big data analytics. What You Will Learn See the fundamentals of Scala as a general-purpose programming language Understand functional programming and object-oriented programming constructs in Scala Use Scala collections and functions Develop, package and run Apache Spark applications for big data analytics Who This Book Is For Data scientists, data analysts and data engineers who intend to use Apache Spark for large-scale analytics.
…
Cover unavailable
57
Scala Programming Projects: Build real world projects using popular Scala frameworks like Play, Akka, and Spark
Mikael Valot and Nicolas Jorand
4.5
Scala is a type-safe JVM language that incorporates object-oriented and functional programming (OOP and FP) aspects. This book gets you started with essentials of software development by guiding you through various aspects of Scala programming, helping you bridge the gap between learning and implementing. You will learn about the unique features of Scala through diverse applications and experience simple yet powerful approaches for software development.
Scala Programming Projects will help you build a number of applications, beginning with simple projects, such as a financial independence calculator, and advancing to other projects, such as a shopping application and a Bitcoin transaction analyzer. You will be able to use various Scala features, such as its OOP and FP capabilities, and learn how to write concise, reactive, and concurrent applications in a type-safe manner. You will also learn how to use top-notch libraries such as Akka and Play and integrate Scala apps with Kafka, Spark, and Zeppelin, along with deploying applications on a cloud platform.
By the end of the book, you will not only know the ins and outs of Scala, but you will also be able to apply it to solve a variety of real-world problems
…
Cover unavailable
58
Machine Learning Systems: Designs that scale
Jeff Smith
4.5
Machine learning applications autonomously reason about data at massive scale. It's important that they remain responsive in the face of failure and changes in load. But machine learning systems are different than other applications when it comes to testing, building, deploying, and monitoring.
Reactive Machine Learning Systems teaches readers how to implement reactive design solutions in their machine learning systems to make them as reliable as a well-built web app. Using Scala and powerful frameworks such as Spark, MLlib, and Akka, they'll learn to quickly and reliably move from a single machine to a massive cluster.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
…
Cover unavailable
59
Atomic Scala
Dianne Marsh Bruce Eckel
4.5
Cover unavailable
60
Steps in Scala: An Introduction to Object-Functional Programming
Christos K. K. Loverdos
4.5
Scala is a highly expressive, concise and scalable language. It is also the most prominent method of the new and exciting methodology known as object-functional programming. In this book, the authors show how Scala grows to the needs of the programmer, whether professional or hobbyist. They teach Scala with a step-by-step approach and explain how to exploit the full power of the industry-proven JVM technology. Readers can then dive into specially chosen design challenges and implementation problems, inspired by the trials of real-world software engineering. It also helps readers to embrace the power of static typing and automatic type inference. In addition, the book shows how to use the dual-object and functional-oriented natures combined at Scala's core, and so write code that is less 'boilerplate', giving a genuine increase in productivity.
…
Cover unavailable
61
Learning Akka
Jason Goodwin
4.5
Cover unavailable
62
Actors in Scala
Philipp Haller, Frank Sommers
4.5
Cover unavailable
63
Inkscape 0.48 Illustrator's Cookbook
Mihaela Jurkovic and Rigel Di Scala
4.5
Each recipe comprises step-by-step instructions followed by an analysis of what was done in each task and other useful information. The book is designed so that you can read it chapter by chapter, or look at the list of recipes and refer to them in no particular order. It is packed with useful screenshots to make your learning even easier. This book is written for both beginners and developers who have a basic knowledge of Inkscape. With this book illustrators who have just started using Inkscape can quickly dive into the world of Inkscape and graphics editing. Software developers and web designers can learn how to create graphics for their software on their own or build SVG and other web-based interfaces. Users of other graphics editing applications can find out how Inkscape can be used as an alternative to solve common graphics problems.
…
Cover unavailable
64
SBT in Action
Josh Suereth and Matthew Farwell
4.5
Simple Build Tool: sbt. The idea of a high quality build tool for Scala is indeed simple, but sbt itself is richly-featured and powerful. Documentation for sbt is sparse, and the blogs, tutorials, and other bits scattered across the web leave you wanting a comprehensive, accurate picture of how to build Scala projects effectively and efficiently. This book will help you transform ugly, complex builds into a streamlined, automated, and repeatable process.
SBT in Action is first and foremost a tutorial about effectively building Scala projects. It introduces the sbt tool with a simple project that establishes the fundamentals of running commands and tasks. Next, it shows you how to use the peripheral libraries in sbt to make common tasks simpler. This includes an I/O library to deal with files and how to parse user input in a meaningful fashion. Finally, it covers how to deploy software effectively.
…
Cover unavailable
65
Becoming Functional
Joshua Backfield
4.5
If you have an imperative (and probably object-oriented) programming background, Becoming Functional will help you through the sometimes alien world of functional programming. Many functional programming books begin by focusing on the more difficult concepts such as recursion and immutability. This book lets you dive right in to functional programming by teaching the most useful implementation concepts first.
Once you finish a chapter, you’ll be able to take the concept you just learned and use it in their current day-to-day job. Each chapter introduces a problem and investigates ways to solve it by going from imperative pseudo-code to functional pseudo-code.
…
Cover unavailable
66
Scala High Performance Programming
Vincent Theron and Michael Diaman
4.5
Cover unavailable
67
Getting Started with Sbt for Scala
Shiti Saxena
4.5
A practical and fast-paced guide, Getting Started with SBT for Scala walks you through the setup of Scala projects in SBT with sample code for common as well as critical scenarios.Getting Started with SBT for Scala is for developers working on Scala projects who are interested in learning and utilizing Simple Build Tool to manage the build process.