Common Mistakes in Golang and How to Avoid Them
Explore common Golang pitfalls and learn effective strategies to enhance code quality, covering arrays, channels, goroutines, interfaces, and more.
Python in Parallel: Sub-Interpreters vs. NoGIL vs. Multiprocessing
Explore Python's parallel processing options: Sub-Interpreters, NoGIL, and Multiprocessing. Compare their pros and cons for CPU-bound and IO-bound applications to make informed decisions on leveraging multi-core capabilities.
Configuring JVM Thread Pools for Optimal CPU Utilization
Optimize JVM thread pools for maximum CPU efficiency. Learn configuration techniques to enhance performance and resource utilization in Java applications.
Hazard Pointers with Reference Counter - A New Synchronization API
Explore a new synchronization API combining hazard pointers and reference counters, leveraging their strengths for efficient object existence guarantees.
Keep It Local - Reasoning About Code in Software Design
Explore diverse programming paradigms and their shared goal of enhancing code reasoning, from variable scoping to functional programming and data ownership systems.
Introducing MuJoCo.jl - Julia Bindings for the MuJoCo Simulator
Explore MuJoCo.jl, Julia bindings for the advanced physics engine. Learn about high-performance wrappers, user-friendly interfaces, and native Julia access to simulation data. Discover real-time visualization tools for robotic applications.
Zephyr 101 - Thread Control
Learn to manage threads in Zephyr RTOS, covering stack and heap usage, thread creation, message queues, and practical implementation for efficient embedded system development.
KSVD.jl: A Case Study in Performance Optimization
Explore performance optimization techniques for K-SVD algorithm implementation, including execution order adjustments, single-core optimizations, multi-threading, and distributed computing.
DistributedWorkflow.jl - A Task-Based Workflow System Interface
Explore DistributedWorkflow.jl, a Julia interface for task-based workflow management. Learn to build domain-specific workflows, leverage dynamic scheduling, and simplify parallel distributed application development for HPC and domain scientists.
Asynchronous Programming in Rust
Dive deep into Rust's asynchronous programming, comparing it with Go and exploring syntax, implementation, and real-world challenges through a Red Hat team's migration experience.
Master Multithreading: Thread Pool in C++
Implement a C++ thread pool from scratch, covering basics, benefits, task management, synchronization, best practices, and advanced topics for efficient multithreading.
Using and Implementing Differential Reference Counting in Realtime Audio Code
Explore differential reference counting for safe memory sharing in realtime audio, improving throughput with a limited API. Learn implementation strategies for efficient thread management.
Introduction to Lock/Wait Free Algorithms - Defining and Understanding the Terms
Explore lock/wait-free algorithms: understand definitions, motivations, and applications in concurrent programming. Gain insights into hardware design and synchronization challenges.
Applications of Distributed Task Parallelism
Explore distributed task parallelism in Julia, comparing Dagger with other frameworks and libraries. Learn about unique features for efficient, scalable, and maintainable code.
Using Dynamically Layered Definite Releases for Verifying the RefFS File System
Explore RefFS, a groundbreaking concurrent file system with proven liveness and safety. Learn about dynamically layered definite releases and the MoLi framework for verifying concurrent systems.
IntOS: Persistent Embedded Operating System for Multi-threaded Intermittent Computing
Innovative embedded OS for battery-less devices, enabling efficient multi-threaded computing with crash consistency and simplified programming through novel replay-and-bypass approach.
CrossMapping - Harmonizing Memory Consistency in Cross-ISA Binary Translation
Innovative framework for cross-ISA binary translation, enhancing emulation correctness and performance. Introduces specification tables for unified memory model description and efficient primitive mapping.
Embracing Virtual Threads with Java's Project Loom - Spring Boot Tutorial
Explore Java's Virtual Threads in Spring Boot applications, enhancing scalability and performance. Learn implementation, advantages, and practical demonstrations for efficient concurrent programming.
Using Java 8 Lambdas and Stampedlock to Manage Thread Safety
Explore StampedLock in Java 8 for efficient thread safety management, learn common idioms, and discover lock-free solutions using Lambdas in multi-producer/consumer systems.
CompletableFuture and Its Quirks in Java - Live Coding Session
Explore CompletableFuture's quirks, traps, and surprises in Java through live coding, covering thread pools, exception handling, cancellations, and unintuitive API methods.
The Erlang VM or How I Stopped Worrying and Started Loving Parallel Programming
Discover how Erlang VM simplifies parallel programming, enabling scalable 24/7 services. Learn about message passing, process isolation, and dynamic code loading for robust system development.