The 12 recurring concepts: A theoretical and technical journey through universal principles in science and programming

Introduction

From the orbits of planets to molecular biology, all the way to the simplest sorting algorithm, recurring principles cross our scientific and technological disciplines. As developers, we often learn programming by solving specific problems, but sooner or later we feel the need to grasp the fundamentals. The 12 recurring concepts we’ll explore here aren’t just theoretical tools—they are unwritten laws that explain how the universe works and cut across physics, biology, and computer science. Recognizing and understanding them is a step from being a self-taught coder to becoming a mindful engineer.

1. Link or Association

Why?
In nature and any complex system, it’s necessary to connect abstract entities to form concrete structures that allow function or generate meaning. Without associations, we couldn’t define relationships between ideas, objects, or processes. The world, in a way, is built from these interrelations.

What is it?
Link or association is the process of taking a general abstraction and attaching specific properties that make it concrete. In other words, it’s the union between an abstract entity and its attributes or concrete representations.

What is it for?
This concept is essential to model real systems and represent them in any discipline, ranging from naming variables in a program to assigning functions to team members.

How does it show up?

• In physics, forces are associated with specific particles acting on objects.
• In biology, genes associate with concrete phenotypic expressions.
• In computer science, assigning a process to a processor is a dynamic association where an abstract resource links to a concrete execution.
• In programming, class instances or binding a method to a message are direct examples that make object-oriented programming and state management possible.

2. Complexity

Why?
Complexity naturally arises when the size or number of elements in a system increases. Non-linear interactions create effects that are hard to predict, making system management require special methods.

What is it?
Complexity is a system characteristic where overall behavior isn’t just the sum of parts but includes emergent properties and growing difficulties to understand or control as size increases.

What is it for?
Understanding complexity is crucial to choosing fitting methodologies for different contexts, from organizing teams in big projects to selecting algorithms that scale well with data size.

How does it show up?

• In math and physics, chaotic and non-linear systems like the weather are paradigms.
• In biology, ecosystems and species interactions show rising complexity.
• In software development, as projects grow, coordination between modules and dependencies become complexity challenges. That’s why design patterns and modular architectures help separate concerns and contain complexity growth.

3. Models (Conceptual and Formal)

Why?
To think through and solve complex problems, we need to represent, abstract, and formalize them in models that simplify reality without losing essence. Models are cognitive tools that give meaning and allow manipulation of ideas.

What is it?
A model is a structured representation of a system or concept, whether visual, mathematical, or logical, that captures its essential features for reasoning, designing, or simulating.

What is it for?
Models enable rigorous analysis, prediction, and effective design in science and technology. Without them, handling or communicating complex systems would be impossible.

How does it show up?

• In physics, differential equations model physical system dynamics.
• In biology, population models explain evolution within ecosystems.
• In computer science, formal models like automata theory underpin compilers and languages.
• In software, entity-relationship diagrams, flowcharts, and abstract data types are core conceptual models to design systems before coding.

4. Coherence and Integrity

Why?
For a system to work correctly and be reliable, its parts need to align without contradictions. Coherence and integrity ensure each component fits the whole’s rules and behaves as expected.

What is it?
Coherence is the logical internal consistency among concepts, data, or components; integrity is the preservation of that coherence over time and under adverse conditions.

What is it for?
It validates that systems meet specifications, maintain data validity, and withstand errors or attacks, critical for reliability and security.

How does it show up?

• In math, a theory with no internal contradictions is coherent.
• In biology, homeostasis maintains functional coherence.
• In computer science, relational databases enforce referential integrity to avoid inconsistencies.
• In programming, state validation and exception handling ensure a program keeps coherence and integrity during execution.

5. Efficiency

Why?
Physical and technological resources are limited: time, space, energy, and money are not infinite. So, efficiency is vital to maximizing output and minimizing costs. Without it, systems become slow, costly, or unfeasible.

What is it?
Efficiency measures how well a system or process uses resources to achieve a goal. In computing, this often means runtime (time complexity) and memory use (space complexity).

What is it for?
It guides choosing practical, sustainable solutions and technologies and planning projects to optimize resource use. It’s key for fast, cheap, scalable systems.

How does it show up?

• In physics, energy efficiency measures how much input energy converts to useful work.
• In biology, organisms optimize energy for survival and reproduction.
• In computing, efficiency is analyzed via algorithmic complexity, like using quicksort with average O(n log n) over less efficient sorts.
• In programming, writing code that avoids unnecessary loops or costly memory usage applies efficiency, critical for embedded or cloud systems.

This entry covers the technical criteria used to measure efficiency in algorithms, from Big O notation to real-world implications. Algorithmic efficiency fundamentals

6. Evolution

Why?
All systems—from living organisms to software programs—face constant change through internal or external adaptations. The ability to evolve and adapt is critical for survival and relevance in dynamic environments.

What is it?
Evolution is the process and capacity for change over time, involving transformation, improvement, or adjustment to new conditions or demands.

What is it for?
It helps design resilient, flexible systems that stay useful despite technological, environmental, or user changes. It encourages innovation and continuous improvement.

How does it show up?

• In biology, natural selection is the classic example.
• In physics and chemistry, phase changes and evolving conditions illustrate dynamics.
• In computing, software versions and updates evolve systems to fix bugs, add features, or boost performance.
• In programming, maintainable code using patterns and principles facilitates extension and refactoring.

7. Levels of Abstraction

Why?
To handle complexity, we can’t focus on all details at once. Abstraction hides secondary info and lets us focus on what’s relevant, easing design, understanding, and communication.

What is it?
Abstraction is creating simplified, generalized representations that let us see systems from different viewpoints or detail layers.

What is it for?
It enables organizing complex systems in layers or modules, helping incremental development and collaboration among specialists at different levels.

How does it show up?

• In physics, atomic models or classical versus quantum laws are different description levels.
• In biology, from molecules to ecosystems, each organization level is abstraction.
• In computer science, hardware, OS, programming languages, and apps are abstraction layers letting us design without knowing all internal details at once.
• In programming, functions, classes, interfaces, and modules are clear abstraction levels organizing code.

To dig deeper into abstraction and its everyday uses in high-level programming, this article offers a clear, accessible explanation. Explaining abstraction in high-level programming

8. Spatial Ordering

Why?
Systems depend on the physical or logical locations of components to work correctly. Proximity or spatial order affects efficiency, communication, and organization.

What is it?
Being mindful of placing or considering elements based on physical, organizational, or conceptual location to optimize interaction and accessibility.

What is it for?
It helps design architectures and networks efficiently, easing coordination and reducing communication costs and data access times.

How does it show up?

• In biology, organs and cells distribute spatially optimally in organisms.
• In physics, particle location determines interactions and forces.
• In computing, memory architecture (cache, RAM, disk) reflects spatial ordering to optimize access.
• In programming, data structures like arrays (contiguous order) or trees (hierarchical order) show spatial order aiding search and operations.

9. Temporal Ordering

Why?
Time is a fundamental dimension where events and processes happen. Ordering and coordinating these events are essential to understand, control, and predict behavior in dynamic systems.

What is it?
Temporal ordering is the sequential or synchronized arrangement of events and actions, considering their duration, dependencies, and timing.

What is it for?
It allows modeling causal processes, synchronizing concurrent activities, and ensuring correct execution of time-dependent systems.

How does it show up?

• In physics, time sequences phenomena like movement or energy flow.
• In biology, time organizes and regulates vital processes through circadian rhythms, which determine when we sleep, when we have energy, how our hormones adjust, and so on.
• In computing, synchronizing processes in distributed systems or concurrency control need temporal order.
• In programming, sequential execution, timing, and event handling depend on this concept to avoid errors and ensure coherence.

10. Reuse

Why?
Building everything from scratch is costly and risky. Reusing proven knowledge, components, and patterns speeds development, improves quality, and reduces mistakes.

What is it?
Reuse is applying concepts, techniques, or components designed for one context in another without rebuilding them.

What is it for?
It boosts production efficiency, standardization, scalability, and eases maintenance and evolution.

How does it show up?

• In engineering, standardized parts in various products increase efficiency.
• In computing, libraries, frameworks, and APIs are reuse tools.
• In programming, modular design, inheritance, and design patterns promote code and architecture reuse.

For a visual and practical introduction to common design patterns and their reuse in software engineering, this site is highly recommended. Design Patterns overview.

11. Security

Why?
Systems must defend against errors, attacks, or failures to ensure integrity, confidentiality, and availability. Security is vital for trust and stability in technical systems and real life.

What is it?
Security is a system’s ability to resist, mitigate, or recover from adverse events, intentional or accidental.

What is it for?
It preserves functionality, protects data, and prevents physical or logical damage in critical systems.

How does it show up?

• In biology, the immune system protects against infections and harm.
• In physics, radiation or impact protection systems are security mechanisms.
• In computing, encryption, access control, and validation are security pillars.
• In programming, input validation, secure memory management, and authentication strengthen software security.

12. Trade-offs and Consequences

Why?
No solution is perfect or universal; there are always trade-offs affecting different aspects. Recognizing and managing these trade-offs is essential for balanced and effective decisions.

What is it?
Choices that involve sacrificing or balancing certain attributes or requirements in favor of others, with technical, economic, or cultural repercussions.

What is it for?
Helps plan and design considering limits, costs, and benefits to avoid naive solutions that fail in practice.

How does it show up?

• In physics, energy and stability trade-offs govern structures and reactions.
• In biology, evolutionary adaptations balance pros and cons.
• In computing, choosing between speed and security or simplicity and flexibility are classic examples.
• In programming, designing easy-to-use but less flexible APIs, or efficient but complex systems, are inevitable trade-offs.

Conclusion

Understanding these 12 recurring concepts lets us go beyond empirical programming toward deeper, universal knowledge. They’re laws not only governing computer systems but the physical and biological world, too. Integrating them into our thinking, design, and software development elevates our practice into more conscious, resilient, and efficient engineering. I invite you to keep exploring these concepts and apply them in your projects, turning every line of code into a manifestation of universal principles.

Credits

This article was inspired by the opening minutes of the first session from the Recurrence in Software Development Course taught at EscuelaIT. I want to acknowledge and thank instructor Luis Fernández, whose deep knowledge of programming fundamentals and inspiring teaching style continue to encourage many developers —including myself— to think more critically and deeply about software.