Update README.md

Author: tom-sapletta-com

README.md

@@ -10,26 +10,45 @@ Reverse design is focusing on logs and step by steps to unit test and code
 How to call the design software focusing on creating logs file, integration test, unit tests, and on the end on writing the code?
 
 
-## Reverse modular design 
+## Log-Driven Development (LDD)
+
+**LDD** align closely with Test-Driven Development (TDD) and behaviour-driven development (BDD), but with a particular focus on understanding system behavior through logs, is working based on such main principles:
 
-Reverse modular design principles working based on such main principles:
-+ TDD
++ TDD - Test-Driven Development
++ BDD - Behaviour-Driven Development
 + Reverse Engineering
 + Modular design to create monorepo
++ Continouous improvement with CI/CD integration
+
+This method allows you to create an autonomous system that, starting from only the system logs, will be able to recreate it, step by step, using humans and machines
+
+
+## Reverse modular design 
 
+**Reverse modular design** align closely with Test-Driven Development (TDD) and behaviour-driven development (BDD), but with a particular focus on understanding system behavior through logs - **Log-Driven Development (LDD)**
 
-Reverse design is from logs manual written to descibe the expected and unexpected behaviors, and next the the mock function with expected inputs and outputs, writing test and on the end writing the code inside the mocks.
+#### Manual Analysis of Logs 
++ Understanding Expected and Unexpected Behaviors
+Review system logs to understand how the existing software behaves. This step involves deducing requirements, specifications, and system functionality strictly from the information contained in logs, which may represent both expected and unexpected system behavior.
 
-1. Create 2 logs file: info.log, error.log
-2. Describe line by line with values, the outputs. So we should know how should work the software when should be seeing an error
-3. Write the logs function or the decorator to build the logs on each starting the function in form of sentence
-4. Write the mock function with just name, parameters and example value on return
-5. Write integration, functional and unit test
-6. Test each test with live data from function, and replace step by step the empty mocks to source code
+#### Mock Function Development 
++ Abstraction of Functionality
+Developers create mock functions that produce the expected outputs for given inputs based on the analyzed behavior. 
+These mocks serve as temporary stand-ins for the actual implementations until they are developed.
 
+#### Writing Tests based on Behaviours
++ TDD/BDD Principles
+Developers write tests for the expected functionality, essentially formalizing the behavior observed and expected from the logs. 
+These tests are written to fail initially, as the actual functions are not implemented yet.
 
+#### Implementing Code Within Mocks 
++ Iterative Development
+Actual functional code is gradually introduced to replace the mock bodies. 
+The development follows the previously established tests.
 
-## reverse Engineering
+
+
+## Reverse Engineering
 
 is the process of analyzing a system to identify the system's components and their interrelationships and to create representations of the system in another form or at a higher level of abstraction. 
 
@@ -68,11 +87,65 @@ To learn from existing solutions to build new, improved systems that do things d
 
 
 
+
+
+
+
+
+## Log-Driven Development (LDD)
+
+**Definition**:
+Log-Driven Development (LDD) is a software development approach where the design and construction of software are primarily informed and driven by the analysis of system logs. In this approach, logs are used as the fundamental source of truth for determining how a system should behave in both routine and exceptional circumstances. Developers use logs to abstract system requirements and functionality, write targeted tests, and then develop system features iteratively while respecting the guidance provided by the logs.
+
+**Specification**:
+1. **Log Analysis**:
+   - Collect and review logs from the system to examine successful operations, errors, warnings, and any other significant events.
+   - Document system behavior as described by the logs, distinguishing between normal behavior and exceptions.
+
+2. **Mock Implementation**:
+   - Develop mock implementations or skeleton functions/classes that encapsulate the expected behavior inferred from the logs.
+   - Ensure mocks provide expected outputs for various input scenarios as evidenced by the logs.
+
+3. **Test Creation**:
+   - Derive and write a comprehensive suite of test cases to verify the correct behavior of system components.
+   - Adhere to classical TDD practices: tests should initially fail since the mocks only simulate real functionality.
+
+4. **Real Implementation**:
+   - Step by step, replace the mock implementations with actual code, ensuring at each step that the code passes all tests.
+   - Optimize and refactor as necessary, always maintaining the integrity of the tests.
+
+5. **Continuous Integration and Testing**:
+   - Automatically build and test the system regularly — or even after every change — to reveal integration errors as soon as possible.
+   - Keep logs for ongoing analysis to feed back into the development cycle for continuous improvement.
+
+Using such an approach can lead to a thorough understanding of the system and its interactions, as well as how to handle various types of data and errors. However, care must be taken when using logs as the sole source of truth; logs can sometimes be incomplete or misrepresentative. Thus, LDD should be complemented by additional information and insights from other system documentation and stakeholder input where possible.
+
+
+
+
+
+
+
+
+
+
+
+
 ## How to write the code with modular reverse design principle?
 
 Implement a basic logging system in Python, using the built-in logging module. 
 Below I will outline each step to create this logging system and demonstrate usage with a mock function and tests:
 
+Log-Driven Development (LDD) is form of reverse design where we start from logs manual written to descibe the expected and unexpected behaviors, and next the the mock function with expected inputs and outputs, writing test and on the end writing the code inside the mocks.
+
+1. Create 2 logs file: info.log, error.log
+2. Describe line by line with values, the outputs. So we should know how should work the software when should be seeing an error
+3. Write the logs function or the decorator to build the logs on each starting the function in form of sentence
+4. Write the mock function with just name, parameters and example value on return
+5. Write integration, functional and unit test
+6. Test each test with live data from function, and replace step by step the empty mocks to source code
+
+
 
 ### Create 2 logs file: `info.log`, `error.log`