chore: sync content to repo

2026-08-30 17:57:21 +08:00 · 2026-03-09 10:16:33 +00:00
parent b788750ef1
commit f3ef3c5d5b
6 changed files with 9 additions and 57 deletions
@@ -1,19 +1,8 @@
 # Architectural Styles

-Architectural styles in software refer to the overall design and organization of a software system, and the principles and patterns that are used to guide the design. These styles provide a general framework for the design of a system, and can be used to ensure that the system is well-structured, maintainable, and scalable.
-
-Some common architectural styles in software include:
-
-*   Microservices: where the system is built as a collection of small, independent, and loosely-coupled services.
-*   Event-Driven: where the system reacts to specific events that occur, rather than being continuously polled for changes.
-*   Layered: where the system is divided into a set of layers, each of which has a specific responsibility and communicates with the other layers through well-defined interfaces.
-*   Service-Oriented: where the system is built as a collection of services that can be accessed over a network.
-*   Data-Centric: where the system is focused on the storage, retrieval and manipulation of data, rather than the processing of data.
-*   Component-Based: where the system is composed of reusable and independent software components.
-*   Domain-Driven: where the system is organized around the core business domain and business entities.
+Architectural styles are sets of principles and constraints that define the characteristics of a software system. They provide a vocabulary and a framework for describing common system properties such as structure, behavior, and interaction. These styles act as blueprints, offering reusable solutions to recurring design problems and guiding the organization of components and their relationships within a software architecture. Examples of architectural styles include layered architecture, microservices, and event-driven architecture, each with its own strengths and weaknesses that make it suitable for specific scenarios.

 Visit the following resources to learn more:

- [@article@What is Software Architecture & Styles?](https://study.com/academy/lesson/software-architecture-styles-patterns-components.html)
 - [@video@Types of Architectural Styles in Software Engineering](https://www.youtube.com/watch?v=2Pp0BcXN9YY)
 - [@video@10 Architecture Patterns Used In Enterprise Software Development Today](https://www.youtube.com/watch?v=brt3ao8bvqy)
@@ -1,17 +1,6 @@
 # Clean Code Principles

-Clean code is code that is easy to read, understand, and maintain. It follows a set of principles that are designed to make the code more readable, testable, and less error-prone. Some of the key principles of clean code include:
-
-*   Clarity: The code should be easy to read and understand.
-*   Simplicity: The code should be as simple as possible, avoiding unnecessary complexity.
-*   Comments: Comments should be used sparingly and only when necessary to explain complex or non-obvious code.
-*   Naming: Variables, functions, and classes should have meaningful and descriptive names.
-*   Formatting: The code should be consistently formatted to improve readability.
-*   Functionality: The code should be organized into small, single-purpose functions and classes.
-*   Error handling: The code should handle errors in a consistent and predictable way.
-*   Testing: The code should be testable and have a high test coverage.
-*   Reusability: The code should be designed to be reusable and modular.
-*   Performance: The code should be designed to be efficient and performant.
+Clean code principles are guidelines for writing code that is easy to understand, maintain, and modify. These principles emphasize readability, simplicity, and reducing complexity to improve collaboration and reduce the likelihood of errors. Ultimately, the goal is to create source code that is as easy to read and understand as well-written prose.

 Visit the following resources to learn more:

@@ -1,19 +1,9 @@
 # Enterprise Patterns

-Enterprise patterns are a set of design patterns that are commonly used in the development of enterprise software applications. These patterns provide a common vocabulary and a set of best practices for solving common problems that arise in the development of large, complex software systems. Some examples of enterprise patterns include:
-
-*   Domain-Driven Design (DDD)
-*   Model-View-Controller (MVC)
-*   Service Oriented Architecture (SOA)
-*   Command and Query Responsibility Segregation (CQRS)
-*   Event Sourcing
-*   Microservices
-*   Event-Driven Architecture (EDA)
-
-These patterns can help to improve the maintainability and scalability of the software, by providing a clear separation of concerns and allowing for a more modular and flexible architecture.
+Enterprise Patterns are well-documented, reusable solutions to commonly occurring problems in enterprise software development. These patterns provide a vocabulary and a set of best practices for designing robust, scalable, and maintainable enterprise applications, addressing recurring challenges like data access, concurrency, distribution, and integration with legacy systems. They serve as blueprints for solving complex architectural and design issues, promoting consistency and reducing development time.

 Visit the following resources to learn more:

- [@article@Software Architecture Patterns in Enterprise Software](https://blog.devgenius.io/10-software-architecture-patterns-in-enterprise-software-development-fabacb5ed0c8)
+- [@article@Enterprise Software Architecture Patterns: An Ultimate Guide](https://www.rishabhsoft.com/blog/enterprise-software-architecture-patterns)
 - [@video@What are Enterprise Integration Patterns?](https://www.youtube.com/watch?v=WNm3QmJadNs)
 - [@feed@Explore top posts about Enterprise](https://app.daily.dev/tags/enterprise?ref=roadmapsh)
@@ -1,8 +1,6 @@
 # Indentation and Code Style

-Indentation is the practice of using whitespace to visually group related lines of code together, making it easier to read and understand the structure of the code. Code style refers to the conventions and guidelines used to format and structure code, such as naming conventions, commenting, and use of whitespace.
-
-Having a consistent indentation and code style can help to make the code more readable and understandable, which can improve the maintainability of the system.
+Indentation and code style refer to the consistent formatting of source code to improve readability and maintainability. This involves using whitespace, line breaks, and naming conventions in a standardized manner across a project. The goal is to create code that is visually appealing and easy for developers to understand, regardless of who wrote it. Consistent indentation highlights the code's structure, making it easier to follow control flow and identify logical blocks. Adhering to a specific code style, which dictates rules for naming, commenting, and other formatting aspects, further enhances the clarity and consistency of the codebase.

 Visit the following resources to learn more:

@@ -1,17 +1,6 @@
 # Minimize Cyclomatic Complexity

-Cyclomatic complexity is a measure of the structural complexity of a program, which is determined by the number of linearly independent paths through a program's control flow. High cyclomatic complexity can make a program difficult to understand, test, and maintain, so it's often desirable to minimize it in system architecture.
-
-Here are some ways to minimize cyclomatic complexity in system architecture:
-
-*   Break down complex functions into smaller, simpler functions that perform specific tasks.
-*   Use control structures, such as if-else statements and loops, in a consistent and predictable way.
-*   Use functional programming concepts and techniques, such as immutability and pure functions, to reduce the need for complex control flow.
-*   Use design patterns, such as the state pattern, to simplify complex control flow.
-*   Regularly review the code and refactor it to simplify the control flow.
-*   Use static code analysis tools that can detect and report high cyclomatic complexity in the code.
-
-By following these best practices, the system architecture will be more maintainable, testable, and less error-prone.
+Cyclomatic complexity measures the number of linearly independent paths through a program's source code.  It's calculated based on the number of decision points (like `if`, `for`, `while`, `case`) within a function or code block. High cyclomatic complexity indicates code that is harder to understand, test, and maintain due to its increased number of possible execution paths. Reducing this complexity aims to simplify the control flow and logic within code, leading to more readable and reliable software.

 Visit the following resources to learn more:

@@ -1,10 +1,7 @@
 # Pure Functions

-A pure function is a specific type of function that meets the following criteria:
+Pure functions are a type of function in programming where the output is solely determined by its input values, without any side effects. This means that for the same input, a pure function will always return the same output, and it does not modify any state outside of its own scope. They are deterministic, predictable, and make code easier to test and reason about.

-*   It takes some input, known as arguments, and returns a value or output.
-*   It does not cause any observable side effects, such as modifying the state of the system or interacting with external resources.
-*   Given the same input, it will always return the same output.
-*   It does not depend on any state or variables that are outside of its scope.
+Visit the following resources to learn more:

-Pure functions are considered to be more predictable and easier to test, as their behavior is determined solely by the input they receive and their internal logic. They also make it easier to reason about the behavior of a program, since the output of a pure function is not affected by any external factors. Pure functions are often used in functional programming, where they are considered a key principle. They are also useful in concurrent and parallel programming, as they are less prone to race conditions and other concurrency-related issues.
+- [@video@What are Pure Functions? | Javascript Functions Tutorial](https://www.youtube.com/watch?v=ZXxahQS1PN8)