Slide 1

Slide 1 text

April 4, 2017 IPT – Intellectual Products & Technologies @ DEV.BG Reactive Java Robotics & IoT with Spring Reactor Trayan Iliev [email protected] http://iproduct.org Copyright © 2003-2017 IPT - Intellectual Products & Technologies

Slide 2

Slide 2 text

IPT - Intellectual Products & Technologies IT Education Evolved 2 Since 2003 we provide trainings and share tech knowledge in Java SE/ EE/ Web/ JS/ ES/ TypeScript/ Node/ Express/ Socket.IO/ NoSQL/ Angular 2/ React / REST SOA: Java EE6/7, Spring, JSF, Portals/Portlets: Liferay, GateIn Reactive IoT with Reactor / RxJava / RxJS Node.js + Express/ hapi + React.js + Redux + GraphQL Angular 2 + TypeScript + Redux (ngrx) SOA & Distributed Hypermedia APIs (REST) Domain Driven Design & Reactive Microservices

Slide 3

Slide 3 text

3 Trademarks Oracle®, Java™ and JavaScript™ are trademarks or registered trademarks of Oracle and/or its affiliates. LEGO® is a registered trademark of LEGO® Group. Programs are not affiliated, sponsored or endorsed by LEGO® Education or LEGO® Group. Raspberry Pi™ is a trademark of Raspberry Pi Foundation. Other names may be trademarks of their respective owners.

Slide 4

Slide 4 text

4 Disclaimer All information presented in this document and all supplementary materials and programming code represent only my personal opinion and current understanding and has not received any endorsement or approval by IPT - Intellectual Products and Technologies or any third party. It should not be taken as any kind of advice, and should not be used for making any kind of decisions with potential commercial impact. The information and code presented may be incorrect or incomplete. It is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the information, materials or code presented or the use or other dealings with this information or programming code.

Slide 5

Slide 5 text

Tales of JAVA Robotics 5 There are several tales to share: Tale of Robotics, IoT and Complexity Tale of Common Sense: DDD Tale of two cities - Imperative and Reactive  Tale of two brave robots: LeJaRo and IPTPI  And some real reactive Java + TypeScript / Angular 2 / Reactive WebSocket code 

Slide 6

Slide 6 text

6 High Performnce Reactive JAVA  Reactive programming. Reactor & Proactor design patterns. Reactive Streams (java.util.concurrent.Flow)  High performance non-blocking asynchronous apps on JVM using Reactor project & RxJava  Disruptor (RingBuffer), Flux & Mono, Processors  End-to-end reactive web applications and services: Reactor IO (REST, WebSocket) + RxJS + Angular 2  Demo - reactive hot event streams processing on Raspberry Pi 2 (ARM v7) based robot IPTPI.  RxJava (not Zen only :) coans for self assessment

Slide 7

Slide 7 text

Tales of JAVA Robotics 7 There are several tales to share: Tale of Robotics, IoT and Complexity Tale of Common Sense: DDD Tale of two cities - Imperative and Reactive  Tale of two brave robots: LeJaRo and IPTPI  And some real reactive Java + TypeScript / Angular 2 / Reactive WebSocket code 

Slide 8

Slide 8 text

Where to Find the Demo Code? 8 IPTPI Reactive Demo is available @ GitHub: https://github.com/iproduct/course-social-robotics https://github.com/iproduct/jprime-demo

Slide 9

Slide 9 text

Robots Can Be Complex 9

Slide 10

Slide 10 text

… Even More Complex 10 Cross-section of many disciplines:  mechanical engineering  electrical engineering  computer science  artificial intelligence (AI)  human-computer interaction  sociology & psychology Picture by Hugo Elias of the Shadow Robot Company - http://www.shadowrobot.com/media/pictures.shtml, CC BY-SA 3.0

Slide 11

Slide 11 text

Engineering, Science & Art 11 Source: https://commons.wikimedia.org/w/index.php?curid=551256, CC BY-SA 3.0

Slide 12

Slide 12 text

and How Can We Forget 12 Source: https://commons.wikimedia.org/ w/index.php?curid=234900, CC BY-SA 3.0 Source: Korea Institute of Industrial Technology, http://news.naver.com/main/read.nhn? mode=LSD&mid=sec&sid1=102&oid=020&aid=0000371339

Slide 13

Slide 13 text

Robots: The Most Intelligent Things 13 CC BY 2.0, Source: https://www.flickr.com/photos/wilgengebroed/8249565455/ Radar, GPS, lidar for navigation and obstacle avoidance ( 2007 DARPA Urban Challenge )

Slide 14

Slide 14 text

The Internet of Things has the potential to change the world, just as the Internet did. Maybe even more so.  Nearly 50 petabytes of data are captured and created by human beings  People have limited time, attention and accuracy  Capturing data about things in the real world in real time  Track and count everything, reduce waste, loss & cost.  Know when things need replacing, repairing or recalling — Kevin Ashton, 'That 'Internet of Things' Thing', RFID Journal, 2009 Internet of Things (IoT)

Slide 15

Slide 15 text

 There will be nearly 26 billion devices on the Internet of Things by 2020. [Gartner]  More than 30 billion devices will be wirelessly connected to the Internet of Things by 2020 [ABI Research]  It's expected to be a 19 Trillion USD market [John Chambers, Cisco CEO] IoT Perspectives

Slide 16

Slide 16 text

"Basket of remotes" problem – we'll have hundreds of applications to interface with hundreds of devices that don't share protocols for speaking with one another [Jean-Louis Gassée, Apple initial team, and BeOS co-founder] Only IPv6 addresses are not enough – IoT devices should be also easily and directly accessible for users and [their] agents In read/write mode Preferably using a standard web browser Even behind firewalls IoT - Need for Standards

Slide 17

Slide 17 text

IoT Services Architecture 17 Devices: Hardware + Embedded Software + Firmware UART/ I2C/ 2G/ 3G/ LTE/ ZigBee/ 6LowPan/ BLE Aggregation/ Bus: ESB, Message Broker Device Gateway: Local Coordination and Event Aggregation M2M: HTTP(/2) / WS / MQTT / CoAP Management: TR-069 / OMA-DM / OMA LWM2M HTTP, AMQP Cloud (Micro)Service Mng. Docker, Kubernetes/ Apache Brooklyn Web/ Mobile Portal PaaS Dashboard PaaS API: Event Processing Services, Analytics

Slide 18

Slide 18 text

Tracking Complexity 18 We need tools to cope with all that complexity inherent in robotics and IoT domains. Simple solutions are needed – cope with problems through divide and concur on different levels of abstraction: Domain Driven Design (DDD) – back to basics: domain objects, data and logic. Described by Eric Evans in his book: Domain Driven Design: Tackling Complexity in the Heart of Software, 2004

Slide 19

Slide 19 text

Common Sense: DDD 19 Main concepts:  Entities, value objects and modules  Aggregates and Aggregate Roots [Haywood]: value < entity < aggregate < module < BC  Repositories, Factories and Services: application services <-> domain services  Separating interface from implementation

Slide 20

Slide 20 text

Imperative and Reactive 20 We live in a Connected Universe ... there is hypothesis that all the things in the Universe are intimately connected, and you can not change a bit without changing all. Action – Reaction principle is the essence of how Universe behaves.

Slide 21

Slide 21 text

Imperative and Reactive  Reactive Programming: using static or dynamic data flows and propagation of change Example: a := b + c  Functional Programming: evaluation of mathematical functions, ➢ Avoids changing-state and mutable data, declarative programming ➢ Side effects free => much easier to understand and predict the program behavior. Example: books.stream().filter(book -> book.getYear() > 2010) .forEach( System.out::println )

Slide 22

Slide 22 text

Functional Reactive (FRP) 22 According to Connal Elliot's (ground-breaking paper @ Conference on Functional Programming, 1997), FRP is: (a) Denotative (b) Temporally continuous

Slide 23

Slide 23 text

Reactive Manifesto 23 [http://www.reactivemanifesto.org]

Slide 24

Slide 24 text

Reactive Programming 24  Microsoft® opens source polyglot project ReactiveX (Reactive Extensions) [http://reactivex.io]: Rx = Observables + LINQ + Schedulers :) Java: RxJava, JavaScript: RxJS, C#: Rx.NET, Scala: RxScala, Clojure: RxClojure, C++: RxCpp, Ruby: Rx.rb, Python: RxPY, Groovy: RxGroovy, JRuby: RxJRuby, Kotlin: RxKotlin ...  Reactive Streams Specification [http://www.reactive-streams.org/] used by:  (Spring) Project Reactor [http://projectreactor.io/]  Actor Model – Akka (Java, Scala) [http://akka.io/]

Slide 25

Slide 25 text

Trayan Iliev IPT – Intellectual Products & Technologies Ltd. Multi-Agent Systems & Social Robotics 15/01/2015 Slide 25 Copyright © 2003-2015 IPT – Intellectual Products & Technologies Ltd. All rights reserved. Подход на интелигентните агенти при моделиране на знания и системи

Slide 26

Slide 26 text

Reactive Streams Spec. 26  Reactive Streams – provides standard for asynchronous stream processing with non-blocking back pressure.  Minimal set of interfaces, methods and protocols for asynchronous data streams  April 30, 2015: has been released version 1.0.0 of Reactive Streams for the JVM (Java API, Specification, TCK and implementation examples)  Java 9: java.util.concurrent.Flow

Slide 27

Slide 27 text

Reactive Streams Spec. 27  Publisher – provider of potentially unbounded number of sequenced elements, according to Subscriber(s) demand. Publisher.subscribe(Subscriber) => onSubscribe onNext* (onError | onComplete)?  Subscriber – calls Subscription.request(long) to receive notifications  Subscription – one-to-one Subscriber ↔ Publisher, request data and cancel demand (allow cleanup).  Processor = Subscriber + Publisher

Slide 28

Slide 28 text

FRP = Async Data Streams 28  FRP is asynchronous data-flow programming using the building blocks of functional programming (e.g. map, reduce, filter) and explicitly modeling time  Used for GUIs, robotics, and music. Example (RxJava): Observable.from( new String[]{"Reactive", "Extensions", "Java"}) .take(2).map(s -> s + " : on " + new Date()) .subscribe(s -> System.out.println(s)); Result: Reactive : on Wed Jun 17 21:54:02 GMT+02:00 2015 Extensions : on Wed Jun 17 21:54:02 GMT+02:00 2015

Slide 29

Slide 29 text

29  Performance is about 2 things (Martin Thompson – http://www.infoq.com/articles/low-latency-vp ): – Throughput – units per second, and – Latency – response time  Real-time – time constraint from input to response regardless of system load.  Hard real-time system if this constraint is not honored then a total system failure can occur.  Soft real-time system – low latency response with little deviation in response time  100 nano-seconds to 100 milli-seconds. [Peter Lawrey] What About High Performance?

Slide 30

Slide 30 text

33  Low garbage by reusing existing objects + infrequent GC when application not busy – can improve app 2 - 5x  JVM generational GC startegy – ideal for objects living very shortly (garbage collected next minor sweep) or be immortal  Non-blocking, lockless coding or CAS  Critical data structures – direct memory access using DirectByteBuffers or Unsafe => predictable memory layout and cache misses avoidance  Busy waiting – giving the CPU to OS kernel slows program 2-5x => avoid context switches  Amortize the effect of expensive IO - blocking Low Latency: Things to Remember

Slide 31

Slide 31 text

34  Non-blocking (synchronous) implementation is 2 orders of magnitude better then synchronized  We should try to avoid blocking and especially contended blocking if want to achieve low latency  If blocking is a must we have to prefer CAS and optimistic concurrency over blocking (but have in mind it always depends on concurrent problem at hand and how much contention do we experience – test early, test often, microbenchmarks are unreliable and highly platform dependent – test real application with typical load patterns)  The real question is: HOW is is possible to build concurrency without blocking? Mutex Comparison => Conclusions

Slide 32

Slide 32 text

35  Message Driven – asynchronous message-passing allows to establish a boundary between components that ensures loose coupling, isolation, location transparency, and provides the means to delegate errors as messages [Reactive Manifesto].  The main idea is to separate concurrent producer and consumer workers by using message queues.  Message queues can be unbounded or bounded (limited max number of messages)  Unbounded message queues can present memory allocation problem in case the producers outrun the consumers for a long period → OutOfMemoryError Scalable, Massively Concurrent

Slide 33

Slide 33 text

36  Queues typically use either linked-lists or arrays for the underlying storage of elements. Linked lists are not „mechanically sympathetic” – there is no predictable caching “stride” (should be less than 2048 bytes in each direction).  Bounded queues often experience write contention on head, tail, and size variables. Even if head and tail separated using CAS, they usually are in the same cache- line.  Queues produce much garbage.  Typical queues conflate a number of different concerns – producer and consumer synchronization and data storage Queues Disadvantages [http://lmax-exchange.github.com/disruptor/files/Disruptor-1.0.pdf]

Slide 34

Slide 34 text

37  LMAX Disruptor design pattern separates different concerns in a “mechanically sympathetic” way: - Storage of items being exchanged - Producer coordination – claiming the next sequence - Consumers coordination – notified new item is available  Single Writer principle is employed when writing data in the Ring Buffer from single producer thread only (no contention),  When multiple producers → CAS  Memory pre-allocated – predictable stride, no garbage LMAX Disruptor (RingBuffer) [http://lmax-exchange.github.com/disruptor/files/Disruptor-1.0.pdf]

Slide 35

Slide 35 text

38 LMAX Disruptor (RingBuffer) High Performance [http://lmax-exchange.github.com/disruptor/files/Disruptor- 1.0.pdf] Source: LMAX Disruptor github wiki - https://raw.githubusercontent.com/wiki/LMAX- Exchange/disruptor/images/Models.png LMAX-Exchange Disruptor License @ GitHub: Apache License Version 2.0, January 2004 - http://www.apache.org/licenses/

Slide 36

Slide 36 text

39 LMAX Disruptor (RingBuffer) High Performance [http://lmax-exchange.github.com/disruptor/files/Disruptor- 1.0.pdf] Source: LMAX Disruptor @ GitHub - https://github.com/LMAX- Exchange/disruptor/blob/master/docs/Disruptor.docx LMAX-Exchange Disruptor License @ GitHub: Apache License Version 2.0, January 2004 - http://www.apache.org/licenses/

Slide 37

Slide 37 text

Project Reactor 40  Reactor project allows building high-performance (low latency high throughput) non-blocking asynchronous applications on JVM.  Reactor is designed to be extraordinarily fast and can sustain throughput rates on order of 10's of millions of operations per second.  Reactor has powerful API for declaring data transformations and functional composition.  Makes use of the concept of Mechanical Sympathy built on top of Disruptor / RingBuffer.

Slide 38

Slide 38 text

Project Reactor 41  Pre-allocation at startup-time  Message-passing structures are bounded  Using Reactive and Event-Driven Architecture patterns => non-blocking end-to-end flows, replies  Implement Reactive Streams Specification – efficient bounded structures requesting no more than capacity  Applies above features to IPC and provides non- blocking IO drivers that are flow-control aware  Expose a Functional API – organize their code in a side-effect free way, which helps you determine you are thread-safe and fault-tolerant

Slide 39

Slide 39 text

Reactor Projects 42 https://github.com/reactor/reactor, Apache Software License 2.0 IPC – Netty, Kafka, Aeron

Slide 40

Slide 40 text

Reactor Projects 43

Slide 41

Slide 41 text

Reactor Flux 44 https://github.com/reactor/reactor-core, Apache Software License 2.0

Slide 42

Slide 42 text

Reactor Mono 45 https://github.com/reactor/reactor-core, Apache Software License 2.0

Slide 43

Slide 43 text

Example: Flux.combineLatest() 46 https://projectreactor.io/core/docs/api/, Apache Software License 2.0

Slide 44

Slide 44 text

Reactor: Hello World 47 public static void main(String... args) throws InterruptedException { EmitterProcessor emitter = EmitterProcessor.create(); BlockingSink sink = emitter.connectSink(); emitter.publishOn(Schedulers.single()) .map(String::toUpperCase) .filter(s → s.startsWith("HELLO")) .delayMillis(1000).subscribe(System.out::println); sink.submit("Hello World!"); // emit - non blocking sink.submit("Goodbye World!"); sink.submit("Hello Trayan!"); Thread.sleep(3000); }

Slide 45

Slide 45 text

Reactor: Flux Example 48 Flux.fromIterable(getSomeLongList()) .mergeWith(Flux.interval(100)) .doOnNext(serviceA::someObserver) .map(d -> d * 2) .take(3) .onErrorResumeWith(errorHandler::fallback) .doAfterTerminate(serviceM::incrementTerminate) .subscribe(System.out::println); https://github.com/reactor/reactor-core, Apache Software License 2.0

Slide 46

Slide 46 text

Reactor Bus: IPTPI Java Robot 49

Slide 47

Slide 47 text

Disruptor (Ring Buffer) used in Reactor 50 Reactor provides 3 major types of Processors:  EmitterProcessor – using 0 threads (on same thread)  TopicProcessor using – N threads concurrently processing the messages (AND operation)  WorkQueueProcessor – N threads alternatively processing the messages (XOR operation – messages are processed exactly by one thread – load ballancing and work distribution)

Slide 48

Slide 48 text

51 Meet IPTPI :)

Slide 49

Slide 49 text

52 Ups...

Slide 50

Slide 50 text

IPTPI: RPi2 + Ardunio Robot 53  Raspberry Pi 2 (quad-core ARMv7 @ 900MHz) + Arduino Leonardo cloneA-Star 32U4 Micro  Optical encoders (custom), IR optical array, 3D accelerometers, gyros, and compass MinIMU-9 v2  IPTPI is programmed in Java using Pi4J, Reactor, RxJava, Akka  More information about IPTPI: http://robolearn.org/iptpi-robot/

Slide 51

Slide 51 text

IPTPI: RPi2 + Ardunio Robot 54 3D accelerometers, gyros, and compass MinIMU-9 v2 Pololu DRV8835 Dual Motor Driver for Raspberry Pi Arduino Leonardo clone A-Star 32U4 Micro USB Stereo Speakers - 5V LiPo Powebank 15000 mAh

Slide 52

Slide 52 text

IPTPI: RPi2 + Ardunio Robot 55 Raspberry Pi 2 (quad-core ARMv7 @ 900MHz) IR Optical Sensor QRD1114 Array (Line Following) Adafruit 2.8" PiTFT - Capacitive Touch Screen

Slide 53

Slide 53 text

56

Slide 54

Slide 54 text

LeJaRo: Lego® Java Robot 57  Modular – 3 motors (with encoders) – one driving each track, and third for robot clamp.  Three sensors: touch sensor (obstacle avoidance), light color sensor (follow line), IR sensor (remote).  LeJaRo is programmed in Java using LeJOS library.  More information about LeJaRo: http://robolearn.org/lejaro/  Programming examples available @GitHub: https://github.com/iproduct/course-social-robotics/tre e/master/motors_demo LEGO® is a registered trademark of LEGO® Group. Programs of IPT are not affiliated, sponsored or endorsed by LEGO® Education or LEGO® Group.

Slide 55

Slide 55 text

Tale of Simplicity: DDD 58

Slide 56

Slide 56 text

IPTPI Reactive Streams 59 Encoder Readings ArduinoData Flux Arduino SerialData Position Flux Robot Positions Command Movement Subscriber RobotWSService (using Reactor) Angular 2 / TypeScript MovementCommands

Slide 57

Slide 57 text

IPTPI: IPTPIDemo I 60 public class IPTPIVDemo { ... public IPTPIDemo() { //receive Arduino data readings ArduinoData = ArduinoFactory.getInstance().createArduinoData(); //calculate robot positions PositionsFlux = PositionFactory.createPositionFlux( arduinoData.getEncoderReadingsFlux()); resentationViews.add( PositionFactory.createPositionPanel(positionsFlux)); //enable sending commands to Arduino ArduinoCommandsSub = ArduinoFactory.getInstance() .createArduinoCommandSubscriber(); /

Slide 58

Slide 58 text

IPTPI: IPTPIDemo II 61 //Audio player - added @jPrime 2016 Hackergarten audio = AudioFactory.createAudioPlayer(); //wire robot main controller with services movementSub =MovementFactory.createMovementCommandSubscriber( positionsFlux, arduinoData.getLineReadingsFlux()); controller = new RobotController(this::tearDown, movementSub, arduinoCommandsSub, audio); //create view with controller and delegate material views from query services view = new RobotView("IPTPI Reactive Robotics Demo", controller, presentationViews);

Slide 59

Slide 59 text

IPTPI: IPTPIDemo III 62 //expose as WS service movementSub2 =MovementFactory.createMovementCommandSubscriber( positionsFlux, arduinoData.getLineReadingsFlux()); positionsService = new RobotWSService( positionsFlux, movementSub2); } public static void main(String[] args) { // initialize wiringPi library Gpio.wiringPiSetupGpio(); try { IPTPIDemo demo = new IPTPIDemo(); } catch (IOException e) { e.printStackTrace(); } }

Slide 60

Slide 60 text

IPTPI: ArduinoData I 63 positionsFlux = EmitterProcessor.create(); positionsSink = positionsFlux.connectSink(); lineFlux = EmitterProcessor.create(); lineSink = lineFlux.connectSink(); final Serial serial = SerialFactory.createInstance(); serial.addListener(new SerialDataEventListener() { private ByteBuffer buffer = ByteBuffer.allocate(1024); public void dataReceived(SerialDataEvent event) { try { ByteBuffer newBuffer = event.getByteBuffer(); buffer.put(newBuffer); buffer.flip(); ... buffer.get(); long timestamp = buffer.getInt(); //get timestamp int encoderL = -buffer.getInt(); //motors mirrored int encoderR = buffer.getInt();

Slide 61

Slide 61 text

IPTPI: ArduinoData II 64 EncoderReadings readings = new EncoderReadings(encoderR, encoderL, timestamp); emitter.submit(readings); ... buffer.compact(); } catch (Exception e) { e.printStackTrace(); } } }); try { serial.open(PORT, 38400); } catch(SerialPortException | IOException ex) { System.out.println(“SERIAL SETUP FAILED:"+ex.getMessage()); }

Slide 62

Slide 62 text

IPTPI: PositionFlux I 65 Redux Pattern! public PositionsFlux( Flux readingsFlux) { this.encoderReadings = readingsFlux; Flux skip1 = readingsFlux.skip(1); positionsFlux = Flux.zip(readingsFlux, skip1) .map(tupple -> .scan(new Position(0, 0, 0), (last, tupple) -> { EncoderReadings prev = tupple.getT1(); EncoderReadings curr = tupple.getT2(); int prevL = prev.getEncoderL(); int prevR = prev.getEncoderR(); int currL = curr.getEncoderL(); int currR = curr.getEncoderR(); int sL = currL - prevL; int sR = currR - prevR; double alpha0 = last.getHeading();

Slide 63

Slide 63 text

IPTPI: PositionFlux II 66 double alpha0 = last.getHeading(); if(sR == sL) { return new Position((float)(last.getX() + sL * ENCODER_STEP_LENGTH * cos(alpha0)), (float)(last.getY()+ sL * ENCODER_STEP_LENGTH * sin(alpha0)), alpha0, curr.getTimestamp()); } else { … } }) ); }

Slide 64

Slide 64 text

CommandMovementSubscriber I 67 public class CommandMovementSubscriber extends ConsumerSubscriber> { private PositionFluxion positions; public CommandMovementSubscriber(PositionFluxion positions){ this.positions = positions; Gpio.wiringPiSetupGpio(); // initialize wiringPi library Gpio.pinMode(5, Gpio.OUTPUT); // Motor direction pins Gpio.pinMode(6, Gpio.OUTPUT); Gpio.pinMode(12, Gpio.PWM_OUTPUT); // Motor speed pins Gpio.pinMode(13, Gpio.PWM_OUTPUT); Gpio.pwmSetMode(Gpio.PWM_MODE_MS); Gpio.pwmSetRange(MAX_SPEED); Gpio.pwmSetClock(CLOCK_DIVISOR); } @Override public void doNext(Command command) { ... } }

Slide 65

Slide 65 text

CommandMovementSubscriber II 68 private void runMotors(MotorsCommand mc) { //setting motor directions Gpio.digitalWrite(5, mc.getDirR() > 0 ? 1 : 0); Gpio.digitalWrite(6, mc.getDirL() > 0 ? 1 : 0); //setting speed if(mc.getVelocityR()>=0 && mc.getVelocityR() <=MAX_SPEED) Gpio.pwmWrite(12, mc.getVelocityR()); // set speed if(mc.getVelocityL()>=0 && mc.getVelocityL() <=MAX_SPEED) Gpio.pwmWrite(13, mc.getVelocityL()); } }

Slide 66

Slide 66 text

Reactor IO – NetStreams API 69 http://projectreactor.io/io/docs/reference/, Apache License 2.0

Slide 67

Slide 67 text

Takeaways: Why Go Reactive? 70 Benefits using Reactive Programming + DDD:  DDD helps to manage complexity in IoT and Robotics - many subsystems = sub-domains  Reactive Streams (Fluxes, Monos) = uni-directional data flows, CQRS, event sourcing, microservices  Reactive Streams can be non-blocking and highly efficient, or can utilize blocking if needed  Naturally implement state management patterns like Redux, allow time travel, replay and data analytics  Clear, declarative data transforms that scale (Map- Reduce, BigData, PaaS)

Slide 68

Slide 68 text

Takeaways: Why Maybe Not? 71 Cons using Reactive Programming + DDD:  DDD requires additional efforts to clearly separate different (sub) domains – DSL translators, factories...  Reactive Streams utilize functional composition and require entirely different mindset then imperative – feels like learning foreign language  Pure functions and Redux provide much benefits, but there's always temptation to “do it the old way” :)  Tool support for functional programming in Java is still not perfect (in Eclipse at least :)

Slide 69

Slide 69 text

Where to Find the Demo Code? 72 IPTPI Reactive Demo is available @ GitHub: https://github.com/iproduct/course-social-robotics https://github.com/iproduct/jprime-demo

Slide 70

Slide 70 text

73 Resources: RxMarbles & Rx Coans RxMarbles: http://rxmarbles.com/ Lite Rx API Hands-On with Reactor Core 3: https://github.com/reactor/lite-rx-api-hands-on/ RxJava Koans – Let's try to solve them at: https://github.com/mutexkid/rxjava-koans RxJS Koans – for those who prefer JavaScript :) https://github.com/Reactive-Extensions/RxJSKoans

Slide 71

Slide 71 text

Tale of Simplicity: DDD 74 http://robolearn.org/ Let's move! http://iproduct.org/

Slide 72

Slide 72 text

Thank’s for Your Attention! 75 Trayan Iliev CEO of IPT – Intellectual Products & Technologies http://iproduct.org/ http://robolearn.org/ https://github.com/iproduct https://twitter.com/trayaniliev https://www.facebook.com/IPT.EACAD https://plus.google.com/+IproductOrg