Software_Engineering

Architecture as system-level decisions about boundaries, dependencies, deployment, data, quality attributes, and evolutionary trade-offs.

Choosing monolith, layered, event-driven, microservice, read/write split, and domain-oriented patterns from constraints rather than fashion.

A single deployable application and the trade-offs between operational simplicity, modularity, scaling, and organizational boundaries.

Separating presentation/application/domain/infrastructure responsibilities while controlling dependency direction.

Separating write authority from read replicas/projections and handling replication lag, read-your-writes, routing, and failover.

Producing and reacting to events with asynchronous coupling, delivery semantics, ordering, idempotency, and observability.

DDD concepts: bounded contexts, ubiquitous language, aggregates, entities, value objects, domain services, and context integration.

Independently deployable service boundaries with explicit data ownership and the distributed-systems/operational costs they introduce.

Identity layer on OAuth with ID tokens, UserInfo, issuer/audience/nonce validation, and authentication sessions.

Signed token format, claims, validation, expiration, key management, and common security misconceptions.

Delegated authorization with resource owner, client, authorization server, resource server, scopes, access tokens, and secure redirect flows.

Versioned configuration distribution with environments, validation, watches, rollout, caching, security, and rollback.

Endpoint discovery, selection algorithms, health/outlier detection, connection reuse, locality, weighting, and overload-aware routing.

Service membership registration, discovery, leases/health, staleness, replication, client caches, and failure handling.

Gateway routing and cross-cutting policy with authentication, limits, deadlines, observability, resilience, and safe ownership boundaries.

Metrics, logs, traces, events, SLOs, correlation, storage, alerting, dashboards, and cost/cardinality control.

Trace/span context propagation, sampling, storage, causality, asynchronous work, and correlation with metrics/logs.

Timeouts, deadlines, retries, circuit breakers, bulkheads, rate limits, load shedding, fallbacks, and idempotency.

Structured logs, severity, correlation, context, sampling, retention, privacy, and operational querying.

Metric naming/types, labels, cardinality control, RED/USE signals, SLOs, aggregation, and alerting.

Identity proof, sessions/tokens, authorization policy, least privilege, service identity, revocation, and audit.

Modeling entities, attributes, identifiers, and relationships for data-oriented system design.

Using UML selectively to communicate structural and behavioral views of software systems.

Modeling types, interfaces, responsibilities, associations, inheritance, and composition.

Modeling time-ordered interactions, calls, asynchronous messages, branches, and failure paths between participants.

Representing procedural control flow, decisions, loops, and terminal outcomes.

Modeling finite states, transitions, events, guards, and lifecycle invariants.

Describing coarse-grained modules/components, provided interfaces, dependencies, and boundaries.

Mapping software artifacts and services onto runtime nodes, networks, zones, and infrastructure.

Communicating system boundaries, dependencies, data flows, deployment units, and operational context.

Configuring constructors through composable option functions, especially in Go APIs.

Using function values to satisfy small behavioral contracts and inject behavior without heavyweight objects.

Persisting domain changes as an append-only event history and rebuilding state through replay/projections.

Decoupling event publishers and subscribers while handling delivery, ordering, replay, and failure semantics.

Decoupling work generation from processing with queues, bounded capacity, backpressure, and worker concurrency.

Designing stable boundaries so common extensions require less modification to trusted core code.

Ensuring subtypes preserve the behavioral contract expected from the base abstraction.

Keeping high-level policy independent from volatile low-level implementation details.

Grouping behavior around a coherent responsibility and a focused reason to change.

Keeping contracts focused so clients depend only on capabilities they actually use.

Reducing knowledge of distant object structure and avoiding brittle navigation through internal collaborators.

Reusing behavior through composition/delegation when subtype inheritance would create unnecessary coupling.

A practical view of SOLID and related principles for controlling coupling, responsibilities, and change.

Reusable design structures and the trade-offs behind creational, structural, and behavioral patterns.

A single shared instance, initialization safety, lifecycle, testability, and global-state trade-offs.

Interposing an object to control or augment access to another object while preserving its contract.

Fixing an algorithm skeleton while allowing selected steps to vary in subclasses or callbacks.

Separating object creation decisions from clients that consume the created abstraction.

Representing state-dependent behavior with explicit state objects instead of sprawling conditionals.

Constructing complex objects step by step with readable optional configuration and validation.

Encapsulating interchangeable algorithms or policies behind a common contract.

Notifying registered observers about subject changes and managing coupling, ordering, and lifecycle.

Adding composable behavior around an object without changing the wrapped implementation.

Passing a request through an ordered pipeline of handlers that may process, enrich, reject, or forward it.

Translating one interface/protocol/data model into the contract expected by a client.