Tech World With Milan·1yHow to learn API?
Learn the essentials of API development, including core protocols, architecture styles, and security practices. Discover best practices for designing, documenting, and testing APIs, alongside a curated list of resources to aid in your API journey. Avoid common API anti-patterns with practical examples and tips.
System Design Codex·1yIntro to GraphQL
GraphQL is a powerful open-source language for querying and manipulating data, aiming to address issues common in RESTful APIs. Developed initially by Facebook in 2012 and publicly released in 2015, GraphQL stands out by allowing clients to specify exactly what data they need, reducing both over-fetching and under-fetching of data. Key features include declarative queries, hierarchical data structure, type safety, and support for real-time data with subscriptions. Implementing a GraphQL server involves setting up a web server, defining schemas, and handling requests efficiently. While GraphQL offers significant advantages like flexible data fetching and improved analytics, it also has drawbacks such as potential performance issues with complex queries and reduced suitability for small applications.
Milan Jovanović·2yClean Architecture: The Missing Chapter
Clean Architecture is about dependencies, not folders. Many developers mistakenly turn the Clean Architecture diagram into a project structure, but the focus should be on managing dependencies. Traditional layer-based organization scatters related components and creates maintenance challenges. Organizing code by feature or component helps achieve better dependency management and business focus. The post provides practical examples and best practices for implementing these principles in .NET, highlighting the importance of managing dependencies and keeping related code together.
Community Picks·2y8 System Design Courses to learn Distributed System Architecture (2025)
Discover the 8 best Udemy courses to learn system design and distributed system architecture in 2025. These courses are ideal for those preparing for technical interviews at top tech companies like Google, Meta, Amazon, and Microsoft. Learn from industry experts and ex-hiring managers, covering essential system design concepts, scalability, high availability, and more. Take advantage of Udemy's seasonal discounts to access these valuable resources.
Community Picks·2yTDD - Rewriting 3 million lines of code
Andreas Frömer, Head of Software Development at Finanztip, successfully used TDD to rewrite a legacy application consisting of 3 million lines of code. Key lessons include starting with system level tests to avoid regression bugs and using feature flags to replace old code while retaining system behavior. The approach emphasizes starting with system level tests before moving to component tests and applying TDD for both rewriting and refactoring.
DEV·2yAm I a Senior or an Obsolete Architect?
Being an architect involves harmonizing diverse elements like a conductor in an orchestra. Key behaviors for success include active listening and clear communication, thinking holistically, ensuring coherence and alignment, being a catalyst for change, and constantly raising the bar. Effective architects understand and align technical and business needs, drive transformation, and foster continuous improvement and innovation.
Quastor Daily·2yThe Architecture of Dropbox's Load Balancing Service
Dropbox reduced the sizes of its hardware fleets by 25% and saved millions annually by deploying the Robinhood load balancing service in 2020, improving load distribution among backend machines. Key components of Robinhood include a service discovery system, a routing database, and a proxy for aggregating load reports. Dropbox evaluates load balancer performance using CPU utilization ratios such as max/avg and p95/avg. They emphasized simplicity in configuration, minimizing client changes, and early migration planning as crucial lessons learned.
theburningmonk.com·1yWhen to use Light Events vs. Rich Events in Event-Driven Architectures
Choosing between light and rich events in event-driven architectures involves trade-offs. Light events, containing minimal information, are cost-efficient but may increase complexity for subscribers needing additional data. Rich events include more information, reducing the need for extra calls by subscribers but increasing data transfer and storage costs. Domain events, often benefitting from light events, are shared within the same domain, while integration events, suited for rich events, are shared across domains. Understanding these differences helps optimize event design and system efficiency.
ByteByteGo·2yHow McDonald Sells Millions of Burgers Per Day With Event-Driven Architecture
McDonald's has developed a unified, event-driven platform to handle its global operations efficiently. The platform supports scalability, high availability, performance, security, reliability, consistency, and simplicity. Core components include AWS Managed Streaming for Kafka (MSK), a schema registry, a standby event store, custom SDKs, and an event gateway. The system ensures data integrity and efficient processing through schema validation and robust error-handling mechanisms. Key techniques include data governance, cluster autoscaling, and domain-based sharding. Future enhancements include formal event specification, transition to serverless MSK, and improved developer tooling.
Venture Beat·1yWhy microservices might be finished as monoliths return with a vengeance
Many organizations are re-evaluating the trend towards microservices and returning to monolithic architectures. This change is driven by the difficulties encountered during the transition, such as defining domain boundaries, managing deeply coupled data, and handling complex data migrations. Despite the theoretical advantages of microservices, practical implementation challenges often outweigh the benefits, leading to issues like increased system complexity, data integrity problems, and unclear team ownership.
ITNEXT·1yDependency inversion in architectural patterns
The concept of dependency inversion is widely employed in various architectural patterns to protect the core components from external variability. This includes using interfaces for polymorphism and adapters to bridge differences between the core and external APIs. Patterns such as Hexagonal Architecture, Plugins, and Microkernel leverage these strategies to maintain robustness and adaptability in their designs.
Engineering Leadership·1yHow to master React software design and architecture. Read these 10 articles:
Discover essential practices and tools to master React software design and architecture. From organizing applications and managing state to performance optimization and testing best practices, this post compiles ten articles to help improve your React projects.
Microservices.io·2yReducing insider trading in a microservice architecture
Reducing insider trading in microservice architectures involves ensuring loose design-time coupling by avoiding direct database queries between services and using APIs instead. However, APIs alone don't guarantee loose coupling. Encapsulation is crucial, where each service hides its internal data and logic, resembling icebergs. This approach, applied in examples like takeout burritos, helps manage dependencies and improve the maintainability of the system.
Cerbos·1yHow to pick the right inter-service communication pattern for your microservices
Efficient inter-service communication is essential for a successful microservices architecture. Different communication patterns, such as synchronous, asynchronous, and event-driven, offer various benefits and challenges. Strategies like retries, circuit breakers, timeouts, and bulkheads can enhance fault tolerance and resilience. Spotify's adoption of Apache Kafka for event-driven communication illustrates a scalable and decoupled microservices environment, supporting independent service evolution and robust failure management.
Cerbos·1yDesigning service discovery and load balancing in a microservices architecture
Transitioning from a monolithic architecture to microservices involves navigating numerous challenges, including service discovery and load balancing. Dynamic service discovery mechanisms, such as service registries and service meshes, are essential for maintaining flexibility and resilience. Service registries maintain a centralized database of services, enabling features like load balancing, health checks, and metadata storage. Service meshes take this further by managing service-to-service communication, traffic management, security, observability, resilience, and policy enforcement. Tools like NGINX, HAProxy, and cloud-based load balancers also assist in distributing traffic efficiently. Airbnb's use of a proprietary solution, SmartStack, showcases the effectiveness of these systems in a complex microservices architecture.
The New Stack·2yHow To Fail at Microservices
Microservices can fail due to numerous reasons, such as delaying problem fixes, using shared databases, making services too small, relying on manual deployments, and focusing only on unit testing. Success requires automating deployments, using various testing techniques, improving local testing capabilities, creating robust tooling, fostering technical proficiency, simplifying complexity, and developing comprehensive documentation. Regular refactoring and a solid, adaptable architectural vision are also vital.
Community Picks·1yImplementing the Transactional Outbox Pattern from Scratch
The post discusses the implementation of the transactional outbox pattern, demonstrating how to reliably update the database and publish messages to a queue using an orders API and a shipping API. It explains potential issues with traditional methods where a transaction could leave the system in an inconsistent state. The outbox pattern is proposed as a solution, which involves persisting messages in the database as part of the same transaction and processing them later. The post thoroughly explains how to set up and implement this pattern, highlighting key considerations and potential improvements for reliability.
Cerbos·1yHow to address decentralized data management in microservices
Transitioning from monolithic to microservices architecture includes challenges and benefits in handling decentralized data management. The post discusses the advantages like scalability, flexibility, performance, and fault isolation, alongside challenges such as complex data integration, increased development complexity, latency issues, and security risks. It details patterns and techniques like eventual consistency, Saga pattern, event sourcing, domain-driven design (DDD), and command query responsibility segregation (CQRS) to mitigate these challenges. Uber's case study highlights practical implementation of these methods to maintain data integrity and ensure system reliability.
Community Picks·1yStop Hardcoding Service URLs! Service Discovery in .NET Made Easy
Learn how to implement service discovery in .NET applications to avoid hardcoding service URLs. This guide demonstrates setting up service discovery using Microsoft.Extensions.ServiceDiscovery and YARP for reverse proxying, and even incorporating it into the deployment process with Azure. Enhance your microservices' communication flexibility and ensure seamless scaling and updating by using logical names instead of static URLs.
.NET Blog·1yClean Architecture with ASP.NET Core 9
Steve Smith, also known as R Dallas, discusses the implementation of clean architecture in ASP.NET Core 9. Emphasizing practical demos, the presentation covers the benefits of clean architecture, its role in dependency management, and how it helps in organizing code effectively. A demo project, eShop on web, showcases the architecture in action, including the setup of core, infrastructure, and web projects to maintain separation of concerns and enable testability.
Telerik·2yGetting Started with Domain-Driven Design in ASP.NET Core
Domain-driven design (DDD) aligns code structure with business logic to address complex problems. This guide introduces the basics of DDD and steps for creating a microservice using ASP.NET Core, focusing on strategic and tactical design. It covers setting up various layers, including domain, infrastructure, and application, and provides a practical example of a commission processing module, complete with code snippets and explanations.
JetBrains·2yCreate a Full-Stack App With Go and React
Learn to create a full-stack application called Go Eats using Go for the backend and React for the frontend. The project uses GoLand IDE, Postgres, NATS for messaging, and Gin for building APIs. Key components include a modular service layer, SSE, and WebSocket implementation. Useful insights on project structuring, database design, and testing are provided. Look out for more updates and potential improvements.
InfoWorld·1yIs your software architecture as clean as your code?
Building a scalable and resilient system requires a clean software architecture. By adhering to principles like vertical separation, horizontal separation, and qualification, developers can minimize complexity and technical debt. Benefits include improved system quality, reduced technical debt, and enhanced developer productivity. Organizations should leverage processes to measure and remediate technical debt, use AI-driven observability tools, and provide continuous training to maintain architectural health.
Community Picks·1yKafka Architecture & Troubleshooting Quiz
Gauge your knowledge of Apache Kafka with a quiz that covers multi-datacenter deployments, event sourcing patterns, performance optimization, and troubleshooting in production. Enhance your understanding of Kafka's internals and best practices for building reliable, scalable distributed systems.
Cerbos·2yDetermining service boundaries and decomposing your monolith
Transitioning from a monolithic architecture to microservices is a complex task that requires careful planning and execution. This series provides guidance on decomposing monoliths and defining service boundaries, emphasizing the importance of Domain-Driven Design and the Single Responsibility Principle. Practical insights and examples, such as Netflix's migration, highlight the benefits and challenges of this process. Continuous refactoring and alignment with business domains are essential for successful microservices migration.