Using Immutable Data Structures
Explore immutability in C# for cleaner, more reliable code. Learn to apply immutable objects and collections, refactor existing codebases, and understand the implications for .NET development.
Reactive Programming - A Better Way To Write Frontend Applications
Explore functional reactive programming for simplified frontend development, treating data as asynchronous streams and transforming values over time to handle events more effectively.
So, You Want to Be a CTO?
Explore the path to becoming a successful CTO, covering essential skills, leadership strategies, and experiences needed for this pivotal tech leadership role.
Domain-Driven Refactoring
Explore techniques for transforming existing code into a more cohesive, domain-driven design through refactoring, pattern recognition, and strategic application of DDD principles.
TDD and the Terminator - An Introduction to Test Driven Development
Explore Test Driven Development through reprogramming a Terminator, covering SOLID principles, architecture, and practical examples to create maintainable applications.
Reinventing the Transaction Script
Explore functional programming principles to reinvent the Transaction Script pattern, enhancing domain-driven design while maintaining simplicity and productivity in business logic organization.
Modernizing an Existing System to Take a More Domain-Driven Approach
Explore refactoring patterns and steps to transform a non-DDD SOA system into a domain-driven design approach, covering key concepts, implementation strategies, and decision-making processes.
Embrace the Interface
Explore powerful abstraction techniques in Go using interfaces to create modular, lean, and clean code. Learn practical patterns for software craftsmanship and sane abstraction.
A Custom Design Pattern for Building Dynamic ActiveRecord Queries
Explore a custom design pattern for creating efficient, flexible, and readable ActiveRecord queries in Rails applications using query objects and builders.
ML Ops Design Patterns with Kubeflow Pipelines
Explore ML Ops design patterns using Kubeflow Pipelines to transition from notebook exploration to production, addressing challenges and implementing effective solutions.
Inversion of Control Containers Beyond Constructor Injection
Learn to leverage IoC containers beyond constructor injection, writing loosely coupled code and decoupling apps from frameworks. Explore advanced features for better design and implementation.
No More Graphical Passwords
Explore the challenges and weaknesses of graphical passwords, discussing alternative authentication methods and their implications for security and user experience.
Resilient Microservices Architecture with Kubernetes
Explore resilient microservices architecture using Kubernetes, covering key design patterns like timeout, circuit breaker, retry, and bulkheads for building robust, scalable systems.
There Is No Shortcut to Serverless - From Your Legacy System
Explore challenges and design options for migrating to serverless architecture, focusing on security, integration, and performance optimization for legacy system connectivity.
G ∘ F Patterns
Explore functional programming in Java 8 with Mario Fusco as he demonstrates how to simplify and reimagine common design patterns using lambda expressions and higher-order functions.
G ∘ F Patterns
Explore functional programming in Java 8 through live coding, reimagining GoF design patterns using lambda expressions for simpler, more concise implementations.
Design Patterns with Kotlin
Explore Gang of Four Design Patterns implemented in Kotlin, leveraging IntelliJ's native support to enhance your coding skills and apply object-oriented wisdom effectively.
Design Patterns in the Light of Lambda Expressions
Explore how Java 8's lambda expressions transform traditional design patterns, enhancing their implementation and enabling new patterns for more efficient and expressive code.
Refactor Your Java EE Application Using Microservices and Containers
Learn to decompose monolithic Java EE applications into microservices, exploring design patterns, tools for CI/CD, service discovery, load balancing, and orchestration challenges.
Design Pattern Reloaded
Explore how functional programming and OOP can be combined in Java 8, using GoF design patterns as examples. Learn to rewrite behavioral and creational patterns with a mix of FP and OOP concepts.
JavaScript Design Patterns
Explore unique JavaScript design patterns like Event Delegation and Context-based Inheritance, tailored to the language's nature and modern use cases.