29 docs tagged with "architecture"

A comprehensive guide to advanced, scenario-based, and practical Spring Boot interview questions.

A senior deep dive into advanced Redis data types for massive scale, covering Bitmaps, HyperLogLog, and Geospatial.

Core principles of distributed systems architecture including CAP theorem, consistency models, availability, partition tolerance, and key trade-offs every engineer must understand.

A comprehensive guide to the CAP theorem in distributed systems, covering network partitions, consistency models, microservice-level trade-offs, interview questions, and real-world implementations.

Martin demolishes the false distinction between "design" and "architecture", then presents the singular goal of software architecture: minimizing the human effort required to build and maintain a system.

Components are the units of deployment — JARs, DLLs, shared libraries. Martin traces their history from early relocatable binaries to modern package managers, establishing the foundation for the component cohesion and coupling principles that follow.

Three principles govern which classes belong in which component: REP (Reuse/Release Equivalence), CCP (Common Closure), and CRP (Common Reuse). They form a tension triangle — understanding the trade-offs helps you choose the right grouping strategy for your project's stage.

Three principles govern dependencies between components: ADP (no dependency cycles), SDP (depend in the direction of stability), and SAP (stable components should be abstract). These principles shape large-scale architecture and determine which components can evolve independently.

Architecture is the shape of a system — the decisions that divide a system into components, arrange those components, and specify how they communicate. A good architect maximizes the number of decisions NOT made, keeping options open as long as possible.

A good architecture supports independent developability, deployability, and operability. Martin explains the use-case, operational, and deployment decoupling modes and why the monolith-vs-microservices decision can and should be deferred.

Every software system delivers two values — behavior and structure. Martin argues that structure (architecture) is almost always the more important of the two, yet teams chronically neglect it. Learn to use Eisenhower's Matrix to fight for architectural health.

The three programming paradigms — structured, object-oriented, and functional — each impose discipline by removing capabilities from the programmer. Martin shows how each paradigm maps directly to a fundamental concern of software architecture.

Functional programming's core discipline — immutability — eliminates entire classes of concurrency bugs. Learn how immutability, segregation of mutability, and event sourcing shape modern system design.

A software artifact should be open for extension but closed for modification. OCP is the architectural goal that drives Clean Architecture: protect high-level policy from changes in low-level details by controlling the direction of dependencies.

Boundaries separate software elements and restrict knowledge between them. This section covers drawing lines between components, anatomy of boundaries, policy levels, entities, and use cases — the core of Clean Architecture.

The Main Component is the dirtiest place in the system — where everything is wired together. Services are not architecturally special. Tests are a component too — they must respect boundaries or become a maintenance burden.

Databases, web frameworks, and all third-party frameworks are details — implementation choices that should be deferred and hidden behind boundaries. Learn why treating them as the center of your architecture leads to rigidity and how to protect your business rules from them.

Comprehensive guide on Command Query Responsibility Segregation (CQRS) and Event Sourcing, detailing architecture, implementation patterns, comparisons with alternatives, and deep dives for senior engineers.

A comprehensive guide covering real technical interview questions and answers from an EPAM Java Developer interview for a candidate with 3 to 7 years of experience.

A comprehensive overview of the ELK Stack (Elasticsearch, Logstash, Kibana) and Beats — covering roles, system architecture, data flow, and primary use cases.

Scenario-based interview questions for Java lead developers on scaling, optimization, and architecture.

A comprehensive guide to JPA and Hibernate persistence methods — entity lifecycle states, persist vs save vs merge vs update, primary key strategies, performance implications, and production deep dives for senior engineers.

A comprehensive guide comparing Apache Kafka's legacy ZooKeeper architecture with the modern KRaft (Kafka Raft) metadata mode — covering internal mechanics, failure scenarios, migration strategies, and production deep dives for senior engineers.

Kubernetes architecture for beginners — control plane components, worker nodes, the API server, etcd, scheduler, kubelet, kube-proxy, and how they work together to run containerised workloads.

Redis architecture internals, single-threaded model, I/O multiplexing, and use case decision guide for senior engineers.

A comprehensive guide comparing reverse proxies, load balancers, and API gateways — their differences, internal mechanics, architectural roles, alternatives, and production deep dives for senior engineers.

Advanced Serverless Integration Patterns for DVA-C02 and Senior Engineering roles. Orchestration vs Choreography, Saga Pattern, and Strangler Fig.

A comprehensive knowledge base for system design patterns, architectural principles, scalability strategies, and interview preparation for software engineers.

A comprehensive guide comparing Virtual Machines, Docker, and Kubernetes — starting with ELI5 analogies for beginners and ending with kernel-level deep dives for seniors.