MLOps in Practice: Common Challenges and Lessons Learned - Meetup 114
Explore common MLOps challenges and lessons learned from industry experts. Gain insights on best practices, tool selection, and integrating MLOps into systems with varying maturity levels.
From Core to Containers to Orchestration - Modernizing Compute
Explore Azure's evolution from PaaS to modern compute options, containerization, and microservices. Learn to make informed decisions for scalability, availability, and cost-effectiveness in cloud architecture.
Dynamic Routing Between AWS and Google Cloud - Setting Up High Availability Site-to-Site VPN
Master dynamic routing and high-availability VPN setup between AWS and Google Cloud. Configure site-to-site connectivity, implement BGP sessions, and ensure resilient hybrid cloud networking.
Fault Tolerant Routing Protocols on High-Dimensional Expanders
Delve into fault-tolerant routing protocols on high-dimensional expanders, exploring efficient message transmission systems that maintain reliability even with corrupted network edges and enable advanced distributed computing applications.
Designing a Slimmer Vector of C++ Variants
Dive into advanced C++ optimization techniques for memory-efficient heterogeneous containers, focusing on bit-packed data structures as alternatives to standard vector-variant implementations.
Migrating from Monolith to Microservices with Consul and Nomad
Master microservices deployment using Consul and Nomad to break down monolithic applications, implement configuration-as-code, and enable automated scaling for modern infrastructure.
C++ Development Tools: Past, Present and Future
Explore the evolution of C++ development tools through time, examining their impact on software creation, current capabilities, and potential future innovations in this insightful keynote presentation.
Learning Is Teaching Is Sharing - Building a Great Software Development Team
Discover effective strategies for team growth and knowledge sharing in software development, focusing on collaborative learning techniques to build stronger, more skilled development teams.
A Practitioner's Guide to Safeguarding LLM Applications
Master essential techniques for securing and optimizing LLM applications, from structured outputs to data protection, with hands-on practice using open-source tools for enhanced reliability and performance.
From Prototype to Production: Implementing LLM-Based Applications
Discover practical strategies for transitioning LLM prototypes to production, covering system design, maintenance, integration challenges, and implementation best practices for scalable AI applications.
The C++ Vector Challenge - Exploring Object Interfaces and Formal Specifications
Delve into the complexities of C++ vector implementation, exploring formal interfaces, static checking mechanisms, and the challenges of specifying object interfaces through a deep technical analysis.
Melocoton: A Program Logic for Verified Interoperability Between OCaml and C
Explore Melocoton, a groundbreaking program logic for verifying interactions between OCaml and C components through OCaml's foreign function interface, mechanized in Coq using Iris.
Rethinking Serverless with FLAME
Explore the FLAME pattern for auto-scaling existing app code without added complexity, revolutionizing serverless architecture in Elixir.
How to Use Dependency Injection to Write Maintainable Software
Explore dependency injection techniques in C++ to create decoupled, easily refactored, and testable components. Learn to manage data and behavior dependencies for simplified, maintainable software.
Breaking Dependencies: The Path to High-Quality Software
Discover strategies to reduce software dependencies, enhancing code quality and maintainability. Learn practical techniques for creating robust, flexible, and scalable C++ applications.
Properties of Unit Tests
Explore key properties of unit tests and their impact on design goals, enhancing your understanding of effective test-driven development in C++.
Abstraction: The True Superpower of C++ - Meeting C++ 2022
Explore abstraction in C++: its meaning, mechanisms, and benefits. Learn to create clearer, more maintainable code using C++'s powerful abstraction facilities.
Dependency Injection Patterns: Efficiency and Usability - Meeting C++ 2023
Explore efficient dependency injection patterns in C++ for maintainable, reusable, and testable software. Learn techniques, language features, and best practices for effective implementation.
Type Erasure - The Implementation Details
Explore Type Erasure implementation techniques, from simple wrappers to advanced optimizations. Master this powerful design pattern to reduce coupling in C++ codebases.
Observability Strategies to Not Overload Engineering Teams
Explore observability strategies to optimize engineering team workload, including proxy, OpenTelemetry, and eBPF approaches for effective monitoring and performance management.
Journey Beyond - AWS Quest for Excellence
Explore AWS optimization strategies for media production workloads. Learn about SES, workload analysis, evolution, rightsizing, scaling, and database management to enhance cloud performance and efficiency.