Artificial Life Programming in the Robust-First Attractor

DOI: http://dx.doi.org/10.7551/978-0-262-33027-5-ch097

Artiﬁcial life programming in the robust-ﬁrst attractor

David H. Ackley1 and Elena S. Ackley2

1University of New Mexico, Albuquerque, NM 87131 2Ackleyshack LLC, Placitas, NM 87043 [email protected] Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021

Abstract Although the SDA robustness and security properties are dubious, and its scalability is rapidly dwindling, it has Despite mounting awareness of the liabilities of determinis- been so dominant that alternatives may seem unthinkable. tic CPU and RAM computing, across industry and academia One might imagine that fields like fault tolerance (IEEE, there remains little clear vision of a fundamental, general- 2013, e.g.,) or probabilistic algorithms (Karp, 1991) fall purpose alternative. To obtain indefinitely scalable computer architectures offering improved robustness and security, we outside the SDA, but by ‘virtually guaranteeing’ determin- have advocated a realignment of the roles of hardware and istic execution, they actually entrench it. The same is software based on artificial life principles. In this paper we true of many other non-traditional but still deterministic propose an active media computational abstraction to under- models, such as synchronous cellular automata (von Neu- lie such a hardware-software renegotiation. The active me- mann and Burks, 1966; Ulam, 1950; Toffoli and Margolus, dia framework is much in the spirit of probabilistic cellular automata, but designed for indefinite scalability and serious 1987, e.g.), data flow machines and systolic arrays (Borkar programmability, rather than simplicity and analytic tractabil- et al., 1988; Budzynowski and Heiser, 2013, e.g.), and ity. We discuss active media programming techniques based asynchronous circuit-level techniques such as GALS and on living systems principles, and present anecdotal data from RALA (Kishinevsky et al., 2007; Gershenfeld et al., 2010). sample programs to introduce a new programming language called ulam, that we are developing as an underlying lan- Probabilistic cellular automata (PCA) (Grinstein et al., guage for active media. 1985; Agapie et al., 2014, e.g.) do go decisively beyond determinism, and they are general enough to embrace the kind of models we explore—but their motivations and meth- Introduction ods are sharply divergent from the present effort. PCA work often presumes simple and stylized noise models, and As the hegemony of CPU and RAM declines, for the first proceeds—preferably by formal analysis—to derive insights time in decades significantly new computer architectures are into equilibrium distributions and other system properties. appearing—from the nothing-but-net neural architecture of But when such research begins by postulating a state transi- IBM’s TrueNorth (Merolla et al., 2014), to the memristor- tion matrix, the small matter of actual PCA programming is driven flat parallelism of HP’s “The Machine” (Williams, silently assumed away. Yes, the transition matrix is a pow- 2014). With the potential on the horizon for a major evo- erfully general device; no, you don’t want to program in it. lutionary transition in computer architecture, it is an oppor- tune time to reconnect with first principles before shortlist- Recently, there have been some serious programming re- ing successors. The result of such a process, we believe, will search efforts that, while remaining mostly traditional, do be the recognition of artificial life as a (perhaps the) major explicitly abandon determinism and accept some small out- force driving future architectural innovation. put errors—often with the motivation of increased parallel efficiency (Cappello et al., 2009; Elliott et al., 2014; Mis- Escape from the SDA ailovic et al., 2013; Renganarayana et al., 2012, e.g.). We cheer all such efforts but worry they may fail to gain traction Serial deterministic computing based on CPU and RAM is a because their incremental practicality leaves them struggling vast attractor, a valley deep and wide, in a notional space of up the sides of the SDA valley, with all the downhill direc- all possible models of computation. This Serial Determin- tions behind them. istic Attractor (SDA) is laced with interlocking design decisions surrounding its core demand for logical correctness— Colonize the RFA which allows the inherent fragility of extremely efficient software to be masked by extremely reliable hardware. Until There is at least one fundamental alternative, which we here a bug, or an attacker, appears. call the Robust-First Attractor (RFA), in the space of all pos-

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 sible models of computation. We have been breaking trail in Stefanovic, 2003, e.g.); it is already possible in electron- the RFA for some time (Ackley and Cannon, 2011; Ack- ics (Ackley et al., 2013; Ganapati, 2009). ley, 2013b; Ackley et al., 2013; Ackley, 2013a; Ackley and Small, 2014a), and can report it is strikingly unlike the SDA, A new deal for hardware and software but at least as vast: It is a natural way to understand the com- Clearly, compared to an SDA computer architecture, the ac- putational properties of living systems, which have always tive media model represents a very different division of labor made do without the luxury of deterministic execution. between hardware and software, as large blocks like ‘pro- Life fills space, as long as suitable resources are available; cessor’ and ‘memory’ and ‘bus’—and their floorplanning— every RFA architecture must do the same, and that core de- are placed largely under software control. This refactoring mand for indefinite scalability is surrounded by interacting will presumably incur a hardware price-complexity penalty design decisions often deeply complementary to the SDA’s. something like FPGA vs ASIC or worse—but that, in turn, A von Neumann machine by itself simply isn’t an RFA ar- may be more than offset by enabling new optimizations akin Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 chitecture; it is just incomplete, and thus unevaluatable, until to RISC vs CISC, combined with the hair-down liberation a method is defined for tiling unbounded space with it. of merely best-effort hardware determinism. Most software-based artificial life models are designed So, while the programmable active media framework2 is 1 to run on single von Neumann machines. Unsurprisingly, likely a splendid deal for hardware, it may seem a brutal one- therefore, the properties of such models typically depend two punch for software, stunned by nondeterminism from critically on deterministic execution, as typified by the ut- below then flattened by expanded mission responsibilities ter collapse of constructs in Conway’s game of life when from above. We take that added software engineering com- facing even mild asynchrony (Bersini and Detours (1994); plexity as underlying the “hard to program” objection lev- see also Beer (2014)). eled against our approach in a discussion of a very interest- Determinism is a property of the small and the fragile; it ing spatial and parallel—though apparently deterministic— is fundamentally misaligned with living systems. It warps model of computation (Budzynowski and Heiser, 2013). our expectations; it’s time to move on. But here’s the thing: On the one hand, the software engineering job should be harder, because its relative simplic- Programmable active media ity was purchased with precisely those von Neumann ma- SDA models are well-suited to implementation in passive, chine features—a single processing locus, uniform passive “cold” materials, where uniformity rules, change is rare, and memory, reliability all on hardware—that led to its Achilles’ free energy is expensive—conditions where, indeed, living heels of unscalability and unsecurability. Serial determin- systems may survive but will rarely thrive. However, some ism was a simple, sensible starting point, but software en- environments are diverse in space, dynamic in time, and engineering and many related fields have emerged since von ergetically rich, bountiful, like a rain forest or a sunny day at Neumann’s time, and we now know quite a bit about con- the shore. We abstract such circumstances into active media structing, managing, and evolving complex systems. Look- computational models—unbounded spatial architectures in ing back from the RFA, for software still to be demanding which each discretized location performs logical state tran- general pointers and flat RAM and cache coherent global sitions based on its local neighborhood, but with uncertain determinism seems like clutching blankie. The future will and variable frequencies and only limited reliability. arrive anyway. An active medium can change spontaneously and is inher- That said, and on the other hand, software’s big promo- ently nondeterministic. In a programmable active medium tion becomes less terrifying as we get down to work, be- we get to pick its state transition function—to specify, up cause, like hope from Pandora’s box, “best effort” wafts up- to reliability limits, that certain neighborhood patterns shall wards from the nondeterministic hardware into the software stay constant like memory, say, while others produce transi- as well. As a system component, we’ll do our best with what tions like a processor or a data transport, or, indeed, act like we’ve got and what we get, but if things go really wrong, different types of hardware at different moments. The state we can simply delete ourselves and let our kin cover for us. transition function we supply is executed asynchronously in Correctness and robustness are measured by degrees and cir- parallel across the medium, avoiding overlapping state tran- cumstances in living systems; in the RFA they are highly sitions, again, with good but not guaranteed reliability. It respected qualities rather than merely purported necessities. may become possible to implement programmable active media in, say, DNA (Canton et al., 2008; Stojanovic and Outline The rest of this paper focuses on the challenges and oppor- 1Though there have certainly been exceptions, both pro- posed (Ray, 1995) and implemented (Ackley, 1996). Addition- tunities of indefinitely scalable programming in the RFA. ally, powerful modeling systems like Ready (Hutton et al., 2012), The next section briefly presents a few slogans or rules of though still fundamentally deterministic, now exploit many-core parallelism. 2It’s probably too late to call it “Software-Defined Hardware”?

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 thumb we have developed, to serve both as antidotes to Chance it The SDA is typically deterministic even when decades of SDA thinking and as prototype design patterns, it’s not supposed to matter, as in breaking ties or sizing a yet to be fully detailed, for RFA programming based on liv- supposedly ample buffer or timeout. But with determinism ing systems principles. Then Section “The Ulam program- off the table many RFA tasks can be dramatically simpli- ming language” briefly introduces our new language, Sec- fied by replacing state with probabilities, and rather complex tion “Programming examples on active media” presents sev- dynamics can be implemented using remarkably little per- eral examples, and finally Section “Artificial life on active object state, as demonstrated in Section “Stochastic timer” media” offers brief concluding thoughts. below. Alife models are mixed on this, but the field faces some hard unlearning. Principles of active media programming To help make the RFA more concrete and clearly distinct Use it or lose it The active media abstraction is a pro- from the SDA, in this section we offer some RFA slogans grammable space in which energy is a nonrefundable sunk Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 or design principles, with brief alife motivations or impli- cost, and even though actual power is limited, this idealiza- cations. The end of Section “A new deal for hardware and tion shifts the discussion from the stultifying task of mini- software” above concerns a principle that might be called mizing the cost of energy consumed to the galvanizing task There’s always dying; here are five more: of maximizing the value of energy provided. Other things being equal, the RFA programmer seeks to minimize the av- Happy and you know it: Make the goals obvious, • erage change age per site in some productive way. Space is the place: Space is the core data structure, • Such slogans can help establish shared context, but code Embrace the race: Just help the better answer win, • is what really talks, and that’s where we head next. Chance it: Replace state with statistics, and • Use it or lose it: A cycle saved is a cycle wasted. • The Ulam programming language For some time, we have been exploring an indefinitely Happy and you know it: The key to robustness is effec- scalable architecture called the Movable Feast Machine tive redundancy, and one excellent approach is to give sub- (MFM) (Ackley and Cannon, 2011; Ackley et al., 2013; components not just tasks to do but also ways to measure Ackley, 2013a). We have recently developed an open-source their own success. Unit tests are a simple SDA example; in C++ MFM implementation (Ackley and Small, 2014b) that the RFA, geometric goals (“Bigger should be lower”) and is currently incorporated into thread-per-tile simulators run- local consistency rules (“I should be able to see you seeing ning on conventional multicores, but is designed and writ- me”) allow the execution of external ‘productive’ computa- ten for eventual cross-compilation onto indefinitely scalable tions to be combined with ongoing internal processes like “tile per tile” physical hardware. machine construction and maintenance. We have also been developing an open-source compiler for a new language we call ulam (Ackley and Ackley, 2014), Space is the place The SDA tries to obliterate space using mostly named after Stanislaw Ulam for his pioneering con- Random-Access Memory, then acts all surprised by buffer tributions especially in cellular automata (Ulam, 1950), but overflows; the RFA uses space as the backbone organizing also for various weak bacronyms such as that concluding principle for both access control and computation, like the this paper’s abstract. We give only a few bullet points here, cat that’s picky about who’s allowed near, but then grooms for grounding and flavor—there’s runnable code in the next everything in reach. We are in largely good shape here: A section—but ulam deliberately looks, and is, rather like a great strength of typical alife models is their fundamentally conventional object-oriented procedural language: spatial organization, unlike, say, typical genetic algorithms. The top-level compilation driver, called ulam, is a Perl • script; culam, the ulam compiler proper, is written in Embrace the race The SDA generally abhors race con- 3 C++, and its output is heavily templated C++, so that de- ditions but in the RFA, with many components interacting spite weird data sizes and packing (see next point), the and making things better locally, a race can be, not a re- g++ compiler downstream can sometimes find quite deli- grettable shame to be hidden, but a fine tool for making a cious assembly code sequences. larger-scale decision, which may then be amplified by spec- Numbers can be declared in any width from 1 to 32 bits, • tators for subsequent processing. Alife models also do well using both more and less conventional interpretations (Ta- with this—often identifying its race conditions with names ble 1). All primitive type casts and assignments saturate involving “selection”. in the destination type. One dimensional arrays of zero or 3Even those rare authors who accept non-determinism usually more items are provided, bit-packed up to 32 total bits. The ulam analog to an object instance is called an Atom, see races as no more than tolerable (Misailovic et al., 2013; Boehm, • 2012), although there are exceptions (Madhavan et al., 2014, e.g.). but an Atom is also analogous to a word of memory in a

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 Ulam type Interpretation 1 ulam 1; 2 / Fork bomb. ∗∗ Unary(k) Base 1 (population count) 3 symbol FB color #f00 \ \ Unsigned(k) Base 2 positional 4 symmetries all \ 5 / Int(k) Two’s complement base 2 ∗ Bool(k) Boolean (majority of pop. count) 6 element ForkBomb { 7 EventWindow ew; k Uninterpreted bit values Bits( ) 8 Void behave() { ew[1] = ew[0]; } 9 } Table 1: ulam primitive bit structures, widths k =1..32 (except Bool uses only odd widths). Figure 1: A complete ulam element. Copies itself from the event window center (ew[0]) to ew[1], which in this case

might be any adjacent site. See text. Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 tagged architecture, so each one is the same size—96 bits in the current design, with 25 reserved for the object type and error correction. The analog to a class is called an element, which may define (non-static) methods and up to (96-25=) 71 bits of data members. A native keyword instead of a method body provides an escape to C++, with all the usual caveats. There is composition but no inheritance; the analog to a • struct is called a quark, which may be any size from 0 to 32 bits. There is also union with the typical meaning. The has operator determines if an Atom contains a given quark, so a quark method (for example) can try to ‘find one of its own’ inside an arbitrary atom. Figure 2: Uncontrolled (and uncontested) growth of a single For indefinite scalability, the only persistent data memory initial ForkBomb. Left: After an average of 8 events per site • is a spatial grid of Atom storage; there is no dedicated (8 AEPS). Right: After 64 AEPS. heap or random-access main memory. There is a per- event function call stack, and an EventWindow library provides read/write access to the local grid neighborhood, Programming examples on active media comprising 41 total Atoms within Manhattan distance 4 Here, briefly presented, are five examples of ulam code that of the center. (The underlying MFM tile structure is not we have created recently, embodying living principles like directly accessible from ulam.) reproduction (uncontrolled and controlled) and group for- All method arguments are passed by value, except the im- mation and action. In a nod to more traditional engineering, • plicit self argument is passed by reference. There is rather than only alife, the final example is a tiny toy data no privileged main() method; from the point of view of switch implementation. an element, execution occurs during a call to a handful of special methods (see Table 2), especially the behave Fork bomb method, which is called to perform one state transition on Figure 1 presents complete ulam code for a simple runaway- the Atom and/or its encompassing EventWindow. reproducing fork bomb. Line 1 declares the language version in use. Line 7 declares an instance of the EventWin- dow library, as a size 0 data member. In addition to the expected 2D neighborhood access methods, EventWindow Special method On Purpose also offers a one-dimensional mechanism that often suffices, as here: The self—the atom having the event—is by defi- Void behave() E Perform event nition at ew[0], with increasing 1D array indices spreading Int test() EQ Run unit tests outwards in 2D breadth-first. Int toInt() Q Custom cast to Int With up as “north”, is the adjacent site east, so one T aref(Int) EQ Custom array read ew[1] might expect to produce an eastward growing Void aset(Int, T) EQ Custom array write ForkBomb line. But the element metadata (inside the structured com- ment, at Line 4) declares that all eight square rotations and Table 2: ulam privileged methods for elements (E) and/or quarks and unions (Q) reflections are valid for ForkBomb, so a random transform is chosen for each of its events, and it explodes (Figure 2). Running the ulam driver on ForkBomb.ulam compiles

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 14 4 bit exponential timer 12 1 ulam 1; 10 2 8 3 / A stochastic exponential timer; a template taking 6 ∗∗ k=1 4 an exponential factor (exp) and a multiplicative 4 2 k=5 5 factor (k). After a reset(), count() can be called Expected count log x 0 2 6 approximately k 2 exp times before alarm() will ∗ ∗∗ 7 begin returning true. 1 8 64 512 4096 32768 8 / count() calls ∗ 9 quark Timexp(Unsigned exp, Unsigned k) { (b) Timexp(4,1) counts powers of two. 10 Random r; // PRNG is infrastructure, costs 0 bits 11 Unsigned(exp) t; // costs exp bits

12 Void reset() { t = 0; } Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 10 13 Unsigned count() { 8 k=1 14 if (!alarm() && r.oneIn(k<

Figure 4: A stochastic timer. A four-bit Timexp(4,1) separates time scales over four orders of magnitude, combining ﬁne- grained initial resolution with overall long duration.

1 ulam 1; Telomere 2 quark Telomere(Unsigned width) { 3 typedef Unsigned(width) Tail; The forkbomb is so simple and obvious that it’s sort of a 4 typedef EventWindow.SiteNum SiteNum; 5 “Hello world!” for active media, but its cancerous rampage 6 EventWindow ew; is a poor example of alife programming. Inspired by the 7 Tail age; telomere DNA sequences that shrink during reproduction, 8 / Duplicate into ew[to] if self isn’t ∗∗ Figure 3 illustrates a reusable ulam software component that 9 too old and ew[to] is a live, empty site. / ∗ provides controlled reproduction of a single starting cell into 10 Bool dup(SiteNum to) { width 1 2 − 11 if (age < Tail.maxof) { a clonal population of 2 atoms, assuming all clones 12 if (!ew.isLive(to) || !(ew[to] is Empty)) survive and spread out sufﬁciently. The group-forming ele- 13 return false; ment in Section “Mob rule”, below, uses this strategy. 14 ++age; // Must increment before copying! 15 ew[to] = self; 16 } Stochastic timer 17 return true; 18 } 19 } Figure 4a shows an example of using statistics instead of state as mentioned with the “Chance It” principle in Sec- tion “Principles of active media programming”. Timexp is Figure 3: An excerpted Telomere.ulam, offering a quark a quark template taking a bit size (exp) parameter, and a that provides controlled growth to elements containing it. multiplier (k). The exp speciﬁes both its range of count- ing ability, and how much it consumes from the atomic bit budget; k scales the entire curve. it into C++ ‘intermediate code’, which is then processed by So a Timexp(4,1) quark, for example, can be dropped the standard gcc tools, yielding a custom ulam element li- into any element with four bits to spare, and its count() brary (libcue.so) that can be dynamically loaded into method can be called thousands of times, with very high the Movable Feast Machine simulator—and, hopefully soon, probability (Figure 4b), before its alarm() method returns into actual hardware tiles. Loaded into the simulator, the li- true. When its t data member is 0, k<

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021

Figure 5: Two mob atom types evaluate their options, having picked at random from the empty sites (green or light grey) and a random other mob atom. (Left) The basic mob rule: Swap if the empty is closer to the kin. (Right) Mobs induce drift by discouraging moves against a heading direction (orange or dark grey). See text and Figure 6.

Figure 6: (Left) At 10 kAEPS a mob using just the basic mob rule (Figure 5, left) has broken up, but (right) adding statistical gravity and a directional bias (Figure 5, right) yields a long-lived, slowly-moving mob. Mobs began as single centered atoms.

Mob rule fixed-size data cells between eight bidirectional ports. We This fourth example demonstrates both cohesion and mo- made Router atoms that self-assemble into a grid, while bility in a single structure—a “mob”—that’s larger than gossiping amongst themselves to derive spatial gradients to- an event window but smaller than the whole universe. A wards eight Port atom clusters, which emit and consume Telomere(3) quark induces a single “Mob” atom to form gradient-following data Cell atoms, each carrying a four a cluster of 128 clones all following the mob rule (Figure 5). byte payload destined for a random other Port. That proved insufficient for mob cohesion (Figure 6, left), In this demo, about 550 lines of switch-specific ulam code but it works if we skip some mob moves with a probabil- compile into about 30K lines of very stylized C++; Figure 7 ity that grows with the number of Mob atoms in our event shows some data (7a, 7b) and a day-in-the-life image re- window, a fix we call statistical gravity. (Figure 6, right). drawn from a screenshot (7c). This little switch knows noth- Mobs are new but we hope they find use—as either code ing of packet reassembly and sometimes drops cells, and it’s or inspiration—as a medium-scale mobile spatial data struc- slow, jittery, prone to catastrophic crowding at higher data ture. They are slow and sloppy, but note all that dynamics— rates, totally impractical and completely glorious. the managed growth, the group cohesion, and the control- lable, directed movement—costs just one byte per atom. Artificial life on active media Active media are powerful but twitchy. Depending on their Data switch programming, small deviations may grow, positive feedback As a final example, to explore and stress ulam’s programma- loops may erupt, chain reactions are possible. Of course bility, we developed a toy “data switch”, designed to carry there are fork bombs in traditional computing as well, but

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 Data rate v s failed transfers Smoothed average latency of successful cel l transfer s 100 2.01 1 0 3.49 4.56

Data 6.94 rate 1 1000 0.1 % failed cell transfers 0.01 Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 100 none in 10kAEPS 0.001 55 Average time in switch (AEPS) 1.75 2.01 2.33 2.77 3.49 4.56 6.94 13.87 Avg. arri val rate 0 1 2 3 4 5 (cells/AEPS) Switch run ti me (kA EPS) (a) Cell arrival rate vs % lost. (b) Data switch latency vs machine uptime. (c) Snapshot at 10kAEPS; cell arrival rate=4.56. Figure 7: Performance of the 8 port switch: The data loss (a) is low until a critical arrival rate is reached; initial average latency (b) is high until the routing grid is constructed. Colored square borders in (c) are Port atoms, some in the color of just-received data; scattered dots are in-flight data Cells; the grid of Router atoms can be seen against the grey background. See text. indefinite scalability forces the issues by raising the stakes; We must explore and colonize and settle the RFA, but ul- that is a feature. timately we will also leverage the technology that is now Yes, to a degree, programming active media genuinely filling our society, after seventy years of relentless optimiza- will be harder, but that’s because the programs, once written, tion in the serial deterministic attractor. There is nothing will do that much more for us, providing a vertical slice from wrong with von Neumann machines that cannot be fixed by function to floorplan to hardware construction and mainte- making them small and individually insignificant parts of an nance. And partly, the programming will just seem harder indefinitely scalable architecture. because we’re unfamiliar with its idioms, and we haven’t Change is coming. Alife research can lead the way. done the software engineering yet, so the accommodations look quite rustic. But as suggested by the work reported in Acknowledgments this paper, that last problem we are starting to fix. This work was supported in part by a Google Faculty Re- The ulam compiler has been under heavy development search Award, and in part by grant VSUNM201401 from since August 2014, and to coincide with ECAL 2015 we are VanDyke Software, both to the first author. Trenton R. Small planning an official version 1.0 release, complete with doc- implemented much of the C++ MFM implementation. Spe- umentation, tutorials and Ubuntu packaging so that installa- cial thanks to the F’14 “Robust Artificial Life” students at tion can be as simple as apt-get install ulam from a UNM for contributing ideas and enthusiasm, and for explor- public personal package archive. ing lots of hand-coded C++ elements for their projects. There is so much to be learned and relearned, designed References and redesigned, implemented and reimplemented. It can Ackley, D. H. (1996). ccr: A network of worlds for research. seem positively daunting, but we hope to entice you or your In Langton, C. and Shimohara, K., editors, Artificial Life students (or advisors!) to give it a try. V. (Proceedings of the Fifth International Workshop on the You might be a Ruby fan, or Python or Haskell or Java Synthesis and Simulation of Living Systems), pages 116–123, or Forth; some if not many of our language design decisions Cambridge, MA. The MIT Press. in ulam will almost surely not be your cup of tea; that’s Ackley, D. H. (2013a). Bespoke physics for living technology. Ar- okay. We just need to keep our eyes on the prize: The goal is tificial Life, 19(3 4):347–364. neither maximum parallel efficiency, nor maximum expres- Ackley, D. H. (2013b). Beyond efficiency. Commun. ACM, sive purity. The goal is indefinite scalability while balancing 56(10):38–40. Author preprint: http://nm8.us/1. concurrency and programmability—and to that end, robust- Ackley, D. H. and Cannon, D. C. (2011). Pursue robust indefi- ness must be inherent not just in hardware, but across the nite scalability. In Proc. HotOS XIII, Napa Valley, California, computational stack. USA. USENIX Association.

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561 Ackley, D. H., Cannon, D. C., and Williams, L. R. (2013). A mov- Grinstein, G., Jayaprakash, C., and He, Y. (1985). Statistical me- able architecture for robust spatial computing. The Computer chanics of probabilistic cellular automata. Phys. Rev. Lett., Journal, 56(12):1450–1468. 55:2527–2530. Ackley, D. H. and Small, T. R. (2014a). Indefinitely scalable com- Hutton, T., Munafo, R., Trevorrow, A., Rokicki, T., and Wills, puting = artificial life engineering. In Proceedings of The D. (2012). Ready, a cross-platform implementation of vari- Fourteenth International Conference on the Synthesis and ous reaction-diffusion systems. https://code.google. Simulation of Living Systems (ALIFE 14) 2014, pages 606– com/p/reaction-diffusion. Accessed Mar 2015. 613. MIT Press. IEEE, editor (2013). 2013 43rd Annual IEEE/IFIP International Ackley, D. H. and Small, T. R. (2014b). The MFM version 2 code- Conference on Dependable Systems and Networks (DSN), base. https://github.com/DaveAckley/MFMv2. Budapest, Hungary, June 24-27, 2013. IEEE. Ackley, E. S. and Ackley, D. H. (2014). The Ulam compiler for Karp, R. M. (1991). An introduction to randomized algorithms. MFM programming language. https://github.com/ Discrete Applied Mathematics, 34(13):165 – 201. elenasa/ULAM. Downloaded from http://direct.mit.edu/isal/proceedings-pdf/ecal2015/27/554/1903815/978-0-262-33027-5-ch097.pdf by guest on 27 September 2021 Kishinevsky, M., Shukla, S. K., and Stevens, K. S. (2007). Guest Agapie, A., Andreica, A., and Giuclea, M. (2014). Probabilis- editors’ introduction: GALS design and validation. IEEE De- tic cellular automata. Journal of Computational Biology, sign and Test of Computers, 24:414–416. 21(9):699–708. Madhavan, A., Sherwood, T., and Strukov, D. (2014). Race logic: a Beer, R. D. (2014). The cognitive domain of a glider in the game hardware acceleration for dynamic programming algorithms. of life. Artificial Life, 20(2):183–206. In Computer Architecture (ISCA), 2014 ACM/IEEE 41st In- ternational Symposium on, pages 517–528. IEEE. Bersini, H. and Detours, V. (1994). Asynchrony induces stability in cellular automata based models. Artificial Life IV, pages Merolla, P. A., Arthur, J. V., Alvarez-Icaza, R., Cassidy, A. S., 382–387. Sawada, J., Akopyan, F., Jackson, B. L., Imam, N., Guo, C., Nakamura, Y., Brezzo, B., Vo, I., Esser, S. K., Appuswamy, Boehm, H.-J. (2012). Position paper: Nondeterminism is unavoid- R., Taba, B., Amir, A., Flickner, M. D., Risk, W. P., Manohar, able, but data races are pure evil. In Proceedings of the 2012 R., and Modha, D. S. (2014). A million spiking-neuron in- ACM Workshop on Relaxing Synchronization for Multicore tegrated circuit with a scalable communication network and and Manycore Scalability, RACES ’12, pages 9–14, New interface. Science, 345(6197):668–673. York, NY, USA. ACM. Misailovic, S., Kim, D., and Rinard, M. (2013). Parallelizing se- Borkar, S., Cohn, R., Cox, G., Gleason, S., Gross, T., Kung, H. T., quential programs with statistical accuracy tests. ACM Trans. Lam, M., Moore, B., Peterson, C., Pieper, J., Rankin, L., Embed. Comput. Syst., 12(2s):88:1–88:26. Tseng, P. S., Sutton, J., Urbanski, J., and Webb, J. (1988). iWarp: An integrated solution to high-speed parallel comput- Ray, T. S. (1995). A proposal to create a network-wide biodiver- ing. In Proceedings of Supercomputing ’88, pages 330–339. sity reserve for digital organisms. Technical Report Technical Report TR-H-133, ATR. Budzynowski, A. and Heiser, G. (2013). The Von Neumann architecture is due for retirement. In Proceedings of the 14th Renganarayana, L., Srinivasan, V., Nair, R., and Prener, D. (2012). USENIX Conference on Hot Topics in Operating Systems, Programming with relaxed synchronization. In Proceedings HotOS’13, pages 25–25, Berkeley, CA, USA. USENIX As- of the 2012 ACM Workshop on Relaxing Synchronization for sociation. Multicore and Manycore Scalability, RACES ’12, pages 41– 50, New York, NY, USA. ACM. Canton, B., Labno, A., and Endy, D. (2008). Refinement and stan- dardization of synthetic biological parts and devices. Nature Stojanovic, M. N. and Stefanovic, D. (2003). A deoxyribozyme- biotechnology, 26(7):787–793. based molecular automaton. Nature Biotechnology, 21(9):1069–1074. Cappello, F., Geist, A., Gropp, B., Kal, L. V., Kramer, B., and Snir, M. (2009). Toward exascale resilience. IJHPCA, 23(4):374– Toffoli, T. and Margolus, N. (1987). Cellular Automata Machines: 388. A New Environment for Modeling (Scientific Computation). The MIT Press. Elliott, J., Hoemmen, M., and Mueller, F. (2014). Exploiting data representation for fault tolerance. In Proceedings of the Ulam, S. (1950). Statistical mechanics of cellular automata, 1952. 5th Workshop on Latest Advances in Scalable Algorithms for Proceedings of the International Congress on Mathematics, Large-Scale Systems, ScalA ’14, pages 9–16, Piscataway, NJ, 2:264–275. USA. IEEE Press. von Neumann, J. and Burks, A. W., editors (1966). Theory of Self- Ganapati, P. (2009). Hardware hackers create a modular moth- Reproducing Automata. University of Illinois Press, Urbana, erboard. http://www.wired.com/gadgetlab/2009/ IL, USA. . 08/modular-motherboard Williams, S. (2014). K2I distinguished lecture - The Gershenfeld, N., Dalrymple, D., Chen, K., Knaian, A., Green, Machine: The HP memristor solution for comput- F., Demaine, E. D., Greenwald, S., and Schmidt-Nielsen, ing big data. Video retrieved January 2015 from P. (2010). Reconfigurable asynchronous logic automata: https://mediacosmos.rice.edu/app/plugin/ RALA. In Proceedings of the 37th annual ACM SIGPLAN- embed.aspx?ID=vVUTzFCE006yZu3TF1sXKg& SIGACT symposium on Principles of programming lan- destinationID=URka-_E5-0-e4girH4pDPQ& guages, POPL ’10, pages 1–6, New York, NY, USA. ACM. contentID=vq2oQtAqPkeAqm5F6uSnqA.

David H. Ackley, Elena S. Ackley (2015) Artificial life programming in the robust-first attractor. Proceedings of the European Conference on Artificial Life 2015, pp. 554-561