Asynchronous Programming in Kotlin with Coroutines

Mar 12, 20183 likes124 views

This document summarizes a meetup about asynchronous programming in Kotlin using coroutines. It discusses how coroutines allow direct-style asynchronous code by suspending coroutines instead of blocking threads. Coroutines appear like regular blocking code but are lightweight like threads. Suspending functions can pause and return values later. Demos show using coroutines with builders, contexts, and channels for asynchronous programming compared to callbacks and RxJava.

2 ••
Asynchronous progamming in Kotlin with Coroutines
🍕 🍕 🍕
Tensorflowing like a pro - without a clue

3 ••
Coroutines
Asynchronous programming in Kotlin

4 ••
How programming works
Intro
Do something (create a resource)
↓
Wait (for completion)
↓
Do something (send it to backend)
↓
Wait (for the response)
↓
Do something (process response or try again)
↓
…

5 ••
Dealing with long running tasks
Asynchronicity
- Direct style
- max 16 ms
- Blocking the main Thread
- Callback
- Error Handling
- Callback Hell
- Futures (RxJava, Promises, …)
- Idea: we wrap the result
- Pro: nice code, errors, good looking
- cons: complex
- Coroutines
- Direct style

6 ••
What is a Coroutine?
- It’s an instance of a suspendable computation
- General concept was already created in 1958
- Similar to a very lightweight Thread – cheap in creation
- Looks like regular blocking code
- Coroutines give us a way to write code that feels imperative, even if it is asynchronous.

7 •• ••
Suspend functions
- A function ‘super powers’
- It’s a function which can suspend and return a value later on

8 •• ••
Suspend functions II
- Suspension points
- Many things work out-of-the box
- Loops
- Exceptions
- Higher-Order-Functions
- …

9 ••
suspension functions are designed to
imitate sequential behavior by default

12 ••
https://www.slideshare.net/elizarov/deep-dive-into-coroutines-on-jvm-kotlinconf-2017
Coroutines in detail

20 ••
Reuse closure / state object
State Machine vs Callbacks
Easier loop

21 ••
Suspending functions cannot be invoked from
regular functions
• launch (fire and forget)
• async (and await)
• Returns a Deferred
• runBlocking
• Not keywords but functions!
Coroutine Builder

23 ••
Coroutine Context
- *without*
- UI
- CommonPool
- Unconfined

24 ••
Demo III
– Channels and Actors
- Comparison RX

26 ••
Links & References
- Coroutines guide Informal
- https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md
- Coroutine guide reactive
- https://github.com/Kotlin/kotlinx.coroutines/blob/master/reactive/coroutines-guide-reactive.md
- Deep dive into Coroutines on JVM, KotlinConf 2017 – Roman Elizarov
https://www.slideshare.net/elizarov/deep-dive-into-coroutines-on-jvm-kotlinconf-2017
- Images from https://www.pexels.com

This document describes EhTrace, a tool for tracing the execution of binary programs through hooking and branch stepping. EhTrace uses the Windows VEH exception handler to single step programs by setting flags in the CPU context. It can be used to analyze program control flow at the basic block level for purposes like malware analysis, debugging, and code coverage. The document discusses techniques for maintaining control during tracing and fighting attempts by the target program to detect or alter the tracing.

JDD 2016 - Andrej Mihály - How To Bake Reactive Behavior Into Your Java Ee Ap...PROIDEA

Reactive applications are flexible and robust. Reactive programming is already an established concept and there are many modern frameworks and tools which support it. You need to understand the concept in order to build truly reactive applications. But you do not need to switch from what you already know to build them. With standard Java EE you have wide range of options to add reactive behavior to new and even existing applications. I will show that Java EE is a modern and evolving framework, which supports reactive concepts. The latest versions of JDK and Java EE add even more asynchronous API to write fully reactive applications. On top of asynchronous processing in servlets, REST services and EJBs, there is asynchronous IO, managed multithreading and CompletableFuture with its promise-like API to tackle callback hell. Several Java EE implementations, like Payara Micro, go even further and provide extensions to scale your applications in natural way.

Clojure Conj 2014 - Paradigms of core.async - Julian GambleJulian Gamble

Rabbits, indians and... Symfony meets queueing brokersGaetano Giunta

This document discusses using message brokers like RabbitMQ to introduce queues for processing document conversions. It describes how using a queue allows processing to be distributed across multiple consumers for better reliability and scalability compared to a single process approach. Specifically, it outlines how the Kaliop QueueingBundle for Symfony provides an easy way to integrate queues and supports multiple broker protocols with a common API.

Making Symfony Services async with RabbitMq (and more Symfony)Gaetano Giunta

This document discusses using RabbitMQ and Symfony to generate Microsoft Office documents asynchronously from XML content. Currently, using just LibreOffice is slow, unreliable, and does not scale well. The proposed solution is to use RabbitMQ with Symfony services to queue document generation jobs and process them in parallel with multiple worker processes. This improves performance, reliability and allows the process to scale. Some challenges that still need to be addressed are network security, throughput and determining if a existing solution could be used instead of a custom one.

CBDW2014 - Down the RabbitMQ hole with ColdFusionOrtus Solutions, Corp

In this talk I will introduce attendees to the basics of messaging queues, their goals and applications from CFML. Messaging enables software applications to connect and scale. Thus, providing applications to connect to each other as components of a larger application, or to user devices and data. Messaging is asynchronous, and can decouple your software concerns with ease. However, messaging is much more than the traditional publish/subscribe patterns but also the ability to create work queues, routing and much more.

VMware studio practice in TIMYi-Huan Chan

This document provides an introduction to VMware Studio and its benefits for building virtual appliances. Key points include that VMware Studio automates the creation of virtual appliances by integrating APIs to build, manage, and deploy appliances. It allows defining hardware specifications, installed applications, and custom scripts in a reusable VM profile template. This standardizes and streamlines the previously manual process of building appliances. The document also acknowledges some challenges encountered, such as specific package installation issues and the need for deployment configuration modifications.

Realtime web2012Timothy Fitz

The document discusses building real-time web applications. It addresses three hard problems: talking to the browser in real-time using techniques like polling, websockets, and flash sockets; handling high concurrency through non-blocking I/O; and scaling to support many users. It reviews common real-time frameworks like Twisted, Tornado, gevent, Node.js, and Erlang and recommends Twisted for Python and Node.js with Socket.IO for non-Python. It also discusses using Redis for a real-time backend pub/sub system and scaling strategies like adding frontend and backend nodes.

Zero mq logsTomas Doran

This document discusses using ZeroMQ and Elasticsearch for log aggregation. It proposes using ZeroMQ to transmit structured log data from application servers to a central Logstash server, which would then insert the logs into Elasticsearch for querying and analysis. This approach aims to provide a lightweight logging solution that doesn't block application servers like traditional logging to databases can. The document also provides background on tools like Logstash, Elasticsearch, and Splunk.

Automating Your Daily Tasks with Scripting - RubyConf 2015 TaiwanAdler Hsieh

This talk aims to go through basic scripting skills in Ruby. Participants will have a better understanding in managing their daily tasks with scripting. For example, we can setup automated scripts to delete old files on a daily basis instead of doing it manually. These can be done with Bash, Perl and many other scripting languages, but among of which Ruby is better known for its readability. It is easier to write, maintain, and reuse. It saves some time on system management and allows us to put more focus on the projects.

Sonata Block Bundle - sfPot March 2014th0masr

The SonataBlockBundle allows developers to manage reusable content fragments called blocks that can be incorporated into page layouts. It provides an interface and services to define block content through block services, handle block rendering, and integrate blocks with caching for improved performance. The bundle is used by several Symfony projects and e-commerce platforms to build modular and reusable content.

Brad wood - 5 CommandBox Modules You Should Be Using [Into The Box 2020]Ortus Solutions, Corp

Enterprise messagingColdFusionConference

This document discusses decoupling applications and scaling with enterprise messaging. It introduces messaging concepts like producers, consumers, and message brokers. It focuses on the AMQP protocol and RabbitMQ as a messaging implementation. Key points covered include RPC vs messaging styles, decoupling applications, cross-platform communication, and load balancing. The presenter demonstrates a messaging example using Java, CFML, Node.js, and JavaScript producers and consumers communicating via a RabbitMQ broker.

A look at FastCgi & Mod_PHP architectureAimee Maree Forsstrom

They why behind php frameworksKirk Madera

Coroutines in KotlinJemo Mgebrishvili

This document provides an overview of Kotlin and coroutines. Kotlin is a statically typed language that runs on the JVM, Android and browsers. It features null safety, expressiveness, and full interoperability with Java. Coroutines allow writing asynchronous code that looks synchronous and avoid callback hell by running multiple async computations simultaneously using less memory than threads. Coroutines are lightweight and cooperative rather than preemptive like threads, and are managed by dispatchers instead of mapping to OS threads directly.

MongoDB backup service overview Boston MUGMongoDB

The document discusses MongoDB backup options including mongodump/mongorestore, storage-level backups, and the MongoDB Management Service (MMS) backup. MMS provides cloud-based, encrypted backups of MongoDB deployments with point-in-time recovery. It takes periodic snapshots of data and oplog to enable restores. Setup involves installing agents, registering with MMS, and an initial sync replicates data to MMS for backups.

Capistrano demoEdward Meehan

Capistrano is a Ruby-based tool that automates and simplifies deployment of applications to remote servers. It connects to servers via SSH and runs commands to deploy code between servers quickly. It allows for custom tasks, deployment hooks, automated processes like cache cleaning, and provides deployment logs. Capistrano requires Ruby 1.9 or later and installation is done by running `gem install capistrano`. Config files define project-level and environment-level settings.

Riak at Posterouscapotej

Brad wood - Integrating MVC Into Legacy [Into The Box 2020]Ortus Solutions, Corp

Cooking a rabbit pieTomas Doran

This document discusses using AMQP and RabbitMQ for real-time system performance monitoring and job queueing. It describes key AMQP concepts like exchanges, queues, routing keys, and delivery modes. It then discusses how the speaker built a job queueing system called CatalystX::JobServer that uses these concepts and RabbitMQ. Demo examples are shown of using this system to queue and monitor the status of jobs. Potential next steps and other solutions like Gearman are also mentioned.

bol.com Dutch Container Day presentationMaarten Dirkse

Containerizing the largest Dutch e-commerce site: The bol.com story Bol.com moved to running several mission-critical applications in containers on their infrastructure to gain the benefits of dynamic environments that can be spun up quickly. They initially used containers through Mayfly to allow isolated development environments for each feature branch. They have since expanded container usage and learned several lessons along the way regarding orchestration, metrics, image building, and cultural shifts for developers and operations. Their next steps include implementing IP-per-container and migrating more applications to their dynamic infrastructure.

Hybrid concurrency patternsKyle Drake

Ruby developers need to stop using EventMachine. It's the wrong direction. Lost in the "Threads vs Event Driven vs Process Spawning" debate is that you can combine them! Learn how Celluloid is improving thread programming by abstracting them using a higher level framework called Celluloid, how you can use Celluloid::IO to throw a reactor pattern into a thread. Using this approach, you can take advantage of threading and use all CPU power on a machine with JRuby or Rubinius. I also discuss the future of distributed objects and computing, and where I think things are going.

CI/CD at bol.comMaarten Dirkse

OSBConf 2015 | Vm backup beyond bacula by christian theuneNETWAYS

The Flying Circus is an Operations-as-a-Service platform that supports project development teams to run their custom-develop software for clients. Earlier in 2014 we experienced a major data loss and had to perform massive disaster recovery. Unfortunately our Bacula setup was not up to the task and it took us longer and more effort to restore the data than we and our customers expected. In this case study I’d like to present our public and very honest root cause analysis on how we managed to lose a lot of VMs’ data, how the restore happened, what we learned and how we’re trying to get better. After investigating our options for the future we decided to move away from Bacula’s file and VTL-oriented model and are currently implementing a solution based on CoW-filesystems (ZFS/btrfs), block-layer snapshots and diffing, and a small utility to glue things together.

Vmth projectRicardo Sanchez

The Virtual Machine Test Harness (VMTH) is an automation tool that runs unit tests against a virtual machine running a live system image. It integrates with continuous integration servers to trigger tests after every code commit. The tool uses VM snapshotting to quickly run through test cases. It was created to help test configuration management like Puppet in a safe, isolated way compared to testing in production. The document outlines the VMTH workflow using Puppet as an example, describes the tools used like the virb interactive browsing tool, and provides resources for more information.

How to stuff a 900 pound gorilla into a smartphoneJoel Maher

Ratpack for RealTomAkehurst

Ratpack is a fully asynchronous web toolkit for Java and Groovy applications. It is built for high performance and developer productivity. Some key features include handler abstraction for HTTP requests, promises for asynchronous programming, and integration with RxJava. Ratpack applications are configured through JSON, YAML, system properties or environment variables. Testing in Ratpack uses harnesses like ExecHarness to run asynchronous operations outside the framework. Pottermore found success adopting Ratpack for its asynchronous features and deployment ease but faced challenges with learning curves and lack of community support. Ratpack is best for performance-critical apps but more ordinary workloads may not require its complexity.

Applying the paradigms of core.async in Clojure and ClojureScriptJulian Gamble

Performance Benchmarking: Tips, Tricks, and Lessons LearnedTim Callaghan

More Related Content

What's hot (20)

Zero mq logsTomas Doran

Automating Your Daily Tasks with Scripting - RubyConf 2015 TaiwanAdler Hsieh

Sonata Block Bundle - sfPot March 2014th0masr

Brad wood - 5 CommandBox Modules You Should Be Using [Into The Box 2020]Ortus Solutions, Corp

Enterprise messagingColdFusionConference

A look at FastCgi & Mod_PHP architectureAimee Maree Forsstrom

They why behind php frameworksKirk Madera

Coroutines in KotlinJemo Mgebrishvili

MongoDB backup service overview Boston MUGMongoDB

Capistrano demoEdward Meehan

Riak at Posterouscapotej

Brad wood - Integrating MVC Into Legacy [Into The Box 2020]Ortus Solutions, Corp

Cooking a rabbit pieTomas Doran

bol.com Dutch Container Day presentationMaarten Dirkse

Hybrid concurrency patternsKyle Drake

CI/CD at bol.comMaarten Dirkse

OSBConf 2015 | Vm backup beyond bacula by christian theuneNETWAYS

Vmth projectRicardo Sanchez

How to stuff a 900 pound gorilla into a smartphoneJoel Maher

Ratpack for RealTomAkehurst

Zero mq logsTomas Doran

Automating Your Daily Tasks with Scripting - RubyConf 2015 TaiwanAdler Hsieh

Sonata Block Bundle - sfPot March 2014th0masr

Brad wood - 5 CommandBox Modules You Should Be Using [Into The Box 2020]Ortus Solutions, Corp

Enterprise messagingColdFusionConference

A look at FastCgi & Mod_PHP architectureAimee Maree Forsstrom

They why behind php frameworksKirk Madera

Coroutines in KotlinJemo Mgebrishvili

MongoDB backup service overview Boston MUGMongoDB

Capistrano demoEdward Meehan

Riak at Posterouscapotej

Brad wood - Integrating MVC Into Legacy [Into The Box 2020]Ortus Solutions, Corp

Cooking a rabbit pieTomas Doran

bol.com Dutch Container Day presentationMaarten Dirkse

Hybrid concurrency patternsKyle Drake

CI/CD at bol.comMaarten Dirkse

OSBConf 2015 | Vm backup beyond bacula by christian theuneNETWAYS

Vmth projectRicardo Sanchez

How to stuff a 900 pound gorilla into a smartphoneJoel Maher

Ratpack for RealTomAkehurst

Similar to Asynchronous Programming in Kotlin with Coroutines (20)

Applying the paradigms of core.async in Clojure and ClojureScriptJulian Gamble

Performance Benchmarking: Tips, Tricks, and Lessons LearnedTim Callaghan

Jenkins-Koji plugin presentation on Python & Ruby devel group @ BrnoVaclav Tunka

Steamlining your puppet development workflowTomas Doran

The document discusses ways to streamline a Puppet development workflow including using revision control, running Puppet in noop or automatic mode, moving changes slowly through testing and using branches, reporting on changes, and implementing testing strategies like unit testing with rspec-puppet and integration testing with serverspec. It also recommends tools like Foreman, Norman, Puppetfile, and Jenkins to improve testing and deployment.

Puppet Camp New York 2014: Streamlining Puppet Development Workflow Puppet

Queick: A Simple Job Queue System for PythonRyota Suenaga

Ryota SUENAGA presented Queick, a simple job queue system he created for Python. Queick uses multi-threading to asynchronously execute jobs in the background. It was designed to be lightweight and use only Python's standard libraries. Key features include asynchronous and scheduled job execution, retries of failed jobs, and checking for network connectivity to re-enqueue jobs if the connection is lost. The architecture includes a job queue, worker processes to run jobs, and a separate process to monitor network status and retry downed jobs when the connection returns.

WTF is Twisted?hawkowl

OpenWhisk Go RuntimeMichele Sciabarrà

This document discusses developing a Go runtime for Apache OpenWhisk to improve upon the existing DockerSkeleton approach. The key points are: 1) The current DockerSkeleton approach has some limitations like being fragile and having potential race conditions. 2) The new design keeps the Python proxy but uses a Go executable that runs as a Unix command, reading input and writing output on stdin/stdout/stderr. 3) An initial implementation has been done in a GitHub repository replacing DockerSkeleton with a Go server and refactoring to a piped loop. Testing with a Swift executable showed promising performance improvements over DockerSkeleton.

Byteman and The Jokre, Sanne Grinovero (JBoss by RedHat)OpenBlend society

This document provides an introduction to Byteman and The Jokre. Byteman is a scriptable Java agent that allows testing code behavior at runtime without changing sources by simulating unexpected events. The Jokre is an optimization technique that modifies the Infinispan API to avoid unnecessary remote procedure calls. A demonstration shows using standard map operations while The Jokre fixes performance issues transparently. Questions are welcomed about these projects.

Web development basics (Part-5)Rajat Pratap Singh

A first look into the Project Loom in JavaLukas Steinbrecher

Project Loom aims to bring asynchronous programming to Java with virtual threads. Virtual threads allow blocking code to run asynchronously by scheduling continuations across lightweight threads. This avoids the "blue world" problem of rewriting synchronous code for asynchronous systems. It also enables scaling applications by utilizing non-blocking I/O without changing existing code or libraries. While virtual threads are not yet production-ready, Project Loom has the potential to improve scalability for Java applications without a major paradigm shift.

Functional Programming in ClojureTroy Miles

Paul Graham, the founder of startup incubator YCombinator, put it best when he described LISP as his old company's secret weapon. Think about, if you use all of the same tools as everyone else, how do you expect to achieve better results? Clojure is a LISP language created in 2009 by Rich Hickey. Built initially on the Java Virtual Machine (JVM) it has since been ported to run on Microsoft and JavaScript. (That's right the browser). Clojure gives you all of the power and stability of the JVM without the clunkiness of Java. Most developers have never worked with a functional language before and many who have found the use of parenthesis instead of braces intimidating. Don't worry. Once it is broken down to you, I think you will see the beauty of it. In this fast and fun session, we will build an app using Clojure. We will enhance it, test it and explore why functional is a better programming model than OOPs. We will even explore why such programs are better at multitasking than object oriented ones.

Ruby and Distributed Storage SystemsSATOSHI TAGOMORI

This document discusses using Ruby for distributed storage systems. It describes components like Bigdam, which is Treasure Data's new data ingestion pipeline. Bigdam uses microservices and a distributed key-value store called Bigdam-pool to buffer data. The document discusses designing and testing Bigdam using mocking, interfaces, and integration tests in Ruby. It also explores porting Bigdam-pool from Java to Ruby and investigating Ruby's suitability for tasks like asynchronous I/O, threading, and serialization/deserialization.

Hadoop Demystified + Automation Smackdown! Austin JUG June 24 2014datafundamentals

This document discusses two approaches to ETL jobs in Hadoop: a manual "special snowflake" approach and an automated approach. The manual approach involves a team spending a year copying and pasting code for 15 jobs. This leads to spaghetti code and is not sustainable. The automated approach involves designing reusable templates and rules to automate the ETL process. This frees up the developer Brent to focus on design rather than manual work. It results in code that is clean, consistent, easy to maintain and passes the "10 minute test" of being idempotent. The document demonstrates generating ETL code from metadata and deploying the automated jobs to Hadoop.

Implementing a command line client to GitHub in GoOwen Ou

This document discusses implementing the command line tool "gh" for interacting with GitHub using the Go programming language. It summarizes gh as a tool for automating Git and GitHub workflows. It then discusses why Go was chosen and some key aspects of Go like compilation speed, static typing, garbage collection, goroutines and channels for concurrency. It also shares lessons learned from building gh in Go like using the right tool, clarity and simplicity in code, and leveraging Go features like fast compilation and static binaries.

Why Plone Will DieAndreas Jung

This document discusses reasons why the author believes Plone may decline or become a "CMS zombie" unless changes are made. Key points include: - Growing developer and integrator frustration due to legacy code, complexities, lack of documentation and APIs. - Difficult and unpredictable migrations between major Plone versions that introduce issues and costs. - Stagnating community and market as Plone relies on aging technologies like Zope and ZODB. The author argues Plone needs to remove legacy code, simplify architectures, introduce explicit APIs, support new databases and Python 3 to thrive in the future. A potential approach is starting from scratch with Pyramid and new components rather than continuing to build on aging foundations.

Jfokus 2016 - A JVMs Journey into Polyglot RuntimesCharlie Gracie

Reames-FalconKeynote java falcon about jit.pptxGuoliangDing3

CodeScene: Get Deep Insights into Your (Clojure) Code [Clojure Vienna meetup ...Juraj Martinka

Come and meet CodeScene, a unique behavioral code analysis tool written in Clojure. This tool goes beyond traditional static analysis by looking for patterns in version control data to understand the history and evolution of a code base: unraveling things like hotspots, temporal coupling between modules and an interesting social view of the code. I'll briefly describe the ideas behind CodeScene, how it works and then show you an analysis of real Clojure code.

Kernel Recipes 2018 - Live (Kernel) Patching: status quo and status futurus -...Anne Nicolas

Applying the paradigms of core.async in Clojure and ClojureScriptJulian Gamble

Performance Benchmarking: Tips, Tricks, and Lessons LearnedTim Callaghan

Jenkins-Koji plugin presentation on Python & Ruby devel group @ BrnoVaclav Tunka

Steamlining your puppet development workflowTomas Doran

Puppet Camp New York 2014: Streamlining Puppet Development Workflow Puppet

Queick: A Simple Job Queue System for PythonRyota Suenaga

WTF is Twisted?hawkowl

OpenWhisk Go RuntimeMichele Sciabarrà

Byteman and The Jokre, Sanne Grinovero (JBoss by RedHat)OpenBlend society

Web development basics (Part-5)Rajat Pratap Singh

A first look into the Project Loom in JavaLukas Steinbrecher

Functional Programming in ClojureTroy Miles

Ruby and Distributed Storage SystemsSATOSHI TAGOMORI

Hadoop Demystified + Automation Smackdown! Austin JUG June 24 2014datafundamentals

Implementing a command line client to GitHub in GoOwen Ou

Why Plone Will DieAndreas Jung

Jfokus 2016 - A JVMs Journey into Polyglot RuntimesCharlie Gracie

Reames-FalconKeynote java falcon about jit.pptxGuoliangDing3

CodeScene: Get Deep Insights into Your (Clojure) Code [Clojure Vienna meetup ...Juraj Martinka

Kernel Recipes 2018 - Live (Kernel) Patching: status quo and status futurus -...Anne Nicolas

Recently uploaded (20)

F-Secure Freedome VPN 2025 Crack Plus Activation New Versionsaimabibi60507

PRTG Network Monitor Crack Latest Version & Serial Key 2025 [100% Working]saimabibi60507

Copy & Past Link 👉👉 https://dr-up-community.info/ PRTG Network Monitor is a network monitoring software developed by Paessler that provides comprehensive monitoring of IT infrastructure, including servers, devices, applications, and network traffic. It helps identify bottlenecks, track performance, and troubleshoot issues across various network environments, both on-premises and in the cloud.

Kubernetes_101_Zero_to_Platform_Engineer.pptxCloudScouts

Foundation Models for Time Series : A Surveyjayanthkalyanam1

Microsoft AI Nonprofit Use Cases and Live Demo_2025.04.30.pdfTechSoup

In this webinar we will dive into the essentials of generative AI, address key AI concerns, and demonstrate how nonprofits can benefit from using Microsoft’s AI assistant, Copilot, to achieve their goals. This event series to help nonprofits obtain Copilot skills is made possible by generous support from Microsoft. What You’ll Learn in Part 2: Explore real-world nonprofit use cases and success stories. Participate in live demonstrations and a hands-on activity to see how you can use Microsoft 365 Copilot in your own work!

Why Orangescrum Is a Game Changer for Construction Companies in 2025Orangescrum

Exceptional Behaviors: How Frequently Are They Tested? (AST 2025)Andre Hora

Exceptions allow developers to handle error cases expected to occur infrequently. Ideally, good test suites should test both normal and exceptional behaviors to catch more bugs and avoid regressions. While current research analyzes exceptions that propagate to tests, it does not explore other exceptions that do not reach the tests. In this paper, we provide an empirical study to explore how frequently exceptional behaviors are tested in real-world systems. We consider both exceptions that propagate to tests and the ones that do not reach the tests. For this purpose, we run an instrumented version of test suites, monitor their execution, and collect information about the exceptions raised at runtime. We analyze the test suites of 25 Python systems, covering 5,372 executed methods, 17.9M calls, and 1.4M raised exceptions. We find that 21.4% of the executed methods do raise exceptions at runtime. In methods that raise exceptions, on the median, 1 in 10 calls exercise exceptional behaviors. Close to 80% of the methods that raise exceptions do so infrequently, but about 20% raise exceptions more frequently. Finally, we provide implications for researchers and practitioners. We suggest developing novel tools to support exercising exceptional behaviors and refactoring expensive try/except blocks. We also call attention to the fact that exception-raising behaviors are not necessarily “abnormal” or rare.

Tools of the Trade: Linux and SQL - Google CertificateVICTOR MAESTRE RAMIREZ

Download YouTube By Click 2025 Free Full Activatedsaniamalik72555

Societal challenges of AI: biases, multilinguism and sustainabilityJordi Cabot

Exploring Wayland: A Modern Display Server for the FutureICS

FlakyFix: Using Large Language Models for Predicting Flaky Test Fix Categorie...Lionel Briand

Full Cracked Resolume Arena Latest Versionjonesmichealj2

Scaling GraphRAG: Efficient Knowledge Retrieval for Enterprise AIdanshalev

If we were building a GenAI stack today, we'd start with one question: Can your retrieval system handle multi-hop logic? Trick question, b/c most can’t. They treat retrieval as nearest-neighbor search. Today, we discussed scaling #GraphRAG at AWS DevOps Day, and the takeaway is clear: VectorRAG is naive, lacks domain awareness, and can’t handle full dataset retrieval. GraphRAG builds a knowledge graph from source documents, allowing for a deeper understanding of the data + higher accuracy.

Innovative Approaches to Software Dev no good at allayeshakanwal75

Requirements in Engineering AI- Enabled Systems: Open Problems and Safe AI Sy...Lionel Briand

How can one start with crypto wallet development.pptxlaravinson24

Top 10 Client Portal Software Solutions for 2025.docxPortli

Landscape of Requirements Engineering for/by AI through Literature ReviewHironori Washizaki

Mastering Fluent Bit: Ultimate Guide to Integrating Telemetry Pipelines with ...Eric D. Schabell

It's time you stopped letting your telemetry data pressure your budgets and get in the way of solving issues with agility! No more I say! Take back control of your telemetry data as we guide you through the open source project Fluent Bit. Learn how to manage your telemetry data from source to destination using the pipeline phases covering collection, parsing, aggregation, transformation, and forwarding from any source to any destination. Buckle up for a fun ride as you learn by exploring how telemetry pipelines work, how to set up your first pipeline, and exploring several common use cases that Fluent Bit helps solve. All this backed by a self-paced, hands-on workshop that attendees can pursue at home after this session (https://o11y-workshops.gitlab.io/workshop-fluentbit).