LOADING
This talk presents McCCT, a new concurrency testing tool developed at KTH by the speakers in the context of an ongoing research project.
Building resilient and scalable distributed systems is necessary to support emerging and future digital services processing increasing amounts of data and requiring increasing amounts of computing resources to support artificial intelligence. One challenge in building such systems is safe large-scale concurrency. Due to the inherent nondeterminism of concurrent programs, it is notoriously difficult to find, reproduce, and fix concurrency bugs.
This talk presents McCCT, a new concurrency testing tool developed at KTH by the speakers in the context of an ongoing research project. McCCT helps find concurrency hazards, such as race conditions and deadlocks, by systematically exploring the possible schedules of concurrent Scala programs. Importantly, McCCT supports replaying problematic schedules, aiding in the reproduction of concurrency bugs. In addition, the tool provides a scheduler that can enforce a sequential schedule, enabling deterministic execution, suitable for integration in unit test suites.
The talk will start with an overview of McCCT and its capabilities from the user's perspective. Using live coding, we will show how to use McCCT to find and replay a series of concurrency bugs in real-world concurrent code. After that, we will explain how the tool can be used to create powerful regression tests for concurrent code. At the end, the talk will provide an introduction to the inner workings of McCCT.
For nearly a decade, Scala's concurrency has been driven by Akka, Cats Effect and ZIO, each with its own vision for purity, safety, and pragmatism. Kyo enters this incredible ecosystem with a fresh perspective.This talk provides a critical, technical comparison of these systems through a unified framework.
Don't miss out on this opportunity to connect with Scalar community and create lasting memories!
Code generation is one of the most promising applications of large language models (LLMs), offering substantial productivity boosts for developers. However, this benefit is tempered by serious concerns surrounding the correctness and security of the generated code - especially outside the happy path.
In this talk, we will walk through a concrete example of a boilerplate-heavy domain. By replacing common Scala 2 workarounds with Opaque Types, Extension Methods, Enums, and Union Types, we will demonstrate how to achieve a strictly typed, decoupled architecture without the noise.
When writing software, we currently seem to have to choose between an imperative style - easy to read and write, hard to reason about - and a monadic style - hard to read and write, easy to reason about.This talk is about being greedy and getting the best of both worlds, because we deserve it.
