Abstract
In Natural Complexity: A Modeling Handbook, Paul Charbonneau introduces a number of computer models that are well known as complex systems, from Langton’s ant, through sand piles and forest fires, to flocks of birds and traffic jams. The book takes a pragmatic, subjective view of complexity, in which a system of simple rules leads to an outcome that is in itself notable, but not at all obvious from the simple rule. Langton’s ant, for example, traverses an infinite grid of black or white squares, turning left or right according to the color of each square as it advances, and changing the color of the cell it leaves behind. The first few thousand iterations appear to be a random walk, but eventually some kind of order emerges when the ant, seen from a distance, begins to carve out a straight, unending highway. An evocative notion then, that the overall behavior of a system can be described by an apparently simple if approximate rule that appears to be unrelated to the underlying mechanism.
Complexity, as it is understood in applied mathematics, has over the years been discussed in numerous books from the technical to the popular. The proposition here, though, is to promote hands-on experience with a number of example systems. Although the book does not shy away from the mathematical discussion of the examples, needed especially to illustrate their properties in common, it guides readers to program and run a set of – at a first glance – straightforward models on ordinary computers using the freely available and widespread Python programming language.
The subject matter and its treatment in this book might well answer a question for readers of The Holocene. How can students, both undergraduate and postgraduate, come to appreciate computer models in geographical science? The problem is that students must jump several hurdles before they can start to work with the complicated models of the ocean, atmosphere, and other earth system components that the field depends upon. They might need to learn a compiled programming language: FORTRAN, C or C++, which will seem loaded with arcane notions: isn’t it obvious that x is a real number? A seasoned programmer might understand otherwise, but that is a lesson that can wait. Students might also need to come to grips with fluid mechanics, vector calculus, discretization methods, involved visualization techniques, statistical analysis, and a host of difficult material that they may or may not be prepared to tackle by their studies to date. All in all, it is a lot to ask for students to expend so much effort, especially if the model results are not themselves immediately illuminating.
The beauty of the models described in this book, and the way in which they are described, is that students can start to explore scientific computing and see some exciting results in short order. Each of the models is complemented with a short Python program – and I appreciate the author’s frequent reminders that they are designed for brevity not performance – which means that students with a laptop can start to work with them with minimum fuss, and learn a transferable skill to boot. More importantly, though, the complex systems discussed produce intriguing, elegant results that are not obvious given the simple rules embedded in the programs. These results can be appreciated at a face value, with their tendency to produce intricate pictures, and at a deeper level by considering properties such as self-similarity and quasi-periodicity.
Take the forest fire case of Chapter 6 as an example. The rules of the game are simple and make immediate sense: a tree might grow in an empty space with a given probability, a lightning strike might ignite an existing tree with a different probability, fire jumps to neighboring trees, and burnt trees leave an empty space behind them. The obvious outcome is that an expanding front will cover the model forest, but turns out to be a partial description of the result at best, and varies substantially depending on the choice of the growth and lightning strike probabilities. For a realistic choice, where trees grow slowly compared to the advancing fire, and lightning strikes are infrequent, the model forest subdivided into domains, each with a distinct density, and not for the first time in the book we meet with self-organized criticality, with the relative frequency of larger and smaller fires described by the same power law that appears for avalanches, flooding, and of course, sand piles.
The approach to Python programming is suitable for a novice, both in that it favors short programs over performance and in that it points to the next step for an improving programmer. Python’s inbuilt data structures and iteration methods are not designed for substantial number crunching, with the result that a Python program that looks much like a C or FORTRAN program will run an order-of-magnitude more slowly, and a Python program that looks like an R or MATLAB program will not work as expected. The solution to this is to make proper use of the add-on NumPy library, which is introduced primarily to take advantage of its data structures, leaving the reader to find out how to work more efficiently with it should the need arise. The graphics library matplotlib also features, so that novice programmers will finish the book equipped with a practical apparatus of scientific computing on Python.
The book itself is available in the common perfect bound paperback format. The style of writing is friendly and conversational, akin to a well-written popular science book. That said, there are more than a few formulae to follow, though nothing that should frighten a reader already with any pragmatic interest in scientific computing. Each chapter includes a number of good quality color and black-and-white figures, many of which have been generated by the Python programs. These are included in full, and are generally short enough to type by hand and certainly to read and understand. To paraphrase the author, ‘no procrastinating, start modeling now’.