What Every Node.js Developer Needs to Know About Elixir
Discover Elixir: A versatile, safe alternative to Node.js for server-side development. Learn its benefits, including expressive syntax, massive concurrency, and fault-tolerance.
Thinking Outside the Synchronisation Quadrant
Explore concurrency beyond threads and locks, covering immutability, actors, and other patterns in modern C++ for efficient parallel programming and system design.
Functional C++
Explore functional programming concepts in C++, focusing on immutability, concurrency, and function composition. Learn idiomatic approaches to apply these ideas in modern C++ development.
Better Code - Concurrency
Explore advanced concurrency techniques in C++14, including task systems and performance optimization, to create efficient parallel software without waiting.
Get to Grips with Asyncio in Python 3
Explore asyncio in Python 3: futures, tasks, event loops, and async/await syntax. Learn to solve concurrency problems and test asynchronous code effectively.
The Tension Between Expediency and Correctness
Explore tradeoffs between expediency and correctness in programming, discussing their implications for software development and introducing Elixir's advantages in building robust systems.
First Class Commands - The 2017 Edition
Explore the Command Pattern in functional and OOP, and its modern applications in concurrency, serializability, and separation of concerns.
Concurrent Programming in C++
Explore C++ concurrency API, learn to create and manage threads, avoid race conditions and deadlocks, and utilize async operations and futures for efficient concurrent programming.
The Erlang Ecosystem
Explore Erlang's history, design principles, and ecosystem. Learn about its concurrency model, error handling, and scalability for distributed systems, plus new languages in the Erlang environment.
Kotlin for the Curious
Explore Kotlin's pragmatic design, multi-platform capabilities, and key features like null safety, extension functions, and coroutines in this comprehensive introduction for curious developers.
12 Factor Microservices
Explore 12 Factor methodology for building scalable, deployable microservices using ASP.NET Core. Learn key principles for configuration, logging, concurrency, and more to enhance application stability and ecosystem integration.
IncludeOS - Running C++ Applications Without an Operating System
Explore IncludeOS, a library operating system that enhances performance and security. Learn about its unique features, deployment, and live application updates without downtime.
Developing Kernel Drivers with Modern C++
Explore modern C++ techniques for kernel driver development, covering memory management, synchronization, and data structures optimized for the Windows kernel environment.
Generators, Coroutines and Other Brain Unrolling Sweetness
Explore C++20 coroutines for creating generators, iterables, and ranges. Learn to write cleaner, more abstract code with improved composition and reduced callback usage.
Rust in Edge Computing: Enhancing Performance and Security
Explore Rust's role in edge computing, focusing on performance and security enhancements. Learn core principles, real-world applications, and implementation strategies for optimized edge solutions.
Making a Working Implementation of Async Functions in Python 2.1
Dive into the evolution of Python's async/await syntax through a fascinating reverse-engineering journey, exploring coroutines implementation from modern Python back to version 2.1.
From Global to Local Quiescence: Wait-Free Code Patching of Multi-Threaded Processes
Explore wait-free code patching for multi-threaded processes, enabling gradual application of updates without disrupting service. Learn about WfPatch's implementation and its impact on system performance.
Tackling Thread Safety in Python
Explore thread safety challenges in Python, understand race conditions, GIL's impact on multithreading, and learn to fix unsafe code using synchronization primitives.
Responsive Parallelism with Synchronization
Explore a novel approach combining static and dynamic techniques to prevent priority inversion in concurrent programs using mutexes and condition variables, enhancing responsiveness and efficiency.
Go Performance Unleashed - Optimizing Runtime and Memory
Unlock Go's performance potential through runtime scheduler insights, memory optimization techniques, and benchmarking best practices for efficient code execution.
What's New in Apollo Kotlin 3
Explore Apollo Kotlin 3's new features: coroutines, Flow API, Kotlin Multiplatform support, codegen options, and test builders. Learn how to implement this type-safe GraphQL client in your projects.