Introduction to Kotlin coroutines
22 likes6,559 views
The document introduces coroutines in Kotlin. It discusses how coroutines make asynchronous code easier to write by allowing suspending functions and avoiding callback hell. Coroutines were introduced in early languages like Simula but fell out of favor due to multithreading. They are now regaining popularity for writing asynchronous non-blocking code. The document then covers how coroutines work in Kotlin, including suspending functions, coroutine builders like launch and async, and how coroutines avoid issues with approaches like callbacks and futures. It notes that coroutines in Kotlin are currently experimental but can be used in production code.
1 of 36
Ad
Recommended
Introduction to kotlin coroutines
Introduction to kotlin coroutinesNAVER Engineering Kotlin Coroutines provide a new way to write asynchronous and concurrent code using suspending functions and structured concurrency. Coroutines avoid callbacks and allow sequencing of asynchronous code using async/await. Coroutines are lightweight threads that can be suspended and resumed. Channels allow coroutines to communicate and share data. Flows provide a reactive streams API for coroutines. Kotlin coroutines offer improvements over other asynchronous programming models like callbacks and RxJava.
Deep dive into Coroutines on JVM @ KotlinConf 2017
Deep dive into Coroutines on JVM @ KotlinConf 2017Roman Elizarov The document provides an in-depth exploration of coroutines in Kotlin, detailing various programming styles including direct style, continuation-passing style (CPS), and their transformations. It explains how Kotlin manages suspending functions, continuations, and the coroutine context, touching upon thread management and job cancellation. The content also addresses the use of callbacks, state machines, and integrates with frameworks like kotlinx-coroutines, showcasing practical examples and coding techniques.
Kotlin Coroutines. Flow is coming
Kotlin Coroutines. Flow is comingKirill Rozov Kotlin Coroutines Flow is coming to provide a cold asynchronous data stream that emits values sequentially within a coroutine. Flow allows mapping, filtering, and collecting values, handles exceptions transparently, and preserves context. It can integrate with existing APIs like Room and Retrofit using adapters, and is the primary way to handle async streams going forward. Channels will still be used for hot streams and synchronization between coroutines.
Introduction to Spring WebFlux #jsug #sf_a1
Introduction to Spring WebFlux #jsug #sf_a1Toshiaki Maki The document provides an introduction and overview of Spring WebFlux, a non-blocking web framework for Spring. It discusses the differences between blocking and non-blocking web stacks, and how Spring WebFlux uses reactive streams and programming. Code examples are provided showing how to build reactive controllers and streams in Spring WebFlux that support backpressure.
Introduction to Koltin for Android Part I
Introduction to Koltin for Android Part I Atif AbbAsi The document provides an extensive overview of Kotlin programming language best practices and its integration with Android development, covering syntax, null safety, control flow, functions, object-oriented principles, and data binding. It emphasizes Kotlin's features such as nullability, concise syntax, data classes, and various Kotlin constructs like coroutines and dependency injection. Additionally, it outlines recommended best practices for Android development, including clean architecture, code quality maintenance, and performance considerations.
Jetpack Compose a new way to implement UI on Android
Jetpack Compose a new way to implement UI on AndroidNelson Glauber Leal Jetpack Compose is a modern declarative UI toolkit for Android that simplifies and accelerates UI development using Kotlin APIs. It is designed to create components over screens, allowing compatibility with existing Android apps and encouraging progressive adoption, although it is currently in an experimental alpha stage. The document provides an overview of its features, materials, and example code snippets for implementing UI elements and layouts.
Build RESTful API Using Express JS
Build RESTful API Using Express JSCakra Danu Sedayu This document provides a comprehensive guide on building APIs using Node.js and Express, highlighting the basic concepts of non-blocking I/O and RESTful API design. It details installation instructions, HTTP verbs for CRUD operations, and the organization of files and modules within an Express application. Additionally, it covers the integration of a NoSQL database using Mongoose for managing user data.
Digital light processing
Digital light processingRamrao Desai DLP (Digital Light Processing) technology was developed by Texas Instruments in 1987. It uses a digital micromirror device (DMD) chip containing a grid of hundreds of thousands of tiny tilting mirrors to produce high-quality images with high brightness and contrast. Each mirror represents one pixel and rapidly tilts between on and off positions to reflect light and produce colors using a spinning color wheel. DLP has advantages over other display technologies as it can create images of any size, has excellent brightness uniformity, and does not use heat-sensitive organic materials. It is widely used in projectors, TVs, and other applications demanding superior visuals.
Junit
JunitFAROOK Samath JUnit is a unit testing framework for Java programming language. It was originally written by Kent Beck and Erich Gamma. Some key points:
- JUnit was one of the first unit testing frameworks for Java and has become the de facto standard.
- It allows writing and running repeatable tests to help find and prevent bugs. Tests are written in plain Java classes and methods.
- JUnit provides annotations like @Test, @Before, @After to identify test methods and set up/tear down methods.
- It includes assertions for validations and will report failures immediately. Tests can be organized into test suites.
JavaScript Promises
JavaScript PromisesL&T Technology Services Limited The document discusses callback functions and their implications in JavaScript, particularly the issue known as 'callback hell' where nested callbacks complicate code readability. It introduces promises as a solution to manage asynchronous operations in a cleaner manner, outlining their structure, use cases, and advantages over callbacks. The document also compares jQuery's promise model with the 'q' library and AngularJS's implementation, highlighting important functional differences.
JavaScript Promises
JavaScript PromisesDerek Willian Stavis The document provides an extensive overview of JavaScript promises, detailing their definitions, states, and APIs, as well as the transition from callback functions to using promises for managing asynchronous operations. It discusses the advantages of promises, including chaining and handling multiple promises, as well as introducing Promise A+ specifications and libraries like Bluebird. Additionally, it illustrates practical examples and use cases for promises in modern JavaScript development.
Android kotlin coroutines
Android kotlin coroutinesBipin Vayalu The document discusses coroutines as asynchronous tasks and lightweight threads, which help simplify complex concurrent programming. It covers implementation details such as the use of suspend functions and coroutine builders like runBlocking, launch, and async. Additionally, it provides references to various resources for further learning about Kotlin coroutines.
Intro to Asynchronous Javascript
Intro to Asynchronous JavascriptGarrett Welson The document provides an introduction to asynchronous JavaScript. It discusses callbacks and their disadvantages like callback hell. Promises are introduced as a better way to handle asynchronous code by making it easier to write and chain asynchronous operations. Async/await is described as syntactic sugar that allows asynchronous code to be written more readably in a synchronous style using await and try/catch. Key aspects like the event loop, microtask queue, and Promise methods like all and race are explained. Overall the document aims to help understand what makes asynchronous code different and newer methods like promises and async/await that improve handling asynchronous operations in JavaScript.
Coroutines in Kotlin
Coroutines in KotlinAlexey Soshin Coroutines are Kotlin's solution for concurrency and allow doing something else while waiting for results. They avoid issues with threading like memory usage and bottlenecks. Coroutines use suspending functions to pause execution and switch to other coroutines. They can be cancelled, have timeouts set, and structured hierarchically with jobs. Common coroutine patterns include producers that return values on channels and actors that receive messages on inbound channels. Coroutines are backed by event loops and may require yield() if CPU bound to allow other coroutines to run.
From Generator to Fiber the Road to Coroutine in PHP
From Generator to Fiber the Road to Coroutine in PHPAlbert Chen The document discusses generators, fibers, and coroutines in PHP. It explains that generators allow for yielding values iteratively without building an array, while fibers provide each their own call stack allowing suspension at any point. Coroutines in Swoole make blocking I/O non-blocking through automatic yielding and resuming. Event loops power asynchronous non-blocking I/O by handling callbacks from I/O streams. Both generators and fibers are building blocks for implementing coroutines to improve PHP application concurrency.
JavaScript: Variables and Functions
JavaScript: Variables and FunctionsJussi Pohjolainen This document discusses JavaScript variables, functions, and objects. It covers JavaScript datatypes like numbers, strings, and objects. It describes variable scope and how variables are hoisted or moved to the top of their function. It also discusses how functions can be defined and used as variables. Global objects like the window object are described. Finally, it provides examples of defining basic functions and using objects with properties and methods.
Spring Boot
Spring BootJaran Flaath Spring Boot is a framework that makes it easy to create stand-alone, production-grade Spring based applications that you can "just run". It allows you to create stand-alone applications, embed Tomcat/Jetty directly with no need to deploy WAR files, and provides starter POMs to simplify configuration. Spring Boot applications are run by adding a spring-boot-gradle-plugin and can then be run as an executable JAR. Features include REST endpoints, security, external configuration, and production monitoring via Actuators.
Introduction to kotlin
Introduction to kotlinNAVER Engineering The document discusses the Kotlin programming language. It highlights that Kotlin is a modern, pragmatic language that provides good tooling and interoperability with Java. It has grown significantly in popularity since its initial release. The document then discusses various features of Kotlin like its concise and readable syntax, null safety, support for lambdas and extensions, and how it can be used for multi-platform projects. Kotlin aims to be an improvement over Java by making code more concise, safe, and expressive while maintaining interoperability with existing Java code and libraries.
Introduction to Coroutines @ KotlinConf 2017
Introduction to Coroutines @ KotlinConf 2017Roman Elizarov The document introduces Kotlin coroutines for asynchronous programming, demonstrating how to handle requests and posts without blocking threads. It contrasts traditional blocking calls, callbacks, and futures with coroutines, highlighting the benefits of clarity and ease of use in asynchronous code. Key examples illustrate the transition from callbacks to using suspend functions for cleaner, more manageable code.
Asynchronous JavaScript Programming with Callbacks & Promises
Asynchronous JavaScript Programming with Callbacks & PromisesHùng Nguyễn Huy This presentation by Hung Nguyen Huy covers the concepts of callbacks, asynchronous processing, and promises in JavaScript. It explains the challenges of callback hell and how promises can simplify asynchronous coding with better error handling and chaining capabilities. The document details promise states, methods like then() and catch(), and features such as promise.all() and promise.race().
Kotlin for Android Development
Kotlin for Android DevelopmentSpeck&Tech The document discusses Kotlin, a programming language developed by JetBrains that targets JVM, Android, and JavaScript, emphasizing its interoperability with Java and advantages over Java 6 limitations for Android development. It highlights Kotlin's features such as immutability, nullability handling, extension functions, and the Anko library for simplifying UI layout generation and asynchronous tasks. The document also provides coding examples illustrating how Kotlin reduces boilerplate code and enhances functionality.
Idiomatic Kotlin
Idiomatic Kotlinintelliyole The document provides idiomatic Kotlin coding style guidelines and best practices for expressions, classes, functions, and the standard library. Some key recommendations include using 'when' and 'try' as expression bodies, avoiding classes just for functions, extracting non-essential APIs to extensions, using data classes, type aliases, and destructuring declarations, and leveraging functions like 'apply', 'filterIsInstance', and 'groupBy' from the standard library. Overall the document advises organizing code in a concise and functional way that fully utilizes Kotlin language features.
Java And Multithreading
Java And MultithreadingShraddha The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
Android | Android Activity Launch Modes and Tasks | Gonçalo Silva
Android | Android Activity Launch Modes and Tasks | Gonçalo SilvaJAX London The document discusses Android activity launch modes and tasks, explaining the structure and behavior of activities within applications. It covers key concepts like intents, activity stacks, and launch modes (standard, singleTop, singleTask, singleInstance) that influence how activities are managed and reused. Additionally, it details the usage of intent flags and manifest attributes that guide task and activity lifecycle management.
Intro to kotlin
Intro to kotlinTomislav Homan The document discusses the drawbacks of using Java for Android development and presents Kotlin as a modern alternative. It highlights Kotlin's advantages such as interoperability with Java, concise syntax, and features like null safety and data classes, while also mentioning possible disadvantages including some instability and code generation challenges. The content also covers migration strategies for transitioning to Kotlin from Java.
Rust
RustChih-Hsuan Kuo Rust is a systems programming language that provides memory safety without using a garbage collector. It achieves memory safety through rules of ownership, borrowing, and lifetimes that are checked at compile time. These rules prevent common memory bugs like memory leaks, dangling pointers, and use-after-free errors that are common in C and C++.
API for Beginners
API for BeginnersSébastien Saunier This document introduces APIs and how they are used by developers. It explains that APIs allow programs to interact with other applications and services to access useful data and functionality. Developers can use APIs by making HTTP requests to consume data and build their own applications. The document provides examples of popular APIs like Google Maps, Twilio, and Meetup that developers integrate into their applications. It also discusses the differences between making API calls and using webhooks to receive automatic notifications from a service.
REST APIs with Spring
REST APIs with SpringJoshua Long The document is a comprehensive guide on building REST services using Spring, authored by Josh Long. It covers topics such as Spring framework features, RESTful principles, HTTP methods, status codes, content negotiation, and security measures. The guide emphasizes the importance of error handling, API versioning, and the role of HATEOAS in RESTful services.
Eclipse OMR: a modern toolkit for building language runtimes
Eclipse OMR: a modern toolkit for building language runtimesMark Stoodley Eclipse OMR is a modern toolkit for building language runtimes that provides high quality runtime ingredients like a porting library, threading library, garbage collection framework, and JIT compiler tools. It has no language semantics of its own and is designed to be integrated into various language runtimes. The presentation demonstrates how OMR has already been used successfully in Ruby, Python, and Smalltalk runtimes and provides performance benefits. It invites others to get involved in the open source project.
Scratching the itch, making Scratch for the Raspberry Pie
Scratching the itch, making Scratch for the Raspberry PieESUG The document discusses performance improvements for Scratch on Raspberry Pi, highlighting that it is a widely used educational tool despite its slow execution. It details various profiling challenges, code optimization techniques, and the need for better algorithms, particularly for graphical operations. The project aims to enhance Scratch's overall efficiency and user experience, moving towards a more modern software architecture.
More Related Content
What's hot (20)
Junit
JunitFAROOK Samath JUnit is a unit testing framework for Java programming language. It was originally written by Kent Beck and Erich Gamma. Some key points:
- JUnit was one of the first unit testing frameworks for Java and has become the de facto standard.
- It allows writing and running repeatable tests to help find and prevent bugs. Tests are written in plain Java classes and methods.
- JUnit provides annotations like @Test, @Before, @After to identify test methods and set up/tear down methods.
- It includes assertions for validations and will report failures immediately. Tests can be organized into test suites.
JavaScript Promises
JavaScript PromisesL&T Technology Services Limited The document discusses callback functions and their implications in JavaScript, particularly the issue known as 'callback hell' where nested callbacks complicate code readability. It introduces promises as a solution to manage asynchronous operations in a cleaner manner, outlining their structure, use cases, and advantages over callbacks. The document also compares jQuery's promise model with the 'q' library and AngularJS's implementation, highlighting important functional differences.
JavaScript Promises
JavaScript PromisesDerek Willian Stavis The document provides an extensive overview of JavaScript promises, detailing their definitions, states, and APIs, as well as the transition from callback functions to using promises for managing asynchronous operations. It discusses the advantages of promises, including chaining and handling multiple promises, as well as introducing Promise A+ specifications and libraries like Bluebird. Additionally, it illustrates practical examples and use cases for promises in modern JavaScript development.
Android kotlin coroutines
Android kotlin coroutinesBipin Vayalu The document discusses coroutines as asynchronous tasks and lightweight threads, which help simplify complex concurrent programming. It covers implementation details such as the use of suspend functions and coroutine builders like runBlocking, launch, and async. Additionally, it provides references to various resources for further learning about Kotlin coroutines.
Intro to Asynchronous Javascript
Intro to Asynchronous JavascriptGarrett Welson The document provides an introduction to asynchronous JavaScript. It discusses callbacks and their disadvantages like callback hell. Promises are introduced as a better way to handle asynchronous code by making it easier to write and chain asynchronous operations. Async/await is described as syntactic sugar that allows asynchronous code to be written more readably in a synchronous style using await and try/catch. Key aspects like the event loop, microtask queue, and Promise methods like all and race are explained. Overall the document aims to help understand what makes asynchronous code different and newer methods like promises and async/await that improve handling asynchronous operations in JavaScript.
Coroutines in Kotlin
Coroutines in KotlinAlexey Soshin Coroutines are Kotlin's solution for concurrency and allow doing something else while waiting for results. They avoid issues with threading like memory usage and bottlenecks. Coroutines use suspending functions to pause execution and switch to other coroutines. They can be cancelled, have timeouts set, and structured hierarchically with jobs. Common coroutine patterns include producers that return values on channels and actors that receive messages on inbound channels. Coroutines are backed by event loops and may require yield() if CPU bound to allow other coroutines to run.
From Generator to Fiber the Road to Coroutine in PHP
From Generator to Fiber the Road to Coroutine in PHPAlbert Chen The document discusses generators, fibers, and coroutines in PHP. It explains that generators allow for yielding values iteratively without building an array, while fibers provide each their own call stack allowing suspension at any point. Coroutines in Swoole make blocking I/O non-blocking through automatic yielding and resuming. Event loops power asynchronous non-blocking I/O by handling callbacks from I/O streams. Both generators and fibers are building blocks for implementing coroutines to improve PHP application concurrency.
JavaScript: Variables and Functions
JavaScript: Variables and FunctionsJussi Pohjolainen This document discusses JavaScript variables, functions, and objects. It covers JavaScript datatypes like numbers, strings, and objects. It describes variable scope and how variables are hoisted or moved to the top of their function. It also discusses how functions can be defined and used as variables. Global objects like the window object are described. Finally, it provides examples of defining basic functions and using objects with properties and methods.
Spring Boot
Spring BootJaran Flaath Spring Boot is a framework that makes it easy to create stand-alone, production-grade Spring based applications that you can "just run". It allows you to create stand-alone applications, embed Tomcat/Jetty directly with no need to deploy WAR files, and provides starter POMs to simplify configuration. Spring Boot applications are run by adding a spring-boot-gradle-plugin and can then be run as an executable JAR. Features include REST endpoints, security, external configuration, and production monitoring via Actuators.
Introduction to kotlin
Introduction to kotlinNAVER Engineering The document discusses the Kotlin programming language. It highlights that Kotlin is a modern, pragmatic language that provides good tooling and interoperability with Java. It has grown significantly in popularity since its initial release. The document then discusses various features of Kotlin like its concise and readable syntax, null safety, support for lambdas and extensions, and how it can be used for multi-platform projects. Kotlin aims to be an improvement over Java by making code more concise, safe, and expressive while maintaining interoperability with existing Java code and libraries.
Introduction to Coroutines @ KotlinConf 2017
Introduction to Coroutines @ KotlinConf 2017Roman Elizarov The document introduces Kotlin coroutines for asynchronous programming, demonstrating how to handle requests and posts without blocking threads. It contrasts traditional blocking calls, callbacks, and futures with coroutines, highlighting the benefits of clarity and ease of use in asynchronous code. Key examples illustrate the transition from callbacks to using suspend functions for cleaner, more manageable code.
Asynchronous JavaScript Programming with Callbacks & Promises
Asynchronous JavaScript Programming with Callbacks & PromisesHùng Nguyễn Huy This presentation by Hung Nguyen Huy covers the concepts of callbacks, asynchronous processing, and promises in JavaScript. It explains the challenges of callback hell and how promises can simplify asynchronous coding with better error handling and chaining capabilities. The document details promise states, methods like then() and catch(), and features such as promise.all() and promise.race().
Kotlin for Android Development
Kotlin for Android DevelopmentSpeck&Tech The document discusses Kotlin, a programming language developed by JetBrains that targets JVM, Android, and JavaScript, emphasizing its interoperability with Java and advantages over Java 6 limitations for Android development. It highlights Kotlin's features such as immutability, nullability handling, extension functions, and the Anko library for simplifying UI layout generation and asynchronous tasks. The document also provides coding examples illustrating how Kotlin reduces boilerplate code and enhances functionality.
Idiomatic Kotlin
Idiomatic Kotlinintelliyole The document provides idiomatic Kotlin coding style guidelines and best practices for expressions, classes, functions, and the standard library. Some key recommendations include using 'when' and 'try' as expression bodies, avoiding classes just for functions, extracting non-essential APIs to extensions, using data classes, type aliases, and destructuring declarations, and leveraging functions like 'apply', 'filterIsInstance', and 'groupBy' from the standard library. Overall the document advises organizing code in a concise and functional way that fully utilizes Kotlin language features.
Java And Multithreading
Java And MultithreadingShraddha The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
Android | Android Activity Launch Modes and Tasks | Gonçalo Silva
Android | Android Activity Launch Modes and Tasks | Gonçalo SilvaJAX London The document discusses Android activity launch modes and tasks, explaining the structure and behavior of activities within applications. It covers key concepts like intents, activity stacks, and launch modes (standard, singleTop, singleTask, singleInstance) that influence how activities are managed and reused. Additionally, it details the usage of intent flags and manifest attributes that guide task and activity lifecycle management.
Intro to kotlin
Intro to kotlinTomislav Homan The document discusses the drawbacks of using Java for Android development and presents Kotlin as a modern alternative. It highlights Kotlin's advantages such as interoperability with Java, concise syntax, and features like null safety and data classes, while also mentioning possible disadvantages including some instability and code generation challenges. The content also covers migration strategies for transitioning to Kotlin from Java.
Rust
RustChih-Hsuan Kuo Rust is a systems programming language that provides memory safety without using a garbage collector. It achieves memory safety through rules of ownership, borrowing, and lifetimes that are checked at compile time. These rules prevent common memory bugs like memory leaks, dangling pointers, and use-after-free errors that are common in C and C++.
API for Beginners
API for BeginnersSébastien Saunier This document introduces APIs and how they are used by developers. It explains that APIs allow programs to interact with other applications and services to access useful data and functionality. Developers can use APIs by making HTTP requests to consume data and build their own applications. The document provides examples of popular APIs like Google Maps, Twilio, and Meetup that developers integrate into their applications. It also discusses the differences between making API calls and using webhooks to receive automatic notifications from a service.
REST APIs with Spring
REST APIs with SpringJoshua Long The document is a comprehensive guide on building REST services using Spring, authored by Josh Long. It covers topics such as Spring framework features, RESTful principles, HTTP methods, status codes, content negotiation, and security measures. The guide emphasizes the importance of error handling, API versioning, and the role of HATEOAS in RESTful services.
Similar to Introduction to Kotlin coroutines (20)
Eclipse OMR: a modern toolkit for building language runtimes
Eclipse OMR: a modern toolkit for building language runtimesMark Stoodley Eclipse OMR is a modern toolkit for building language runtimes that provides high quality runtime ingredients like a porting library, threading library, garbage collection framework, and JIT compiler tools. It has no language semantics of its own and is designed to be integrated into various language runtimes. The presentation demonstrates how OMR has already been used successfully in Ruby, Python, and Smalltalk runtimes and provides performance benefits. It invites others to get involved in the open source project.
Scratching the itch, making Scratch for the Raspberry Pie
Scratching the itch, making Scratch for the Raspberry PieESUG The document discusses performance improvements for Scratch on Raspberry Pi, highlighting that it is a widely used educational tool despite its slow execution. It details various profiling challenges, code optimization techniques, and the need for better algorithms, particularly for graphical operations. The project aims to enhance Scratch's overall efficiency and user experience, moving towards a more modern software architecture.
Isomorphic Kotlin
Isomorphic KotlinBenjamin Snider The document discusses the benefits and features of Kotlin, emphasizing its ability to facilitate code sharing across platforms and the concept of isomorphism in programming. It compares two teams: one with fragmented knowledge across different platforms and a standardized 'team Kotlin' that promotes collaboration through shared code. The document also outlines various techniques and examples for effective code sharing in Kotlin, including multiplatform projects and server/client interactions.
Future of Kotlin - How agile can language development be?
Future of Kotlin - How agile can language development be?Andrey Breslav The document outlines the future vision for Kotlin, focusing on its growth, strategic directions, and planned enhancements including a transition towards multiplatform support and metaprogramming capabilities. It discusses the balance between maintaining backward compatibility and fostering innovation, alongside the importance of community engagement in the development process. Key updates will include support for Java 9, performance improvements, and an emphasis on shared code across various platforms.
2018-09 - F# and Fable
2018-09 - F# and FableEamonn Boyle The document discusses F# and Fable for functional client-side development, highlighting its features like strong static typing, type inference, and interop with .NET and JavaScript. While it praises the succinct and safe nature of the language and tooling, it also notes challenges such as confusing type inference, difficulties with error messages, and a complex structuring process. The author concludes that while F# and Fable are impressive for functional programming fans, TypeScript offers a better balance of productivity and interoperability with existing JavaScript libraries.
Craft Beer & Clojure
Craft Beer & ClojureMetosin Oy The document summarizes Clojure, a functional programming language that runs on the JVM and JavaScript virtual machines. It notes that Clojure is strongly typed, functional, immutable, and allows macros and runtime polymorphism. It then discusses Clojure adoption in Finland, providing examples of startups and consultancies using it. Finally, it recommends some resources for learning Clojure, including books and online courses.
Intro to elixir and phoenix
Intro to elixir and phoenixJared Smith This document provides an overview of Elixir and the Phoenix framework. It discusses how Elixir runs on the Erlang VM and inherits properties like high availability and distribution. Phoenix is introduced as a web framework for Elixir that focuses on productivity, reliability, and speed. Key Phoenix concepts like the request pipeline, router, controllers, models and views are briefly outlined.
Eclipse OMR: a modern, open-source toolkit for building language runtimes
Eclipse OMR: a modern, open-source toolkit for building language runtimesDev_Events The document presents an overview of Eclipse OMR, an open-source toolkit for building language runtimes, with insights into the speaker's background at IBM and the goals of the project. It details the components of language runtimes, the significance of Eclipse OMR in cloud platform innovation, and various technology integrations, including Java, Ruby, Lua, and Smalltalk. The document also invites participation in the development community and addresses the importance of collaboration for advancing language runtime technologies.
Monorepo at Pinterest
Monorepo at PinterestSuman Karumuri The document discusses the advantages and challenges of adopting a monorepo approach for code management at Pinterest, highlighting its role in dependency management, code consistency, and streamlined developer workflows. It elaborates on benefits such as easier code discovery and unified tooling, while also addressing downsides like slower repo syncing and more complex CI/CD processes. The conclusion underscores that despite technical hurdles, implementing a monorepo can significantly enhance code management efficiency and productivity.
Kotlin Multiplatfom In Action
Kotlin Multiplatfom In ActionMarko Mitic This document discusses why and how to share code across platforms using Kotlin Multiplatform. It notes that sharing code can increase productivity by reducing duplicated code and bugs, while allowing apps to share features and business logic. However, performance may decrease and innovation could slow if too much code is shared. Kotlin Multiplatform allows writing code once that can run natively on multiple platforms, while each platform still gets optimized binaries and access to native APIs. It provides optional code sharing without limiting developers to a subset of platforms or requiring shared UIs.
Go - A Key Language in Enterprise Application Development?
Go - A Key Language in Enterprise Application Development?C4Media The document discusses the relevance of the Go programming language in enterprise application development, highlighting its increasing popularity and impact on engineering productivity. It reviews the characteristics and benefits of Go compared to other languages, focusing on its simplicity, concurrency features, and strong community support. The presentation also covers its design philosophy, use in various applications, and comparisons with languages like Java and C++.
Kotlin Multiplatfom In Action
Kotlin Multiplatfom In ActionMarko Mitic The document discusses reasons for using Kotlin Multiplatform including writing code once that can run on multiple platforms, sharing business logic between server and client apps, and accessing native platform APIs from Kotlin. It notes Kotlin Multiplatform allows optional code sharing so only common code is shared. It also discusses why other cross-platform solutions may not be ideal and provides an overview of Kotlin/Native and concurrency in Kotlin.
Introduction to course
Introduction to coursenikit meshram This document provides an overview and introduction to a course on principles of compiler design. It discusses the motivation for studying compilers, as language processing is important for many software applications. It outlines what will be covered in the course, including the theoretical foundations and practical techniques for developing lexical analyzers, parsers, type checkers, code generators, and more. The document also describes the organization of the course with lectures, programming assignments, and exams.
Building a Cross-Platform Mobile SDK in Rust.pdf
Building a Cross-Platform Mobile SDK in Rust.pdfIanWagner13 This document discusses building a cross-platform mobile SDK in Rust. It introduces UniFFI, an open-source binding generator that produces idiomatic bindings for Swift, Kotlin, and other languages from an Interface Definition Language file. While cross-compilation for iOS is straightforward, Android requires configuring linker paths. Shipping the library also requires additional steps like creating a framework and dealing with platform-specific quirks in Swift and Android. Open questions remain around repository structure, build systems, and exploring Android further. Resources for UniFFI and compiling Rust for Android are provided.
NetWork - 15.10.2011 - Applied code generation in .NET
NetWork - 15.10.2011 - Applied code generation in .NET Dmytro Mindra This document discusses code generation in .NET. It begins by outlining some common problems developers face when dealing with large amounts of repetitive code. It then discusses various approaches to solving this problem, including hand coding everything, fully generic design, and using a combination of tools including code generation. The rest of the document discusses specific code generation tools for .NET like StringBuilder, CodeSnippets, XSLT, Reflection.Emit, EnvDTE, CodeDom, and T4. It also discusses pros and cons of each approach and provides examples of using code generation in different real world scenarios.
Putting Compilers to Work
Putting Compilers to WorkSingleStore Compilers can have a huge effect on software efficiency and performance by changing what user experiences are possible and reducing CPU and resource usage. They work by parsing code, generating machine-friendly representations, and emitting optimized machine code. As web programming grew in complexity, developers started building more efficient compilers for dynamic languages to preserve rapid development workflows while improving performance. There are various approaches to building compilers like interpreters, transpilers, using backends like LLVM, and fully custom solutions. The best approach depends on goals, constraints, and tradeoffs around control, performance, and development effort. Optimization focuses should include memory usage, caching, and runtime layout. Future areas may include database query compilation for real-time analytics on large datasets.
CSP: Huh? And Components
CSP: Huh? And ComponentsDaniel Fagnan This document discusses Communicating Sequential Processes (CSP) and building modular applications using components. It defines concurrency vs parallelism, explaining that concurrency is the model and parallelism is the act. Channels are presented as a powerful primitive for communication between concurrent tasks, allowing values to be put on or taken from the channel. Examples are given of CSP in Clojure and JavaScript. Components are described as a way to build modular applications from small, focused modules that do one thing well and avoid using globals.
Scalable game-servers-tgc
Scalable game-servers-tgcAshkan Saeedi Mazdeh The document discusses the author's extensive experience in developing scalable game servers, with a focus on concurrency, parallelism, and distributed systems. It highlights the actor model, specifically Microsoft's Orleans, as a solution for managing state in large-scale distributed environments effectively. The document includes a case study of a game backend architecture utilizing Orleans for handling real-time game functionalities like matchmaking and leaderboards.
CSP: Huh? And Components
CSP: Huh? And ComponentsDaniel Fagnan This document discusses Communicating Sequential Processes (CSP) and building modular applications with components. It defines concurrency vs parallelism, explaining that concurrency is the model and parallelism is the act. Channels are presented as a powerful primitive for communication between concurrent tasks, allowing values to be put on or taken from the channel. Examples are given of CSP in Clojure and JavaScript. Components are described as a way to build modular applications with common client-server code sharing via a Unix style of small, concentrated modules. Globals are discouraged in favor of the module pattern.
'Full Stack Kotlin' Workshop at KotlinConf
'Full Stack Kotlin' Workshop at KotlinConfGarth Gilmour This document provides information about a Kotlin workshop that will use Kotlin to build a full-stack web application from scratch. The workshop schedule includes introductions to Kotlin.js, React, Spring WebFlux, and Spring Data for Neo4J. Iterations will have participants building components of the application, putting it all together by the end of the day. Breaks are scheduled throughout the workshop. The trainers' backgrounds are also provided.
Ad
More from Roman Elizarov (20)
Kotlin Coroutines in Practice @ KotlinConf 2018
Kotlin Coroutines in Practice @ KotlinConf 2018Roman Elizarov The document discusses Kotlin coroutines, highlighting their lightweight nature similar to threads and practical usage for tasks such as downloading content. It emphasizes structured concurrency for managing references and downloading processes, addressing concerns about shared mutable state and potential crashes. The document also describes various patterns for handling worker threads and using channels for efficient communication in concurrent programming.
Fresh Async with Kotlin @ QConSF 2017
Fresh Async with Kotlin @ QConSF 2017Roman Elizarov The document discusses asynchronous programming with Kotlin coroutines. It begins by describing problems with callbacks and futures for asynchronous code, such as callback hell and complex combinators. Kotlin coroutines provide a natural way to write asynchronous code using suspending functions that read like regular synchronous code but can suspend and resume. This is achieved by compiling coroutines to state machines under the hood. The document demonstrates how coroutines integrate well with libraries like Retrofit for making asynchronous HTTP requests. It also discusses different ways to launch coroutines, such as using coroutine builders.
Scale Up with Lock-Free Algorithms @ JavaOne
Scale Up with Lock-Free Algorithms @ JavaOneRoman Elizarov This document provides a summary of a presentation on using lock-free algorithms to scale shared mutable state on the JVM. It begins with an introduction to the speaker and discusses why shared mutable state is needed for big data and real-time processing. It then uses a toy problem of implementing a concurrent stack to demonstrate the challenges of synchronization and contention. The presentation introduces the use of atomic references and compare-and-set operations to implement lock-free push and pop operations on the concurrent stack in a non-blocking manner, improving scalability.
Kotlin Coroutines Reloaded
Kotlin Coroutines ReloadedRoman Elizarov The document summarizes Roman Elizarov's presentation on Kotlin coroutines at the JVM Language Summit in 2017. The presentation recapped the initial Kotlin coroutines prototype, discussed issues with its design, and outlined the solutions adopted in Kotlin 1.1. This included using suspending functions instead of async/await keywords, tail suspension to avoid stack overflows, and abstraction to provide a natural coroutine declaration syntax.
Lock-free algorithms for Kotlin Coroutines
Lock-free algorithms for Kotlin CoroutinesRoman Elizarov The document discusses lock-free algorithms for Kotlin coroutines. It covers the implementation of a lock-free doubly linked list using single-word compare-and-swap operations. It also discusses how to build more complex atomic operations, like a multi-word compare-and-swap, to enable select expressions in Kotlin coroutines.
Non blocking programming and waiting
Non blocking programming and waitingRoman Elizarov This document discusses advanced non-blocking concurrency techniques. It begins with an introduction to lock-free programming and why it can provide benefits over locking approaches. It then covers concepts like blocking, non-blocking algorithms, and waiting without locks. Specific lock-free algorithms for a toy problem, waiting, and wakeup are presented. The document also discusses using the AbstractQueuedSynchronizer for implementing lock-free waiting queues and provides examples of how to make lock-free code fair. It concludes by emphasizing that lock-free programming is error-prone and the importance of learning patterns for concurrent code.
ACM ICPC 2016 NEERC (Northeastern European Regional Contest) Problems Review
ACM ICPC 2016 NEERC (Northeastern European Regional Contest) Problems ReviewRoman Elizarov The document reviews the 2016-2017 ACM ICPC Northeastern European Regional Contest, detailing the performance of 228 teams across 13 problems over 5 hours. It includes a summary table of problem statistics such as authors, number of attempts, and success rates, alongside problem-solving strategies for selected challenges. Additionally, it highlights solution approaches using programming techniques and algorithms, illustrating the complexity and variations in problem-solving among participating teams.
Многопоточное Программирование - Теория и Практика
Многопоточное Программирование - Теория и ПрактикаRoman Elizarov Документ обсуждает теорию и практику многопоточности, включая закон Мура, формальные модели параллельных вычислений и важность корректности алгоритмов. Рассматриваются общие переменные как основы параллельных алгоритмов, а также модели чередования и глобального времени, их применение и ограничения. Обсуждаются проблемы линеаризуемости и порядок операций в контексте синхронизации потоков в современных языках программирования.
Wait for your fortune without Blocking!
Wait for your fortune without Blocking!Roman Elizarov The document discusses concurrency, emphasizing the importance of non-blocking algorithms for performance and scalability, as opposed to blocking methods that can lead to thread suspension and potential deadlocks. It explains concepts like shared state management, the use of locks, and the advantages of lock-free programming, particularly through the AbstractQueuedSynchronizer (AQS) class. The author warns that while lock-free programming can reduce performance costs and deadlocks, it is also highly challenging and prone to bugs.
ACM ICPC 2015 NEERC (Northeastern European Regional Contest) Problems Review
ACM ICPC 2015 NEERC (Northeastern European Regional Contest) Problems ReviewRoman Elizarov The document summarizes the problems from the Northeastern European Regional Contest (NEERC). It provides statistics on each of the 12 problems, including the number of teams that solved it and the overall success rate. It then discusses the key ideas for solving three of the problems - Adjustment Office, Binary vs Decimal, and Cactus Jubilee - in 1-3 sentences each.
ACM ICPC 2014 NEERC (Northeastern European Regional Contest) Problems Review
ACM ICPC 2014 NEERC (Northeastern European Regional Contest) Problems ReviewRoman Elizarov The document provides solutions to various problems from the 2014 ACM ICPC Northeastern European Regional Contest, summarizing methods for each problem, including techniques like graph parsing, greedy algorithms, and dynamic programming. It addresses problems including board manipulation, optimization problems, game strategies, and pathfinding in graphs, demonstrating a range of algorithmic approaches. Each problem is described with a brief explanation of the underlying concepts and the optimal approaches to solve them.
Why GC is eating all my CPU?
Why GC is eating all my CPU?Roman Elizarov The document discusses Java memory allocation profiling using the Aprof tool. It explains that Aprof works by instrumenting bytecode to inject calls that count and track object allocations. This allows it to provide insights on where memory is being allocated and identify potential performance bottlenecks related to garbage collection.
Многопоточные Алгоритмы (для BitByte 2014)
Многопоточные Алгоритмы (для BitByte 2014)Roman Elizarov Документ обсуждает многопоточные алгоритмы и их корректность через формальные модели параллельных вычислений. Основное внимание уделяется отношениям между потоками, общими переменными и условиям согласованности, включая последовательную согласованность и линеаризуемость. Также рассматриваются проблемы гонок данных и механизмы синхронизации, предлагаемые современными языками программирования.
Теоретический минимум для понимания Java Memory Model (для JPoint 2014)
Теоретический минимум для понимания Java Memory Model (для JPoint 2014)Roman Elizarov Документ рассматривает модель памяти Java и теоретические основы параллельного программирования, включая законы параллелизма и свойства исполнения. Основное внимание уделяется корректности алгоритмов, динамике доступа к общим переменным и условиям согласованности. Обсуждаются модели, такие как последовательная согласованность и линеаризуемость, а также их применение в контексте многопоточных систем.
DIY Java Profiling
DIY Java ProfilingRoman Elizarov This document discusses different approaches for profiling Java applications without using third-party tools. It begins by explaining the benefits of a do-it-yourself approach such as avoiding reliability and compliance concerns with tools. Various profiling types are then covered, including CPU profiling using wall clock time and calls, sampling, and memory profiling using JVM options. Bytecode manipulation is also presented as a method using ASM to add profiling code without changing sources. The document emphasizes learning the Java Virtual Machine and using its built-in capabilities for profiling purposes.
ACM ICPC 2013 NEERC (Northeastern European Regional Contest) Problems Review
ACM ICPC 2013 NEERC (Northeastern European Regional Contest) Problems ReviewRoman Elizarov This document summarizes 9 problems from the ACM ICPC 2013-2014 Northeastern European Regional Contest. It provides an overview of the key algorithms and approaches for each problem, describing them concisely in 1-3 sentences per problem. The problems cover a range of algorithmic topics including exhaustive search, dynamic programming, graph algorithms, geometry, and more.
Java Serialization Facts and Fallacies
Java Serialization Facts and FallaciesRoman Elizarov The document discusses Java serialization and common myths surrounding it. It summarizes that Java serialization allows for flexible evolution of classes while maintaining backwards compatibility through the use of serialVersionUID. It debunks common myths that Java serialization is slow, inflexible, or that changing private fields breaks compatibility. The document explains that serialization performance depends more on how streams are used rather than the underlying implementation.
Millions quotes per second in pure java
Millions quotes per second in pure javaRoman Elizarov The document discusses a market data vendor that processes data from exchange feeds and distributes it to customers. It provides millions of quotes per second using a pure Java solution called QDS Core, which parses, normalizes, and distributes the data. QDS Core uses optimized data structures like arrays and lock-free synchronization to achieve high performance. The vendor also provides an easier to use API called dxFeed on top of QDS Core to enable integration.
ACM ICPC 2012 NEERC (Northeastern European Regional Contest) Problems Review
ACM ICPC 2012 NEERC (Northeastern European Regional Contest) Problems ReviewRoman Elizarov The document describes solutions to several algorithmic problems:
1) It proposes using a sweeping line algorithm to check polygons for self-intersections and intersections between polygons.
2) It suggests a solution that uses left-hand and right-hand rule traversals from an entrance to a lair, precomputing blocked cells to efficiently check if an obstacle blocks both paths.
3) It outlines an approach using dynamic programming to build a protein sequence from prefix and suffix to maximize the number of explained peaks in a matrix, in O(n3) time.
The theory of concurrent programming for a seasoned programmer
The theory of concurrent programming for a seasoned programmerRoman Elizarov The document discusses concurrent programming theory and models. It begins with basic definitions of processes, threads, and shared memory models. It then covers formal models of computation including shared objects and registers. Key concepts discussed include linearizability, happens-before relations, mutual exclusion, and non-blocking algorithms.
Ad
Recently uploaded (20)
“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...
“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...Edge AI and Vision Alliance For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2025/06/key-requirements-to-successfully-implement-generative-ai-in-edge-devices-optimized-mapping-to-the-enhanced-npx6-neural-processing-unit-ip-a-presentation-from-synopsys/
Gordon Cooper, Principal Product Manager at Synopsys, presents the “Key Requirements to Successfully Implement Generative AI in Edge Devices—Optimized Mapping to the Enhanced NPX6 Neural Processing Unit IP” tutorial at the May 2025 Embedded Vision Summit.
In this talk, Cooper discusses emerging trends in generative AI for edge devices and the key role of transformer-based neural networks. He reviews the distinct attributes of transformers, their advantages over conventional convolutional neural networks and how they enable generative AI.
Cooper then covers key requirements that must be met for neural processing units (NPU) to support transformers and generative AI in edge device applications. He uses transformer-based generative AI examples to illustrate the efficient mapping of these workloads onto the enhanced Synopsys ARC NPX NPU IP family.
AI vs Human Writing: Can You Tell the Difference?
AI vs Human Writing: Can You Tell the Difference?Shashi Sathyanarayana, Ph.D This slide illustrates a side-by-side comparison between human-written, AI-written, and ambiguous content. It highlights subtle cues that help readers assess authenticity, raising essential questions about the future of communication, trust, and thought leadership in the age of generative AI.
Powering Multi-Page Web Applications Using Flow Apps and FME Data Streaming
Powering Multi-Page Web Applications Using Flow Apps and FME Data StreamingSafe Software Unleash the potential of FME Flow to build and deploy advanced multi-page web applications with ease. Discover how Flow Apps and FME’s data streaming capabilities empower you to create interactive web experiences directly within FME Platform. Without the need for dedicated web-hosting infrastructure, FME enhances both data accessibility and user experience. Join us to explore how to unlock the full potential of FME for your web projects and seamlessly integrate data-driven applications into your workflows.
OWASP Barcelona 2025 Threat Model Library
OWASP Barcelona 2025 Threat Model LibraryPetraVukmirovic Threat Model Library Launch at OWASP Barcelona 2025
https://owasp.org/www-project-threat-model-library/
Security Tips for Enterprise Azure Solutions
Security Tips for Enterprise Azure SolutionsMichele Leroux Bustamante Delivering solutions to Azure may involve a variety of architecture patterns involving your applications, APIs data and associated Azure resources that comprise the solution. This session will use reference architectures to illustrate the security considerations to protect your Azure resources and data, how to achieve Zero Trust, and why it matters. Topics covered will include specific security recommendations for types Azure resources and related network security practices. The goal is to give you a breadth of understanding as to typical security requirements to meet compliance and security controls in an enterprise solution.
From Manual to Auto Searching- FME in the Driver's Seat
From Manual to Auto Searching- FME in the Driver's SeatSafe Software Finding a specific car online can be a time-consuming task, especially when checking multiple dealer websites. A few years ago, I faced this exact problem while searching for a particular vehicle in New Zealand. The local classified platform, Trade Me (similar to eBay), wasn’t yielding any results, so I expanded my search to second-hand dealer sites—only to realise that periodically checking each one was going to be tedious. That’s when I noticed something interesting: many of these websites used the same platform to manage their inventories. Recognising this, I reverse-engineered the platform’s structure and built an FME workspace that automated the search process for me. By integrating API calls and setting up periodic checks, I received real-time email alerts when matching cars were listed. In this presentation, I’ll walk through how I used FME to save hours of manual searching by creating a custom car-finding automation system. While FME can’t buy a car for you—yet—it can certainly help you find the one you’re after!
Securing Account Lifecycles in the Age of Deepfakes.pptx
Securing Account Lifecycles in the Age of Deepfakes.pptxFIDO Alliance Securing Account Lifecycles in the Age of Deepfakes
FIDO Seminar: New Data: Passkey Adoption in the Workforce.pptx
FIDO Seminar: New Data: Passkey Adoption in the Workforce.pptxFIDO Alliance FIDO Seminar: New Data: Passkey Adoption in the Workforce
MuleSoft for AgentForce : Topic Center and API Catalog
MuleSoft for AgentForce : Topic Center and API Catalogshyamraj55 This presentation dives into how MuleSoft empowers AgentForce with organized API discovery and streamlined integration using Topic Center and the API Catalog. Learn how these tools help structure APIs around business needs, improve reusability, and simplify collaboration across teams. Ideal for developers, architects, and business stakeholders looking to build a connected and scalable API ecosystem within AgentForce.
A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy.pdf
A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy.pdfPriyanka Aash A Constitutional Quagmire - Ethical Minefields of AI, Cyber, and Privacy
Raman Bhaumik - Passionate Tech Enthusiast
Raman Bhaumik - Passionate Tech EnthusiastRaman Bhaumik A Junior Software Developer with a flair for innovation, Raman Bhaumik excels in delivering scalable web solutions. With three years of experience and a solid foundation in Java, Python, JavaScript, and SQL, she has streamlined task tracking by 20% and improved application stability.
The Future of Technology: 2025-2125 by Saikat Basu.pdf
The Future of Technology: 2025-2125 by Saikat Basu.pdfSaikat Basu A peek into the next 100 years of technology. From Generative AI to Global AI networks to Martian Colonisation to Interstellar exploration to Industrial Nanotechnology to Artificial Consciousness, this is a journey you don't want to miss. Which ones excite you the most? Which ones are you apprehensive about? Feel free to comment! Let the conversation begin!
"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...
"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...Fwdays We will explore how e-commerce projects prepare for the busiest time of the year, which key aspects to focus on, and what to expect. We’ll share our experience in setting up auto-scaling, load balancing, and discuss the loads that Silpo handles, as well as the solutions that help us navigate this season without failures.
Wenn alles versagt - IBM Tape schützt, was zählt! Und besonders mit dem neust...
Wenn alles versagt - IBM Tape schützt, was zählt! Und besonders mit dem neust...Josef Weingand IBM LTO10
Coordinated Disclosure for ML - What's Different and What's the Same.pdf
Coordinated Disclosure for ML - What's Different and What's the Same.pdfPriyanka Aash Coordinated Disclosure for ML - What's Different and What's the Same
The Future of Data, AI, and AR: Innovation Inspired by You.pdf
The Future of Data, AI, and AR: Innovation Inspired by You.pdfSafe Software The future of FME is inspired by you. We can't wait to show you what's ahead for FME and Safe Software.
cnc-processing-centers-centateq-p-110-en.pdf
cnc-processing-centers-centateq-p-110-en.pdfAmirStern2 מרכז עיבודים תעשייתי בעל 3/4/5 צירים, עד 22 החלפות כלים עם כל אפשרויות העיבוד הדרושות. בעל שטח עבודה גדול ומחשב נוח וקל להפעלה בשפה העברית/רוסית/אנגלית/ספרדית/ערבית ועוד..
מסוגל לבצע פעולות עיבוד שונות המתאימות לענפים שונים: קידוח אנכי, אופקי, ניסור, וכרסום אנכי.
FIDO Seminar: Perspectives on Passkeys & Consumer Adoption.pptx
FIDO Seminar: Perspectives on Passkeys & Consumer Adoption.pptxFIDO Alliance FIDO Seminar: Perspectives on Passkeys & Consumer Adoption
“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...
“Key Requirements to Successfully Implement Generative AI in Edge Devices—Opt...Edge AI and Vision Alliance
Introduction to Kotlin coroutines
- 2. Speaker: Roman Elizarov • 16+ years experience • Previously developed high-perf trading software @ Devexperts • Teach concurrent & distributed programming @ St. Petersburg ITMO University • Chief judge @ Northeastern European Region of ACM ICPC • Now work on Kotlin @ JetBrains
- 3. Disclaimer • Most ideas presented herein are very old • Simula ‘67 was one of the first languages to introduce coroutines • detach – was a coroutine suspension statement • resume – was to resume coroutine execution • CLU ‘75 was the first language with generators and Icon ‘77 was prominently using them • Coroutines fell out of favor due to emergence of multithreading • And now they are back to write asynchronous code
- 5. Real need for async when … ü You cannot afford threads • They are expensive to keep and to switch • High-load server-side, micro-tasks, etc ü You cannot do threads • You code is single thread only • JS/web target, μC, etc ü You do not want threads • You have lot of mutable state • Mobile/Desktop UI apps, etc
- 14. Bonus features • Regular loops • Regular exception handing • Regular high-level operators • let, apply, repeat, forEach, filter, map, use, etc Everything like in blocking code
- 17. Kotlin suspending functions callback Kotlin Java/JVM Continuation is a generic callback interface
- 22. A digression on async/await async function preparePost() { let request = composeTokenRequest(); let result = await makeRequest(request); return result.parseToken(); } async function preparePost(): Promise<Token> { let request = composeTokenRequest(); let result = await makeRequest(request); return result.parseToken(); } JS approach to the same problem (also TS, C#, Dart, etc) mark with async use await to suspend JS
- 23. Why no await keyword in Kotlin? The problem with async makeRequest(request) VALID – produces Promise<Result> await makeRequest(request) VALID – produces Result concurrent & async behavior sequential behavior The most needed one, yet the most syntactically clumsy, esp. for suspend-heavy (CSP) code style
- 29. Kotlin approach to async async function doSomething(): Promise<Result> { /* ... */ } Sometimes you need the Promise and async let request1 = doSomething(); let request2 = doSomething(); 1 2 To start multiple operations concurrently await request1; await request2; JS and then wait for them async builder await function Returns Deferred<Result> Suspends until deferred is complete
- 30. Recap • Coroutine builders • launch • runBlocking • async • Suspending functions with suspend keyword • Can nest to any depth (not stackless) • suspendCoroutine Regular world Coroutine Coroutine Callback Coroutine Coroutine
- 32. Library vs language • Kotlin language only has suspend keyword • Transforms suspend functions to callbacks • Compiles code to state machines • stdlib has Continuation and CoroutineContext • Everything else is in a library • It includes launch/join, async/await, runBlocking, etc • We were using kotlinx.coroutines library • http://github.com/kotlin/kotlinx.coroutines • You can study source and contribute It is designed to be composable Mix & match different libs
- 33. Experimental status of coroutines • This design is new and unlike mainstream • For some very good reasons • We want community to try it for real • So we released it as an experimental feature • We guarantee backwards compatibility • Old code compiled with coroutines continues to work • We reserve the right to break forward compatibility • We may add things so new code may not run w/old RT • Design will be finalized at a later point • Old code will continue to work via support library • Migration aids to the final design will be provided opt-in flag
- 35. There is more • Channels/Actors • Selection and synchronization • Job hierarchies and cancellation • buildSequence/yield • Restricted (sync) suspension • Interop with other futures/promise/reactive libs • The actual implementation details • Learn more in Guide to kotlinx.coroutines by example • KotlinConf on 2-3 November, 2017 in SF