@123olp: Programming Mindset ├── 0. Core Definition │ ├── Turn fuzzy problems into computable problems │ ├── Turn real-world objects into data representations │ ├── Turn the solution process into clear steps │ ├── Turn results into verifiable outputs │ └── Turn one-time solutions into reusable systems │ ├──…

Programming Mindset ├── 0. Core Definition │ ├── Turn fuzzy problems into computable problems │ ├── Turn real-world objects into data representations │ ├── Turn the solution process into clear steps │ ├── Turn results into verifiable outputs │ └── Turn one-time solutions into reusable systems │ ├── 1. Problem Modeling │ ├── 1.1 Clarify the Problem │ │ ├── What is the problem │ │ ├── Why solve it │ │ ├── Who uses the results │ │ └── What are the success criteria │ │ │ ├── 1.2 Define Inputs │ │ ├── Where does input come from │ │ ├── What is the input format │ │ ├── Is the input complete │ │ ├── Is the input reliable │ │ └── What are the exceptional inputs │ │ │ ├── 1.3 Define Outputs │ │ ├── Who sees the output │ │ ├── What is the output format │ │ ├── How to judge correctness of output │ │ └── How is output used subsequently │ │ │ └── 1.4 Clarify Constraints │ ├── Time limits │ ├── Space limits │ ├── Data scale │ ├── Security requirements │ ├── Maintainability requirements │ └── Usage scenario constraints │ ├── 2. Data Representation │ ├── 2.1 Basic Data │ │ ├── Numbers │ │ ├── Strings │ │ ├── Booleans │ │ └── Null │ │ │ ├── 2.2 Data Structures │ │ ├── Lists / Arrays │ │ ├── Dictionaries / Hash tables │ │ ├── Sets │ │ ├── Stacks │ │ ├── Queues │ │ ├── Trees │ │ └── Graphs │ │ │ ├── 2.3 Type Awareness │ │ ├── What operations can be performed on the data │ │ ├── What operations cannot be performed on the data │ │ ├── Type conversion │ │ └── Type errors │ │ │ └── 2.4 State Representation │ ├── Current state │ ├── Historical state │ ├── State changes │ └── State consistency │ ├── 3. Process Design │ ├── 3.1 Sequential Execution │ │ ├── What to do in step one │ │ ├── What to do in step two │ │ └── Dependencies of each step │ │ │ ├── 3.2 Conditional Judgment │ │ ├── if │ │ ├── else │ │ ├── Multiple branches │ │ └── Boundary conditions │ │ │ ├── 3.3 Loops │ │ ├── Traversal │ │ ├── Counting │ │ ├── Accumulation │ │ ├── Searching │ │ └── Termination conditions │ │ │ ├── 3.4 Recursion │ │ ├── Base case │ │ ├── Recursive case │ │ ├── Problem reduction │ │ └── Call stack │ │ │ └── 3.5 Algorithms │ ├── Sorting │ ├── Searching │ ├── Divide and conquer │ ├── Greedy │ ├── Dynamic programming │ └── Graph algorithms │ ├── 4. Abstraction and Decomposition │ ├── 4.1 Function Abstraction │ │ ├── Input parameters │ │ ├── Return result │ │ ├── Function responsibility │ │ └── Side effect control │ │ │ ├── 4.2 Module Abstraction │ │ ├── File organization │ │ ├── Functional layering │ │ ├── Internal implementation │ │ └── External interface │ │ │ ├── 4.3 Interface Abstraction │ │ ├── What the user needs to know │ │ ├── What the user doesn't need to know │ │ ├── Input contract │ │ ├── Output contract │ │ └── Error contract │ │ │ └── 4.4 System Decomposition │ ├── Split into subproblems │ ├── Split into components │ ├── Split into flows │ ├── Split into data layers │ └── Split into interaction layers │ ├── 5. Correctness and Verification │ ├── 5.1 Correctness Awareness │ │ ├── Running doesn't mean correct │ │ ├── Correct for examples doesn't mean universally correct │ │ ├── Correct on small data doesn't mean correct on large data │ │ └── Currently correct doesn't mean maintainable in the future │ │ │ ├── 5.2 Testing │ │ ├── Normal cases │ │ ├── Edge cases │ │ ├── Exceptional cases │ │ ├── Regression testing │ │ └── Automated testing │ │ │ ├── 5.3 Debugging │ │ ├── Reproduce the problem │ │ ├── Narrow down the scope │ │ ├── Propose a hypothesis │ │ ├── Verify the hypothesis │ │ ├── Fix the problem │ │ └── Prevent recurrence │ │ │ └── 5.4 Complexity │ ├── Time complexity │ ├── Space complexity │ ├── Data scale │ ├── Performance bottlenecks │ └── Scalability │ ├── 6. Engineering Mindset │ ├── 6.1 Readability │ │ ├── Naming │ │ ├── Comments │ │ ├── Code structure │ │ └── Concise expression │ │ │ ├── 6.2 Maintainability │ │ ├── Low coupling │ │ ├── High cohesion │ │ ├── Single responsibility │ │ ├── Replaceable │ │ └── Extensible │ │ │ ├── 6.3 Version Control │ │ ├── Git │ │ ├── commit │ │ ├── branch │ │ ├── diff │ │ └── merge │ │ │ ├── 6.4 Documentation │ │ ├── README │ │ ├── Usage instructions │ │ ├── Design notes │ │ ├── API documentation │ │ └── Changelog │ │ │ └── 6.5 Refactoring │ ├── Eliminate duplication │ ├── Extract functions │ ├── Improve naming │ ├── Simplify conditions │ ├── Split modules │ └── Preserve behavior │ ├── 7. Systems Thinking │ ├── 7.1 Programs Don't Exist in Isolation │ │ ├── Users │ │ ├── Data │ │ ├── Files │ │ ├── Networks │ │ ├── Databases │ │ └── External services │ │ │ ├── 7.2 Feedback Mechanisms │ │ ├── Logs │ │ ├── Error messages │ │ ├── Monitoring │ │ ├── User feedback │ │ └── Test feedback │ │ │ ├── 7.3 Risk Awareness │ │ ├── Data loss │ │ ├── Permission errors │ │ ├── Security vulnerabilities │ │ ├── Performance crashes │ │ └── Dependency failures │ │ │ └── 7.4 Evolutionary Awareness │ ├── Requirements will change │ ├── Data will change │ ├── Users will change │ ├── Environment will change │ └── Code must be modifiable │ ├── 8. Tool Chain Proficiency │ ├── 8.1 Editor │ │ ├── Code editing │ │ ├── Shortcuts │ │ ├── Search and replace │ │ └── Plugin management │ │ │ ├── 8.2 Command Line │ │ ├── File operations │ │ ├── Running programs │ │ ├── Environment management │ │ └── Automation scripts │ │ │ ├── 8.3 Package Management │ │ ├── Install dependencies │ │ ├── Manage versions │ │ ├── Virtual environments │ │ └── Dependency conflicts │ │ │ ├── 8.4 Debugging Tools │ │ ├── Breakpoints │ │ ├── Logging │ │ ├── Variable inspection │ │ └── Call stack │ │ │ └── 8.5 Collaboration Tools │ ├── GitHub │ ├── Issue │ ├── Pull Request │ ├── Code Review │ └── CI/CD │ ├── 9. Typical Application Scenarios │ ├── 9.1 Automation │ │ ├── File organization │ │ ├── Data cleaning │ │ ├── Batch processing │ │ └── Report generation │ │ │ ├── 9.2 Data Processing │ │ ├── Reading data │ │ ├── Transforming data │ │ ├── Analyzing data │ │ └── Visualizing data │ │ │ ├── 9.3 Web Applications │ │ ├── Frontend interface │ │ ├── Backend services │ │ ├── API │ │ ├── Database │ │ └── Deployment │ │ │ ├── 9.4 Tool Development │ │ ├── Command-line tools │ │ ├── Plugins │ │ ├── Mini-programs │ │ └── Internal systems │ │ │ └── 9.5 Programming in the AI Era │ ├── Prompt-to-code │ ├── Code reading │ ├── Code verification │ ├── Automated testing │ └── Humans are responsible for judgment │ ├── 10. Common Misconceptions │ ├── 10.1 Equating programming with syntax │ ├── 10.2 Equating copying code with programming │ ├── 10.3 Equating running code with correctness │ ├── 10.4 Equating solving problems on platforms with engineering ability │ ├── 10.5 Equating frameworks with fundamentals │ ├── 10.6 Equating AI generation with understanding │ ├── 10.7 Equating lines of code with ability │ └── 10.8 Equating amount of learning material with progress │ └── 11. Minimal Learning Loop ├── 11.1 Pick a real small problem ├── 11.2 Write down input and output clearly ├── 11.3 Design data structures ├── 11.4 Break into functions ├── 11.5 Write a minimal working version ├── 11.6 Add test cases ├── 11.7 Debug and record errors ├── 11.8 Use Git for version control ├── 11.9 Write a README └── 11.10 Review design trade-offs