The Expected Outcome: Error Handling with std::expected in C++
Explore unified error handling with std::expected in C++23, advanced usage patterns, and integration with C++20 coroutines for a more familiar syntax without exception baggage.
What We've Been Awaiting For - Coroutines in C++
Explore coroutines in C++, starting from simple functions and progressing to complex coroutine tasks. Learn to demystify and implement this powerful programming concept.
Anko: The Ultimate Ninja of Kotlin Libraries - YOW! 2016
Explore Anko, a powerful Kotlin library for Android development. Learn its features, benefits, and how it can streamline your coding process and enhance app functionality.
Coroutines and Go - Understanding Generalized Subroutines
Explore coroutines in Go: history, characteristics, and implementation. Learn about subroutines, cooperative multitasking, and potential runtime changes for efficient concurrent programming.
Building Autosuggest Infrastructure for High-Performance E-commerce
Explore OTTO's journey in building and reinventing autosuggest infrastructure, covering deep technology, architecture, scalability, and team insights for high-performance e-commerce solutions.
The Dark Side of Kotlin - Experimental and Controversial Features - GeeCON Prague 2023
Explore controversial Kotlin features like coroutines, receivers, and extension methods to write clean yet complex code. Delve into experimental and lesser-known aspects of the language.
Revolutionizing Backend Development with Kotlin and Spring Boot
Explore Kotlin and Spring Boot's synergy for robust, scalable applications. Enhance web and microservice development with powerful technologies.
Coroutine Intuition in C++ - Lecture
Gain intuition on coroutines in C++20. Explore stackless asyncrony, generators, and senders/receivers through concise examples to improve code readability, maintainability, and composability.
What's New in C++23
Explore C++23's new features with Sy Brand, enhancing code simplicity, expressiveness, and power. Learn how upcoming changes benefit your programming and prepare for future upgrades.
Multiqueue in the Block Layer: Challenges and Solutions for Thread Safety in QEMU
Explore challenges and solutions for making QEMU's block layer thread-safe, enabling true parallel processing of multiple I/O queues for improved performance.
Demystifying AsyncIO - Building Your Own Event Loop in Python
Explore AsyncIO's inner workings by building a custom event loop in Python, culminating in running a FastAPI application. Gain insights into core concepts and practical applications.
Upload a File With Progress Bar Using Ktor - Android Studio Tutorial
Learn to implement file uploads with progress tracking in Android using Ktor and multipart requests, enhancing user experience with real-time upload status.
Demystifying AsyncIO - Building Your Own Event Loop in Python
Explore AsyncIO's inner workings by building a custom event loop in Python, culminating in running a FastAPI application. Gain insights into core concepts and practical applications.
Implementing Async with Coroutines and Fibers - Project Loom in C#
Explore alternative async implementations using monads, coroutines, and fibers in C#. Learn about Project Loom's approach and potential improvements over thread-pool-based async/await.
Contemporary C++ in Action
Live coding demonstration showcasing modern C++ features and techniques, including modules, coroutines, and C++23 additions, aimed at practical application for everyday developers in embedded and industrial settings.
How to Build a C++ Coroutine Type - What We've Been Awaiting For
Explore building user-friendly C++ coroutine types for async operations, including file downloads and promise handling, with insights on potential improvements and advanced implementations.
C++ Coroutines and Structured Concurrency in Practice
Explore C++20 coroutines and structured concurrency with Corral, an open-source framework. Learn practical implementation, task management, and integration with existing systems for simplified concurrent logic.
Creating a Sender/Receiver HTTP Server for Asynchronous Operations in C++
Explore building an HTTP server using C++'s sender/receiver framework for asynchronous operations. Learn to implement networking senders, coroutine tasks, and async scopes for efficient, embedded server development.
Deciphering Coroutines - A Visual Approach
Explore C++20 coroutines through visual diagrams and examples. Learn to decipher complex syntax, understand core concepts, and navigate advanced presentations on this powerful feature.
C++ Coroutines from Scratch - Lecture 1
Explore C++ 20 coroutines: simplify async code, understand core concepts, and see practical applications with library support. Gain insights into this powerful feature.
C++20's Coroutines for Beginners - Lecture 1
Explore C++20 coroutines from basics to advanced concepts. Learn new keywords, customization points, and how to implement generators. Understand cooperative multitasking and coroutine benefits in concurrent programming.