Project Loom - Structured Concurrency in Java
Explore structured concurrency in Project Loom, streamlining multi-threaded task management for improved reliability and observability in Java applications.
Thinking in Parallel
Learn techniques for parallel programming in Java, including array programming and stream operations, to create efficient and easily parallelizable code from Java experts Stuart Marks and Brian Goetz.
Drinking a River of IoT Data with Akka NET
Explore scalable IoT data processing using Akka.NET's actor model. Learn strategies for handling massive device streams and developing resilient, stateful code for improved performance.
Building Confidence in Concurrent Code with a Model Checker
Explore model-checking with TLA+ to detect concurrency errors at design time, enhancing code quality and confidence in concurrent systems beyond conventional practices.
Thinking Erlang in a Connected World
Explore Erlang/OTP's tools and philosophy for building highly concurrent, reliable, fault-tolerant software systems that meet modern industry requirements.
A Lock-Free Atomic Shared_Ptr
Explore lock-free atomic shared_ptr implementation for C++, covering motivation, existing strategies, and a new portable solution for low-latency and real-time applications.
Backporting C++ Safety - Techniques for Pre-Modern Environments
Explore techniques for implementing modern C++ safety in pre-modern environments, focusing on library-based approaches and design patterns for memory safety in large-scale systems.
Rust AI Function Calling Tutorial - Using async-openai
Comprehensive tutorial on implementing AI function calling in Rust, covering setup, chat functionality, tool calls, responses, refactoring, and concurrent requests using OpenAI API.
Smarter C++ Atomic Smart Pointers - Efficient Concurrent Memory Management
Explore efficient concurrent memory management techniques, combining atomic smart pointers and deferred reclamation for scalable C++ code. Learn to write high-performance, memory-safe concurrent programs.
Writing Python Bindings for C++ Libraries - Easy-to-use Performance
Learn to create Python bindings for C++ libraries, focusing on API design, memory management, data conversion, and performance optimization for seamless integration between C++ and Python.
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.
Verifying a Concurrent File System with Sequential Reasoning
Explore a verified, concurrent file system using GoTxn and Dafny. Learn about crash safety, concurrency, and combining interactive and automated proofs for robust systems software.
JEP Explained: Stream Gatherers in Java 23 - JEP 473
Explore Java 23's Stream Gatherers with experts Viktor Klang and Tagir Valeev. Learn about custom intermediate operations, design considerations, and the impact on Stream API functionality.
An Introduction to Multithreading in C++20
Explore C++20's multithreading tools for beginners, covering essential facilities and safe usage in new or existing applications.
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.
Keeping Track of Deadlines in Time-Critical Systems - Lecture
Explore techniques for monitoring and enforcing deadlines in real-time systems using a lightweight C++ API. Learn to implement time constraints and gather runtime statistics in multi-threaded environments.
Concurrency in C++20: A Deep Dive
Explore advanced concurrency features in C++20, including higher-level abstractions built on the C++11 multithreading foundation.
Concurrency Hylomorphism - A Structured Approach to Safe and Efficient Concurrent Programming
Explore a structured concurrency model for safe, efficient, and easy concurrent programming, inspired by Aristotle's hylomorphism. Learn to build effective abstractions with safety guarantees and performance considerations.
Template Task Graphs: An Introduction to Parallel Programming for Irregular Data Sets
Explore the Template Task Graph programming paradigm for expressing task parallelism in algorithms with irregular data sets. Learn installation and integration techniques.