Akka Made Our Day

1. Akka Made Our Day ! JFokus 2014 Daniel Deogun & Daniel Sawano Email: Daniel.deogun@Omegapoint.se, Daniel.Sawano@Omegapoint.se 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. - Domain

24. influences

25. - Lessons

26. learned

27. from

28. building

29. real

30. systems

31. with

32. Akka

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

34. 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

35. System Routers

37. System Routers

39. System Routers

41. System Routers

43. System Routers

45. System Routers

46. 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

47. 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”

48. What is Legacy Code? Characteristics

49. of

51. reactive

52. system,

53. as

54. defined

55. by

56. the

57. reactive

58. manifesto:

60. responsive

62. scalable

64. resilient

66. event-driven reactivemanifesto.org

67. Java or Scala I

68. want

69. to

70. build

71. an

72. application

73. with

74. Akka,

75. should

77. use

78. Java

79. or

80. Scala?

81. Well,

82. it

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

84. Java or Scala Assume

85. we

86. want

87. to

88. build

90. machine

92. to

93. solve

95. problem

97. where,

98. • Efficiency

99. is

100. imperative

102. • Sequential

103. computations

104. shall

105. be

106. independent

107. • Implementation

108. of

109. M

110. shall

111. be

112. platform

113. independent

114. • Complexity

115. and

116. boilerplate

117. code

118. shall

119. be

120. reduced

121. • M’s

122. behavior

123. shall

124. be

125. verifiable

126. • Time

127. to

128. Market

129. is

130. essential

131. and

132. risks

133. minimized

134. Java or Scala Pros Cons Assume

135. we

136. want

137. to

138. build

139. a

140. machine

141. M

142. to

143. solve

144. a

152. problem

153. P

154. where,

156. Efficiency

157. is

158. imperative

160. Sequential

161. computations

162. shall

163. be

164. independent

166. Implementation

167. of

168. M

169. shall

170. be

171. platform

172. independent

174. Complexity

175. and

176. boilerplate

177. code

178. shall

179. be

180. reduced

182. M’s

183. behavior

184. shall

185. be

186. verifiable

188. Time

189. to

190. Market

191. is

192. essential

193. and

194. risks

195. shall

196. be

197. minimized Scoreboard

198. Java:

199. Scala:

202. we

203. want

204. to

205. build

206. a

207. machine

208. M

209. to

210. solve

211. a

219. problem

220. P

221. where,

223. Efficiency

224. is

225. imperative

227. Sequential

228. computations

229. shall

230. be

231. independent

233. Implementation

234. of

235. M

236. shall

237. be

238. platform

239. independent

241. Complexity

242. and

243. boilerplate

244. code

245. shall

246. be

247. reduced

249. M’s

250. behavior

251. shall

252. be

253. verifiable

255. Time

256. to

257. Market

258. is

259. essential

260. and

261. risks

262. shall

263. be

265. Java:

266. Scala:

267. X I I

269. we

270. want

271. to

272. build

273. a

274. machine

275. M

276. to

277. solve

278. a

286. problem

287. P

288. where,

290. Efficiency

291. is

292. imperative

294. Sequential

295. computations

296. shall

297. be

298. independent

300. Implementation

301. of

302. M

303. shall

304. be

305. platform

306. independent

308. Complexity

309. and

310. boilerplate

311. code

312. shall

313. be

314. reduced

316. M’s

317. behavior

318. shall

319. be

320. verifiable

322. Time

323. to

324. Market

325. is

326. essential

327. and

328. risks

329. shall

330. be

332. Java:

333. Scala:

334. X I I X I I

336. we

337. want

338. to

339. build

340. a

341. machine

342. M

343. to

344. solve

345. a

353. problem

354. P

355. where,

357. Efficiency

358. is

359. imperative

361. Sequential

362. computations

363. shall

364. be

365. independent

367. Implementation

368. of

369. M

370. shall

371. be

372. platform

373. independent

375. Complexity

376. and

377. boilerplate

378. code

379. shall

380. be

381. reduced

383. M’s

384. behavior

385. shall

386. be

387. verifiable

389. Time

390. to

391. Market

392. is

393. essential

394. and

395. risks

396. shall

397. be

399. Java:

400. Scala:

401. X I I X I I X I I

403. we

404. want

405. to

406. build

407. a

408. machine

409. M

410. to

411. solve

412. a

420. problem

421. P

422. where,

424. Efficiency

425. is

426. imperative

428. Sequential

429. computations

430. shall

431. be

432. independent

434. Implementation

435. of

436. M

437. shall

438. be

439. platform

440. independent

442. Complexity

443. and

444. boilerplate

445. code

446. shall

447. be

448. reduced

450. M’s

451. behavior

452. shall

453. be

454. verifiable

456. Time

457. to

458. Market

459. is

460. essential

461. and

462. risks

463. shall

464. be

466. Java:

467. Scala:

468. X I I X I I X I I X I

470. we

471. want

472. to

473. build

474. a

475. machine

476. M

477. to

478. solve

479. a

487. problem

488. P

489. where,

491. Efficiency

492. is

493. imperative

495. Sequential

496. computations

497. shall

498. be

499. independent

501. Implementation

502. of

503. M

504. shall

505. be

506. platform

507. independent

509. Complexity

510. and

511. boilerplate

512. code

513. shall

514. be

515. reduced

517. M’s

518. behavior

519. shall

520. be

521. verifiable

523. Time

524. to

525. Market

526. is

527. essential

528. and

529. risks

530. shall

531. be

533. Java:

534. Scala:

535. X I I X I I X I I X I I X

537. we

538. want

539. to

540. build

541. a

542. machine

543. M

544. to

545. solve

546. a

554. problem

555. P

556. where,

558. Efficiency

559. is

560. imperative

562. Sequential

563. computations

564. shall

565. be

566. independent

568. Implementation

569. of

570. M

571. shall

572. be

573. platform

574. independent

576. Complexity

577. and

578. boilerplate

579. code

580. shall

581. be

582. reduced

584. M’s

585. behavior

586. shall

587. be

588. verifiable

590. Time

591. to

592. Market

593. is

594. essential

595. and

596. risks

597. shall

598. be

600. Java:

601. Scala:

602. X I I X I I X I I X I I X X

603. Java or Scala Conclusion •Both

604. Java

605. and

606. Scala

607. works

608. well

609. with

610. Akka

611. ! •Choose

612. the

613. language

614. that

615. makes

616. most

617. sense

618. ! •Don’t

619. add

620. unnecessary

621. risk

622. Scoreboard

623. Java:

624. Scala:

625. I I I I I I I I

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

627. level

629. level

631. level

633. level

635. level

637. level

638. Domain Specific Requirements • Akka

639. is

640. more

641. or

642. less

643. a

644. perfect

645. match

646. for

647. all

648. parallelizable

649. domains

651. ! • But

652. what

653. about

654. • reactive

655. domains

656. with

657. blocking

658. parts?

660. • legacy

661. domains

662. with

663. reactive

664. 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]

665. Blocking in a Reactive Environment • If

666. we

667. choose

668. Akka,

669. we

670. need

671. to

672. block

673. actors,

674. yuck!

676. ! ! ! • The

677. main

678. advantage

679. is

680. that

681. we

682. can

683. reuse

684. actors

685. from

686. parallelizable

687. parts

688. but

689. are

690. there

691. any

692. downsides?

693. ! • The

694. other

695. option

696. is

697. to

698. use

699. legacy

700. design oh

701. no

703. I’m

704. blocked but

705. I’m

706. still

708. pretty

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

710. it

711. possible

712. to

713. replace

714. D

715. by

716. a

717. component

718. implemented

719. with

720. Akka?

721. Debugger Friend or Foe? We

722. often

723. get

724. the

725. question:

726. !

727. “The

728. asynchrony

729. in

730. Akka

731. makes

732. it

733. very

734. hard

735. to

745. use

746. the

747. debugger,

748. Am

749. I

750. doing

751. it

752. wrong?”

753. debugger in Legacy Design Legacy

754. Design Object

755. A Object

756. B Object

757. N

759. Design Object

760. A Object

761. B

763. Design Object

764. A Object

765. B Object

766. N Place

767. a

768. break

769. point

770. in

771. N

772. to

773. find

774. out

776. -

777. Which

778. value

779. caused

780. the

781. crash?

783. -

784. Who

785. created

786. it?

787. debugger in Reactive Design Reactive

788. design Break

789. point

790. in

791. actor

792. N

793. Supervision We’re

794. reactive

795. Supervision oh

796. no

798. I’m

799. blocked but

800. I’m

801. still

803. pretty We’re

804. reactive

805. Supervision Asynchronous

806. Supervision Asynchronous Failure

807. Supervision Synchronous Blocking

808. call

810. call

812. call Send

813. failure

815. call Send

816. failure

817. Supervision ! private ActorRef targetActor;! private ActorRef caller;! private AskParam askParam;! 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) message;! 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 + askParam.timeout.toString()));! context().stop(self());! }! else {! unhandled(message);! }! }! ! private void sendFailureToCaller(final Throwable t) {! caller.tell(new Failure(t), self());! }

818. Supervision -Write

819. legacy

820. code

821. -Use

822. Akka

823. actors

824. Supervision -Write

825. legacy

826. code

827. -Use

828. Akka

829. actors Sequential

830. does

831. not

832. imply

833. synchronicity

834. The Shared Mutable State Trap Keeping

835. state

836. between

837. messages

838. in

839. an

840. actor

841. is

842. extremely

843. dangerous

844. because

845. it

846. may

847. cause

848. a

849. shared

850. mutable

851. state

852. ! ! !

853. The Shared Mutable State Trap Actor Properties

854. -

855. One

856. message

857. queue

858. -

859. Only

860. one

861. message

862. is

863. processed

864. at

865. a

866. time

867. -

868. Messages

869. are

870. processed

871. in

872. order

873. received

874. -

875. An

876. actor

877. may

878. choose

879. to

880. divide

881. and

882. conquer

883. a

884. task

885. by

886. calling

887. other

888. actors

889. The Shared Mutable State Trap Router Actors

890. may

891. be

892. grouped

893. in

894. a

895. router Properties

896. -

897. Messages

898. are

899. distributed

900. among

901. actors

902. according

903. to

904. some

905. message

906. delivery

907. scheme,

908. eg

909. Round

910. Robin

911. or

912. Smallest

913. Mailbox

914. ! -

915. A

916. router

917. may

918. receive

919. a

920. lot

921. of

922. messages

923. The Shared Mutable State Trap -

924. A

925. stateful

926. actor

927. is

928. part

929. of

930. a

931. router

932. ! -

933. It

934. uses

935. divide

936. and

937. conquer

938. to

939. solve

940. its

941. task Actor

942. with

943. state Scenario

944. The Shared Mutable State Trap Actor

945. with

946. state -

947. Each

948. message

949. recived

950. from

951. the

953. router

954. resets

955. the

956. state

957. ! -

958. New

959. messages

960. are

961. inter

962. mixed

963. with

964. child

965. responses

967. ! -

968. Hence,

969. we

970. have

971. a

972. shared

973. mutable

974. state

975. Scenario

976. The Shared Mutable State Trap Solution

977. -

978. Each

979. request

980. sent

981. by

982. the

983. router

984. results

985. in

986. a

987. “Gather”

988. actor

989. ! -

990. The

991. Gather

992. actor

993. is

994. responsible

995. for

996. collecting

997. the

998. result

1000. ! -

1001. A

1002. Gather

1003. actor

1004. is

1005. NEVER

1006. reused Gather

1007. actor result

1008. Key Take-Aways -

1009. It’s

1010. very

1011. easy

1012. to

1013. accidentally

1014. fall

1015. back

1016. to

1017. sequential

1018. “thinking”

1019. with

1020. state

1021. ! -

1022. Often

1023. one

1024. does

1025. not

1026. realize

1027. this

1028. until

1029. the

1030. system

1031. is

1032. placed

1033. under

1034. heavy

1035. load

1036. ! -

1037. Try

1038. to

1039. avoid

1040. state!

1041. Readability By

1042. Various.

1043. Edited

1044. by:

1045. W

1046. H

1047. Maw

1048. and

1049. J

1050. Dredge

1051. (Abandoned

1052. library

1053. clearance.

1054. Self

1055. photographed.)

1056. [Public

1057. domain],

1058. via

1059. Wikimedia

1060. Commons

1061. Implications of untyped actors ! Akka

1062. actors

1063. are

1064. untyped

1065. -

1066. by

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

1068. Implications of untyped actors ! Akka

1069. actors

1070. are

1071. untyped

1072. -

1073. by

1074. design - Readability

1075. - No

1076. support

1077. from

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

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

1080. 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);! }! }!

1081. 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);! }! }!

1082. 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

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

1084. 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);!! ...! }!

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

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

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

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

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

1090. 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);! }!

1091. 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();! }! }!

1092. Conclusions - Contracts

1093. to

1094. explicitly

1095. define

1096. behavior

1097. works

1098. pretty

1099. well

1100. - Can

1101. be

1102. a

1103. useful

1104. tool

1105. in

1106. your

1107. toolbox

1108. - Scala

1109. can

1110. give

1111. similar

1112. support

1113. via

1114. traits

1116. match

1117. Testing Akka Code Interact

1118. by

1119. sending

1120. messages BDD

1121. Scenarios Integration

1122. tests

1123. Scenarios Case

1124. A1:

1125. Sort

1126. any

1127. sequence

1128. of

1129. numbers

1130. in

1131. increasing

1132. order

1134. ! ! Given

1135. a

1136. sequence

1137. of

1138. numbers

1139. in

1140. decreasing

1141. order

1142. ! When

1143. applying

1144. the

1145. sort

1146. algorithm

1147. ! Then

1148. the

1149. resulting

1150. sequence

1151. of

1152. numbers

1153. is

1154. in

1155. increasing

1156. order

1157. 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));! ! }!

1158. Key Take-Aways - It’s

1159. possible

1160. to

1161. use

1162. Akka

1163. in

1164. legacy

1165. code

1166. - Akka

1167. is

1168. Scala

1170. Java

1171. compliant

1172. - Akka

1173. is

1174. a

1175. toolkit

1176. with

1177. a

1178. lot

1179. of

1180. goodies

1181. - Stop

1182. writing

1183. legacy

1184. code

1185. Thank

1186. you @DanielDeogun

1188. @DanielSawano

Akka Made Our Day

Recommended

Recommended

More Related Content

What's hot

What's hot (14)

Viewers also liked

Viewers also liked (20)

Similar to Akka Made Our Day

Similar to Akka Made Our Day (20)

More from Daniel Sawano

More from Daniel Sawano (13)

Recently uploaded

Recently uploaded (20)

Akka Made Our Day