HPX - A C++ Runtime System for Parallel and Distributed Computing
Explore HPX, a C++ runtime system for parallel and distributed computing. Learn about its innovative approach to multi-core processing, asynchronous task execution, and scalable addressing for high-performance applications.
Argot - Simplifying Variants, Tuples, and Futures
Explore Argot, a library simplifying complex operations with tuples, variants, and futures in C++. Learn powerful techniques to enhance code readability and efficiency in handling these abstractions.
Parallelism on Ranges - Should We?
Explore parallelizing C++ ranges, discussing implementation challenges, algorithmic fusion, and potential benefits using HPX library examples. Insights on combining composability with performance in modern C++.
Applicative - The Forgotten Functional Pattern in C++
Explore the powerful applicative pattern in C++, its practical applications, and how it enhances code simplicity and composability across various programming scenarios.
Lessons Learned with Asyncio - Look Ma, I Wrote a Distributed Hash Table
Explore asyncio for concurrent programming in Python, focusing on event loops, coroutines, futures, and networking. Learn through a distributed hash table implementation example.
Better Asynchronous Code with Tornado and Python 3
Explore asynchronous programming with Tornado and Python 3.4's asyncio module. Learn about coroutines, futures, and ioloop concepts for efficient concurrent event-driven code in web development.
Python and Async Programming
Explore Python's async programming approaches, including Futures, asyncio, coroutines, and event loops. Learn best practices for efficient asynchronous code in Python 3.4 and 3.5.
Algorithmic Trading with Python
Explore systematic trading at Winton Capital Management, focusing on Python's role in data management, signal generation, and order execution for algorithmic trading on global exchanges.
Darts - Unifying Time Series Forecasting Models from ARIMA to Deep Learning
Explore time series forecasting with Darts, a Python library unifying traditional and deep learning models. Learn best practices for preprocessing, backtesting, and achieving quick results in forecasting problems.
Algorithmic Architecture, Real-time AI and Alpha
Explore real-time AI trading systems, algorithmic architecture, and overcoming challenges in building scalable, robust AI for multi-instrument trading and cross-sector correlation analysis.
Beyond the Buzzword - A Reactive Web Application in Practice
Practical exploration of building a reactive web application using Play Framework, covering key concepts like Futures, Actors, and Circuit Breakers through live coding and load testing.
Inside the Map Implementation
Explore Go's map implementation, including hash functions, buckets, and performance considerations for efficient data storage and retrieval.
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.
Coroutine Concurrency in Python 3 with asyncio
Explore coroutine-based concurrency in Python 3, from building a simple framework to using asyncio. Learn about futures, tasks, and asynchronous streams for efficient, cooperative multitasking.
A Performance Analysis of a Trading System over Compilers
Explore high-frequency trading optimization techniques, compiler quirks, and performance analysis in C++. Gain insights on static branch prediction, switch statements, and hardware impacts on trading systems.
A Performance Analysis of a Trading System over Compliers
Explore micro-optimizations in C++ for high-frequency trading systems, analyzing compiler quirks, branch prediction, and switch statements. Examine performance impacts across different compilers and operating systems.
Using Kotlin Coroutines for Asynchronous and Concurrent Programming
Explore Kotlin coroutines for efficient asynchronous and concurrent programming, covering suspending functions, structured concurrency, and thread management in HTTP APIs and microservices.
Simple Harmonic Motion - Physics 101 / AP Physics 1 Review with Dianna Cowern
Explore simple harmonic motion, pendulums, and spring systems with Physics Girl. Learn key concepts, solve practical problems, and prepare for AP Physics exams through engaging explanations and exercises.
Delivering Immediate Precision Time in Financial Services
Explore precision time synchronization challenges in cloud applications, focusing on PTP/1588 and PCIe PTM implementations for financial services with performance optimization strategies.
Uniswap V3 Fee Calculation, Fee APR Backtesting, and LP Tools
Dive into advanced Uniswap v3 concepts, exploring fee calculations, APR backtesting strategies, and essential liquidity provider tools for optimizing DeFi investments.
A Case Study of Enhancing gRPC Micro-Services for Supporting High Throughput, Low Latency Trading
Explore optimizations for high-throughput, low-latency trading systems using gRPC and Golang. Learn strategies for enhancing performance and deploying improvements in live environments.