Reactive Programming With Akka - Lessons Learned

1. Platinum Sponsor REACTIVE PROGRAMMING WITH AKKA -‐ LESSONS LEARNED -‐ Daniel Deogun & Daniel Sawano Twitter: @DanielDeogun, @DanielSawano

2. Who We Are Daniel

3. Deogun Daniel

4. Sawano Omegapoint

5. Stockholm

7. Gothenburg

9. Malmoe

11. Umea

13. New

14. York

15. Agenda - Akka

16. in

18. nutshell

19. - Akka

21. Java

23. - Akka

24. and

25. Java

27. Lambdas

28. - Domain

29. influences

30. - Lessons

31. learned

32. from

33. building

34. real

35. systems

36. with

37. Akka

38. Akka in a Nutshell http://akka.io/

39. Akka in a Nutshell Actors [1] By Dickelbers (Own work) [CC-BY-SA-3.0 (http://creativecommons.org/licenses/by-sa/3.0)], via Wikimedia Commons ! http://upload.wikimedia.org/wikipedia/commons/0/09/Sweden_postbox.JPG Messages Mailbox [1] Actor

40. System Routers

42. System Routers

44. System Routers

46. System Routers

48. System Routers

50. System Routers

51. Our definition of Legacy Code Legacy ˈle-gə-sē “: something that happened in the past or that comes from someone in the past” ! - Merriam-Webster

52. Our definition of Legacy Code Legacy ˈle-gə-sē “: something that happened in the past or that comes from someone in the past” ! - Merriam-Webster - Deogun-Sawano Legacy Code ˈle-gə-sē ˈkōd “: code that does not satisfy the characteristics of a reactive system”

53. What is Legacy Code? Characteristics

54. of

56. reactive

57. system,

58. as

59. defined

60. by

61. the

62. reactive

63. manifesto:

65. responsive

67. scalable

69. resilient

71. event-driven reactivemanifesto.org

72. Java or Scala I

73. want

74. to

75. build

76. an

77. application

78. with

79. Akka,

80. should

82. use

83. Java

84. or

85. Scala?

86. Well,

87. it

88. depends... [1] https://duke.kenai.com/wave/.Midsize/Wave.png.png! [2] http://www.scala-lang.org/ [1] [2]

89. Java or Scala Assume

90. we

91. want

92. to

93. build

95. machine

97. to

98. solve

100. problem

101. P

102. where,

103. • Efficiency

104. is

105. imperative

107. • Sequential

108. computations

109. shall

110. be

111. independent

112. • Implementation

113. of

114. M

115. shall

116. be

117. platform

118. independent

119. • Complexity

120. and

121. boilerplate

122. code

123. shall

124. be

125. reduced

126. • M’s

127. behavior

128. shall

129. be

130. verifiable

131. • Time

132. to

133. Market

134. is

135. essential

136. and

137. risks

138. minimized

139. Java or Scala Pros Cons Assume

140. we

141. want

142. to

143. build

144. a

145. machine

146. M

147. to

148. solve

149. a

157. problem

158. P

159. where,

161. Efficiency

162. is

163. imperative

165. Sequential

166. computations

167. shall

168. be

169. independent

171. Implementation

172. of

173. M

174. shall

175. be

176. platform

177. independent

179. Complexity

180. and

181. boilerplate

182. code

183. shall

184. be

185. reduced

187. M’s

188. behavior

189. shall

190. be

191. verifiable

193. Time

194. to

195. Market

196. is

197. essential

198. and

199. risks

200. shall

201. be

202. minimized Scoreboard

203. Java:

204. Scala:

207. we

208. want

209. to

210. build

211. a

212. machine

213. M

214. to

215. solve

216. a

224. problem

225. P

226. where,

228. Efficiency

229. is

230. imperative

232. Sequential

233. computations

234. shall

235. be

236. independent

238. Implementation

239. of

240. M

241. shall

242. be

243. platform

244. independent

246. Complexity

247. and

248. boilerplate

249. code

250. shall

251. be

252. reduced

254. M’s

255. behavior

256. shall

257. be

258. verifiable

260. Time

261. to

262. Market

263. is

264. essential

265. and

266. risks

267. shall

268. be

270. Java:

271. Scala:

272. X I I

274. we

275. want

276. to

277. build

278. a

279. machine

280. M

281. to

282. solve

283. a

291. problem

292. P

293. where,

295. Efficiency

296. is

297. imperative

299. Sequential

300. computations

301. shall

302. be

303. independent

305. Implementation

306. of

307. M

308. shall

309. be

310. platform

311. independent

313. Complexity

314. and

315. boilerplate

316. code

317. shall

318. be

319. reduced

321. M’s

322. behavior

323. shall

324. be

325. verifiable

327. Time

328. to

329. Market

330. is

331. essential

332. and

333. risks

334. shall

335. be

337. Java:

338. Scala:

339. X I I X I I

341. we

342. want

343. to

344. build

345. a

346. machine

347. M

348. to

349. solve

350. a

358. problem

359. P

360. where,

362. Efficiency

363. is

364. imperative

366. Sequential

367. computations

368. shall

369. be

370. independent

372. Implementation

373. of

374. M

375. shall

376. be

377. platform

378. independent

380. Complexity

381. and

382. boilerplate

383. code

384. shall

385. be

386. reduced

388. M’s

389. behavior

390. shall

391. be

392. verifiable

394. Time

395. to

396. Market

397. is

398. essential

399. and

400. risks

401. shall

402. be

404. Java:

405. Scala:

406. X I I X I I X I I

408. we

409. want

410. to

411. build

412. a

413. machine

414. M

415. to

416. solve

417. a

425. problem

426. P

427. where,

429. Efficiency

430. is

431. imperative

433. Sequential

434. computations

435. shall

436. be

437. independent

439. Implementation

440. of

441. M

442. shall

443. be

444. platform

445. independent

447. Complexity

448. and

449. boilerplate

450. code

451. shall

452. be

453. reduced

455. M’s

456. behavior

457. shall

458. be

459. verifiable

461. Time

462. to

463. Market

464. is

465. essential

466. and

467. risks

468. shall

469. be

471. Java:

472. Scala:

473. X I I X I I X I I X I

475. we

476. want

477. to

478. build

479. a

480. machine

481. M

482. to

483. solve

484. a

492. problem

493. P

494. where,

496. Efficiency

497. is

498. imperative

500. Sequential

501. computations

502. shall

503. be

504. independent

506. Implementation

507. of

508. M

509. shall

510. be

511. platform

512. independent

514. Complexity

515. and

516. boilerplate

517. code

518. shall

519. be

520. reduced

522. M’s

523. behavior

524. shall

525. be

526. verifiable

528. Time

529. to

530. Market

531. is

532. essential

533. and

534. risks

535. shall

536. be

538. Java:

539. Scala:

540. X I I X I I X I I X I I X

542. we

543. want

544. to

545. build

546. a

547. machine

548. M

549. to

550. solve

551. a

559. problem

560. P

561. where,

563. Efficiency

564. is

565. imperative

567. Sequential

568. computations

569. shall

570. be

571. independent

573. Implementation

574. of

575. M

576. shall

577. be

578. platform

579. independent

581. Complexity

582. and

583. boilerplate

584. code

585. shall

586. be

587. reduced

589. M’s

590. behavior

591. shall

592. be

593. verifiable

595. Time

596. to

597. Market

598. is

599. essential

600. and

601. risks

602. shall

603. be

605. Java:

606. Scala:

607. X I I X I I X I I X I I X X

608. Java or Scala Conclusion •Both

609. Java

610. and

611. Scala

612. works

613. well

614. with

615. Akka

616. ! •Choose

617. the

618. language

619. that

620. makes

621. most

622. sense

623. ! •Don’t

624. add

625. unnecessary

626. risk

627. Scoreboard

628. Java:

629. Scala:

630. I I I I I I I I

631. Akka All or nothing? Elastic Distributed Decentralized Resilient Akka Supervision Modularization Integration Parallelism Abstraction

632. level

634. level

636. level

638. level

640. level

642. level

643. Domain Specific Requirements • Akka

644. is

645. more

646. or

647. less

648. a

649. perfect

650. match

651. for

652. all

653. parallelizable

654. domains

656. ! • But

657. what

658. about

659. • reactive

660. domains

661. with

662. blocking

663. parts?

665. • legacy

666. domains

667. with

668. reactive

669. parts? [1] By Renesis (Own work) [CC-BY-SA-2.5 (http://creativecommons.org/licenses/by-sa/2.5)], via Wikimedia Commons. http://upload.wikimedia.org/wikipedia/commons/1/19/Stop2.png [1]

670. Blocking in a Reactive Environment • If

671. we

672. choose

673. Akka,

674. we

675. need

676. to

677. block

678. actors,

679. yuck!

681. ! ! ! • The

682. main

683. advantage

684. is

685. that

686. we

687. can

688. reuse

689. actors

690. from

691. parallelizable

692. parts

693. but

694. are

695. there

696. any

697. downsides?

698. ! • The

699. other

700. option

701. is

702. to

703. use

704. legacy

705. design oh

706. no

708. I’m

709. blocked but

710. I’m

711. still

713. pretty

714. Reactive in a Legacy Environment? Blocking Blocking Blocking Blocking A B C D Is

715. it

716. possible

717. to

718. replace

719. D

720. by

721. a

722. component

723. implemented

724. with

725. Akka?

726. Debugger Friend or Foe? We

727. often

728. get

729. the

730. question:

731. !

732. “The

733. asynchrony

734. in

735. Akka

736. makes

737. it

738. very

739. hard

740. to

750. use

751. the

752. debugger,

753. Am

754. I

755. doing

756. it

757. wrong?”

758. debugger in Legacy Design Legacy

759. Design Object

760. A Object

761. B Object

762. N

764. Design Object

765. A Object

766. B

768. Design Object

769. A Object

770. B Object

771. N Place

772. a

773. break

774. point

775. in

776. N

777. to

778. find

779. out

781. -

782. Which

783. value

784. caused

785. the

786. crash?

788. -

789. Who

790. created

791. it?

792. debugger in Reactive Design Reactive

793. design Break

794. point

795. in

796. actor

797. N

798. Supervision We’re

799. reactive

800. Supervision oh

801. no

803. I’m

804. blocked but

805. I’m

806. still

808. pretty We’re

809. reactive

810. Supervision Asynchronous

811. Supervision Asynchronous Failure

812. Supervision Synchronous Blocking

813. call

815. call

817. call Send

818. failure

820. call Send

821. failure

822. Supervision ! private ActorRef targetActor;! private ActorRef caller;! private Timeout timeout;! private Cancellable timeoutMessage;! ! @Override! public SupervisorStrategy supervisorStrategy() {! return new OneForOneStrategy(0, Duration.Zero(), new FunctionThrowable, SupervisorStrategy.Directive() {! public SupervisorStrategy.Directive apply(Throwable cause) {! caller.tell(new Failure(cause), self());! return SupervisorStrategy.stop();! }! });! }! ! @Override! public void onReceive(final Object message) throws Exception {! if (message instanceof AskParam) {! AskParam askParam = (AskParam) message;! timeout = askParam.timeout;! caller = sender();! targetActor = context().actorOf(askParam.props);! context().watch(targetActor);! targetActor.forward(askParam.message, context());! final Scheduler scheduler = context().system().scheduler();! timeoutMessage = scheduler.scheduleOnce(askParam.timeout.duration(), self(), new AskTimeout(), context().dispatcher(), null);! }! else if (message instanceof Terminated) {! sendFailureToCaller(new ActorKilledException(Target actor terminated.));! timeoutMessage.cancel();! context().stop(self());! }! else if (message instanceof AskTimeout) {! sendFailureToCaller(new TimeoutException(Target actor timed out after + timeout.toString()));! context().stop(self());! }! else {! unhandled(message);! }! }! ! private void sendFailureToCaller(final Throwable t) {! caller.tell(new Failure(t), self());! }

823. Supervision -Write

824. legacy

825. code

826. -Use

827. Akka

828. actors

829. Supervision -Write

830. legacy

831. code

832. -Use

833. Akka

834. actors Sequential

835. does

836. not

837. imply

838. synchronicity

839. Changing mindset Sequential

840. does

841. not

842. imply

844. synchronicity

846. does

847. not

848. imply

850. synchronicity

852. does

853. not

854. imply

856. synchronicity

858. does

859. not

860. imply

862. synchronicity

863. Loose Coupling? Messages

864. The Shared Mutable State Trap Keeping

865. state

866. between

867. messages

868. in

869. an

870. actor

871. is

872. extremely

873. dangerous

874. because

875. it

876. may

877. cause

878. a

879. shared

880. mutable

881. state

882. ! ! !

883. The Shared Mutable State Trap Actor Properties

884. -

885. One

886. message

887. queue

888. -

889. Only

890. one

891. message

892. is

893. processed

894. at

895. a

896. time

897. -

898. Messages

899. are

900. processed

901. in

902. order

903. received

904. -

905. An

906. actor

907. may

908. choose

909. to

910. divide

911. and

912. conquer

913. a

914. task

915. by

916. calling

917. other

918. actors

919. The Shared Mutable State Trap Router Actors

920. may

921. be

922. grouped

923. in

924. a

925. router Properties

926. -

927. Messages

928. are

929. distributed

930. among

931. actors

932. according

933. to

934. some

935. message

936. delivery

937. scheme,

938. eg

939. Round

940. Robin

941. or

942. Smallest

943. Mailbox

944. ! -

945. A

946. router

947. may

948. receive

949. a

950. lot

951. of

952. messages

953. The Shared Mutable State Trap -

954. A

955. stateful

956. actor

957. is

958. part

959. of

960. a

961. router

962. ! -

963. It

964. uses

965. divide

966. and

967. conquer

968. to

969. solve

970. its

971. task Actor

972. with

973. state Scenario

974. The Shared Mutable State Trap Actor

975. with

976. state -

977. Each

978. message

979. recived

980. from

981. the

983. router

984. resets

985. the

986. state

987. ! -

988. New

989. messages

990. are

991. inter

992. mixed

993. with

994. child

995. responses

997. ! -

998. Hence,

999. we

1000. have

1001. a

1002. shared

1003. mutable

1004. state

1005. Scenario

1006. The Shared Mutable State Trap Solution

1007. -

1008. Each

1009. request

1010. sent

1011. by

1012. the

1013. router

1014. results

1015. in

1016. a

1017. “Gather”

1018. actor

1019. ! -

1020. The

1021. Gather

1022. actor

1023. is

1024. responsible

1025. for

1026. collecting

1027. the

1028. result

1030. ! -

1031. A

1032. Gather

1033. actor

1034. is

1035. NEVER

1036. reused Gather

1037. actor result

1038. Key Take-Aways -

1039. It’s

1040. very

1041. easy

1042. to

1043. accidentally

1044. fall

1045. back

1046. to

1047. sequential

1048. “thinking”

1049. with

1050. state

1051. ! -

1052. Often

1053. one

1054. does

1055. not

1056. realize

1057. this

1058. until

1059. the

1060. system

1061. is

1062. placed

1063. under

1064. heavy

1065. load

1066. ! -

1067. Try

1068. to

1069. avoid

1070. state!

1071. Readability By

1072. Various.

1073. Edited

1074. by:

1075. W

1076. H

1077. Maw

1078. and

1079. J

1080. Dredge

1081. (Abandoned

1082. library

1083. clearance.

1084. Self

1085. photographed.)

1086. [Public

1087. domain],

1088. via

1089. Wikimedia

1090. Commons

1091. Implications of untyped actors ! Akka

1092. actors

1093. are

1094. untyped

1095. -

1096. by

1097. design ! ! public void onReceive(Object message)

1098. Implications of untyped actors ! Akka

1099. actors

1100. are

1101. untyped

1102. -

1103. by

1104. design - Readability

1105. - No

1106. support

1107. from

1108. compiler/IDE ! ! public void onReceive(Object message)

1109. Message Handling V 1.0 ! ! @Override! public void onReceive(Object message) {! if (message instanceof SomeMessage) {! doStuff();! }! else {! unhandled(message);! }! }!

1110. V 1.0 - If-else contd. ! ! @Override! public void onReceive(Object message) {! if (message instanceof SomeMessage) {! doStuff();! }! else if (message instanceof SomeOtherMessage) {! doSomeOtherStuff();! }! else {! unhandled(message);! }! }!

1111. V 1.0 - If-else mess ! ! @Override! public void onReceive(Object message) {! if (message instanceof SomeMessage) {! doStuff();! }! else if (message instanceof SomeOtherMessage) {! doSomeOtherStuff();! }! else if (message instanceof YetAnotherMessage) {! doEvenMoreStuff();! }! else {! unhandled(message);! }! }!

1112. Evolution of message handling ! ! ! ! @Override! public void onReceive(Object message) {! ...! }! ! http://upload.wikimedia.org/wikipedia/commons/thumb/6/69/Human_evolution.svg/2000px-Human_evolution.svg.png

1113. V 2.0 - Overloading ! public void onMessage(SomeMessage message) {...}! ! public void onMessage(SomeOtherMessage message) {...}

1114. V 2.0 - Overloading ! public void onMessage(SomeMessage message) {...}! ! public void onMessage(SomeOtherMessage message) {...} ! @Override! public void onReceive(Object message) {! ...!! methods.get(message.getClass()).invoke(this, message);!! ...! }!

1115. V 2.1 - Annotations ! ! class Worker extends BaseActor {! ! @Response! public void onMessage(SomeMessage message) {...}! ! ! public void onMessage(SomeOtherMessage message) {...}! }

1116. V 3.0 - Contract ! ! ! interface Messages { ! ! void doSomething(SomeMessage message);! ! void doSomethingElse(SomeOtherMessage message);! ! }! ! ! !

1117. V 3.0 - Contract ! ! ! interface Messages { ! ! void doSomething(SomeMessage message);! ! void doSomethingElse(SomeOtherMessage message);! ! }! ! ! ! ! SomeActor extends BaseActor implements Messages {...}!

1118. V 3.0 - Contract ! ! class Worker extends BaseActor implements Messages {! ! ! public void handleResponse(SomeMessage message) {...}! ! ! public void handleRequest(SomeOtherMessage message) {...}! ! }

1119. V 3.0 - Contract ! ! BaseActor extends UntypedActor {! ! @Override! ! public void preStart() {! methodDelegate = new MethodDelegate(this);! }! ! @Override ! public void onReceive(Object message) {! if (methodDelegate.onReceive(message)) {! return;! }! unhandled(message);! }! }!

1120. Before ! class Worker extends BaseActor implements Messages {! @Override! public void onReceive(Object message) {! if (message instanceof SomeMessage) {! doStuff();! }! else if (message instanceof SomeOtherMessage) {! doSomeOtherStuff();! }! else if (message instanceof YetAnotherMessage) {! doEvenMoreStuff();! }! else {! unhandled(message);! }!

1121. After ! ! class Worker extends BaseActor implements Messages { ! ! public void handleResponse(SomeMessage message) {! doStuff();! }! ! public void handleRequest(SomeOtherMessage message) {! doSomeOtherStuff();! }! ! public void process(YetAnotherMessage message) {! doEvenMoreStuff();! }! }!

1122. Akka Java 8 Lambdas - Duke: https://duke.kenai.com/thumbsup/DukeWithHelmet.png! - Lambda: http://en.wikipedia.org/wiki/Lambda_calculus

1123. Warning http://doc.akka.io/docs/akka/2.3.3/java/lambda-actors.html

1124. The Receive Builder ! ! public class MyActor extends AbstractActor {! public MyActor() {! receive(ReceiveBuilder.! match(SomeMessage.class, m - {! doStuff();! }).! match(SomeOtherMessage.class, m - {! doSomeOtherStuff();! }).! match(YetAnotherMessage.class, m - {! yetSomeMoreStuff();! }).! matchAny(this::unhandled).! build());! }! }!

1125. A Quick Note On Performance - The

1126. partial

1127. functions

1128. created

1129. by

1130. the

1131. ReceiveBuilder

1132. consist

1133. of

1134. multiple

1135. lambda

1136. expressions

1137. for

1138. every

1139. match

1140. statement

1141. which

1142. may

1143. be

1144. hard

1145. for

1146. the

1147. JVM

1148. to

1149. optimize

1150. ! - The

1151. resulting

1152. code

1153. may

1154. not

1155. be

1156. as

1157. performant

1158. as

1159. the

1160. corresponding

1161. untyped

1162. actor

1163. version

1165. Conclusions - Contracts

1166. to

1167. explicitly

1168. define

1169. behavior

1170. works

1171. pretty

1172. well

1173. - Can

1174. be

1175. a

1176. useful

1177. tool

1178. in

1179. your

1180. toolbox

1181. - Java

1182. 8

1183. and

1184. lambdas

1185. provides

1186. additional

1187. approaches

1188. - Scala

1189. can

1190. give

1191. similar

1192. support

1193. via

1194. traits

1196. match

1197. Testing Akka Code Interact

1198. by

1199. sending

1200. messages BDD

1201. Scenarios Integration

1202. tests

1203. Scenarios Case

1204. A1:

1205. Sort

1206. any

1207. sequence

1208. of

1209. numbers

1210. in

1211. increasing

1212. order

1214. ! ! Given

1215. a

1216. sequence

1217. of

1218. numbers

1219. in

1220. decreasing

1221. order

1222. ! When

1223. applying

1224. the

1225. sort

1226. algorithm

1227. ! Then

1228. the

1229. resulting

1230. sequence

1231. of

1232. numbers

1233. is

1234. in

1235. increasing

1236. order

1237. The Test ! ! ! ! @Test! public void caseA1() {! ! given(sequence(9,8,7,6,5,4,3,2,1,0));! ! whenSorting();! ! thenResultIs(sequence(0,1,2,3,4,5,6,7,8,9));! ! }!

1238. Key Take-Aways - It’s

1239. possible

1240. to

1241. use

1242. Akka

1243. in

1244. legacy

1245. code

1246. - Akka

1247. is

1248. Scala

1250. Java

1251. compliant

1252. - Akka

1253. is

1254. a

1255. toolkit

1256. with

1257. a

1258. lot

1259. of

1260. goodies

1261. - Stop

1262. writing

1263. legacy

1264. code

1265. Thank

1266. you @DanielDeogun

1268. @DanielSawano

Reactive Programming With Akka - Lessons Learned

More Related Content

What's hot (17)

Viewers also liked (20)

Similar to Reactive Programming With Akka - Lessons Learned (20)

More from Daniel Sawano (13)

Recently uploaded (20)

Reactive Programming With Akka - Lessons Learned