The Nature of Code

1. Vectors: The Building Blocks of Motion

A vector is typically drawn as a arrow; the direction is indicated by where the arrow is pointing, and the magnitude by the length of the arrow itself.

Vectors define movement. Vectors, with their magnitude and direction, are the fundamental data structure for programming motion. They represent the difference between two points, and can be used to describe location, velocity, acceleration, and forces. Instead of using separate x and y variables, vectors allow us to encapsulate motion into a single object, simplifying code and providing a foundation for more complex simulations.

Vector math is essential. Vector addition, subtraction, multiplication, division, magnitude, and normalization are the basic operations for manipulating motion. These operations are implemented as functions in the PVector class, allowing us to easily calculate and apply forces, change speeds, and control the direction of objects. For example, adding a velocity vector to a location vector moves an object, and normalizing a vector gives us a unit vector that can be scaled to any magnitude.

Vectors simplify code. By using vectors, we can reduce the number of variables needed to describe motion. Instead of separate variables for x, y, xspeed, and yspeed, we can use two PVector objects: location and velocity. This makes code more readable and easier to maintain, and provides a foundation for more complex simulations.

2. Forces: The Why Behind the How

A force is a vector that causes an object with mass to accelerate.

Forces cause acceleration. Forces, also vectors, are the cause of changes in an object's velocity. Newton's second law (F=ma) is the key to understanding how forces affect motion. A force applied to an object causes it to accelerate, and the amount of acceleration is inversely proportional to the object's mass.

Force accumulation is key. Multiple forces can act on an object simultaneously. To simulate this, we must accumulate all forces acting on an object and then apply the net force to its acceleration. This is done by adding all force vectors together and then dividing by the object's mass.

Forces can be made up or modeled. We can create forces arbitrarily (like wind) or model them based on real-world physics (like gravity, friction, and drag). The key is to understand the direction and magnitude of the force and then implement it as a PVector.

3. Oscillation: The Rhythms of Nature

The curve is generated by a mathematical function that defines the probability of any given value occurring as a function of the mean (often written as μ, the Greek letter mu) and standard deviation (σ, the Greek letter sigma).

Angles and angular motion. Understanding angles, angular velocity, and angular acceleration is crucial for simulating rotating and oscillating objects. Angles are measured in radians in Processing, and we can use trigonometry (sine, cosine, tangent) to calculate the components of a vector based on its angle.

Trigonometry for motion. Trigonometry allows us to convert between polar and Cartesian coordinates, which is useful for simulating circular motion and other oscillating behaviors. The sine and cosine functions produce smooth, repeating patterns that can be used to control the position of objects over time.

Oscillation with amplitude and period. Oscillating motion can be described by its amplitude (the distance from the center of motion to either extreme) and its period (the amount of time it takes for one complete cycle). We can use the sine and cosine functions to create oscillating motion, and we can control the amplitude and period to create different effects.

4. Particle Systems: Complexity from Simplicity

Particle systems will allow us to look at some advanced features of object-oriented programming, namely inheritance and polymorphism.

Many objects, one system. Particle systems are a way to manage a large number of independent objects, often represented by simple shapes or dots. They are useful for simulating natural phenomena like fire, smoke, and waterfalls.

Object-oriented design. Particle systems are a great example of object-oriented programming. We create a Particle class to describe the properties and behaviors of a single particle, and then we create a ParticleSystem class to manage a collection of particles. This allows us to organize our code and create complex systems from simple building blocks.

ArrayLists for dynamic systems. ArrayLists are a useful data structure for managing a collection of objects that can grow and shrink over time. They allow us to add and remove objects from the list as needed, which is essential for simulating particle systems where particles are born and die.

5. Physics Libraries: Leveraging Existing Tools

As we move forward into a more complex world of multiple objects and multiple forces (which we’ll introduce in Chapter 2), the benefits of PVector will become more apparent.

Box2D for collisions. Box2D is a powerful physics engine that handles collisions, joints, and other complex physics simulations. It operates in a real-world coordinate system (meters, kilograms, seconds) and requires us to translate between its world and our pixel-based world.

toxiclibs for particles and springs. toxiclibs' VerletPhysics engine is well-suited for simulating particle systems with spring connections. It uses Verlet integration, which is a fast and efficient method for simulating motion. It also operates in the Processing coordinate system, making it easier to use.

Libraries don't replace understanding. While physics libraries can handle the math for us, it's still important to understand the underlying principles of vectors, forces, and motion. This knowledge allows us to use the libraries effectively and to create our own custom simulations.

6. Autonomous Agents: Giving Objects a Mind

By examining techniques behind modeling autonomous agents, we will breathe life into our inanimate objects, allowing them to make decisions about their movements according to their understanding of their environment.

Agents perceive and act. Autonomous agents are objects that can perceive their environment and make decisions about how to move. They are not simply pushed around by forces; they have their own goals and desires.

Steering behaviors. Steering behaviors, like seek, flee, and arrive, are algorithms that allow agents to navigate their environment in a lifelike manner. These behaviors are based on the concept of a desired velocity, which is a vector that points in the direction the agent wants to move.

Steering force = desired - current. The steering force is calculated by subtracting the agent's current velocity from its desired velocity. This force is then applied to the agent's acceleration, causing it to change direction.

7. Cellular Automata: Rules and Emergence

A complex system is typically defined as a system that is “more than the sum of its parts.”

Simple rules, complex results. Cellular automata (CA) are systems of cells that live on a grid and change their state according to a set of simple rules. Even with simple rules, CAs can exhibit complex and unpredictable behavior.

One-dimensional CAs. Wolfram's elementary CAs are one-dimensional systems with two possible states (0 or 1) and a neighborhood of three cells. Despite their simplicity, they can generate a wide variety of patterns, including fractals.

Two-dimensional CAs. The Game of Life is a two-dimensional CA with two states (alive or dead) and a neighborhood of eight cells. It demonstrates how simple rules can lead to complex and emergent behavior, such as stable patterns, oscillators, and gliders.

8. Fractals: The Geometry of Nature

A fractal is a rough or fragmented geometric shape that can be split into parts, each of which is (at least approximately) a reduced-size copy of the whole.

Self-similarity at all scales. Fractals are geometric shapes that exhibit self-similarity, meaning that they look the same at different scales. They are often found in nature, such as in trees, coastlines, and snowflakes.

Recursion is key. Fractals are often generated using recursion, a technique where a function calls itself. This allows us to create complex patterns by repeatedly applying a simple rule.

Deterministic vs. stochastic fractals. Deterministic fractals are generated by applying a fixed set of rules, while stochastic fractals incorporate randomness. Both types of fractals can be used to create visually interesting and complex patterns.

9. Genetic Algorithms: Evolving Solutions

The goal of this book is to fill your toolbox. If all you know is random, then your design thinking is limited.

Evolutionary principles in code. Genetic algorithms (GAs) are inspired by the process of biological evolution. They use concepts like heredity, variation, and selection to solve problems.

Genotype and phenotype. In a GA, the genotype is the genetic code of an element (e.g., an array of numbers), and the phenotype is the expression of that code (e.g., a shape or behavior). The fitness function evaluates how well the phenotype performs.

Selection, crossover, and mutation. GAs use selection to pick the fittest members of a population, crossover to combine the genetic code of two parents, and mutation to introduce variation. These steps are repeated over and over again to evolve a population towards a desired outcome.

10. Neural Networks: Learning from Experience

The goal of this book is to fill your toolbox. If all you know is random, then your design thinking is limited.

Inspired by the brain. Neural networks are computational models inspired by the structure and function of the human brain. They are used for pattern recognition, prediction, and control.

Perceptrons: simple neurons. A perceptron is the simplest neural network, consisting of one or more inputs, a processor, and a single output. It uses weights to adjust the inputs and an activation function to generate the output.

Learning through feedback. Neural networks can learn by adjusting their weights based on feedback from their environment. This can be done through supervised learning (with a teacher), unsupervised learning (without a teacher), or reinforcement learning (through observation).

Last updated: January 16, 2025