Software_Engineering

What architecture is, why it is needed, its categories, architecture patterns, and the hard and soft skills needed to become an architect.

Monolithic, layered, event-driven, CQRS, microservice, and plug-in architecture patterns.

What monolithic architecture is and its advantages and disadvantages.

What layered architecture is and its evolution from one, two, and three tiers to DDD four-layer, hexagonal, and onion architectures.

What read/write separation is, why it is needed, where it applies, how to design it at the service and storage layers, and the materialized-view pattern.

What event-driven architecture is, why it is needed, its real-time trade-off, and publisher-subscriber and event-stream design patterns.

What DDD is: domains, ubiquitous language and bounded contexts, entities and value objects, aggregates, domain events, repositories and factories, and a DDD design process.

Historical notes on what microservice architecture is, its relationship with SOA, trade-offs, decomposition, project architecture, and the microservice technology stack.

Historical notes on what OpenID Connect is and how its flow differs from OAuth by adding OpenID identity information and an ID Token.

Historical JWT notes covering what JWT is, why it is used, JWT versus sessions, token structure, and the basic request flow.

Historical OAuth 2.0 notes covering why OAuth is needed, the authorization flow, grant modes, token refresh, and scopes.

What a configuration center is, why it is needed, storage, client notification, service discovery, caching, canary release, and an example configuration-center database design.

What load balancing is, why it is needed, common algorithms, hardware/software/DNS choices, L2/L3/L7 approaches, and client-side versus server-side load balancing.

What a service registry is, why it is needed, server-side and client-side design, service discovery and routing, registry components, and ZooKeeper versus Eureka.

What an API gateway is, why it is needed, request forwarding and filtering, I/O models, common gateway components, BFF, and gateway aggregation.

What monitoring is, why microservices need it, and the three parts: logs, metrics, and tracing.

What tracing is, why it is needed, Span/Trace/Annotation data, sampling, collection approaches, storage, display, and common tracing components.

What fault tolerance is, service avalanche, and common techniques including timeouts, retries, rate limiting, circuit breaking, isolation, and degradation.

What log monitoring is, why it is needed, logging strategy, collection, aggregation, indexing and storage, analysis, and ELK.

What metrics monitoring is, why it is needed, what to monitor, how to collect and store metrics, alerting, and common metrics components.

Authentication, authorization, and credentials; common techniques; and how authentication and authorization are integrated into a microservice architecture.

What an ER diagram is, with a PlantUML example showing entities, attributes, and relationships.

A note index for structural modeling, behavioral modeling, architecture modeling, and common UML tools.

What a class diagram is, how classes/interfaces and common class relationships are represented, with PlantUML examples.

What a sequence diagram is, with a sanitized PlantUML example showing interactions among a user, development platforms, a service, and its deployed node.

What a flowchart is, with PlantUML examples for a verification workflow and a login-interface activity flow.

What a state diagram is, with a PlantUML example describing login-state transitions.

What a component diagram is, with a sanitized PlantUML example showing dependencies among services, libraries, storage, and local memory.

What a deployment diagram is, with a sanitized PlantUML example showing hardware/network topology and deployed software components.

Business, application, technical, data, security, and deployment architecture diagrams, plus the 4+1 architectural view model.

A Go functional-options example for constructing an object with default values while allowing selected fields to be changed flexibly.

What an interface function is, why it is useful, and a Go implementation that allows either function values or structs to satisfy the same interface.

What event sourcing is, why it is needed, how it addresses some CRUD problems, its disadvantages, and design notes.

What the publish–subscribe pattern is, why it is needed, how it differs from producer–consumer and observer patterns, and a Go implementation.

What the producer/consumer pattern is, why it is needed, and Go implementations using channels, timeouts, object-oriented encapsulation, and error handling.

What the open–closed principle is, why it is needed, and how to implement it through abstractions, inheritance, composition, and aggregation.

What the Liskov substitution principle is, why it is needed, and how subclasses should preserve the meaning of parent-class behavior.

What the dependency inversion principle is, why it is needed, and implementation guidance centered on interfaces and abstract classes.

What the single responsibility principle is, why it is needed, and how to separate different responsibilities into different classes or modules.

What the interface segregation principle is, why it is needed, and how to keep interfaces small and tailored to their callers.

What the Law of Demeter is, why it is needed, and how to reduce coupling by limiting what objects depend on and expose.

What the composition reuse principle is, why it is needed, and how composition or aggregation can be preferred over inheritance for code reuse.

What object-oriented design principles are, why they are needed, and the main principles covered by these notes.

What design patterns are and the three main categories: creational, structural, and behavioral.

A class has one and only one instance, with Java and Go implementations including eager, lazy, DCL, static-inner-class, enum, mutex, and sync.Once approaches.

The proxy pattern adds functionality around an existing class or function without changing the original code, with static, dynamic, AOP, Go, and cache-proxy examples.

The template-method pattern applies when the overall algorithm steps are fixed while some parts vary, with Java and Go implementations and a combined template/factory/strategy example.

The factory-method pattern uses multiple factory classes and delays concrete product creation to subclasses.

The state pattern selects different processing logic according to the current state, with Java and Go examples.

The builder pattern constructs a complex object from many smaller parts; the builder creates the parts and the director assembles them.

The strategy pattern selects one of several algorithms for accomplishing the same task according to a type or context, with Java and Go examples.

The observer pattern broadcasts state changes from a subject to observers, with Java, Go, and application examples.

The decorator pattern adds new functionality to a class or function without changing the original code, with Java and Go examples.

The chain-of-responsibility pattern links handlers that can process the same type of request, with Java, Go, and filter-chain examples.

The adapter pattern is used to make an old-system interface compatible with a new interface, with Java and Go examples.

Historical notes on cloud native, cloud platforms, VPCs, and the evolution, purpose, and common implementations of Service Mesh.

Original VNote placeholder for pluggable architecture.

A short note on what container scheduling is, why it is needed, and Kubernetes as a scheduling component.

A short note on CI/CD pipelines, their purpose, design, and Jenkins.

A short pointer to the programmer career-development note.

Notes on the DOT language and Graphviz: graphs, nodes, edges, attributes, subgraphs, ports, and example diagrams.

A short note containing a custom diagrams.net shape library and reference links.

What a use-case diagram describes, with a simple PlantUML example.

Reference links for Go pipeline fan-out and fan-in concurrency patterns.

Reference link for the Go pipeline concurrency model.

Prototype-pattern notes with UML, Java and Go clone examples, plus a generic DAO example that returns cloned data.

Abstract-factory notes showing related product families and a Go implementation with engines, wheels, factories, and a client.

Simple-factory notes in Java and Go, followed by a generic template-method + simple-factory + strategy example.

A short interview-style note on where singleton, prototype, factory, builder, facade, decorator, template method, state, strategy, and proxy patterns were used.

Flyweight-pattern notes with UML and a Java example using a chess-object pool.

Facade-pattern notes with UML plus Java and Go examples that wrap a complex process behind one interface.

Bridge-pattern notes for class hierarchies with multiple varying dimensions, with UML and a Java brand/device example.

Composite-pattern notes for tree-shaped whole/part structures, with Java and Go file-tree examples.

Mediator-pattern notes with UML, a Java department example, and a Go computer-component example.

Command-pattern notes with a Java Course example, command objects, and a command invoker.

Memento-pattern notes showing how to save an object's state and restore it later.

A minimal original note for the interpreter design pattern.

Visitor-pattern notes separating data structures from operations, with a Java course example.

Iterator-pattern notes showing Java and Go implementations for traversing aggregate objects.

A short index note linking object-oriented design principles and design patterns.

A short index of procedural, event-driven, object-oriented, and functional programming paradigms.

A minimal note outlining the software-development process and the development, testing, and production environments.