Ease Virtual Machine Level Tooling with Language Level Ordinary Object Pointers
Explore techniques to bridge abstraction gaps in VM tooling using Language Level Ordinary Object Pointers, enhancing debugging and error resolution in Pharo environments.
Severing Ties: The Need for Non-Updateable Thunks
Explore non-updateable thunks in Haskell to prevent memory leaks and optimize garbage collection in streaming abstractions and control flow scenarios.
Why Code in Python+C When You Can Code in Lisp+Zig
Explore the benefits of combining GNU Guile Lisp and Zig for bioinformatics, offering quick coding and high performance without fighting Rust's borrow checker.
Modal FRP for All: Functional Reactive Programming Without Space Leaks in Haskell
Explore Modal FRP in Haskell: Learn to prevent space leaks in functional reactive programming and implement a Pong game using this technique.
Haskell Library for Safer Virtual Machine Introspection - Experience Report
Explore a Haskell library for safer virtual machine introspection, leveraging Template Haskell for compile-time code generation and static error detection in VMI programming.
Exploring Perceus for OCaml - ML'23
Explore Perceus algorithm implementation in OCaml, comparing its performance with standard garbage collection. Learn about precise reference counting and its potential benefits.
Wasocaml: A Compiler from OCaml to WebAssembly - Lecture
Explore OCaml to WebAssembly compilation, addressing challenges and strategies for garbage-collected languages. Learn about Wasocaml compiler, value representation, and future plans for FFIs and effects handlers.
Borrow Checking in Hylo - A High-Level Systems Programming Language
Explore Hylo's innovative approach to safe, efficient systems programming using mutable value semantics and abstract interpretation for lifetime verification.
Actix-Telepathy: Distributed Actor Programming in Rust
Explore Actix-Telepathy, an extension for Rust's Actix library enabling remote messaging and clustering support for distributed applications using the actor programming model.
Memory Simulations, Security and Optimization in a Verified Compiler
Explore memory simulations, security features, and optimizations in verified compilers. Gain insights into pointer allocations, stack canaries, and tail recursion elimination in CompCert.
A Family of Fast and Memory Efficient Lock- and Wait-Free Reclamation - PLDI 2024
Explore Crystalline, a novel family of non-blocking memory reclamation schemes addressing high performance, memory efficiency, and wait-freedom challenges in concurrent programming.
Apple Array Allocation - Static Memory Management for Flat, Immutable Arrays
Explore statically determined memory allocation for flat, immutable arrays in Apple array system, extending liveness analysis for JIT compilers in functional languages.
OTP Update - Code BEAM Lite Stockholm 2023
Discover the latest developments from the OTP Team, exploring their recent work and future plans in Erlang/OTP.
High Throughput Data Conversion for Database Virtualization
Explore database virtualization with Hyper-Q, an Erlang application for cross-compiling SQL dialects. Learn about bottleneck diagnosis, architectural improvements, and memory optimization techniques.
Squeezing a Go Function
Optimize Go functions for peak performance through advanced techniques and best practices. Enhance code efficiency and speed.
Rust for Java Programmers - A Personal Perspective
Explore Rust from a Java developer's perspective, comparing language features, promises, and backend frameworks while examining ownership, borrowing, and enterprise considerations.
Rethinking Data Flow in gRPC-Go - Maximizing Memory Efficiency
Maximize memory efficiency in gRPC-Go by rethinking data flow strategies. Learn techniques to optimize performance and resource utilization.
PEP 683 - Immortal Objects: A New Approach for Memory Management in Python
Explore Python's memory management, PEP 683's origins, and its impact on future developments like GIL changes and true parallelism. Gain insights into optimizing large-scale applications.
Tales from the Abyss - Most Obscure CPython Bugs and How to Solve Them
Explore obscure CPython bugs, learn advanced debugging techniques, and gain insights into solving complex issues in large codebases like Python's core implementation.
Is It Me or Python Memory Management? - Understanding and Optimizing Memory Usage
Explore Python memory management, analyze usage, and learn optimization techniques for efficient, memory-conscious coding as applications scale and complexity grows.
Unlocking the Power of WhoIsActive - Monitoring SQL Server Activity
Discover advanced SQL Server monitoring techniques using WhoIsActive. Learn to track activity, troubleshoot issues, and optimize performance effectively.