Deep dive into Coroutines on JVM. Roman Elizarov elizarov at JetBrains
|
|
|
- Adela Harris
- 6 years ago
- Views:
Transcription
1 Deep dive into Coroutines on JVM Roman Elizarov elizarov at JetBrains
2 There is no magic
3 Continuation Passing Style (CPS)
4 A toy problem fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Direct style
5 Direct style fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post)
6 Direct style fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Continuation
7 Continuation-Passing Style fun postitem(item: Item) { requesttoken { token -> val post = createpost(token, item) processpost(post) Continuation CPS == Callbacks
8 Continuation-Passing Style fun postitem(item: Item) { requesttoken { token -> createpost(token, item) { post -> processpost(post)
9 Coroutines Direct Style suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post)
10 Behind the scenes How does it work?
11 Kotlin suspending functions Kotlin suspend fun createpost(token: Token, item: Item): Post {
12 CPS Transformation suspend fun createpost(token: Token, item: Item): Post { Java/JVM Object createpost(token token, Item item, Continuation<Post> cont) {
13 CPS Transformation suspend fun createpost(token: Token, item: Item): Post { Java/JVM callback Object createpost(token token, Item item, Continuation<Post> cont) {
14 Continuation suspend fun createpost(token: Token, item: Item): Post { Object createpost(token token, Item item, Continuation<Post> cont) { interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumewithexception(exception: Throwable)
15 Continuation suspend fun createpost(token: Token, item: Item): Post { Object createpost(token token, Item item, Continuation<Post> cont) { interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumewithexception(exception: Throwable)
16 Continuation suspend fun createpost(token: Token, item: Item): Post { Object createpost(token token, Item item, Continuation<Post> cont) { interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumewithexception(exception: Throwable)
17 Continuation suspend fun createpost(token: Token, item: Item): Post { Object createpost(token token, Item item, Continuation<Post> cont) { interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumewithexception(exception: Throwable)
18 Continuation suspend fun createpost(token: Token, item: Item): Post { Object createpost(token token, Item item, Continuation<Post> cont) { interface Continuation<in T> { val context: CoroutineContext fun resume(value: T) fun resumewithexception(exception: Throwable) Continuation is a generic callback interface
19 Direct to CPS
20 Direct code suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post)
21 Continuations suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) Initial continuation processpost(post)
22 Continuations suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Continuation
23 Continuations suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Continuation Convert to CPS?
24 Callbacks? fun postitem(item: Item) { requesttoken { token -> createpost(token, item) { post -> processpost(post)
25 Labels suspend fun postitem(item: Item) { // LABEL 0 val token = requesttoken() // LABEL 1 val post = createpost(token, item) // LABEL 2 processpost(post)
26 Labels suspend fun postitem(item: Item) { switch (label) { case 0: val token = requesttoken() case 1: val post = createpost(token, item) case 2: processpost(post)
27 State suspend fun postitem(item: Item) { val sm = object : CoroutineImpl { switch (sm.label) { case 0: val token = requesttoken() case 1: val post = createpost(token, item) case 2: processpost(post)
28 CPS Transform fun postitem(item: Item, cont: Continuation) { val sm = object : CoroutineImpl { switch (sm.label) { case 0: requesttoken(sm) case 1: createpost(token, item, sm) case 2: processpost(post)
29 Save state fun postitem(item: Item, cont: Continuation) { val sm = switch (sm.label) { case 0: sm.item = item sm.label = 1 requesttoken(sm) case 1: createpost(token, item, sm) case 2: processpost(post)
30 Callback fun postitem(item: Item, cont: Continuation) { val sm = object : CoroutineImpl { switch (sm.label) { case 0: sm.item = item sm.label = 1 State Machine as Continuation requesttoken(sm) case 1: createpost(token, item, sm) case 2: processpost(post)
31 Callback fun postitem(item: Item, cont: Continuation) { val sm = object : CoroutineImpl { fun resume( ) { postitem(null, this) switch (sm.label) { case 0: sm.item = item sm.label = 1 requesttoken(sm) case 1: createpost(token, item, sm)
32 Callback fun postitem(item: Item, cont: Continuation) { val sm = cont as? ThisSM?: object : ThisSM { fun resume( ) { postitem(null, this) switch (sm.label) { case 0: sm.item = item sm.label = 1 requesttoken(sm) case 1: createpost(token, item, sm)
33 Restore state fun postitem(item: Item, cont: Continuation) { val sm = switch (sm.label) { case 0: sm.item = item sm.label = 1 requesttoken(sm) case 1: val item = sm.item val token = sm.result as Token sm.label = 2 createpost(token, item, sm)
34 Continue fun postitem(item: Item, cont: Continuation) { val sm = switch (sm.label) { case 0: sm.item = item sm.label = 1 requesttoken(sm) case 1: val item = sm.item val token = sm.result as Token sm.label = 2 createpost(token, item, sm)
35 State Machine vs Callbacks suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) fun postitem(item: Item) { requesttoken { token -> createpost(token, item) { post -> processpost(post)
36 State Machine vs Callbacks suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Reuse closure / state object Create new closure fun postitem(item: Item) { requesttoken { token -> createpost(token, item) { post -> processpost(post)
37 State Machine vs Callbacks suspend fun postitems(items: List<Item>) { for (item in items) { val token = requesttoken() val post = createpost(token, item) processpost(post) Easy loops and higher-order functions
38 State Machine vs Callbacks suspend fun postitems(items: List<Item>) { for (item in items) { val token = requesttoken() val post = createpost(token, item) processpost(post) Easy loops and higher-order functions A horrid callback mess fun postitems(items: List<Item>) {
39 Integration
40 Zoo of futures on JVM
41 interface Service { fun createpost(token: Token, item: Item): Call<Post>
42 interface Service { fun createpost(token: Token, item: Item): Call<Post> suspend fun createpost(token: Token, item: Item): Post = serviceinstance.createpost(token, item).await()
43 suspend fun <T> Call<T>.await(): T {
44 Callbacks everywhere suspend fun <T> Call<T>.await(): T { enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { // todo ) override fun onfailure(call: Call<T>, t: Throwable) { // todo
45 suspend fun <T> Call<T>.await(): T = suspendcoroutine { cont -> enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { if (response.issuccessful) cont.resume(response.body()!!) else cont.resumewithexception(errorresponse(response)) ) override fun onfailure(call: Call<T>, t: Throwable) { cont.resumewithexception(t)
46 suspend fun <T> suspendcoroutine(block: (Continuation<T>) -> Unit): T
47 suspend fun <T> suspendcoroutine(block: (Continuation<T>) -> Unit): T Regular function Inspired by call/cc from Scheme
48 Install callback suspend fun <T> Call<T>.await(): T = suspendcoroutine { cont -> enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { if (response.issuccessful) cont.resume(response.body()!!) else cont.resumewithexception(errorresponse(response)) ) override fun onfailure(call: Call<T>, t: Throwable) { cont.resumewithexception(t)
49 Install callback suspend fun <T> Call<T>.await(): T = suspendcoroutine { cont -> enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { if (response.issuccessful) cont.resume(response.body()!!) else cont.resumewithexception(errorresponse(response)) ) override fun onfailure(call: Call<T>, t: Throwable) { cont.resumewithexception(t)
50 Analyze response suspend fun <T> Call<T>.await(): T = suspendcoroutine { cont -> enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { if (response.issuccessful) cont.resume(response.body()!!) else cont.resumewithexception(errorresponse(response)) ) override fun onfailure(call: Call<T>, t: Throwable) { cont.resumewithexception(t)
51 Analyze response suspend fun <T> Call<T>.await(): T = suspendcoroutine { cont -> enqueue(object : Callback<T> { override fun onresponse(call: Call<T>, response: Response<T>) { if (response.issuccessful) cont.resume(response.body()!!) else cont.resumewithexception(errorresponse(response)) ) override fun onfailure(call: Call<T>, t: Throwable) { cont.resumewithexception(t) That s all
52 Out-of-the box integrations rx2 rx1 reactor nio guava jdk8 kotlinx-coroutines-core Contributions are welcome
53 Coroutine context
54 What thread it resumes on? suspend fun postitem(item: Item) { val token = requesttoken() val post = createpost(token, item) processpost(post) Continuation It depends!
55 What thread it resumes on? fun postitem(item: Item) { launch(ui) { val token = requesttoken() val post = createpost(token, item) processpost(post) Continuation
56 Continuation Interceptor interface ContinuationInterceptor : CoroutineContext.Element { companion object Key : CoroutineContext.Key<ContinuationInterceptor> fun <T> interceptcontinuation(continuation: Continuation<T>): Continuation<T>
57 Continuation Interceptor interface ContinuationInterceptor : CoroutineContext.Element { companion object Key : CoroutineContext.Key<ContinuationInterceptor> fun <T> interceptcontinuation(continuation: Continuation<T>): Continuation<T>
58 Continuation Interceptor interface ContinuationInterceptor : CoroutineContext.Element { companion object Key : CoroutineContext.Key<ContinuationInterceptor> fun <T> interceptcontinuation(continuation: Continuation<T>): Continuation<T>
59 Dispatched continuation class DispatchedContinuation<in T>( val dispatcher: CoroutineDispatcher, val continuation: Continuation<T> ): Continuation<T> by continuation { override fun resume(value: T) { dispatcher.dispatch(context, DispatchTask( )) Dispatches execution to another thread
60 Starting coroutines
61 Coroutine builder fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T>
62 A regular function fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T>
63 fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T>
64 fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T> suspending lambda
65 fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T> { val future = CompletableFuture<T>() block.startcoroutine( ) return future
66 fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T> { val future = CompletableFuture<T>() block.startcoroutine( ) return future
67 fun <T> future( context: CoroutineContext = DefaultDispatcher, block: suspend () -> T ): CompletableFuture<T> { val future = CompletableFuture<T>() block.startcoroutine(completion = object : Continuation<T> { ) return future
68 fun <T> future( ): CompletableFuture<T> { val future = CompletableFuture<T>() block.startcoroutine(completion = object : Continuation<T> { override val context: CoroutineContext get() = context override fun resume(value: T) { future.complete(value) override fun resumewithexception(exception: Throwable) { future.completeexceptionally(exception) ) return future
69 fun <T> future( ): CompletableFuture<T> { val future = CompletableFuture<T>() block.startcoroutine(completion = object : Continuation<T> { override val context: CoroutineContext get() = context override fun resume(value: T) { future.complete(value) override fun resumewithexception(exception: Throwable) { future.completeexceptionally(exception) ) return future That s all, folks!
70 Job cancellation
71 Launch coroutine builder fun launch( context: CoroutineContext = DefaultDispatcher, block: suspend () -> Unit ): Job {
72 val job = launch { Launching coroutine
73 val job = launch { job.join()
74 val job = launch { job.join() job.cancel()
75 Job interface Job : CoroutineContext.Element { companion object Key : CoroutineContext.Key<Job>
76 Using coroutine context launch { val job = coroutinecontext[job]!!
77 Using coroutine context launch { val job = coroutinecontext[job]!! val interceptor = coroutinecontext[coroutineinterceptor]!!
78 Timeouts launch { withtimeout(10, TimeUnit.SECONDS) {
79 Cooperative cancellation
80 Cooperative cancellation launch { while (true) {
81 Cooperative cancellation launch { while (isactive) {
82 Cooperative cancellation launch { while (true) { delay( )
83 Cancellable suspension suspend fun <T> Call<T>.await(): T = suspendcancellablecoroutine { cont -> enqueue( )
84 Cancellable continuation suspend fun <T> Call<T>.await(): T = suspendcancellablecoroutine { cont: CancellableContinuation<T> -> enqueue( )
85 Completion handler suspend fun <T> Call<T>.await(): T = suspendcancellablecoroutine { cont: CancellableContinuation<T> -> enqueue( ) cont.invokeoncompletion { this@await.cancel()
86 Completion handler suspend fun <T> Call<T>.await(): T = suspendcancellablecoroutine { cont: CancellableContinuation<T> -> enqueue( ) cont.invokeoncompletion { this@await.cancel()
87 Communicating Sequential Processes (CSP)
88 Shared Mutable
89 The choice Shared Mutable State Share by Communicating
90 Example fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
91 Main coroutine fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
92 Channel fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
93 Launch fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i) Child coroutine
94 Coroutine body fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i) Sequential code!
95 Send fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
96 Close fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
97 Receive for loop fun main(args: Array<String>) = runblocking<unit> { val chan = Channel<Int>() launch(coroutinecontext) { repeat(10) { i -> delay(100) chan.send(i) chan.close() launch(coroutinecontext) { for (i in chan) { println(i)
98 Demo
99 The other way to look at CSP Actors
100 The choice Named channels Named coroutines Actor == named coroutine & inbox channel
101 Example fun main(args: Array<String>) = runblocking<unit> { val printer = actor<int>(coroutinecontext) { for (i in channel) { println(i) launch(coroutinecontext) { repeat(10) { i -> delay(100) printer.send(i) printer.close()
102 Actor coroutine builder fun main(args: Array<String>) = runblocking<unit> { val printer = actor<int>(coroutinecontext) { for (i in channel) { println(i) launch(coroutinecontext) { repeat(10) { i -> delay(100) printer.send(i) printer.close()
103 Actor body fun main(args: Array<String>) = runblocking<unit> { val printer = actor<int>(coroutinecontext) { for (i in channel) { println(i) launch(coroutinecontext) { repeat(10) { i -> delay(100) printer.send(i) printer.close() Sequential!
104 Interacting with an actor fun main(args: Array<String>) = runblocking<unit> { val printer = actor<int>(coroutinecontext) { for (i in channel) { println(i) launch(coroutinecontext) { repeat(10) { i -> delay(100) printer.send(i) printer.close()
105 References
106 Guide to kotlinx.coroutines by example Basics Cancellation and Timeouts Composition Coroutine contexts Channels Shared Mutable State and Concurrency Select expressions
107 Thank you Roman Elizarov elizarov at JetBrains relizarov Any questions? #kotlinconf17
Fresh Async With Kotlin. Presented at QCon SF, 2017 /Roman JetBrains
Fresh Async With Kotlin Presented at QCon SF, 2017 /Roman Elizarov @ JetBrains Speaker: Roman Elizarov 16+ years experience Previously developed high-perf trading software @ Devexperts Teach concurrent
Introduction to Coroutines. Roman Elizarov elizarov at JetBrains
Introduction to Coroutines Roman Elizarov elizarov at JetBrains Asynchronous programming How do we write code that waits for something most of the time? A toy problem Kotlin 1 fun requesttoken(): Token
Lock-free algorithms for Kotlin coroutines. It is all about scalability Presented at SPTCC 2017 /Roman JetBrains
Lock-free algorithms for Kotlin coroutines It is all about scalability resented at TCC 2017 /Roman Elizarov @ JetBrains peaker: Roman Elizarov 16+ years experience reviously developed high-perf trading
Concurrent ML. John Reppy January 21, University of Chicago
Concurrent ML John Reppy jhr@cs.uchicago.edu University of Chicago January 21, 2016 Introduction Outline I Concurrent programming models I Concurrent ML I Multithreading via continuations (if there is
Threads and Continuations COS 320, David Walker
Threads and Continuations COS 320, David Walker Concurrency Concurrency primitives are an important part of modern programming languages. Concurrency primitives allow programmers to avoid having to specify
A Long Time Ago 2 / 64
ndertow 1 / 64 A Long Time Ago 2 / 64 A Long Time Ago 3 / 64 A Long Time Ago 4 / 64 Undertow 5 / 64 Features HTTP/HTTPS HTTP/2 WebSockets 6 / 64 Hello, World! Undertow.builder().addHttpListener(8080, "localhost")
Reactive Programming with Vert.x
Reactive Programming with Vert.x Embrace asynchronous to build responsive systems Clement Escoffier Principal Software Engineer, Red Hat Reactive The new gold rush? Reactive system, reactive manifesto,
Continuations and Continuation-Passing Style
Continuations and Continuation-Passing Style Lecture 4 CS 390 1/16/08 Goal Weʼre interested in understanding how to represent the state of a co-routine Insight into what a thread really means How fundamental
A Deep Dive Into Kotlin
A Deep Dive Into Kotlin By 1 About me (droidyue.com) @Flipboard China GDG 2 3 Kotlin An official language for Android recently Powered by Jetbrains 4 Why Kotlin Concise Safe interoperable tool-friendly
First-class continuations. call/cc, stack-passing CEK machines
First-class continuations call/cc, stack-passing CEK machines But first Assignment 2 e ::= (letrec* ([x e]...) e) (letrec ([x e]...) e) (let* ([x e]...) e) (let ([x e]...) e) (let x ([x e]...) e) (lambda
2 years without Java or reload Android development with Kotlin.
2 years without Java or reload Android development with Kotlin KirillRozov@EPAM Who am I? Team Lead in EPAM More than 6 years in Android development Kotlin Evangelist Co-organizer GDG Minsk, Android Academy
Deferred operations. Continuations Structure and Interpretation of Computer Programs. Tail recursion in action.
Deferred operations Continuations 6.037 - Structure and Interpretation of Computer Programs Mike Phillips (define the-cons (cons 1 #f)) (set-cdr! the-cons the-cons) (define (run-in-circles l) (+
The Kotlin Programming Language. Andrey Breslav Dmitry Jemerov
The Kotlin Programming Language Andrey Breslav Dmitry Jemerov What is Kotlin? Statically typed object-oriented JVM-targeted general-purpose programming language developed by JetBrains intended for industrial
Scale Up with Lock-Free Algorithms. Non-blocking concurrency on JVM Presented at JavaOne 2017 /Roman JetBrains
Scale Up with Lock-Free Algorithms Non-blocking concurrency on JVM Presented at JavaOne 2017 /Roman Elizarov @ JetBrains Speaker: Roman Elizarov 16+ years experience Previously developed high-perf trading
References and Mutable Data Structures
References and Mutable Data Structures Principles of Programming Languages CSE 307 1 Syntax 2 Semantics 3 Version: 1.4 16:44:20 2012/11/29 Compiled at 09:37 on 2018/11/13 Programming Languages References
COPYRIGHTED MATERIAL. Table of Contents. Foreword... xv. About This Book... xvii. About The Authors... xxiii. Guide To The Reader...
Table of Contents Foreword..................... xv About This Book... xvii About The Authors............... xxiii Guide To The Reader.............. xxvii Part I Some Concepts.................. 1 1 On Patterns
Kotlin/Native concurrency model. nikolay
Kotlin/Native concurrency model nikolay igotti@jetbrains What do we want from concurrency? Do many things concurrently Easily offload tasks Get notified once task a task is done Share state safely Mutate
System Building. Events, Co-routines, Continuations and Threads - OS (and application) Execution Models. Event Model. Events
s, o-routines, ontinuations and Threads - OS (and application) Execution Models System uilding General purpose systems need to deal with Many activities potentially overlapping may be interdependent ctivities
Getting Started with Kotlin. Commerzbank Java Developer Day
Getting Started with Kotlin Commerzbank Java Developer Day 30.11.2017 Hello! Alexander Hanschke Hello! Alexander Hanschke CTO at techdev Solutions GmbH in Berlin Hello! Alexander Hanschke CTO at techdev
3.1 Introduction. Computers perform operations concurrently
PROCESS CONCEPTS 1 3.1 Introduction Computers perform operations concurrently For example, compiling a program, sending a file to a printer, rendering a Web page, playing music and receiving e-mail Processes
Scala Actors. Scalable Multithreading on the JVM. Philipp Haller. Ph.D. candidate Programming Methods Lab EPFL, Lausanne, Switzerland
Scala Actors Scalable Multithreading on the JVM Philipp Haller Ph.D. candidate Programming Methods Lab EPFL, Lausanne, Switzerland The free lunch is over! Software is concurrent Interactive applications
Implementing Coroutines with call/cc. Producer/Consumer using Coroutines
Implementing Coroutines with call/cc Producer/Consumer using Coroutines Coroutines are a very handy generalization of subroutines. A coroutine may suspend its execution and later resume from the point
Programming Safe Agents in Blueprint. Alex Muscar University of Craiova
Programming Safe Agents in Blueprint Alex Muscar University of Craiova Programmers are craftsmen, and, as such, they are only as productive as theirs tools allow them to be Introduction Agent Oriented
JAVA Training Overview (For Demo Classes Call Us )
JAVA Training Overview (For Demo Classes Call Us +91 9990173465) IT SPARK - is one of the well-known and best institutes that provide Java training courses. Working professionals from MNC's associated
Implementation Alternatives. Lecture 2: Implementation Alternatives & Concurrent Programming. Current Implementation Alternatives
Lecture 2: Implementation Alternatives & Concurrent ming Implementation Alternatives Controllers can be implemented using a number of techniques [RTCS Ch 3] Implementation Alternatives Processes and threads
CONCURRENCY AND THE ACTOR MODEL
CONCURRENCY AND THE ACTOR MODEL COMP 319 University of Liverpool slide 1 Concurrency review Multi-tasking - Task - Processes with isolated address space - Programming examples - Unix fork() processes -
GETTING STARTED WITH Kotlin INTRODUCTION WHERE TO START CODING BASIC SYNTAX
257 CONTENTS INTRODUCTION GETTING STARTED WITH Kotlin WHERE TO START CODING BASIC SYNTAX CONTROL FLOW: CONDITIONS CONTROL FLOW: LOOPS BASIC TYPES CLASSES FUNCTION TYPES AND LAMBDAS HIGHER-ORDER FUNCTIONS
Keep Learning with Oracle University
Keep Learning with Oracle University Classroom Training Learning SubscripDon Live Virtual Class Training On Demand Cloud Technology ApplicaDons Industries educa7on.oracle.com 2 Session Surveys Help us
n n Official Scala website n Scala API n
n Quiz 8 Announcements n Rainbow grades: HW1-8, Quiz1-6, Exam1-2 n Still grading: HW9, Quiz 7 Scala n HW10 due today n HW11 out today, due Friday Fall 18 CSCI 4430, A Milanova 1 Today s Lecture Outline
...something useful to do with the JVM.
Scala Finally... ...something useful to do with the JVM. Image source: http://www.tripadvisor.com/locationphotos-g187789-lazio.html Young Developed in 2003 by Martin Odersky at EPFL Martin also brought
PATTERN-ORIENTED SOFTWARE ARCHITECTURE
PATTERN-ORIENTED SOFTWARE ARCHITECTURE A Pattern Language for Distributed Computing Volume 4 Frank Buschmann, Siemens, Munich, Germany Kevlin Henney, Curbralan, Bristol, UK Douglas C. Schmidt, Vanderbilt
Architecture using Functional Programming concepts < + >
Architecture using Functional Programming concepts < + > Jorge Castillo @JorgeCastilloPr 1 2 Kotlin and Functional Programming FP means concern separation (declarative computations vs runtime execution),
Writing Reactive Application using Angular/RxJS, Spring WebFlux and Couchbase. Naresh Chintalcheru
Writing Reactive Application using Angular/RxJS, Spring WebFlux and Couchbase Naresh Chintalcheru Who is Naresh Technology professional for 18+ years Currently, Technical Architect at Cars.com Lecturer
Produced by. Design Patterns. MSc in Computer Science. Eamonn de Leastar
Design Patterns MSc in Computer Science Produced by Eamonn de Leastar (edeleastar@wit.ie)! Department of Computing, Maths & Physics Waterford Institute of Technology http://www.wit.ie http://elearning.wit.ie
MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science. Issued: Wed. 26 April 2017 Due: Wed.
ps.txt Fri Apr 07 14:24:11 2017 1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.945 Spring 2017 Problem Set 9 Issued: Wed. 26 April 2017 Due: Wed. 12
PROCESS CONTROL BLOCK TWO-STATE MODEL (CONT D)
MANAGEMENT OF APPLICATION EXECUTION PROCESS CONTROL BLOCK Resources (processor, I/O devices, etc.) are made available to multiple applications The processor in particular is switched among multiple applications
Konzepte von Programmiersprachen
Konzepte von Programmiersprachen Chapter 5: Continuation-Passing Interpreters Stefan Wehr Universität Freiburg 8. Juni 2009 Konzepte von Programmiersprachen 1 / 43 Motivation Continuations: abstraction
Testing for Linearizability
Testing for Linearizability 01 Testing for Linearizability Gavin Lowe Testing for Linearizability 02 Linearizability Linearizability is a well-established and accepted correctness condition for concurrent
First-Class Synchronization Barriers. Franklyn Turbak Wellesley College
First-Class Synchronization Barriers Franklyn Turbak Wellesley College Overview What is a Synchronization Barrier? Dimensions of Barriers Synchrons: First-Class Barriers with a Variable Number of Participants
Writing Browser Extensions in Kotlin. Kirill Rakhman busradar.com
Writing Browser Extensions in Kotlin Kirill Rakhman (@Cypressious) busradar.com KotlinJS No longer expiremental since 1.1.0 Can run anywhere where JS runs Can call JS Websites NodeJS Browser Extensions
IT 540 Operating Systems ECE519 Advanced Operating Systems
IT 540 Operating Systems ECE519 Advanced Operating Systems Prof. Dr. Hasan Hüseyin BALIK (3 rd Week) (Advanced) Operating Systems 3. Process Description and Control 3. Outline What Is a Process? Process
The Kotlin Programming Language. Andrey Breslav
The Kotlin Programming Language Andrey Breslav What is Kotlin? Statically typed object-oriented JVM-targeted general-purpose programming language developed by JetBrains intended for industrial use Docs
Android and Flux: It s a match! Attila Polacsek Senior Android Developer Supercharge
Android and Flux: It s a match! Attila Polacsek Senior Android Developer Supercharge INTRO INTRO WHAT IS FLUX? WHAT IS FLUX? What is FLUX? Application architecture Pattern, not a framework Created by Facebook
Announcements. CSCI 334: Principles of Programming Languages. Lecture 16: Intro to Scala. Announcements. Squeak demo. Instructor: Dan Barowy
Announcements CSCI 334: Principles of Programming Languages Lecture 16: Intro to Scala HW7 sent out as promised. See course webpage. Instructor: Dan Barowy Announcements No class on Tuesday, April 17.
An Overview of Scala. Philipp Haller, EPFL. (Lots of things taken from Martin Odersky's Scala talks)
An Overview of Scala Philipp Haller, EPFL (Lots of things taken from Martin Odersky's Scala talks) The Scala Programming Language Unifies functional and object-oriented programming concepts Enables embedding
Kotlin, Start? Start! (pluu) Android Developer GDG Korea Android Organizer
Kotlin, Start? Start! (pluu) Android Developer GDG Korea Android Organizer Agenda Kotlin Overview Kotlin?? Basic fun main(args: Array): Unit { println("hello, world!") Basic Function Keyword
Chapter 4: Threads. Operating System Concepts 9 th Edition
Chapter 4: Threads Silberschatz, Galvin and Gagne 2013 Chapter 4: Threads Overview Multicore Programming Multithreading Models Thread Libraries Implicit Threading Threading Issues Operating System Examples
Introduction to Asynchronous Programming Fall 2014
CS168 Computer Networks Fonseca Introduction to Asynchronous Programming Fall 2014 Contents 1 Introduction 1 2 The Models 1 3 The Motivation 3 4 Event-Driven Programming 4 5 select() to the rescue 5 1
Scalable Performance for Scala Message-Passing Concurrency
Scalable Performance for Scala Message-Passing Concurrency Andrew Bate Department of Computer Science University of Oxford cso.io Motivation Multi-core commodity hardware Non-uniform shared memory Expose
Kotlin for Android developers
ROME - APRIL 13/14 2018 Kotlin for Android developers Victor Kropp, JetBrains @kropp Kotlin on JVM + Android JS In development: Kotlin/Native ios/macos/windows/linux Links Kotlin https://kotlinlang.org
ARCHETYPE MODERN ANDROID ARCHITECTURE STEPAN GONCHAROV / DENIS NEKLIUDOV
ARCHETYPE MODERN ANDROID ARCHITECTURE STEPAN GONCHAROV / DENIS NEKLIUDOV 90seconds.tv 14000+ VIDEOS 1200+ BRANDS 92+ COUNTRIES data class RegisterViewModelStateImpl( override val email: ObservableString
UNIT -3 PROCESS AND OPERATING SYSTEMS 2marks 1. Define Process? Process is a computational unit that processes on a CPU under the control of a scheduling kernel of an OS. It has a process structure, called
Phaser volle Energie...
Phaser volle Energie...... eine Reise ins Paralleluniversum von JDK7 Hartmut Lang, Ericsson July 2011 Hartmut Lang Senior Software Developer Solution Architect Network Management and Customer Solutions
ELEC 377 Operating Systems. Week 1 Class 2
Operating Systems Week 1 Class 2 Labs vs. Assignments The only work to turn in are the labs. In some of the handouts I refer to the labs as assignments. There are no assignments separate from the labs.
Architectures and Applications for Wireless Sensor Networks ( ) Node Programming
Architectures and Applications for Wireless Sensor Networks (01204525) Node Programming Chaiporn Jaikaeo chaiporn.j@ku.ac.th Department of Computer Engineering Kasetsart University Outline Microcontroller
MultiThreading. Object Orientated Programming in Java. Benjamin Kenwright
MultiThreading Object Orientated Programming in Java Benjamin Kenwright Outline Review Essential Java Multithreading Examples Today s Practical Review/Discussion Question Does the following code compile?
Principles of Programming Languages, 2
Principles of Programming Languages, 2 Matteo Pradella February 2015 Matteo Pradella Principles of Programming Languages, 2 February 2015 1 / 23 1 Object Oriented Programming (OO) Matteo Pradella Principles
Topics in Object-Oriented Design Patterns
Software design Topics in Object-Oriented Design Patterns Material mainly from the book Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides; slides originally by Spiros Mancoridis;
Chapter 4: Threads. Operating System Concepts 9 th Edition
Chapter 4: Threads Silberschatz, Galvin and Gagne 2013 Chapter 4: Threads Overview Multicore Programming Multithreading Models Thread Libraries Implicit Threading Threading Issues Operating System Examples
Process Description and Control
Process Description and Control 1 Process:the concept Process = a program in execution Example processes: OS kernel OS shell Program executing after compilation www-browser Process management by OS : Allocate
Simplifying Asynchronous Code with
Simplifying Asynchronous Code with Scala Async JASON ZAUGG PHILIPP HALLER The Problem Asynchronous code ubiquitous Intrinsic to programming models like actors Required for performance and scalability See
CSC 539: Operating Systems Structure and Design. Spring 2006
CSC 539: Operating Systems Structure and Design Spring 2006 Processes and threads process concept process scheduling: state, PCB, process queues, schedulers process operations: create, terminate, wait,
An actor system for Scala.js Semester project, Fall 2013
An actor system for Scala.js Semester project, Fall 2013 Sébastien Doeraene Under the supervision of Martin Odersky January 31, 2014 Abstract This reports presents the design of an actor system for Scala.js
The Rise and Rise of Dataflow in the JavaVerse
The Rise and Rise of Dataflow in the JavaVerse @russel_winder russel@winder.org.uk https://www.russel.org.uk 1 The Plan for the Session Stuff. More stuff. Even more stuff possibly. Summary and conclusions
Process Concepts. CSC400 - Operating Systems. 3. Process Concepts. J. Sumey
CSC400 - Operating Systems 3. Process Concepts J. Sumey Overview Concurrency Processes & Process States Process Accounting Interrupts & Interrupt Processing Interprocess Communication CSC400 - Process
Decisions Behind the Design of the Queued Message Handler Template
Decisions Behind the Design of the Queued Message Handler Template Name, Title, National Instruments Outline Where QMH fits in with other patterns QMH Design Main VI organization Project organization Inter-loop
Threads SPL/2010 SPL/20 1
Threads 1 Today Processes and Scheduling Threads Abstract Object Models Computation Models Java Support for Threads 2 Process vs. Program processes as the basic unit of execution managed by OS OS as any
Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors. Jonas Bonér Viktor Klang
Akka: Simpler Concurrency, Scalability & Fault-tolerance through Actors Jonas Bonér Viktor Klang We believe that... Writing correct concurrent applications is too hard Scaling out applications is too hard
The Reactive Landscape Clement Escoffier, Vert.x Core Developer, Red Hat
The Reactive Landscape http://bit.ly/jfokus-reactive Clement Escoffier, Vert.x Core Developer, Red Hat Reactive all the things??? Elasticity Manifesto Actor System Asynchrony Programming Events 2 Message
Who am I? Harlan Iverson. Programming enthusiast. Seeker of truth. Imperfect. I'll be wrong about some things. Please correct me if you can.
Who am I? Harlan Iverson. Programming enthusiast. Seeker of truth. Imperfect. I'll be wrong about some things. Please correct me if you can. P.S... I hate boring presentations. Please, engage and stay
Simplifying Asynchronous Code with
Simplifying Asynchronous Code with Scala Async PHILIPP HALLER The Problem Asynchronous code Using an API that requires you to register callbacks? Then you re writing asynchronous code! Problem: callbacks
Knit, Chisel, Hack: Crafting with Guile Scheme. Andy Wingo ~ wingolog.org
Knit, Chisel, Hack: Crafting with Guile Scheme Andy Wingo ~ wingo@igalia.com wingolog.org ~ @andywingo I love craft! Woodworking Gardening Grow-your-own Brew-your-own Knit-your-own Sew-your-own Roast-your-own
آنستیتیوت تکنالوجی معلوماتی و مخابراتی ICTI
آنستیتیوت تکنالوجی معلوماتی و مخابراتی ICTI Information Technology Department Operating System (IT413) 2017-1396 Chapter 4: Process & Thread Contents: What Is a Process? Relationships between Processes
QWeSST. Type-Safe Web Programming. Thierry Sans and Iliano Cervesato. Carnegie Mellon University Qatar
QWeSST Type-Safe Web Programming Thierry Sans and Iliano Cervesato Carnegie Mellon University Qatar Katholieke Universiteit Leuven, Belgium 2 August 2011 Project Goal Study the foundations of web programming
Practical Algebraic Effect Handlers in Multicore OCaml
Practical Algebraic Effect Handlers in Multicore OCaml KC Sivaramakrishnan University of Cambridge OCaml Labs Multicore OCaml Native support for concurrency and parallelism https://github.com/ocamllabs/ocaml-multicore
EXPORT MANAGER USER GUIDE
EXPORT MANAGER USER GUIDE Table of Contents Table of Contents 1 Overview 2 General Concepts 2 Creating a Job 3 General Properties 4 Source Properties 4 Export Properties 4 Running Jobs 5 Options 5 Export
CST242 Concurrency Page 1
CST242 Concurrency Page 1 1 2 3 4 5 6 7 9 Concurrency CST242 Concurrent Processing (Page 1) Only computers with multiple processors can truly execute multiple instructions concurrently On single-processor
Calculating Correct Compilers
university of copenhagen department of computer science Faculty of Science Calculating Correct Compilers Patrick Bahr1 Graham Hutton2 1 University of Copenhagen, Department of Computer Science paba@diku.dk
Info 408 Distributed Applications Programming Exercise sheet nb. 4
Lebanese University Info 408 Faculty of Science 2017-2018 Section I 1 Custom Connections Info 408 Distributed Applications Programming Exercise sheet nb. 4 When accessing a server represented by an RMI
Control in Sequential Languages
CS 242 2012 Control in Sequential Languages Reading: Chapter 8, Sections 8.1 8.3 (only) Section 7.3 of The Haskell 98 Report, Exception Handling in the I/O Monad, http://www.haskell.org/onlinelibrary/io-13.html
OPERATING SYSTEM. Chapter 4: Threads
OPERATING SYSTEM Chapter 4: Threads Chapter 4: Threads Overview Multicore Programming Multithreading Models Thread Libraries Implicit Threading Threading Issues Operating System Examples Objectives To
Grand Central Dispatch and NSOperation. CSCI 5828: Foundations of Software Engineering Lecture 28 12/03/2015
Grand Central Dispatch and NSOperation CSCI 5828: Foundations of Software Engineering Lecture 28 12/03/2015 1 Credit Where Credit Is Due Most of the examples in this lecture were inspired by example code
f() ! " Run a higher-priority task? ! " Yield the processor to another task because our ! " Use the processor for some other activity while
CS 410/510: Advanced Programming Continuing a Computation: Continuations Mark P Jones Portland State University 1 Standard nested function call pattern 2 Continuing a Computation: What might we want to
CS 410/510: Advanced Programming
CS 410/510: Advanced Programming Continuations Mark P Jones Portland State University 1 Continuing a Computation: f() g() h() Standard nested function call pattern 2 Continuing a Computation: f() g() h()
PROCESSES Gursharan Singh Tatla 24/01/2011
1 PROCESSES Gursharan Singh Tatla professorgstatla@gmail.com Process 2 A process is a set of sequential steps that are required to do a particular task. A process is an instance of a program in execution.
Object Oriented Paradigm
Object Oriented Paradigm Ming-Hwa Wang, Ph.D. Department of Computer Engineering Santa Clara University Object Oriented Paradigm/Programming (OOP) similar to Lego, which kids build new toys from assembling
W4118 Operating Systems. Junfeng Yang
W4118 Operating Systems Junfeng Yang What is a process? Outline Process dispatching Common process operations Inter-process Communication What is a process Program in execution virtual CPU Process: an
Next Gen Networking Infrastructure With Rust
Next Gen Networking Infrastructure With Rust Hi, I m @carllerche You may remember me from Most newer databases are written in a language that includes a runtime C / C++ Memory management we ll do it live
DON'T BLOCK YOUR MOBILES AND INTERNET OF THINGS
DON'T BLOCK YOUR MOBILES AND INTERNET OF THINGS Use non blocking I/O for scalable and resilient server applications MAGNUS LARSSON, PÄR WENÅKER, ANDERS ASPLUND 2014-10-23 CALLISTAENTERPRISE.SE AGENDA The
IT Certification Exams Provider! Weofferfreeupdateserviceforoneyear! h ps://
IT Certification Exams Provider! Weofferfreeupdateserviceforoneyear! h ps://www.certqueen.com Exam : 70-484 Title : Essentials of Developing Windows Store Apps using C# Version : V11.02 1 / 6 1.Topic 1,
Questions from last time
Questions from last time Pthreads vs regular thread? Pthreads are POSIX-standard threads (1995). There exist earlier and newer standards (C++11). Pthread is probably most common. Pthread API: about a 100
Concurrent Python. Cody Soyland Austin Web Python User Group - Feb 28, Thursday, February 28, 13
Concurrent Python Cody Soyland Austin Web Python User Group - Feb 28, 2013 Getting started Notes on codysoyland.com Install gevent 1.0 (release candidate) Load my ipython Notebooks The Real-time Web Technologies
CSE 331 Software Design & Implementation
CSE 331 Software Design & Implementation Kevin Zatloukal Summer 2017 Java Graphics and GUIs (Based on slides by Mike Ernst, Dan Grossman, David Notkin, Hal Perkins, Zach Tatlock) Review: how to create
Java 8 Programming for OO Experienced Developers
www.peaklearningllc.com Java 8 Programming for OO Experienced Developers (5 Days) This course is geared for developers who have prior working knowledge of object-oriented programming languages such as
SCXML State Chart XML
SCXML State Chart XML Previously, in this course... Previously, in this course... Running Example all actions omitted wasn t it supposed to help? Previously, in this course... Running Example all actions
SWIFT & #IOExtendedCLT, 18th May 2016
SWIFT & KOTLIN @DagnaBieda, #IOExtendedCLT, 18th May 2016 Software Engineer at Quoin, 209 Delburg Street, Davidson, NC Sources tell The Next Web that Google is considering making Swift a first class language
University of Tartu Faculty of Mathematics and Computer Science Institute of Computer Science
University of Tartu Faculty of Mathematics and Computer Science Institute of Computer Science Martin Vels Concurrent programming languages: Scala Research paper for Distributed Systems Seminar Advisor:
Programming in Scala Second Edition
Programming in Scala Second Edition Martin Odersky, Lex Spoon, Bill Venners artima ARTIMA PRESS WALNUT CREEK, CALIFORNIA Contents Contents List of Figures List of Tables List of Listings Foreword Foreword
High-level Parallel Programming: Scala on the JVM
High-level Parallel Programming: Scala on the JVM Contents of Lecture 4 The Scala programming language Parallel programming using actors Jonas Skeppstedt (jonasskeppstedt.net) Lecture 4 2017 1 / 40 Purpose
Ozma: Extending Scala with Oz Concurrency
Ozma: Extending Scala with Oz Concurrency Peter Van Roy Sébastien Doeraene QCon 2011 San Francisco Nov. 18, 2011 PLDC Research Group (pldc.info.ucl.ac.be) Université catholique de Louvain B-1348 Louvain-la-Neuve,