All Your APIs Are Mine - Secure Them Now
Learn to secure Spring APIs against common attacks through live demos, exploring authentication, authorization, and data protection strategies for REST, GraphQL, and gRPC.
Design Patterns in Modern C++
Explore modern C++ adaptations of classic design patterns, focusing on principles like Open-Closed and Specification, while introducing concepts such as fluent builders and Maybe types for improved code structure and flexibility.
Functional C++ For Fun And Profit
Explore functional programming concepts in C++, including immutable data types, persistent structures, and expression-oriented programming for more efficient and robust code design.
Modern C++ Design Reloaded
Exploring advanced C++ design patterns for resource-constrained systems, featuring metaprogramming techniques, lazy evaluation, and named parameters to create efficient abstractions for bare metal and real-time applications.
Dynamic Polymorphism With Code Injection and Metaclasses
Explore advanced C++ techniques for dynamic polymorphism using code injection and metaclasses, offering alternatives to traditional virtual functions and inheritance for improved performance and flexibility.
Retiring the Singleton Pattern - Concrete Suggestions for What to Use Instead
Explore concrete alternatives to the Singleton pattern in large codebases, focusing on dependency injection, wrapper classes, and gradual implementation strategies for improved testability and maintainability.
Design Patterns - Examples in C++
Explore essential C++ design patterns to enhance code robustness and readability. Learn practical techniques for efficient software development and improve your programming skills.
Spooky Action at a Distance - Revisiting C++ Observers
Explore C++ Observer pattern implementations, trade-offs, and practical applications in various scenarios. Learn from real-world examples to improve code structure and design.
Keeping the Balance - Load Balancing Demystified
Comprehensive overview of load balancing techniques across network layers, exploring various approaches, use cases, and design patterns for high-availability services. Provides evaluation criteria and decision-making framework.
Rust for IOT
Explore Rust for embedded systems: architecture support, paradigm shifts, and techniques for microcontrollers. Survey of outstanding embedded Rust projects in the ecosystem.
Sailing Modern Java
Explore modern Java features and best practices for efficient development. Learn to leverage latest language enhancements and tools to write cleaner, more expressive code.
Critical Code Analysis with Observer Pattern
Explore critical code analysis techniques using the Observer Pattern, enhancing software quality and maintainability in this insightful conference talk.
Classic Design Patterns - Where Are They Now
Explore the evolution and relevance of classic design patterns in modern programming, with insights on their applicability in dynamic languages like Python.
Boost.Asio and Boost.Serialization - Design Patterns for Object Transmission
Explore C++ network programming using Boost.Asio and Boost.Serialization for efficient object transmission, covering complex data structures, serialization techniques, and asynchronous communication patterns.
Thread-Safe Observer Pattern - You're Doing It Wrong
Explore common pitfalls and solutions for implementing a thread-safe Observer Pattern, highlighting fundamental threading issues and providing practical approaches to avoid deadlocks and post-death calls.
Design Patterns in the 21st Century
Explore modern C++ design patterns, functional programming concepts, and improvements to classic Gang of Four patterns. Learn how lambda expressions enable monads and enhance software design.
Implementing Tuple in C++17
Explore C++17's impact on std::tuple implementation, including new language features, library changes, and design considerations. Dive into testing and benchmarking scenarios for tuple implementations.
Instrumentation Nightmares - A Review of Our Toughest Cases
Explore advanced Python instrumentation techniques, challenging real-world cases, and design patterns. Learn to hook into import systems, instrument popular libraries, and make your code instrumentation-friendly.
Python Design Patterns
Learn Python design patterns to enhance code structure and flexibility, covering Facade, Singleton, Dependency Injection, and more, with practical examples and Pythonic approaches.
What Is Wrong with API Wrappers and How Can We Do Better
Explore API wrapper challenges and discover Tapioca, a wrapper generator that simplifies API interactions, promotes consistency, and enhances explorability for developers.
Why You Don't Need Design Patterns in Python
Explore Python's features that simplify or eliminate the need for traditional design patterns, showcasing the language's elegance and efficiency in solving common programming challenges.