In Types We Trust
Explore how types and contracts enhance software reliability, with insights on test-driven development, proof algorithms, and Scala's role in building robust systems.
How Are We Going to Migrate to Scala 3.0, Aka Dotty
Explore Scala 3.0 migration strategies, new features, and design principles. Learn about breaking changes, metaprogramming, and the roadmap for transitioning from Scala 2 to 3.
Compiling to Preserve Our Privacy
Explore secure multiparty computation and privacy-preserving techniques in Scala, including direct embedding, masking, and compiler optimizations for efficient implementation.
Do You Trust Me? - A Look at Trust, Time, and Teams
Explore the psychology of trust in engineering teams, its relationship to time, and strategies for better trust rituals to enhance collaboration and productivity.
What Does Chakra Do with Your JavaScript?
Explore Chakra's internals: profiling interpreter, type system, optimizing compiler, and garbage collector. Gain insights into JavaScript performance in IE10.
Armchair Type Theory
Explore the historical roots and fundamental concepts of type theory, tracing its origins beyond Haskell and examining its impact on modern programming paradigms.
Practical Functional Programming - Pick Two
Explore practical functional programming techniques in JavaScript, including immutability, recursion, and laziness, to enhance code clarity, testability, and maintainability.
A Hammer You Can Only Hold by the Handle
Exploring Rust's type system to enforce API constraints and create self-documenting code. Learn how to leverage affine types for compile-time safety in complex operations.
Rustls - Modern, Faster, Safer TLS
Explore rustls, a modern TLS stack in Rust, offering enhanced security, performance, and design. Learn about its features, deployment, and advantages over traditional implementations.
Rust for Safer Protocol Development
Explore how Rust's type system can enhance network protocol safety through automated parser generation and design validation.
Using Elixir and F# Together
Explore interoperability techniques between Elixir and F#, comparing their strengths in functional programming, type systems, and concurrency models for effective combined usage.
Using C#'s Type System Effectively
Practical tactics to leverage C#'s type system for improved compiler feedback, safer code optimization, and enhanced programming philosophy. Explore simple to advanced techniques.
Domain Modeling Made Functional
Explore domain modeling in functional programming, using types to represent domains, encode business rules, and ensure code correctness at compile time. Learn practical F# examples for effective domain-driven design.
Deconstructing TypeScript’s Type System
Explore TypeScript's advanced type system features, including intersection types, type guards, and discriminated unions. Learn to leverage compile-time checking for cleaner, safer code.
Supergraph(QL) - Scalable API Strategy for Your Data Using GraphQL
Discover how to combine platform engineering and GraphQL to create scalable, declarative data APIs. Learn to leverage type systems for efficient team collaboration and unlock siloed enterprise data.
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.
Revisiting Dynamic Dispatch for Modern Architectures
Explore an alternative dispatch mechanism for dynamic languages, addressing modern hardware concerns while maintaining performance comparable to fully typed programs.
Modern DSL Compiler Architecture in OCaml - Experience with Catala
Explore state-of-the-art DSL implementation in OCaml, featuring concrete examples and insights from the Catala compiler for legal algorithms.
Greedy Implicit Bounded Quantification in Object-Oriented Programming Languages
Explore greedy implicit bounded quantification in object-oriented programming, focusing on type inference algorithms and a variant of kernel F≤ with implicit polymorphism.
Gradual Typing for Effect Handlers
Explore gradual typing for effect handlers, integrating effect typing with existing languages. Learn about GrEff language, its semantics, and the graduality theorem through operational logical relations models.
Verus: Verifying Rust Programs Using Linear Ghost Types
Explore Verus, an SMT-based tool for formally verifying Rust programs. Learn how it leverages Rust's linear types and borrow checking to prove functional correctness in low-level, high-assurance systems.