Angular's Future Without NgModules - Architectures With Standalone Components
Explore Angular's future with standalone components, eliminating NgModules for streamlined, lightweight applications. Learn structuring techniques, lazy loading approaches, and strategies for migrating existing solutions.
Standalone Components - The Motivation
Explore Angular's shift towards optional NgModules, understanding the motivation behind this fundamental change and its impact on component architecture and application structure.
The Past, Present, and Future of Cloud Native API Gateways
Explore the evolution of API gateways, current challenges in Kubernetes, and strategies for exposing services at the edge. Learn about scaling developer workflows and supporting diverse architectures.
TARS, A New Generation of Massive Microservice Architecture - Supporting Tencent’s Billion-user Ecosystem
Explore TARS, Tencent's innovative microservice architecture supporting billion-user ecosystems. Learn about its design, scalability, and impact on large-scale applications.
Using Kubernetes with Data Processing Units to Offload Infrastructure
Explore offloading Kubernetes infrastructure to Data Processing Units (DPUs), enhancing application agility, elasticity, and control. Learn about CNIs, SmartNICs, and Arm CPUs in evolving DPU landscapes.
What We Learned from Reading 100+ Kubernetes Post-Mortems
Insights from 100+ Kubernetes post-mortems: Learn common pitfalls, anti-patterns, and root causes of outages to prevent your next production disaster in Kubernetes-based systems.
Beyond the Buzzword - A Reactive Web Application in Practice
Practical exploration of building a reactive web application using Play Framework, covering key concepts like Futures, Actors, and Circuit Breakers through live coding and load testing.
Building Safe, More Testable Scala Production Systems at x.ai
Explore key coding patterns, libraries, and architecture lessons for building safe, testable Scala production systems. Learn from x.ai's experience in developing a functional "I/O vs. pure" approach for improved application testability.
Reification and Type-Safety in a CQRS World
Explore reification and type-safety in CQRS applications, focusing on modeling domains as Algebraic Data Types with commands and events. Learn different approaches using type parameters, projections, and path-dependent types.
Akka Anti-Patterns You'd Better Be Aware Of
Discover common Akka anti-patterns and learn better alternatives for building concurrent and distributed applications using the actor model on the JVM.
The Realities of Running a Rails App Long Term
Explore the evolution of a Rails app over a decade, covering design choices, testing, integrations, and challenges faced in long-term development and maintenance.
How to Make a Gem of a Gem
Learn to create, publish, and design Ruby gems effectively. Gain insights on gem types, design considerations, testing strategies, and long-term maintenance to ensure your next gem is exceptional.
Ruby Lambdas
Explore Ruby lambdas to write cleaner, simpler, and more flexible code. Learn functional design patterns and discover how lambdas enhance software development beyond traditional object-oriented approaches.
Building a High-Performance Key - Value Store in Go
Explore the internals of a high-performance key/value store in Go, learning basic design principles and techniques for efficient data storage and retrieval.
Designing Software Within Constraints - Building to a Specification
Explore software design within constraints, balancing language-agnostic specs with Go's principles. Learn from MongoDB's Go driver example, covering design, performance, and usage patterns.
Design Command-Line Tools People Love
Design command-line tools that developers love: structure for reusability, leverage Go libraries, improve testability, and create user-friendly interfaces with natural commands and helpful outputs.
Performance Limitations of React Native and How to Overcome Them
Explore React Native's performance limitations and solutions, focusing on developer experience, code reuse, and comparison with native implementations. Learn strategies to optimize React Native apps.
Reactive Programming Demystified - Drink the Kool-Aid
Explore reactive programming with RxJS to create composable, future-proof code that can be easily adapted across JavaScript frameworks, enhancing application architecture and reducing development fatigue.
Evaluating GraphQL for Setting Up an Enterprise-Grade Data Mesh
Explore how GraphQL can establish an enterprise-grade data mesh, focusing on decentralized ownership, data as a product, self-serve infrastructure, and federated governance.
Flight.js
Explore Flight.js, a lightweight JavaScript framework for building scalable web applications with modular, decoupled components and event-driven architecture.
How to Prepare a Distributed NodeJS Application
Learn to slice open and distribute Node.js applications, integrating external services and microframeworks for enhanced scalability and service discovery.