Stretching the Glasgow Haskell Compiler: Nourishing GHC with Domain-Driven Design
Explore Domain-Driven Design principles for enhancing Glasgow Haskell Compiler's architecture, addressing immutability, modularity, and composability in large-scale functional systems.
Typed Design Patterns for the Functional Era - FUNARCH'23
Explore functional design patterns in modern programming, focusing on architectural concepts and their implementation in Rust's type system.
Flow-Based Programming with Elixir and ALF
Explore Flow-Based Programming in Elixir using ALF. Learn advantages, implementation, and practical examples like an online TicTacToe game. Discover how to model application layers effectively with this paradigm.
Building Blocks and How to Use Them: MongooseIM Case Study
Explore MongooseIM's building blocks, architecture, and performance optimization techniques. Learn about configuration, pools, telemetry, and debugging tools for efficient XMPP server development.
Microservices and Events - Friends or Foes?
Explore the architecture, design choices, and lessons learned in building a scalable SaaS platform using microservices and event-driven architecture with Elixir.
How to Safely and Reliably Upgrade Your RabbitMQ Cluster While Maintaining 100% Uptime
Learn to upgrade your RabbitMQ cluster safely and reliably while maintaining 100% uptime. Discover step-by-step techniques for implementing new features, bug fixes, and security patches without service interruption.
How We Rabbit at AWeber - RabbitMQ in Production for 10 Years
Explore AWeber's decade-long use of RabbitMQ in production, covering topologies, standards, monitoring, and operational management for high-volume message delivery.
Erlang vs Elixir: On the Shoulder of Giants There's Room for Larger Giants
Explore the symbiotic relationship between Erlang and Elixir, examining their impact on various domains and the reasons behind their growing popularity in software development.
How to Sell Elixir - Strategies for Adoption and Evolution
Explore Elixir adoption strategies, ecosystem capabilities, and team evolution. Learn to design resilient systems, manage risks, and ensure long-term sustainability in Erlang/Elixir projects.
Don't Fight the Monolith - Choosing the Right Architecture for Your Team - ElixirConf EU 2023
Explore the social and technical implications of monoliths, modular monoliths, and microservices in Elixir. Learn to choose and implement the right architecture for your team structure and project needs.
When Testing Just Doesn't Cut It - Formal Verification in Mission-Critical Software
Explore formal verification techniques for mission-critical software, using a financial application example to demonstrate mathematical proofs beyond standard unit testing.
RabbitMQ Streams: Past, Present, and Future - Design Journey and New Features
Explore RabbitMQ streams' design journey, internals, and new filtering feature. Gain insights into best practices, limitations, and future developments for efficient message streaming and partitioning.
Design Patterns in Elixir: Exploring the Gang of Four - Keynote
Explore classical design patterns in Elixir, deconstructing objects and examining their impact on large system design with José Valim's insightful analysis.
Developing a Bespoke Kafka Client - Against the Grain
Explore the development of a custom Kafka client, overcoming challenges through unconventional approaches and innovative problem-solving techniques.
Reimplementing Technical Debt with State Machines - Code BEAM
Explore reimplementing legacy protocol code using state machines. Learn how to tackle technical debt and create extensible systems with OTP's gen_statem behaviour and telemetry-like event mechanisms.
Minimal Logging Framework in C++20
Develop a minimal, optimized C++20 logging framework from scratch, exploring performance enhancements and efficient data collection techniques for large-scale systems.
Design Patterns: The Most Common Misconceptions
Uncover common misconceptions about design patterns in software development. Gain clarity on Factory, Builder, Bridge, Strategy, Visitor, and Decorator patterns for improved communication and architecture.
gRPC C++ - A Way to Go Generic
Explore gRPC C++ implementation for modernizing legacy codebases, abstracting details, and decoupling services. Learn effective strategies for transitioning to service-oriented architectures.
Art of Building Secure and Scalable Webhooks
Learn to build secure and scalable webhooks for efficient real-time data exchange and system integration in Golang applications.
Scaling an Application Without Microfrontends - The Glorious Monolith Approach
Explore scalable application architecture without microfrontends. Learn about the "glorious monolith" approach, module isolation techniques, and effective code organization for large-scale projects.
APIs - Refactoring to Patterns
Explore API refactoring patterns to improve code quality, maintainability, and architecture. Learn about cohesion, loose coupling, and design patterns for better microservices.