Free PDF Learning Concurrent Programming in Scala, by Aleksandar Prokopec
When going to take the experience or thoughts types others, publication Learning Concurrent Programming In Scala, By Aleksandar Prokopec can be an excellent resource. It's true. You can read this Learning Concurrent Programming In Scala, By Aleksandar Prokopec as the resource that can be downloaded and install right here. The method to download and install is likewise simple. You can visit the link web page that we provide and then buy guide to make a deal. Download Learning Concurrent Programming In Scala, By Aleksandar Prokopec and you can put aside in your very own device.
Learning Concurrent Programming in Scala, by Aleksandar Prokopec
Free PDF Learning Concurrent Programming in Scala, by Aleksandar Prokopec
Learning Concurrent Programming In Scala, By Aleksandar Prokopec. Negotiating with checking out routine is no demand. Reviewing Learning Concurrent Programming In Scala, By Aleksandar Prokopec is not kind of something offered that you could take or not. It is a point that will transform your life to life much better. It is the important things that will make you many points all over the world and also this universe, in the real world and also right here after. As what will be offered by this Learning Concurrent Programming In Scala, By Aleksandar Prokopec, exactly how can you haggle with the many things that has lots of benefits for you?
Reviewing Learning Concurrent Programming In Scala, By Aleksandar Prokopec is a quite valuable interest and also doing that can be undertaken whenever. It suggests that reviewing a publication will certainly not restrict your activity, will certainly not require the time to invest over, and also won't spend much money. It is an extremely inexpensive and also obtainable point to purchase Learning Concurrent Programming In Scala, By Aleksandar Prokopec Yet, keeping that extremely economical thing, you can get something new, Learning Concurrent Programming In Scala, By Aleksandar Prokopec something that you never do as well as get in your life.
A brand-new experience could be gotten by checking out a book Learning Concurrent Programming In Scala, By Aleksandar Prokopec Even that is this Learning Concurrent Programming In Scala, By Aleksandar Prokopec or various other publication compilations. We offer this publication since you could locate more things to encourage your ability and understanding that will make you a lot better in your life. It will be also useful for individuals around you. We advise this soft documents of the book right here. To recognize how you can get this publication Learning Concurrent Programming In Scala, By Aleksandar Prokopec, learn more here.
You could discover the link that we offer in site to download and install Learning Concurrent Programming In Scala, By Aleksandar Prokopec By purchasing the inexpensive price and get finished downloading, you have actually completed to the first stage to obtain this Learning Concurrent Programming In Scala, By Aleksandar Prokopec It will certainly be absolutely nothing when having purchased this book as well as do nothing. Read it as well as expose it! Invest your couple of time to simply review some covers of web page of this book Learning Concurrent Programming In Scala, By Aleksandar Prokopec to check out. It is soft data and also very easy to review wherever you are. Enjoy your brand-new habit.
Learn the art of building intricate, modern, scalable concurrent applications using ScalaAbout This Book
- Design and implement scalable and easy-to-understand concurrent applications
- Make the most of Scala by understanding its philosophy and harnessing the power of multicores
- Get acquainted with cutting-edge technologies in the field of concurrency, with a particular emphasis on practical, real-world applications
- Step-by-step tutorial guide, which is full of pragmatic examples
Who This Book Is For
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.
What You Will Learn
- Get to grips with the fundamentals of concurrent programming on modern multiprocessor systems, with a particular focus on the JVM concurrency model
- Build high-performance concurrent systems from simple, low-level concurrency primitives
- Express asynchrony in concurrent computations with futures and promises
- Seamlessly accelerate sequential programs by using data-parallel collections
- Implement reactive and event-based programs declaratively with Rx-style event streams
- Design safe, scalable, and easy-to-comprehend in-memory transactional data models
- Transparently create distributed applications that scale across multiple machines
- Choose the correct concurrency abstraction and integrate different concurrency frameworks together in large applications
In Detail
This book will give you an insight into the best practices necessary to build concurrent programs in Scala using modern, high-level concurrency libraries. It starts by introducing you to the foundations of concurrent programming on the JVM, outlining the basics of the Java Memory Model, and then shows some of the classic building blocks of concurrency, such as the atomic variables, thread pools, and concurrent data structures, along with the caveats of traditional concurrency. It then walks you through different high-level concurrency abstractions, each tailored toward a specific class of programming tasks. Finally, the book presents an overview of when to use which concurrency library and demonstrates how they all work together.
- Sales Rank: #971288 in Books
- Published on: 2014-11-25
- Released on: 2014-11-28
- Original language: English
- Number of items: 1
- Dimensions: 9.25" h x .83" w x 7.50" l, 1.38 pounds
- Binding: Paperback
- 366 pages
About the Author
Aleksandar Prokopec
Aleksandar Prokopec is a software developer and a concurrent and distributed programming researcher. He holds an MSc in Computing from the Faculty of Electrical Engineering and Computing, University of Zagreb, Croatia, and a PhD in Computer Science from the Ecole Polytechnique Federale de Lausanne, Switzerland. As a doctoral assistant and member of the Scala team at EPFL, he actively contributed to the Scala programming language, and has worked on programming abstractions for concurrency, data-parallel programming support, and concurrent data structures for Scala. He created the Scala Parallel Collections framework, which is a library for high-level data-parallel programming in Scala, and participated in working groups for Scala concurrency libraries, such as Futures and Promises and ScalaSTM.
Most helpful customer reviews
11 of 12 people found the following review helpful.
Scala community needed this for a while
By Robert Dawson
I really enjoyed reading this book. The Scala community needed a manual such as this for a while now. Before this book, documentation on concurrent programming in Scala consisted mostly of online SIP documents, tutorials scattered across multiple websites, Stackoverflow answers and random blog posts. This results in scattered, incomplete and often convoluted information about Scala concurrency. Learning Concurrent Programming in Scala constitutes a readable and authoritative manual on using these concurrency libraries, with everything needed to get you started in one place. Although I recommend getting acquainted with sequential programming in Scala first, people who want to write concurrent programs in Scala should definitely read this book. That does not mean that the book is valuable only for Scala programmers - as someone with 11 years of industry experience in Java, I can honestly say that the concurrency novelties described in this book will be interesting to programmers coming from backgrounds different than Scala - there was much going on in the Scala world in the recent years, in which Java is still lagging behind (in fact, I was able to convince one of my colleagues at work to give Scala a try after he saw the introduction to the Rx framework in this book).
The book starts by presenting the basics of JVM threading and memory model, which serves as the basic . Although this is more low-level than the rest of the concurrency frameworks in the book, the book does a good job arguing why you need to understand basic JVM concurrency, and when to use threads, locks and monitors. Chapter 3 shows the classic concurrency abstractions, such as concurrent data structures, atomics, and thread pools, and explains lock-free programming. Chapter 4 is where the fun begins - it explains the futures and promises concurrency package, shows how to use it for asynchronous programming, how to functionally compose asynchronous computations, how to write new future combinators using promises, shows how to do proper cancellation and blocking in futures, and explains the Scala Async framework. Chapter 5 introduces parallel collections, shows how they differ from normal collections, discusses operations that can be parallelized, shows how to implement custom parallel operations, and how to evaluate performance in your programs. Chapter 6 introduces Rx, asynchronous programming framework based on first-class event streams, and shows how Rx can be used to build user interfaces and streaming applications. Chapter 7 deals with software transactional memories, discusses how STMs work, shows how to avoid side-effects in transactions, how to execute transactions conditionally, explains how transactional collections work, and, importantly, illustrates how easy it is to create a custom transactional, thread-safe collection. Chapter 8 introduces actor programming using Akka, and covers asynchronous message sends, starting and looking up actors, the basics of actor supervision, as well distributing the application across multiple computers. While Akka is not completely covered in this book, as it is a big topic, this chapter teaches the essentials of Akka, and you will be able to write actor programs after you're done. Chapter 9 shows how to achieve scalability and top performance in concurrent applications, what are the common types of errors in concurrent applications, and how to debug them, and, finally, how to combine different concurrency technologies to build a real-world application - a remote file browser. This is the longest chapter, and arguably, it could have been split into two separate chapters.
This is a hands-on book. Every concurrency concept is introduced through a minimal, self-contained example, and you are encouraged to code and try the examples yourself. In almost all places in the book, there is a snippet or a minimal example program that demonstrates or proves the preceding claim. Terms like starvation, deadlock, false sharing and rollbacks are never introduced without the corresponding example program that shows how these effects manifest themselves in practice. These programs are minimal examples, but are realistic and capture the essence of the corresponding real-world programs. I'm sure that, after having written and run the examples, the reader will have no problem recognizing the same effects in practice.
Every chapter is concluded with a list of references, and practical program assignments, which test the knowledge from the corresponding chapter, and, in some cases, touch more advanced topics.
What I especially liked about this book is that the author shows how different concurrency libraries can be used together. As an occasional by-stander in the Scala world, I've often witnessed propaganda and bias towards specific concurrency technologies. This is not the case only with Scala and its concurrency libraries, but also more broadly, with most programming technologies - proponents of specific programming technologies need to ruthlessly advertise their own frameworks to survive. As a result, they sometimes claim that their technology is the best, applicable to every problem or superior to alternatives. The author dismisses such attitude in two ways. First, he explains the underlying motivations for various concurrency primitives and shows their typical use-cases and usage scenarios. In doing so, he teaches the reader what a specific concurrency construct is most appropriate for. Second, he shows that concurrency primitives coming from different frameworks are not incompatible or mutually exclusive, but that they can and should be used together to tackle a task. For example, futures are ideal for issuing remote procedure calls or asynchronous requests, but parallel collections are more efficient for data-intensive tasks. Actors are great for distributed applications, but software transactional memory composes complex state and allows concurrent access to data. Still, the future can start a data-parallel computation or a transaction, and an Rx stream can send messages to an actor - these primitives support each other.
What I'd wish to see more of are advanced concurrency concepts - how does one write his own concurrent data structure, or implement more advanced applications. The book touches performance engineering and achieving best program speeds, and, having read about it, I'd love to learn more. Perhaps a follow-up book about more advanced concurrent programming will address this. Still, this is overall a great book, and will teach you how to think about concurrent programming. I recommend it as an introductory book on concurrent programming, and modern concurrency paradigms.
3 of 3 people found the following review helpful.
Will get you to grab your laptop and start hacking concurrent programs!
By Manohar Jonnalagedda
This book if a great resource for learning concurrent programming in Scala. Actually, it is great for learning concurrent programming in general!
The book starts out with elementary concurrency building blocks. Each subsequent chapters builds on the blocks seen before, to introduce higher level abstractions, which make it easier to write more complex concurrent programs. At the same time, you won't be lost if you are only interested in later chapters: every chapter gives you sufficient context to understand it in isolation.
I love that there are exercises that come with every chapter. They are by no means easy, but very fun and engaging. Many of them are not just programming tasks, but require you to sit down with pen and paper and think for a while. As a result the book satisfies two types of audiences:
- The seasoned Scala developer who needs to refer to a resource every once in a while
- A newbie who wants to learn about concurrent programming in general, and who is interested in building practical solutions with this knowledge. I definitely fall in this category of people, and am now completely hooked.
All in all, this book strikes a pedagogical balance between being a text book and a reference book. Studying it cover to cover (and trying to solve some of the exercises) will give you great insights about concurrent programming.
The only issue I have is with the quality (or lack thereof) of the illustrations/pictures. They have a poor scan look, they could definitely be much improved. Also, I wonder if there is going to be some sort of answer key, at least for a selected subset of the exercises.
Get your copy now!
1 of 1 people found the following review helpful.
I think the book strikes a very good balance between breadth and depth
By I. Maier
You can tell right away that this book was written by a true authority on concurrent programming in Scala. It’s written for programmers already familiar with Scala or for those with a strong background in related languages and/or the JVM. If you are one of them and are interested in getting an overview of different abstractions for concurrent programming in Scala, or more broadly on the JVM, go pick up this book!
The book is very well written and the examples are interesting. It is roughly organized going from low-level to high-level concepts, concluding with a practical example that connects the different abstractions introduced in earlier chapters. Chapter 5 is a bit different than the others as it mostly deals with parallel programming (with collections) rather than concurrent programming, although it shortly relates the two. Since the book can’t cover every single aspect of each subject on 300 pages, most chapters give helpful references to obtain a deeper understanding and background information on the subject. I think the book strikes a very good balance between breadth and depth. It covers all important abstractions and discusses them in just the right amount of detail.
My only gripe is with the book’s design and typesetting. Many figures don’t look too professional and have a rather low resolution, which is noticeable in my paper copy as well as the ebook version. For the price of the book, I’d expect a little more care. Nonetheless, the figures are helpful for the understanding of the subject.
In the end, it’s the content that matters most to me, that’s why I won’t hesitate to give it 5 stars.
See all 11 customer reviews...
Learning Concurrent Programming in Scala, by Aleksandar Prokopec PDF
Learning Concurrent Programming in Scala, by Aleksandar Prokopec EPub
Learning Concurrent Programming in Scala, by Aleksandar Prokopec Doc
Learning Concurrent Programming in Scala, by Aleksandar Prokopec iBooks
Learning Concurrent Programming in Scala, by Aleksandar Prokopec rtf
Learning Concurrent Programming in Scala, by Aleksandar Prokopec Mobipocket
Learning Concurrent Programming in Scala, by Aleksandar Prokopec Kindle
Learning Concurrent Programming in Scala, by Aleksandar Prokopec PDF
Learning Concurrent Programming in Scala, by Aleksandar Prokopec PDF
Learning Concurrent Programming in Scala, by Aleksandar Prokopec PDF
Learning Concurrent Programming in Scala, by Aleksandar Prokopec PDF
