Instant Download Akka in Action, Second Edition (MEAP V10) Francisco Lopez-Sancho Abraham PDF All Chapter
Instant Download Akka in Action, Second Edition (MEAP V10) Francisco Lopez-Sancho Abraham PDF All Chapter
Instant Download Akka in Action, Second Edition (MEAP V10) Francisco Lopez-Sancho Abraham PDF All Chapter
com
OR CLICK BUTTON
DOWLOAD NOW
More products digital (pdf, epub, mobi) instant
download maybe you interests ...
https://ebookmeta.com/product/bayesian-optimization-in-action-
meap-v10-quan-nguyen/
https://ebookmeta.com/product/cloud-observability-in-action-
meap-v10-michael-hausenblas/
https://ebookmeta.com/product/f-in-action-meap-v05-isaac-abraham/
https://ebookmeta.com/product/asp-net-core-in-action-second-
edition-andrew-lock/
Kotlin in Action, Second Edition (MEAP V09) Svetlana
Isakova
https://ebookmeta.com/product/kotlin-in-action-second-edition-
meap-v09-svetlana-isakova/
https://ebookmeta.com/product/go-in-action-second-edition-
meap-v03-andrew-walker/
https://ebookmeta.com/product/spring-security-in-action-second-
edition-meap-spilca-laurentiu/
https://ebookmeta.com/product/elasticsearch-in-action-second-
edition-meap-v13-madhusudhan-konda/
https://ebookmeta.com/product/net-in-action-second-edition-
meap-v06-dustin-metzgar/
Akka in Action, Second Edition MEAP V10
1. Copyright_2022_Manning_Publications
2. welcome
3. 1_Introducing_Akka
4. 2_Up_and_running
5. 3_One_actor_is_no_actor
6. 4_Akka_test_kit
7. 5_Fault_tolerance
8. 6_Discovery_and_routing
9. 7_Configuration
10. 8_Clustering
11. 9_Sharding_and_persistence
12. 10_Streams,_persistence_query_and_projections
13. 11_Akka_Ports
14. 12_Akka_betting_house
15. 13_Clustering_II
16. Appendix_A._Setting_up
17. Appendix_B._Akka_Microservices
MEAP Edition
Akka in Action
Second Edition
Version 10
https://livebook.manning.com/#!/book/akka-in-action-second-
edition/discussion
This book is aimed primarily at two audiences. For those of you who find the
Actor Model topic attractive, but have no specific knowledge. In this edition,
you'll find a simple introduction to Akka, the most commonly used
implementation of the Actor Model. Conversely, as a consultant for
Lightbend, I’ve seen experienced clients encounter common difficulties,
often due to a lack of knowledge of some key tools. Whether you're new to
this or have some experience, you'll find the basics and the most important
tools here.
To get the most out of this book, you need basic knowledge of Git to follow
the exercises, experience with some testing frameworks like Junit or
Scalatest, and some experience as a Java or Scala developer. The examples
are written in Scala, but even if you are not familiar with Scala, the similarity
to Java is enough to understand how the code works and what concepts are
important. Some knowledge of Docker and Kubernetes is beneficial for some
advanced examples. However, they are not absolutely necessary.
After reading this book and understanding the examples, you can consider
yourself a productive professional. There are probably more concepts and
tools you'll want to learn, but the ones taught here are enough to contribute to
a professional project. You'll understand how an entire application works and
how the code you write can be deployed in production.
Your feedback is of great value to me. I encourage you to post your questions
or comments about the content in the liveBook Discussion forum. I will
respond to them quickly.
I am still working on the content and more chapters will appear about every 2
weeks.
Many Thanks,
—Francisco Lopez-Sancho
In this book
Up until the middle of the ’90s, just before the internet revolution, it was
completely normal to build applications that would only ever run on a single
computer, a single CPU. If an application wasn’t fast enough, the standard
response would be to wait for a while for CPUs to get faster; no need to
change any code. Problem solved. Programmers around the world were
having a free lunch, and life was good.
In 2005 Herb Sutter wrote in Dr. Dobb’s Journal about the need for a
fundamental change (http://www.gotw.ca/publications/concurrency-ddj.htm).
In short: a limit to increasing CPU clock speeds has been reached, and the
free lunch is over.
Let’s see what changed since then! Fast-forward to today, and you find
applications running on large numbers of servers in the cloud, integrating
many systems across many data centers. The ever-increasing demands of end
users push the requirements of performance and stability of the systems that
you build.
But that doesn’t mean that you can afford to throw any number of resources
at any problem. In the end, everything is about cost and efficiency. So it’s all
about effectively scaling applications, or in other words, getting bang for
your buck. Just as you’d never use a sorting algorithm with exponential time
complexity, it makes sense to think about the cost of scaling.
Both the number and complexity of resources contribute to the total cost of
scaling.
One doomsday scenario is where you’d need to pay increasingly more for
more underutilized resources. Another nightmare scenario is where the
complexity of the application shoots through the roof when more resources
are added.
This leads to two goals: complexity has to stay as low as possible, and
resources must be used efficiently while you scale the application.
Can you use the common tools of today (threads or fibers and RPC) to satisfy
these two goals? Scaling out with RPC and scaling up with low-level
threading aren’t good ideas. RPC pretends that a call over the network is no
different from a local method call. Every RPC call when is synchronous
needs to block the current thread and wait for a response from the network
for the local method call abstraction to work, which can be costly. This
impedes the goal of using resources efficiently. When RPC is asynchronous
then you are forced to pass a callback and that adds complexity. You may end
up on the infamous callback hell.
Another problem with this approach is that you need to know exactly where
you scale up or scale out. Multithreaded programming and RPC-based
network programming are like apples and pears: they run in different
contexts, using different semantics and running on different levels of
abstraction. You end up hardcoding which parts of your application are using
threads for scaling up and which parts are using RPC for scaling out.
Spinning up thousands of servers is simple today, but as you’ll see in this first
chapter, the same can’t be said for programming them.
Briefly, actors are a lot like message queues without the configuration and
message broker installation overhead. They’re like programmable message
queues shrunk to micro size—you can easily create thousands, even millions
of them. They don’t “do” anything unless they’re sent a message.
Messages are simple data structures that can’t be changed after they’ve been
created, or in a single word, they’re immutable.
Actors can receive messages one at a time and execute some behavior
whenever a message is received. Unlike queues, they can also send messages
(to other actors).
If one node can bring down all other nodes, that’s a waste of resources. So
you need isolation of errors (resilience) to avoid losing all your work.
Systems need to be elastic: If there’s less demand, you want to use fewer
resources. If there’s more demand, use more resources, but never more than
required.
Complexity is a big part of cost, so if you can’t easily test it, change it, or
program it, you’ve got a big problem.
You’ll then look at how the actor programming model simplifies the
application, and how Akka makes it possible to write the application once
and scale it to any demand (thereby handling concurrency issues on any scale
needed). Table 1.1 highlights the differences between the two approaches.
Some of the items will become clear in the next sections, but it’s good to
keep this overview in mind.
— Minä… minä…
— Mais, ma chère…
— Mihin?
— Siihen, että me molemmat, te ja minä, emme olekaan
maailman viisaimpia ihmisiä, vaan että on olemassa muita vielä
meitäkin viisaampia.
VI.
— Seis, odota vielä. Hän on tosin akka, mutta sitä parempi vain
sinulle. Surkuteltava akka, oikeastaan hän ei ole naisen rakkauden
arvoinen. Mutta häntä tulee rakastaa juuri hänen avuttomuutensa
vuoksi, ja rakasta sinäkin häntä sen vuoksi! Ymmärräthän minua?
Ymmärräthän?
— Vaikka oletkin viisas, niin nyt sinä erehdyt. Vaikka onkin totta,
että olen päättänyt välttämättä naittaa sinut, niin se ei kuitenkaan
tapahdu mistään erikoisesta välttämättömyydestä, vaan ainoastaan
siksi, että minä olen sen niin päättänyt ja päättänyt naittaa sinut
juuri Stepan Trofimovitšille eikä kenellekään muulle. Jollei Stepan
Trofimovitšia olisi olemassa, minun mieleenikään ei olisi juolahtanut
naittaa sinua, vaikka oletkin jo kahdenkymmenen vanha… No?
— Ei, ei hän ole puhunut eikä hän vielä tiedä koko asiasta mitään,
mutta… tuossa tuokiossa hän alkaa siitä puhua!
Samassa silmänräpäyksessä hän hypähti seisoalleen ja heitti ylleen
mustan hartialiinan. Daša punastui taas hieman ja katsahti kysyvästi
häneen. Varvara Petrovna käännähti äkkiä vihasta tulipunaisena
hänen puoleensa:
VII.
— Oui, j'ai pris un mot pour un autre… Mais… c'est égal [Tulin
käyttäneeksi väärää sanaa… Mutta sehän on samantekevää…], — ja
Stepan Trofimovitš katsahti Varvara Petrovnaan tuntien olevansa
auttamattomasti hukassa.
VIII.
Toisen synnit.
I.
Oli kulunut viikko, eikä hän vieläkään tietänyt varmasti, oliko hän
sulhanen vai ei, eikä saanut siitä varmuutta, vaikka kuinka olisi
yrittänyt. Morsiantaan hän ei ollut vielä tavannut, ei edes tietänyt,
oliko Darja hänen morsiamensa. Ei hän tietänyt sitäkään, oliko tätä
kaikkea edes otettava oikein vakavalta kannalta! Jostakin syystä
Varvara Petrovna ei tahtonut häntä ottaa vastaan millään ehdolla.
Erääseen hänen ensimmäisistä kirjeistään (hän oli kiellosta
huolimatta kirjoittanut niitä joukoittain) Varvara Petrovna oli
vastannut, että hän ei tahtonut olla hänen kanssaan minkäänlaisissa
tekemisissä, sillä hänellä oli kiireitä, mutta sanoi kyllä itselläänkin
olevan hänelle tärkeätä sanomista ja odotti vain itsekin sopivaa
hetkeä sekä lupasi ajan tullen itse ilmoittaa, milloin hänen sopisi
ottaa vastaan. Kirjeet hän uhkasi lähettää avaamattomina takaisin,
sillä kaikki sellainen oli hänestä "vain pelkkää vallattomuutta".
Tämän kirjelappusen luin minäkin, Stepan Trofimovitš itse näytti sen
minulle.