Meta-Thinking Framework: Reasoning, Categorization, and Abstraction

Meta-Thinking Framework: Reasoning, Categorization, and Abstraction | Original

Home 2025.09

Thinking

By categorizing, abstracting, or reasoning about things, you think.
Systems thinking is about placing objects in a system map. You think about how things interact with each other, how the system works, and how abstraction and categorization function within the system.
Critical thinking is about thinking objectively about the positives and negatives of things. You question everything around you to understand something.
Creative thinking is about generating new ideas or concepts in a creative way. You may combine existing ideas or concepts directly or creatively. You may also combine two unrelated ideas or concepts to create new ones.
Logical thinking is about thinking in a mathematical or programming way. We use structured, rational processes to analyze and solve problems.
Experiential thinking is about reflecting on past experiences to solve new problems.
Intuitive thinking is about thinking in an intuitive way. To have more accurate intuition, we need to explore or experience a lot.
The timing of thinking matters. We may reflect on the problem after some weeks or months.
We may collaborate with others or communicate with others to think.
We may find or search for related information to think. Especially those ideas or opinions that are contrary to our own.
We may record our thinking results. And we can reflect on them carefully after years.
We may conduct more experiments to aid in thinking, just like fixing a bug.
Avoid wishful thinking, as it often intertwines with one’s ego. We should separate our desires from the natural events or societal matters that are beyond our control.

Reasoning

Everything is about reasoning.
Design, software, products, physics, reversing myopia, startups, business, users, strategy, countries, programming languages, variables, and concepts are all about reasoning.
Reasoning is a way of meta-thinking.
By reasoning about things, you understand how x changes y. Why values change from x to y, why people like or dislike products, why people pay attention to or ignore things.
You can reason about things or behaviors, problems in different aspects, such as from first principles, human nature, or unknown causes, which we call mysteries.
The ways of reasoning are what we need to think about. If something happens, we analyze it from the perspectives of time, space, environment, or the nature of objects.
Things happen through some kind of form. It is like an operator in code.
Every reason combined together may form a bigger reason. It is like lambda code. By combining functions, we can create a high-level function.

Categorization

Everything is about categorization.
Design, software, products, physics, reversing myopia, startups, business, users, strategy, countries, programming languages, variables, and concepts are all about categorization.
Categorization is a way of meta-thinking.
By categorizing things into different groups, you can find better or more detailed solutions. It is like conditional branch code. It is like separating electronic components. It is like different network types.
You can compare different things by categorizing them in different aspects.
The number of groups and the standards for categorization are what we need to think about. It is like the conditions of a conditional block of code.
If the conditions themselves have some patterns, we may use a switch statement. If the conditions are different from each other or have some special cases, we may use an if statement.
Lambda code is really interesting. We may combine categorization with lambda code. Different groups of objects need different handling procedures.

Abstraction

Everything is about abstraction.
Design, software, products, physics, reversing myopia, startups, business, users, strategy, countries, programming languages, variables, and concepts are all about abstraction.
Abstraction is a way of meta-thinking.
By abstracting things at a high level, you summarize them and can handle them in a batch. It is like a function or a method. It is like summarization in writing. It is like a table of contents. It is like a company structure.
You can abstract things in different aspects.
The standards for abstraction are what we need to think about. It is like how we extract or organize the code.
We want to organize things by level and level. Each level should only interact with adjacent levels.
If there is a problem or a bug, you can find the problems by starting from a high level. You should trace down to the root cause. It is like the corruptions of a country. They usually happen in some specific groups or people.
The downside of abstraction is that it involves some high-level concepts. Individuals have more freedom in this world. The rules for a high level may not be suitable for all objects included in those levels.
Things change. We may need to refactor code to have better abstraction. We may reorganize the company structure to better reflect the business and serve the customers.
Think about the standards between every level. Do they have some patterns? If they do, it can be written as lambda code to construct high-level order functions.
People wearing eyeglasses with full prescription to watch a blackboard (5m away) and a mobile phone is a poor abstraction. It does not better reflect the interests of the eyeball.
The functions, methods, and procedures to apply that abstraction should be thought through carefully. Do we need to do the same task for the whole batch of objects, or should we treat them separately?

Limits and Edge Cases

Thinking about limits and edge cases is a good way to understand something.
Knowing the limits and edge cases of a person helps you understand how to collaborate with them or live with them.
Knowing the limits and edge cases of an API server helps you assess its security level and capabilities.
Knowing the limits and edge cases of an input field helps you determine whether it is secure and free from bugs.
Thinking about the limits and edge cases of an algorithm can improve efficiency and fix bugs.
The limit is about efficiency, maximum capacity, and resources. Edge cases are about minor or niche conditions.
The term “limit” is sometimes used to refer to edge cases, and edge cases are sometimes called limits.
Think about limits in terms of space, size, length, number, weight, derivatives, time, lifespan, energy, frequency, physical units, computer units, requests, frequency, rate limits, resources, CPU, memory, and computation capacity.
Consider edge cases in algorithms, code, hardware, math problems, large language models, APIs, systems, books, functionalities, or products.
Limits often involve numerical values or constraints, while edge cases are specific, often unusual, conditions.
Think about the limits of rendering lines of text in a browser. Is it feasible to handle one million lines? What are the constraints?
It says the projector can work at least 1.5 meters away. What will happen if it is closer?

Back Donate