The Actor Model: Orchestrating Complex Applications
Explore the Actor Model's role in orchestrating complex applications, with practical demos showcasing its utility in frontend and backend development for improved code performance.
Continuations - The Magic Behind Virtual Threads in Java
Explore the power of Continuations in Java, understanding their role in virtual threads and high scalability. Learn to implement a simple VirtualThread class using the Continuation API.
How to Create a New JVM Language
Explore creating a new JVM language, covering grammar, semantics, interpreters, and interoperability. Learn about parsers, optimizations, and tackle common language design challenges.
Evolutionary History of the RabbitMQ .NET Client Towards Concurrency
Explore RabbitMQ .NET Client's evolution towards concurrency, covering async implementation, message consumption improvements, and performance impacts. Gain insights into modern client development.
Functional Programming with C#
Explore functional programming in C# using familiar features like LINQ and delegates. Learn to write more robust, readable, and maintainable code while enabling concurrency and serverless 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.
Concurrent Affairs - Procedural Programming Unlocked
Explore the history and modern relevance of procedural programming in concurrent systems, from cobegin to coroutines, challenging assumptions and connecting past innovations to current trends.
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.
Parallelism Safety-Critical Guidelines for C++
Explore parallelism safety guidelines for C++, covering challenges in multicore architectures and potential issues with newer features. Gain insights into future rules for safety-critical software development.
Single Producer Single Consumer Lock-free FIFO From the Ground Up - Lecture
Explore lock-free programming by constructing a Single Producer Single Consumer FIFO, optimizing performance and addressing cache coherency issues in modern C++.
Concurrency TS2: Improved C++ Concurrency and Lock-free Programming - Lecture
Explore advanced C++ concurrency features in Concurrency TS2, including Synchronized Value, Safe Reclamation, Bytewise Atomic Memcpy, and Asymmetric Fence. Learn their applications in lock-free and low-latency programming.
Lock-free Atomic Shared Pointers Without a Split Reference Count - Implementation Strategies
Explore lock-free atomic shared pointers implementation without split reference count. Learn an elegant solution using hazard pointers for improved performance in concurrent C++ programming.
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.
Designing and Rewriting Asynchronous Tasks from Scratch
Explore the design and implementation of asynchronous task libraries, uncovering challenges and decisions behind APIs like TPL and async/await through a ground-up approach.
Capture Tracking in Scala
Explore capture tracking in Scala with Martin Odersky, delving into advanced concepts and techniques for efficient memory management and resource handling.
Can We Reason About the Security of Concurrent Systems Code?
Explore challenges and possibilities in reasoning about security in concurrent systems code with expert Peter Sewell.
What I Learned from Sockets: Applying Socket Concepts to C++ Concurrency - Lecture
Explore socket concepts like select and poll for composing concurrent operations in C++. Learn to apply Unix primitives and Go-like semantics to solve concurrency problems efficiently.
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.
Choreographic Programming: Its Essence, Beauty, and Necessity - CP 2024
Explore choreographic programming's essence, beauty, and necessity. Delve into its applications in cloud computing, microservices, concurrency, and digital democracy with Professor Fabrizio Montesi.
Rethinking Serverless with FLAME
Explore the FLAME pattern for auto-scaling existing app code without added complexity, revolutionizing serverless architecture in Elixir.