From Problems to Possibilities: How Intelligence Creates Knowledge

In 1854, London was in the grip of a deadly cholera outbreak. Hundreds of people were dying, and doctors believed the disease was carried through the air. One physician, John Snow, was not convinced. He noticed something strange: many of the victims lived near the same public water pump on Broad Street. Instead of accepting the prevailing explanation, Snow treated the outbreak itself as a problem to be investigated. He carefully mapped the deaths and found that they clustered around the pump. Snow persuaded the local authorities to remove the pump handle. The outbreak soon declined. Years later, scientists confirmed that cholera could indeed spread through contaminated water. The problem that had seemed like a catastrophe forced Snow to ask a better question, and that question helped transform understanding of the issue.

We feel discomfort and irritation when we face problems, yet it's only because of the problems that we make profound discoveries. Problems force us to think in ways that have not been thought of before. Sometimes a problem is not merely an obstacle. It is a signal pointing toward something we have yet to understand. Programming languages like C, C++, Python, etc., are developed to solve certain kinds of problems. It's a way to explain computing.

We often think computing is equal to calculating. For example, 7 * 8 = 56. We might say that a computer is computing because it is calculating. But it's too narrow. Computation is about representation. Suppose you want to remember the number 5. You can either write it or use your fingers. The physical fingers are being used to represent an abstract idea, the number 5. So we have the physical object that represents an abstract object. This is the idea behind computation. A computer does something similar, but at an enormous level of complexity.

Inside a computer, there are physical things: electrical states, transistors, voltages, switches, memory cells, etc. But we interpret those physical states as numbers, characters, images, sounds, variables, objects, instructions, and relationships. So, the computer's physical memory is used to represent abstract things.

A computer program is essentially a set of instructions that causes a physical machine to behave in a particular way. Imagine a simple program that adds two numbers and stores the result. The program isn't just writing words. Those instructions ultimately cause the computer's physical components to undergo particular changes. For instance, an operation causes a transition from memory state A to memory state B. So, there are two levels:

Abstract level: Add 5 and 7.

Physical level: Electrical states inside the processor and memory change in a particular instance.

The program connects the abstract problem to physical changes inside the computer that lead to the desired result. Therefore, software engineers are physicists who cause physical matter to behave in ways that instantiate abstract relationships.

A Turing machine is a mathematical idea of computation associated with Alan Turing. The machine can read information from the tape, change it, and move along the tape according to the rules. A universal Turing machine has an extraordinary property. It can simulate other computational processes. Instead of building a machine for every task, you can build one sufficiently general machine and give it different instructions.

That's essentially the conceptual foundation of the modern programmable computer. Your laptop can play music, display photographs, run a game, edit a document, calculate mathematics, and browse the internet. The hardware is largely the same; only the program changes.

Programming begins because someone wants something to happen that isn't happening. A problem isn't terrible. It's a conflict between two or more ideas. Suppose we want accurate navigation tables. But the tables contain errors. There is a conflict. Desired accuracy is not equal to the actual accuracy. That is a problem, and someone needs to find a solution.

Before modern computers, people needed mathematical tables containing things such as logarithms, trigonometric values, and cosine values. These are useful for navigation and other calculations. But calculating huge tables manually was difficult. A large number of people were employed as computers to perform calculations. Computers were originally referred to a person, but humans make mistakes. An incorrect mathematical table could have serious consequences, particularly for navigation. So there was a problem: humans need accurate calculations, versus human inevitably make errors. The proposed solution is to build a machine that can perform the calculations automatically.

Charles Babbage conceived the Difference Engine, a mechanical calculating machine designed to automate the production of mathematical tables. Babbage was not simply fascinated by machines. A problem motivated him to build a machine that would reduce errors in mathematical tables.

Babbage later imagined something more ambitious: The Analytical Engine. The Difference Engine was designed for particular mathematical calculations. The Analytical Engine was much more general. It was conceived as a programmable machine. It generated the idea of a general-purpose computer.

Ada Lovelace recognised that Babbage's Analytical Engine could potentially manipulate symbols according to the rules, not merely perform ordinary numerical calculations. She wrote what is considered one of the first computer programs.

Technology begins with problems. Suppose you want instant communication. Before digital communication, sending information over long distances could take time. Messaging software solved the problem by sending instant messages. Similarly, facial recognition addresses the need for quick identification without using a username/password or manual identification. Computer security solved the accessibility problem without letting unauthorised people access confidential information.

Suppose you have a problem to sort 1 million pieces of data efficiently. You might write a program that successfully sorts them. But that doesn't necessarily mean you have written a good program. There are multiple solutions to a problem. Some are good while others are bad. So, solving the problem is not enough. You need a good solution.

A good solution is hard to vary and is one that is well adapted to the problem it solves. Imagine a puzzle, and your job is to find a configuration where every piece fits perfectly. If you randomly change one piece, the solution breaks. That is a sign that pieces are arranged for a reason. The same idea applies to programs. A good program has components that work together to solve a particular problem. If you arbitrarily change components, the program may become worse. Therefore, a good solution adapted to a problem is hard to vary.

There are many familiar software engineering principles that can be understood as special cases of being hard to vary. For example, modularity divides a large system into well-defined components, and reusability creates components that can be used appropriately in multiple contexts. These aren't just arbitrary rules programmers invented. Good engineering generally produces structures that are well adapted to their purposes.

Suppose a programmer needs to solve a difficult problem. Does the programmer magically know the correct program?

Usually not. He thinks of a possible solution. Try it and finds problems with it. Upon modification, he tries it again. He rejects unsuccessful approaches, keeps improving until a better solution may emerge. It's basically a trial-and-error approach.

Consider biological evolution. A population contains variation. Some variations are better adapted to particular environments. Those variations become more successful and generate better adaptations. Similarly, a programmer proposes different possible solutions. Some are bad, while others are better. The programmer rejects bad solutions and retains better ones. The creation of a good program is itself an evolutionary process of generating and eliminating candidate solutions.

Karl Popper described the knowledge creation using the ideas of conjecture and refutation. Conjecture is a guessed solution to a problem, and refutation means finding problems in the proposed solution. Then, a new conjecture is made, which is again criticised by refutation. This continues until we have a better explanation for a problem. Therefore, it is reasonable to place programming and scientific reasoning into the same framework.

A programmer guesses a program, runs it, finds bugs, and keeps modifying it until a good solution is found. Similarly, a scientist proposes a theory, tests it, finds contradictions, and keeps refining it until a better explanation is found. A common misunderstanding is that creative people simply have brilliant ideas. In fact, creativity involves generating possible solutions and using criticism to eliminate the bad ones. Therefore, creativity generates candidates and criticism selects them.

Imagine you have written a program that poorly solves a problem. There are multiple ways to improve it. You could change the algorithm, restructure the code, change the data representation, improve efficiency, and remove unnecessary components. This implementation is easy to vary. That suggests it hasn't reached a highly adapted solution. A good solution has few opportunities for improvement.

There are two ways to vary the program: Internal variation and External variation.

Internal Variation: The program solves a particular problem, but you could modify its internal components and make it substantially better. That means the implementation is not well adapted.

External Variation: The program isn't strongly adapted to any particular purpose. It might be capable of doing many things but doesn't solve a particular problem especially well. So, good implementation means the details are strongly connected to a particular purpose.

Programming isn't about producing useful tools. It is connected to the creation of knowledge. Imagine you discover an algorithm that solves a difficult problem. That knowledge can be embodied in the program. The program therefore becomes a kind of explanation. That is why software engineering has a deeper relationship with reasoning than we normally recognise.

If two ideas appear to contradict each other, reality can't contain the contradiction in the same way. For example, the program works correctly, but it fails every test. Both can't simultaneously describe the same program in the same respect. Therefore, when we encounter a problem, at least one assumption may be wrong, incomplete, or inadequate. Solving the problem means discovering what needs to change. For example, we believe objects fall towards Earth. You also discover that Earth is round. Now you can ask, why don't the objects on the other side of the Earth fall off into space?

There appears to be a conflict between your existing ideas. That conflict creates a problem. Your mind searches for an explanation that resolves the conflict. Eventually, Newtonian gravity provides a much deeper explanation.

Knowledge is not obtained by simply collecting observations. It is created through conjecture, criticism, and error correction. Imagine that you see the following: The sun rose yesterday; it rises today; and has risen every day of your life. Therefore, the sun will rise tomorrow. This is a wrong way to predict and generate knowledge. It's basically inductivism, which is the process of finding a pattern from many examples and generalising knowledge using those patterns. For example, you observe many swans and all of them are white. You may conclude that all swans are white. This seems logical, but then you discover a black swan that refutes your conclusion.

The problem is not that induction can sometimes make mistakes. It's about how to identify what observations and patterns to look for. Suppose one person studies birds with long necks. He notices swans, geese, cranes, etc., and suddenly your classification looks different. Another person studies animals whose beaks are approximately 5cm long. Now the relevant observations are different again. So there is no mechanical rule saying that if you look at these observations, a correct theory will automatically emerge. The observer always needs a problem and a conceptual framework.

If knowledge were simply extracted from observations, then creativity wouldn't be fundamental. A sufficiently powerful machine could collect data, process it, and obtain truth. But if knowledge requires new explanations, then something must generate those explanations. That's creativity. Suppose Newton sees an apple fall. The observations itself doesn't contain F = m * a or universal gravitation inside them. The physical event is one thing, and the explanation is another. Someone has to invent the explanation.

It doesn't mean observations don't matter. They matter enormously to criticise theories. For instance, all metals expand when heated. We perform experiments. If we found a counterexample, we have a problem. We must modify or abandon the theory. So experiments are powerful because they allow reality to criticise our ideas.

It's good to think that we could be wrong. It's actually not a weakness but a strength. Suppose someone says my theory is certain and can't possibly be wrong. There is no room for criticism and therefore no mechanism for improvement. But a scientist says This is my best explanation. Show me where it fails. Now other people can attack it, find an error, and knowledge improves. If they can't, the theory remains. Therefore, fallibility is essential to knowledge growth.

If a system can predict correctly, doesn't that mean it knows?

The production of successful outputs and possession of explanatory knowledge are different things. Suppose I give you a complicated formula that predicts tomorrow's weather. You ask, why does this formula work? I say, I don't know. I just discovered that it usually gives the right answers. That's different from understanding the physical mechanism of weather. A good explanation doesn't produce a correct answer. It tells us why the answer is correct and how different phenomena are related.

Is intelligence simply the ability to process data?

An intelligent system must be capable of encountering problems, generating possible solutions, criticising those explanations, detecting errors, creating improved explanations, and applying knowledge to new problems. This is more demanding than simply recognising patterns. A good explanation should not merely fit one observation. It should explain many things at once. Suppose two theories explain why a ball falls:

Theory A: Balls fall because they want to fall.

Theory B: There is a universal gravitational attraction between masses.

Both might be compatible with the observation that balls fall, but Theory B has more explanatory power. It explains why the moon orbits Earth, why planets orbit the Sun, why objects have weight, and why projectiles follow predictable trajectories. So, Theory B has greater explanatory power and is better than Theory A.

Knowledge is closely related to what a program can do. So instead of asking, " What information is stored inside the computer?" We should ask what that information enables the computer to do. You can describe a hammer physically: a metal head, wooden handle, certain weight and dimensions. But none of these descriptions explains what a hammer is for. Its function is to drive nails. Similarly, we should not understand computer knowledge just by looking at its bits, memory locations, and symbols. A program uses the knowledge embedded in it to solve real-world problems.

Computers are machines that represent physical abstractions. Suppose we want a computer to understand the concept of a dog. It doesn't contain a dog. Instead, physical states inside the computer represent abstract objects. The physical computer manipulates electrical states, but those states can represent abstract relationships. Software connects physical processes with abstract ideas. The computer's physical machinery is not itself the knowledge. Rather, its physical states instantiate representations of knowledge.

Suppose there are two programs. Program A contains 10 million facts but requires enormous changes when it encounters a new situation. Program B contains a smaller number of principles that allow it to deal with many different situations. Program B is more powerful than Program A because its knowledge has greater explanatory power. It captures something deeper that explains many cases.

A good program has a well-defined structure to solve a problem. The structure represents relationships about the problem. Those relationships allow the program to produce solutions. Therefore, the program embodies knowledge of how to solve the problem. Specialised knowledge is the one adapted to a particular problem, but general intelligence is the ability to create or discover knowledge that allows you to solve new kinds of problems.

We can make machines that are excellent at games, image classification, language generation, medical prediction, and pattern recognition. But artificial general intelligence requires something broader: the ability to create useful knowledge about problems that were not anticipated by its designers. It means the system must somehow go beyond merely applying predefined knowledge. It must be able to discover new explanations.

A universal system is one that can, in principle, perform or solve everything that belongs to its domain. For example, a basic calculator can add, subtract, multiply, or divide. But it can't be used to write a novel, run a weather simulation, control a robot, or play a video game. A general-purpose computer, however, can potentially do all these things. It's not restricted to one task, but can be programmed to implement many different processes. Human intelligence appears to be extraordinarily general-purpose.

A universal computer is powerful not because of its physical structure. But because it can represent and execute many different solutions. Suppose I want to study a planetary system. I could either build a physical miniature solar system or write software that represents mass, velocity, gravity, and time. The computer can then calculate how the planets would move. The computer doesn't literally become the solar system. It simulates its behaviour. A physical computer represents an abstract system that executes rules to simulate behaviour.

A computer can be universally programmable without being intelligent. For example, a universal computer can run many programs doesn't mean a universal computer understands what problems matter, creates explanations, and invents new knowledge. Intelligence is the system capable of creating explanations across multiple domains. The universal machine moves much of the complexity from hardware into software.

Universality is always relative to a domain. In classical mechanics, Newton's theory can explain an enormous range of phenomena involving motion, falling objects, projectiles, planets, and moons. So, within its domain, it has enormous reach. When an explanation can solve all problems in a domain, it has universal reach in that domain.

Before Newton, people often treated Earthly motion and celestial motion as different things. An apple falling from a tree seemed like one phenomenon, and the moon orbiting Earth was another. Newton showed that the same underlying principle can explain both. That is an enormous increase in explanatory reach. Universality is connected to unification. A good universal explanation can replace many disconnected explanations.

Technologies move from stone tools to specific machines. The specialised machines then transitioned to programmable machines that eventually created the universal computer. At some point, capability doesn't increase quantitatively. There would be a qualitative transition. A machine that can perform one task is fundamentally different from a machine that can perform an enormous variety of tasks. The same idea appears in the history of computation. Universal Turing machines are important precisely because one machine can simulate other machines rather than being dedicated to one computation.

Imagine an animal has an instinct: when a predator appears, run. It can be extremely sophisticated, but it is relatively specific. Now imagine a human encounters a completely new threat. They can potentially reason: what exactly is happening? What could cause it? What experiments could distinguish these possibilities? What new technology could solve it?

The ability to generate new solutions to new problems is the ultimate expression of intelligence. Universality doesn't mean omniscience. In fact, it has the ability to solve problems across broad domains. A universal program doesn't contain the set of all programs. It has the capability of running programs that can be supplied to it. Likewise, an intelligent person doesn't know every scientific fact. They have the ability to create knowledge when confronted with something unknown.

Conclusion: Problems drive discovery and innovation by forcing us to question assumptions and create new explanations. Programming is a form of problem-solving that connects abstract ideas to physical processes in computers. Good programs are well-adapted solutions: they evolve through trial, error, criticism, and refinement. The same process underlies scientific knowledge. As Karl Popper argued, knowledge grows through conjectures and refutations rather than simply collecting observations. Intelligence therefore involves more than processing data: it requires creating, testing, and improving explanations. Universal computers can perform many tasks, but true general intelligence requires the ability to generate new knowledge and solve unfamiliar problems.

If you have liked this post, please share it with others on WhatsApp, Twitter, and LinkedIn. Please share your feedback in the comment box. 

Photo by Vitaly Gariev on Unsplash