Scaling Rails with JRuby in 2022
Explore JRuby's latest features for Ruby 3.1, including improved performance, scaling, and resource efficiency for Rails applications.
Crystal for Rubyists - Similarities and Differences
Explore Crystal, a Ruby-like compiled language, learning its similarities and differences to Ruby while gaining hands-on experience in this engaging workshop.
Using JRuby: What, When, How, and Why - Ruby 3.1 Update
Explore JRuby's benefits, compatibility, and performance. Learn installation, Rails integration, and future developments for this alternative Ruby implementation.
TaskJob: Manage .NET Tasks as PowerShell Jobs - PowerShell Summit 2023
Discover how to manage .NET Tasks as PowerShell Jobs with TaskJob, enhancing your scripting capabilities and workflow efficiency.
Beyond CRUD: PostgreSQL Techniques Your Rails App Is Missing
Explore advanced PostgreSQL techniques for Rails apps, including locking mechanisms and mutex, to enhance scalability and prevent production outages.
Race Conditions in Rails Applications: Detection, Testing, and Fixing
Explore race conditions in Rails, their impact on shared resources, and strategies for detection, testing, and resolution as applications scale.
The Very Hungry Transaction - Avoiding Dangerous Patterns in Database Transactions
Explore database transaction pitfalls and best practices to safeguard data integrity and application performance in Rails applications.
The Very Hungry Transaction - Avoiding Risky Database Patterns
Explore how database transactions grow into liabilities, uncover problematic patterns, and learn strategies to maintain data integrity and database health.
CodeCamp: Introduction to Reactive Programming
Explore reactive programming concepts and techniques to build scalable, responsive applications. Learn to handle asynchronous data streams efficiently.
Akka Streams: Creating Graphs and Dynamic Components
Learn to create Akka streams graphs using graph DSL, explore non-linear components, and design dynamic graphs for efficient stream processing and ingestion.
CodeCamp: Completable Future in Java - Asynchronous Programming
Master asynchronous Java programming with CompletableFuture. Learn its benefits, limitations, and practical implementation for efficient non-blocking code execution.
Effect-Based Reactive Streams in Scala
Master effect-based reactive streaming in Scala to enhance your programming skills and build more efficient, scalable applications.
Revolutionizing Backend Development with Kotlin and Spring Boot
Explore Kotlin and Spring Boot's synergy for robust, scalable applications. Enhance web and microservice development with powerful technologies.
Concurrency Control Using Locks
Learn techniques for managing concurrent access to shared resources using locks in database systems.
Concurrent Self-Adjusting Data Structures - Challenges and Solutions
Explore self-adjusting data structures and their concurrent implementations, focusing on SplayTree, CBTree, and Splay-List. Learn about efficient lazy rebuilding for multi-way structures like B-tree and IST.
Is Loom Really the Future of Enterprise Java?
Explore Project Loom's virtual threads in Java, their benefits, and potential issues. Compare with event loop models and learn to identify and avoid hidden problems in enterprise applications.
Designing for Concurrency Using Message Passing in C++
Explore message passing for concurrent C++ design, reducing synchronization errors. Learn practical implementation through examples like dining philosophers and robot control systems.
Coroutine Intuition in C++ - Lecture
Gain intuition on coroutines in C++20. Explore stackless asyncrony, generators, and senders/receivers through concise examples to improve code readability, maintainability, and composability.
What's New in C++23
Explore C++23's new features with Sy Brand, enhancing code simplicity, expressiveness, and power. Learn how upcoming changes benefit your programming and prepare for future upgrades.
C++ Concurrency TS 2 Use Cases and Future Direction - Lecture
Explore advanced C++ concurrency features, including hazard pointers and RCU. Learn about potential additions to TS 2 and how to create fast, scalable code using Concurrency TS 2 support.
Scalable and Low Latency Lock-free Data Structures in C++
Explore scalable, low-latency lock-free data structures in C++. Learn advanced techniques for high-performance multi-threaded programming, cache-conscious design, and efficient memory usage.