Patent pending

Here is my contact information.

Scroll to the white space and start clicking on the links.

You can also read the self-containing version, which is much shorter.

Firebook is the most detailed account of FIREPEGS. It even can be used as a design guide, although not every trick is covered even here. Some chapters may seem unnecessary expansive, but I had to write them because I was trying to understand the nature of this seemingly unnatural game. The more I am getting used to it, the more natural it appear. Take those longer wait times and compare such firepegs to dormant buds: that's how the living things build their bodies. Firepegs in general are like a simplified living things. They can be seeded, they drop their seeds and they blossom. The order of this events and stages may be, in fact, made different. What you see here is only two versions out of many possible.

FIREPEGS are weird for the people with poor intellectual experience, especially if they are not ready to enrich it. A kid who grew on LEGO may balk at some features, which are perfectly natural for electronics. Those who never had a chance to play with cellular automata may even get upset. I met dynamical patterns then I was 13 years old - how many people were so lucky? Yet we are submerged in dynamical patterns, and we are dynamical patterns ourselves.


The whole chapter is necessary, please excuse me.

FIREPEGS is a computerized toy, which brings together space, time and causality. It can help to run MAKE THEM MAD lessons with toddlers, or to challenge the bigger kids.

FIREPEGS grew from my observations of The Little Girl called TLG, while she was playing MAKE THEM MAD with me.

The game of MAKE THEM MAD officially was about building layouts of colorful pegs. We started with two empty boards. I filled my board one peg at a time, waiting for TLG to duplicate every move.

Playing MAKE THEM MAD, TLG was learning elusive subjects like strategic thinking, problem solving and self control, but those were just words. Suddenly, by the age of four, she started getting symmetries in the layouts and patterns of polyominoes, and discovered the number plane, remembered as Cartesian plane. She even translated, rotated and mirrored shapes. The nationally established machine of education allows the kids of her age to learn only the linear patterns of two colors, like red-blue-red-blue. Not even a number line.

Unbeknownst to me and to her, TLG acquired the most enabling knowledge. Text is a stream of linear layouts, sweeping through the plane. In arithmetic we learn quick ways to perform the binary operations - additions, multiplications - memorizing elementary results from two-dimensional charts.

TLG has never heard of math facts. At 4 years and 6 months she drew her first chart of additions. A year later she became an accomplished reader.

For me it was the game of waiting and watching. My role was to have a secret plan, and to disclose it piece by piece. Sometimes I was only pretending having a plan, sometimes I changed it abruptly if TLG could not follow me, often I learned something from watching her, or I could run a homegrown experiment, but, by and large, my time was spent unproductively.

Naturally, I was asking myself what I was doing there, and if a machine could replace me.

Building a robot, a Mechanical Turk, which could plug those pegs into the holes was, of course, out of question, but, since the goal was usually to build a flat mosaic, the pegs were merely the color spots. I could draw 100 spots organized in 10x10 array on computer screen, and change their colors from gray to something else.

Defining such layout of colors would be my job. I was not planning to teach computer to invent them. So, before playing the game, I would go from spot to spot picking and setting up their secret colors.

The second, and a critical kind of information would be, which peg or spot was to appear after which. As you probably remember, I was playing with a human child. She would not agree to scan the board line by line. To let her follow me, I had to make very well articulated moves, tying every new peg to a prominent pre-existing peg.

I wanted to be able to build a track of pegs, then return and start another track from the middle. The easiest way to do this was timing. If from some point I would want to take 5 steps, and then start from the same point a new track, it should happen 6 time units later.

Hence I decided to break every computer peg into nine squares. The central square defines the color. The eight surrounding squares are the links to the peg's eight neighbors. You see them on the picture below, and you will see them many times on this site, only without those helping arrows.

When a peg discloses its color (or fires up, according to my latest terminology) it uses the links to kick it's neighbors. The message is simple:

"Hi dear! Wake up! Count N ticks, then display your color".

Where N is the number on the link, and ticks are the signals from computer timer.

The picture has 9 firepegs, as I came to call them. Only 5 of them have a color to display. Two yellow pegs always fire up together. Two ticks later fires up the green and the blue pegs. The orange peg fires up 1 tick after the yellow pegs, and it fires back at them, making them fire up again after 5 ticks.

The pattern of blinking is: yellows, orange, blue+green, pause, yellow, orange and so forth.

The whole combination starts blinking as soon as the operator touches or clicks on the orange or any of the two yellow pegs, and, if allowed, it will blink as long as the page is open.

How much longer? Not much. I have finished explaining firepegs. I only want to tell what's happened to them.

I started developing FIREPEGS under the name of ROBOPEGS because I was thinking about the Mechanical Turk, and I achieved this goal. But by that time our MAKE THEM MAD game was different. TLG was building layouts by chunks. OK, I added 0-tick links to disclose a whole chunk at once. But when we started digging holes and walking the shapes peg by peg.

I understood that good layouts were few and far between (although there was well enough of them for a child), and that the parents without background in computing would be able to draw and link only the simplest challenges. CODEPEGS - the "technology" of programming dynamical layouts - was the way to go. I started thinking of ROBOPEGS as of a helping app, offering professionally created challenges.

Meanwhile, the former ROBOPEGS under the new name of FIREPEGS had changed too. I learned to build dynamical patterns, envisioned new elements and 3D extensions. I realized that FIREPEGS can be used to teach time and build controllers, including animation controllers. FIREPEGS still can help with simple challenges, but it is branching off new, much more difficult lines of them.

To get some firsthand experience with FIREPEGS, scroll down to the empty space with the links on the left, and start clicking. I also provide a self-containing version, in which the brief explanations are incorporated into a player.

The following description of FIREPEGS is long, and only mostly understandable for those without background in computers and electronics. FIREPEGS is a STEM game, but if you see something what does not make sense to you, just skip it. None of this stuff is necessary for the parents.

Please remember, it's a very early, limited functionality prototype. Not much of irrelevant fun and nothing addictive. Imagine firepegs jump up and laugh hysterically, or play a melody as they catch fire. I believe you can.

In the following chapters I demonstrate and explain few carefully selected projects, so you can evaluate the toy's potential. I can do more, and you can too, because in the chapter named YOUR TURN below you will find a workable program to tinker with.


Teaching a cyberchild.

Before TLG learned to count, she was positively unable to stick a peg in the right hole, unless this hole was adjacent to a previously established peg. We built our first layouts incrementally, peg by peg, starting from the corners of the boards. Sometimes even this was too hard. How did TLG manage to follow me is still a mystery. Her eyes were barely six inches above the pegs tops, and tall Lauri's pegs are generally not for mosaics. From time to time, when TLG could not get my move, I suggested her to stand on the chair or moved the boards to the floor.

After the first year TLG became wicked good at keeping an eye on the chosen landmark and working around it. She certainly could understand and appreciate our creations, and I started encouraging her to copy recognizable groups of pegs at once. If TLG could not reproduce an addition, she learned to say this phrase: "I can't do it, teach me how". I have no idea where did she get it. Certainly, not from me.

"Teaching how" did not necessarily mean falling back to peg-by-peg. First, I tried to offer TLG a method, a strategy. Not sure if I correctly understood her method, but I imagined the links between the holes, allowing pegs to activate their immediate neighbors. I did not have another toddler to play MAKE THEM MAD with, so now I wanted to teach computer how. Something so easy, that I could teach the growing child to do this, and then... you know, teaching is the best way to learn.

OK, enough talking. Scroll down, click on the links and watch the first two records. I will comment on the rest of them later, and you will always have a players or two at hand.


The record called Bird is exactly what I wanted FIREPEGS for: it shows layout and a method to build it. Layout represents the same rotational symmetry, which you saw in MAKE THEM MAD.

If it stopped playing yet, click on the word MORE next to SHOW. It must change to LESS. Now drop down the menu located next to TPS and change the number to something smaller than the current value of 5. Finally, click on the link to play the record again. The board will show you what makes it tick.

Please use STOP/GO to pause and restart the player. If neither STOP nor GO is there, you can only restart the record from the link.

First of all, it's not animation, it's a theater. Animation is mostly about cheating viewer's brain depicting impossible acts. FIREPEGS is a hotbed of optical illusions too, but in the core it's a honest game of space, time and causality. The Bird was not produced as a sequence of drawings. The pegs behaved like falling dominoes, kicking each other and turning up their colored sides.

Every peg has the color to display and the set of 8 links to talk to its immediate neighbors. Depending on the number on the link, communication can be fast or slow. When the peg fires up it sends the fire through the links. If the number is 0, the peg on the other side of the link fires up immediately. Number 1 means firing up 1 tick later, and so forth. If there is no number, the link is open, and the fire will take forever to pass.

Firing up, firepegs do not change the layout. They only reveal it. That's how it was in MAKE THEM MAD. We were not creating a layout out of nowhere. It was in my mind. Even if it was not, for TLG it was.

In Bird the picture becomes visible as the pegs fire up and display their colors. For the next record called Wires I told the pegs to become transparent and decorated the board with the photo, which gradually appears as the pegs disappear like the pieces of LCD indicator. The remaining grid can be completely hidden too.

I created Wires in hope that the sheer senselessness of it might help to promote the project more than anything else. Sure enough, every peg could have carried another picture, and every picture could have been animated.

Yet, there is more to this than just decorating pictures with live frames. It's an analogy. which may help to explain FIREPEGS one more time. You can think that Bird or any other layout presented here is a picture on the board, which pegs reveal as they become transparent.


Few scary words to read and forget. After all, it's a technical toy!

Please look at Bird. It's based on the spatial layout. This spatial layout is based, in turn, on a pattern of rotating triangles from MAKE THEM MAD. Triangles are variegated with stripes - the thicker stripes, so they don't dissolve and merge into a checkerboard pattern - and the stripes are colored. Stripes and colors follow the same rotating pattern. Do you see more ways to variegate and color those triangles? I am sure you do. Many more ways.

On top of the spatial layout there is a causal layout of links. It defines what causes to fire what. This layout is totally independent from the spatial one. I could swap causal layers between Bird and Wires - I do have such an option - and everything would work just fine. Not sure if it would look just fine, but it's up to the designer.

Note again, for the given spatial layout there can be any number of causal layouts, teaching your student how. I could build Bird by color bars or by multicolor bars and in many other ways, puzzling, challenging, surprising, teasing, deceiving and entertaining your student. With a bigger kid it's a game of anticipation. The color pattern emerge or melt away as we build. Can you figure the next step? How many pegs will you need?

Finally, you watch your creation unfolding in space and time. Soon you will discover that the same causal layout can support many temporal layouts too.

Please use your imaginations. Thorough discussion of Bird would take forever. Thank you very much.



Not sure if you tried to follow the links, but if you did, you could have noticed that Bird and Wires are different. In Bird the first peg pushes the fire through the link. In Wires the next peg pulls it. Compare positions of the numbers on the links with what you see when the record is running: in Bird the numbers are on the sending ends, in Wires they are on the receiving ones.

Early in course of this project I realized that I was making some kind of a "social medium". My first intention was to push fires forward in time, but just as well they could have been pulled. I either tell the senders which of their neighbors to set on fire, or subscribe the recipients to some of the available sources of ignition. The first order would allows to those standing earlier in the chain of command to boss the others around. The second order is called social nowadays (like if the bossing around was not).

If you studied graphs, you probably suspected that there is no difference between the bossial and the social orders. Indeed, I wrote a simple program to convert push networks to pull and back. I only need to tell to the simulator program, which I call The Time Machine, how to handle the links. The outcomes are always exactly the same. By the way, If you are not quite getting me yet, just read on. I will explain the difficult concepts several times, round by round and step by step.

Once the last peg flopped, the virtual energy is dissipated and the time stops. The Time Machine may keep ticking, but nothing can possibly happen unless we intervene. I can reset the board (hence recharging the pegs) and fire up a new chain of events. Or - instead of doing this again and again - I can enhance the model powering up the pegs and making them self-rechargeable.

I wanted to avoid complexity. The goal was to keep the model simple, and the user interface easy. You change what you see and and you see what you changed. No menus of options or pop-up property sheets.

I positively did not want to give the links any memory or logic. As for the pegs, they already had states, and they were in charge of counting the time to turn on. This left no room for any additions. Eventually, I decided to use one and the same number for all pegs. I named it TTG, or Ticks To Glow.

Please start the third record named Spirals and watch it until the color pattern disappears. Click on MORE if you did not do this yet, slow down the time using TPS, and restart. You will see that the pegs are diligently counting their intervals. Each of them was given 35 ticks to glow since it fired up.


Spirals, again, can be understood as another variegation of blue and yellow triangles from MAKE THEM MAD, this time with radially rotating colors.


Toying the time.

Simple layouts like Bird, Wires and Spirals are very easy to build. You just set up the colors and the tracks of 1s. Even TLG got the idea immediately. She was 4 years and 8 months at that time.

I regret I did not do much to support this activity. For the simplest 10x10 layout she had to color 100 pegs and number up to 800 links. It was easier for me: I saw the big picture, I was keenly motivated, I could program web browser and use general purpose tools like text editors with the columnar mode. For TLG I should have developed an attractive layout editor. Had we have it, she could have learned much more even before FIREPEGS.

The reason I left TLG behind was TTG. Once the pegs were "powered" to recover from hits, I could loop the chains and had them oscillate forever. And once I got oscillation, I forgot layout editor and other missing links. Toy dynamical patterns were much bigger game to hunt. Plus, I was already thinking about CODEPEGS at that time.

Below is another player, but let me tell you more about them first. The players are all the same, only the play lists are different. For every new players I scroll the list up, so the previous top titles fall to the bottom.

Let's walk through the controls. From left to right, you have STOP/GO. If you just watched Spirals, this place must be empty because the record had reached its end and can only be restarted from the link. The next comtrol is TPS, or Ticks Per Second, which you already know. It sets the duration of 1 for the links. With TPS equal to 1, it takes 1 second for a fire to pass through a link marked 1. Make TPS bigger, and your record will run faster. First time you start a record, it brings about it's favorite value of TPS. You can change it, and if you restart the record from the link, it will run at your pace. To allow the record to set its TPS again, select P (program) and click on the link.

Then you have TTG, or Ticks To Glow. In players it is FYI only. You can't change it (but I could). TTG is a limit. If there is nothing to apply, the time to glow is not limited. Hence, if TTG is empty, the pegs stay on forever.

The next control you know too: it makes the pegs semi-transparent, so you can see how they work. I will tell you more about it soon.

The last control, named SOFT, sets a fraction of a second, during which the colors of the pegs are changing. At 0% the changes are instant. Anything bigger makes them softer. Transitions, provided by your browser, are crude, but helpful - otherwise, some dynamical patterns in FIREPEGS can be disturbing for us grownups. Kids are happy with practically everything though.

On top of the list in the next player below there are four easy dynamical patterns. I would suggest you to view them one by one, trying to understand how do they juggle those fires. To make a pattern like this, you ask the design program (which you don't have) to create a new board. Next you set the colors, the numbers on the links and the number of TTG, which is the same for all. Finally, you touch some pegs to fire them up by hand, and turn on the timer. You can change TPS to adjust the speed at any time.

The record named Around features a very simple loop. Four pegs pass the color around.

Behind X-Blinker is the same layout started from 2 pegs. It will keep going like this forever.

Eight truly has a loop with two diagonal connections.

Blocks is based on the simple loop, in which two links have 0 instead of 1. A 0-delay link makes the next peg fire up together with the one, which is sending the fire. Several firepegs connected with such links behave like a single body.


If I was writing a book about playing FIREPEGS, I could have spent several chapters discussing building alternative layouts for these patterns, coloring them, scaling them, assembling them in a bigger structures. Instead, I am offering a single example.

Watch my hands. I created a new 4x4 board. I imagined a simple loop of 4 firepegs colored yellow-orange-red-orange (diagonal symmetry). I colored firepegs on the board to create 4 such 2x2 little squares, rotating them 90 degrees every time, so that the red pole of each is in the corner of the board. Then I connected the Northwest square in a loop clockwise, the Northeast square counterclockwise, the Southeast square clockwise and the Southwest square counterclockwise. Am I making you mad? It took 1 minute and 10 seconds. One more minute, and I had the record called Complexity added to the list.

Complexity is a dynamical pattern of dynamical patterns, and it is not terribly complex - it's just 16 colors and 16 1-tick links - but if I asked you to build it from just watching the running pattern, how hard do you think would it be? This is what the game of FIREPEGS is about.

All layouts in this chapter toggle the board to SHOW:MORE. Switch it to SHOW:LESS if you like.


Time to try your hand in FIREPEGS. The link is in the third paragraph.

As you probably noticed, the chapters here are bundled with the player, pre-loaded with the records. The records were made from the actual FIREPEGS program, which can run layouts and provides the tools to create, edit, save and transform them. This motley collection is a truly personal software, which means, it can only work if I am standing by. And it's a terrible programming, because it was my second JavaScript project, and I am not a software developer at all. And it's not done right because it has never been designed - it grew out of my experiments with the virtual boards and the rules.

I wrote the player much later, and made it for public consumption from scratch. It shows more, and it's just nicer to use. At first I was not going to publish FIREPEGS software at all, but in the end I spent three more months to work out a streamlined, slimed down web-app, mostly free from the programming horrors. I even made it user-friendly. At least, I tried.

Here is the link. The app is loaded with pre-built projects. It has help file (link HELP) and even two interactive lesson apps (link TEACH). The lessons has their own libraries of projects, and they are crude, please excuse me.

Combining the main app and the player, I created the challenger app. It shows the patterns, but no the links. You are supposed to load the colors and figure out how to bring them to life.

The purpose of this demo package of apps was to show how to use FIREPEGS and how to cheat the viewers' perception. Dynamical patterns are very deceiving. You can produce the same visual effects in many different ways. The main FIREPEGS app allows you to reverse engineer the patterns to reveal the networks behind them.

The apps have new modular control bars, functionally similar the player's controls, but easier to use. My vocabulary evolved too. I keep the word layout for the passive colors on the board, and use the word network for the linked colors, able to change their look.

I feel I have to explain how did this can of worms came about. Unfortunately, everything I know about computers I had learned when they were to enable us. In the dark age of disabling I am not quite at home. To begin with, I expected much more from web technologies. I knew they were the worst of the worst in practically every aspect, but HTML5 was reportedly cool, and JavaScript, I believed, was a programming language. I heard some people started using it for games and apps. In the end of 2013 I sat down to learn web-programming and make my visions true. My first big project was the counting app from SHNUMBERS. That's why it's so miserable.

Six months later, then FIREPEGS started kicking each other, I knew that web was barely good for this demo. Further investing in it deemed absolutely senseless. Switching to native programming, even for a single platform, was out of question too. Another year later I still would not get the apps right because I don't like "devices" and don't feel I am enabled using them. Meanwhile, I simply could not afford spending so much time on the side anymore.

My other early choices were total failures too. For developing layouts, I started using LibreOffice Draw. It was OK for drawing (not for TLG, of course), but there was no way out. I could not even produce a decent SVG, let alone to extract the pegs from their XML. I ended up making my own tools. Soon they broke Draw, and I abandoned LibreOffice for good.

I hope this explained why I am offering you only a player and the oversimplified app. In my personal software many essential components are all but missing and I am pulling the strings through JavaScript instead of creating slick graphical interfaces. The kernel part - The Time Machine - was being tortured for months, while I was playing with the rules. It badly needs a refactoring, but in the end I did not even clean it up, I only tested it rigorously. In the last year I have not seen any glitches running it for research, for teaching and for developing this demo. If there are any, they are now rules.

FIREPEGS, in short, is a pile of junk, but it's a usable junk. If I released it, however, it would inevitably reach the kids. Sadly, I am not in a position to turn the prototype into a products on my own. It's simply not realistic. However, a prototype of the toy is never a toy, and should not be used as such.

Last but not least, I see many ways to advance this toy. In this chapter, I mentioned new kinds of pegs and links with different behaviors, and provided the link to the chapter, in which I discussed them. In another chapter, I reviewed the ways to use the third dimension. In yet another chapter, I went through some (rather obvious) spatial and visual modifications, including non-rectangular media and warping the board to it's true toroidal shape.


But, really, it's just bad programming.

FIREPEGS in browser is taxing for your computer. If player does not run smoothly, you must have something, most likely a video stream, in the background. Conversely, the player may interfere with the other tasks. On my ThinkPad W530, full-screen MPEG4 video stream takes about 25% of the CPU. A whole 10x10 board record at 10 TPS without softening eats up about 5%. With softening, two such players may consume 30%.

Please note, however, that FIREPEGS are hard to run only because I programmed them in a certain way. Running natively on Windows, Android or Apple operating systems they must be very lightweight, even with the 3D plyboard extension proposed below.

The player support any numbers of records running on the same page side by side, but I decided to allow only two. When you start a new record, the system stops the longest playing one. Browsers (FireFox, Chrome and MSIE) are different, but scrolling or tabbing a running player out of view always throttles it down. Funnily enough, overlapping browser's window with something else does not. The moral here is, when playing with FIREPEGS watch your windows, keep TPS low and set SOFT to 0%, if you can tolerate this.

From funny to incredible. SHOW:MORE makes running player nearly twice as costly. For the initiated, no, I am not using innerHTML, but I can't exclude I am doing wrong something else. Back 40 years ago, who would believe what 3GHz computer of the future would spent 5% of its time displaying 900 digits 10 times a second? The people in computer industry are generating demand for their products better than anybody else. Imagine what life would be like if medicine was so good at that.

You are not going to use SHOW:MORE at 10 TPS, aren't you? OK then, you are now prepared to view two big looped records: Waves and Fireworks.


The static pattern behind Waves is simple checkerboard, and it's not the only way to set it on fire. FIREPEGS do bring new opportunities to the game.

Fireworks loops through gray pegs because they are no different from the colored ones. They turn on, off and send fires. You just don't see them acting unless you click on SHOW:MORE. The gray pegs in Fireworks delay the next shot like a fuse. There are other ways to do it.

Fireworking is the favorite subject, of course. Even I have several fireworks in my design portfolio.

Dynamical patterns are not necessarily toys. Our planetary system does one of them - or, rather, many at once. Life is just a bunch of dynamical patterns. Computers, other machines and the whole industries run in circles. So do our bodies. Our hearts beats, our food gets swallowed and digested, we propel ourselves replaying certain moves. Our society is periodic. The things your child do every day form a dynamical pattern. Like the time itself, dynamical patterns are everywhere.


How firestuff works.

To get an idea, please watch a record first. Any one of the top three. This pattern of motion is not exactly stunning, but it can be very hard to reproduce, and I built several challenges around it. On 3x3 board it's rather easy to solve.

Let's start with the first record. I assume you clicked on SHOW:MORE, so now you can see the delays in action. The central red peg fires up and tells the other pegs when to do follow. The pegs count to zero and fire up in the order, which was prescribed from the center. Finally, the last (the southern) peg fires back, and the central red peg sets up a new round.

Now you've seen everything. Let me piece together the picture of how firepegs operate.

Every peg can assume one of 3 states: idle, waiting and glowing. An idle peg is gray and has no number in the center.

The link numbers are always there and they do not change. The pegs receive the firing up signals through the links. To fire up a peg, the link must have a number on it. In social order the number belongs to the receiving peg, in bossial order it's a property of the boss. Any link is made out of two halves. It is bidirectional and it may have 2 numbers. If a number is missing, there is no transmission of fire in this direction.

If the number is 0, the receiving peg fires up immediately. Otherwise, it enters waiting state. In waiting state the peg counts back the ticks, starting from the number, which was supplied through the link. Please note that links are parts of the pegs.

Until now you've seen only 0s and 1s on the links. Every next peg fired up either immediately or after 1 tick. The first and the second inchworms are using bigger numbers, so when the central peg fires up, it programs the whole 8-ticks loop at once.

A waiting peg is not glowing. Once the count of the "time to on" is over, it fires up and start counting time to glow. That's it. Just few enhancements made the dumb firepegs, which you've seen it the beginning, a whole lot more capable actors, but all their inner work is in plain view all the time.


The second record is the same exact network in social order. The running pattern looks the same too. The bossial one must be easier to understand because everybody is a natural-born boss. Yet if you want your kids to be a boss like Mark Zuckerberg, Steve Jobs or Barack Obama when they grow up, use every opportunity to expose them to social order. The modern bosses evolved into spiders, as you know. Yet, even before the bossial times, thinking like a prey was quintessential for the predators.

The 3x3 Inchworm pattern may hide entirely different machinery, though. Skipping over transitional forms, I provided completely decentralized version. Except, just for fun, every peripheral peg in turn fires into the central one, keeping it glowing all the time.

Boards in Firepegs are toruses. The left side continues into the right side and back. The bottom continues into the top, and the top into the bottom. A corner continues into diagonally opposite corner. That's how the middle pegs in the brainless inchworm reach the corner pegs on the opposite side.

Remember though, before the brainless inchworm could walk, I had to invent it and build. There is no evolution here. Everything got to be intelligently designed.

I hope you noticed watching this layout that FIREPEGS allow to built various programmable control devices without programming. Something like Inchworm could turn on the lights or water. The links on the FIREPEGS layouts have nothing to do with the physical connections. They lets the operator to enforce the desired behavior.


Running a circus, staying out of view.

Fireworks record provided the first example of how the services can run invisibly, if not behind the scene. I've never bothered to prove it, but I believe that any pattern can be run on 0 and 1 tick delays, if extra pegs are available in the right places. Speaking of extra pegs, I meant the pegs, which are not needed to achieve desirable visual effect.

The same is true for TTG. Devices, built out of invisible pegs, can make the target visible pegs glow for more than 1 tick. In fact, they are even better. TTG was intentionally flawed. I just wanted to see if certain modification of behavior could be beneficial. It was not, but I did not fixed it because the difference should not show up in this demo.

The next top record named Waltz has long delays and most of the pegs glow for 2 ticks. Importantly, not all of them. Otherwise the global TTG would be good enough. In this record TTG is set to 1, as you can see. Please click on the link and wait. Like in the real life, it takes some time for all 8 feet to synchronize their "box steps".

I forgot to tell you: the red pegs flash on strong beats. I would have never believed it, but there is no sound in browsers. You can only play prerecorded files. Time and time again, I find web technologies to be just not intellectual enough for teaching kids. Imagine how this demo would look if I put it on Youtube.


The order here is bossial. Click on MORE and note the gray pegs popping up between the black and the white feet. They run the show.


A challenge of advanced synchronization.

Again, like in the real life, many challenging problems in FIREPEGS are due to the scarcity of resources, and the only resource in this game are firepegs themselves. In the top record named Chewing all the pegs are taken and there is no way to connect same color groups to let them fire one after another. Gray vertical strip might provide plenty of extra pegs, but I want a clean borderless solution because... this is what design is about.

Here is the big idea: if we can not fire up a yellow bar from a yellow bar, let's fire it up from a blue bar and vice versa. Now here is the big problem: the timing must be exactly right.


To get the timing right is not easy. One may even wonder if this is possible. A good starting point for a student can be a time-space diagram like the one shown below. It's a great learning opportunity, by the way.

Yes, it's possible, but... take a look. We can only establish some connections between two cycles, and the whole pattern will span 3 cycles. The links can't go back in time. That's why it was so hard to figure them out.

If I was teaching, I would have to explain more. For this demo I only wanted to demonstrate what can be taught and learned while solving such simple problems. Some of them make me think about virtual instruments, like oscilloscopes and logic analyzers.


What You See Is Not What I Built and other new maddeners.

FIREPEGS was conceived as a toy. You probably realized that, soon after I got The Time Machine running, I found FIREPEGS to be a vehicle for a game of challenges too. By the way, there is nothing artificial in this approach. Kids challenge each other all the time. It's a naturally occurring dynamical pattern of their behavior.

Playing MAKE THEM MAD as a parent was not easy. I spent more time preparing the sessions than running them. Executing the plans, I often had to work around my mistakes or improvise new strategies, not to mention coping with a maddened toddler.

FIREPEGS demanded much more, but in the end I liked it. Let me tell you why.

First, in the beginning it's very easy, and it is gradually getting hard. Granted, dynamical systems are generally challenging, and many, if not most adults are not prepared to deal with them. I worked with dynamical systems most of my life, and I am still not getting this one. Whenever I try to imagine FIREPEGS layout for some non-trivial purpose, I fail. It always takes playing with The Time Machine to get anything right. Most of the tricks and solutions demonstrated here (and more of them not even mentioned) I found empirically. To tell you all the truth, it usually started from some brilliant speculation only to prove it to be stillborn, but on the way I could find something useful.

The second reason is WYSINWIB, or What You See Is Not What I Built. Take Chewing: didn't we see it in Waves? Yes and no. Waves were built out of diagonal bars. Diagonal bars are full of holes. The chain of control could go through like the opposite color was not even there. In Chewing we had straight horizontal bars. You can not fire through them without firing them up. The final solutions was quite different from the obvious (and the impossible) one.

The third reason is unintended consequences. Trying to reach a yellow bar from another yellow bar firing up a blue bar sitting between them would be a possibly unexpected outcome.

Here is a more convincing scenario. Suppose you challenge your student to build Hourglass 8. In challenge mode they can see the running pattern, but not the underlying design. No matter, the solution could not be more obvious.

OK then, can you build it on a smaller 7x7 board?

Attempt to use the obvious solution ends up in total mess, which, strangely, finds its attractor. See Hourglass 7.


Every time the central peg fires up, it sets on fire both pegs linked to it, while you always want to proceed to only one of them. The tracks are like two electric wires crossing and touching each other. A novice firepegger will probably declare this dynamical pattern unbuildable. Trust me, there are several ways to fake it, so you can demonstrate a working layout. Once I could even do it with straight intersection.

The fourth reason I liked FIREPEGS is emergence (not emergency). Consider Colors record, but first give it some time to heat up. If I could make the pegs one color pixel small, the whole screen would be changing its color. Computer displays usually have only 3 colors, and their spatial arrangement can be weird, but I could get close.

Naive solution would be to connect same color pegs with zero delay links. This does not seem possible.

I built 4-color squares and let them oscillate synchronously, firing up each other.


FIREPEGS as animation controller.

Back one year ago, when I just started playing with FIREPEGS, I came across this pattern and thought it could have made a challenge.

At that time I just started thinking about challenges in FIREPEGS. It was not at all clear how challenging could it be. My solution (see Rain) was based on vertical stripes. It was WYSINWIB, or What You See is Not What I Built, as I came to call this approach later. Time, not wind makes the visible tracks diagonal. I was not even expecting that a challengee could have actually built what she or he saw.

Soon started producing the challenges, which were reasonably impossible to build as they looked. Several man-months later I came to the conclusion that the game of FIREPEGS was possible, and, even in its current implementation, could be challenging for the new users of the ages from 5 to 12. It was much more than I expected. However, I am not sure yet how quickly a persistent player can exhaust it. TLG has been instantly intrigued, and she did not advance much yet.

Rain is, essentially, a time sweep device, not unlike an oscillograph. A variety of dynamical patterns can be produced changing only the first row of pegs. For example, two fires running to the center made Chevrons.

I drew a rough image by hand and turned on The Time Machine. The resulting record is next under the name Fish.


The animal does not look cute, but I warned you in the beginning: firepegs a merely spots of light uncovering pre-existing static picture, which, in this case, is all blue.

We can create a solid colorful fish and move it, using FIREPEGS for what they are good at. Imagine a picture built on a separate overlay board. It can have any colors and resolution. In the end, pegs are just pixels.

Now suppose the picture board follows a track of firepegs, built on the main board. Firepegs would be telling the picture board where to go next and control the backlight, turning it on of off, maybe, even mixing the colors making them a part of the game. We can attach any kinds of additional commands to this chain. Obeying them, the picture board may, for example, rotate, mirror, flip or switch between alternating layouts. The main board may change its background picture and play the sounds too (provided that it will be implemented for the target computer, not for the browser).

In short, using FIREPEGS we can easily do everything the popular children's computer programming systems, particularly cultivated by MIT, usually do, without even mentioning computer programming. And it will be easy. Just think that developers can create the motion paths, and then snap the picture boards to them.

In CODEPEGS I provide a chapter on FIREPEGS. I did not intend it to be a computer programming system. On the evolutionary tree of information technologies, I prefer to see FIREPEGS next to the modern cam timers and the ancient mechanisms, playing music and moving dolls according to the pins on the rotating cylinder. Computer allows to do more, but why make computer in computer, instead of learning to use those we already have?

I mentioned MIT's systems because I don't believe most of the kids create more than that in, for example, Scratch. Move a sprite, play a drumbeat. Look Mom, I learned computer programming. May I play Minecraft? Of course it's not computer programming, and, sadly, they do practically nothing to teach it. At best, they try to motivate the students, apparently assuming that every kid wants nothing better than producing animations.


The answer to every need.

Adding firepegs could solve many known problems, and, likely, open the way to the new ones. We can do this extending firespace to the third dimension.

The idea of solving problems by design my seem irrelevant to a game. The only purpose of FIREPEGS is to be challenging. We don't allow chess knights to go straight, no matter how pressing is the need. Yet I will be willing to explore new areas. After all, those are just options. We can turn them on and off.

Let's start from the fully 3D toy, in which every firepeg would have 26 connections to its peers. We can easily imagine building 3D layouts and watching dynamical patterns. Obviously, the pegs must me small enough to allow us to travel in the interstellar space.

This would not necessarily provide the ultimate creative freedom, unless we escape into 4th dimension, which we can do too. In general, before firepegs solve the problems, they make them. If we want to bring about one more peg and cannot, that's because some other peg is already here. In 3D space a straight plane would be just as impassable as a straight line is on 2D board.

Staying in 2D, while being able to use 3D, would be more tempting for a lazy mind like mine. 3D FIREPEGS would allow to place the elements on top or below each other, creating over(laying)boards, underboards, sub- and super- boards, as well as hyper- and meta- boards. Did I remember them all? Anyway, these familiar prefixes can also be applied to pegs and links.

Not all such devices deem valuable. Some may produce more problems them solve them. Others can be easily emulated. For example, a longer link can be built as a chain of pegs with zero ticks delays. Here are some worthy of attention.

Super firepeg looks like a firepeg, but has several connected firepegs inside. External links belong to internal pegs. This implies that superpeg's links are functionally different and must be used appropriately.

Please play the record named A Superpeg. There are 4 pegs on the board. For your reference, I will number them from left to right and from top to bottom, starting from 1.


Two bottom pegs 3 and 4 are connected in a circular manner, and start oscillate as soon as any of them gets fired up trough its inbound links, or just by clicking (which is not available in the player, of course). In the record you see me clicking on peg 3. It immediately fires up peg 1 and sets peg 4 to fire up after 1 tick. Then peg 4 fires peg 3, and so forth.

The oscillating pegs keep peg 1 on. More precisely, after every tick peg 1 shuts off and immediately fires up.

Peg 2 stops the oscillation turning both pegs 3 and 4 on at the same time, so they can not pass the fire to each other. After several cycles I click on it and then restart the cell.

Complete device can serve as a multivibrator and as a memory cell at the same time. It has two internal states: off and oscillation. Remember though, it's not electronics, and firepegs have never been intended for information processing.

Another desirable addition would be plyboard. It would comprise several flat boards with occasional vertical connections, much like a multi-layer printed board. The picture on the left shows another superpeg, this time carved out of a plyboard.

This stack of pegs superficially looks like a single peg. It solves the problem of hourglass-shaped track with a central peg. The superpeg can pass the fire between Northwest and Southeast and between Northeast and Southwest independently, without unexpected and unwanted side effects.

Remark that plyboard does make colors a part of the game. Northwest-Southeast passage blinks red, Northeast -Southwest blinks blue. Simultaneous firing would produce some kind of magenta. The upper peg is still partially available, by the way, and it might blink its own color. I assume that the pegs are transparent then turned off.

Moreover, with plyboards we finally might be able to change the whole image and - to some degree - to reverse the time.

One more 2½ solution would be "folding" the board to hide some rows and columns like spreadsheet programs do. The idea does not appeal to me, but it's probably inevitable.

The third enhancement could be truly game-changing. Let me call it metalink. Metalink would connect firepegs with the boards. What's the point?

The point is, the boards have simple controls, which can be operated from firepegs. Speaking of the boards, I mean those controls and nothing else. A board can carry one peg, yet without it the peg would be just a peg.

Arguably, the most enticing control is the button called TICK. Firepegs are hardwired to the system timer. Creating structures driven by external events is tough. You've seen a superpeg, which can be turned on and off. I managed to assemble such superpegs into registers. It is possible to do some computer-like tricks, but they are far cry from Turing machine. Metalink a firepeg to TICK button on another board. Instead of system timer, the second board will be driven by an external dynamical pattern.

At this time I don't know how to buid something like the counting app from SHNUMBERS using regular firepegs. Access to TICK button would solve the problem instantly. Want to switch from addition to subtraction? Hook up another button, which toggles The Time Machine between social and bossial orders.


FIREPEGS can teach time and space directly, but do kids need them?

I could have been blessed with particularly dumb children, but I repeatedly found my American students to be startlingly ignorant about space and time. Ignorance is probably not the right world, phobia could have been better. A school-induced phobia, I suppose. But, to begin with, they did not live in space and time in a way we lived when I was like them. The modern kids travel through wormholes. They enter a car and plug their heads into video-audio streams. Away from the car, there always are grownups to kick their butts at the right moment and in the right direction.

I thought I was very lucky when I understood that FIREPEGS was a natural extension of MAKE THEM MAD in the most general sense. The later was, essentially, a game of space, which lead TLG to figuring out Cartesian plane. FIREPEGS added time.

Spatiotemporal value of FIREPEGS occurred to me just several months ago. Before that, I associated FIREPEGS only with calculations. Obviously, FIREPEGS can do addition, subtraction, multiplication, division and other shnumberings. Without CODEPEGS it may be clumsy, but it's a pegbboard, after all. What stroke me as unexpected was velocity.

To get a slight idea of what might be possible, please watch the record called Tracks. Which color is the fastest? Before I forgot: and please pay attention to the control called TPS. Upon closer examination, it knocks off the socks.

Trying to make such patterns, I realized that FIREPEGS needed some more tweaking.

First, it would be good to have zero-TTG pegs and hold-on pegs. I will explain them later.

Next, only thinking about space and time I understood how disastrous was my decision to use Javascript for this project. It seems so natural to script the board. There is the button called TICK, as I told you. So, instead of turning on the timer, we can just take control. Send a tick, wait for 1 second, send another tick, check on some peg, etc. That's how it would be practically anywhere else, but not in web browser. In web browser pretty much the only solution available to concerned citizens it to hire a JavaSctipter. Or, better, a bunch of them.

In CODEPEGS you will see me cursing web-programming ad nauseam. In FIREPEGS I silently tried to work out a solution, and I could not. The problem is very well entrenched. The best that I could think of were pre-programmed devices plugged in the board like pegs or invisibly attached to them under the surface. Imagine, for example, a fire counter (it could also count ticks). Or a programmable semaphore peg, of a railway kind. Or a sound player on the finishing line.

Sorry, except for zero-TTG pegs, I did not have time to program any of those. I wanted to finish this demo first. It was already taking too long.

To support my claims, I prepared two more records named Race and X-over. TLG was not getting this concept. I printed little stickers and put them on the floor between the tiles. We walked along holding hands making one step at a a time. I asked TLG to explain why the outer walker kept falling behind (and pretty far behind, given that the tiles were 12 inches big). She could not. We did it again, until she clicked and answered that the outer track was longer.


Race is a one-timer and it starts stopped. Click GO to play it once, then reload from the link. X-over would look much better if you make the player SHOW:MORE. I need a simple modification to make space-time tracks always visible.

Remember I told you that the board it really toroidal? The circular motion is already here. Fish could have been a picture on a rotating cylinder.

Here is another challenge. I flattened the torus in only one direction. You can also think that this is a familiar square board 10x10 curved into an annulus.

Believe or not, the meaningless ugly pattern on the ring you know as Spirals. This transformation of the bord demands different symmetries.

Even without fire, computer version of pegboard offers many wonderful opportunities. We can use big and very big boards, or turn the pattern of holes 45 degrees, or make the pegs triangular. Or we can play on 3d torus and manipulate it. Or how about settling on a sphere and tiling it with plyboarded pentagons? On the surface of a parallelepiped pegs have different number of neighbors. Depending on the dimensions, it can be from 4 to 8. Unfortunately, I cannot afford even to discuss such things. I need to finish this demo in the next couple months. But I hope you now better understand why I gave up trying to turn this prototypes and ideas into products.

Just one more digression: looking at the ring, did you think about those digital LED-lighted fans? I did. I can not exactly replicate them because computer displays are not so bright, but I can simply draw what they can draw. We could also program such fans in FIREPEGS. I've seen a monochrome fan with computer interface for downloading text messages. The toy is begging for a simple user-friendly tool for designing dynamical color patterns, which I already have, and bringing them together would be only a matter of programming.


Long, long chapter in three parts. None of them makes any sense.

Irrationale 1: A CHEAP PLASTIC TOY

The call it hardware because it's so hard to make.

The secret reason, which affected all my early design decisions, was too ridiculous to tell, but now is the time to crawl from under the bed and admit: I wanted to keep the door open for a cheap plastic toy.

Cheap plastic reflects my desperation over the modern English words usage. Everybody understands what is virtual, right? What is not virtual? Real? But any virtual toy is real. In commerce they ended up calling "real" stores brick and mortar, even though they are full of computers. Likewise, FIREPEGS toy cannot be made out of cheap plastic only.

The distinction is really about the user interface. If people shop using mice and monitors, that's virtual. If kids grab pegs and stick them into the board, this is cheap plastic.

In MAKE THEM MAD (in the chapter named BETWEEN THE STACKING RING) I explain why I would always prefer a cheap plactic toy to it's even cheaper imitation with traditional computers or touch "devices".

Speaking of "devices", my kids had virtually unrestricted access to tablets, and they liked them at first, but quickly returned to PCs and the wires. Why? Nothing to play, they said. What? Every day I've been reading about billions of users enjoying XXI century games like Angry Birds. I downloaded one release. The kids barely looked at it. I did, and was ashamed of myself.

When I started thinking about computerizing pegs, I had two options in mind: a virtual pegboard simulated through the standard computer interfaces like screen, touch panel, stylus and mouse, and a cheap plastic one, with embedded or connected computer.

I even considered building a cheap plastic prototype, but realized that it would not be a toy. A real toy would requite a real industrial design and manufacturing. Software would be better for prototyping than a string of Christmas lights.

Pegs can be just cheap plastic color caps. The biggest problem is, of course, links. On 10x10 board there are 800 of them. I am not talking about a kind of telephone switchboard with patch cords. Early digital and analog computers were using this technique for programming too, but no, linking as such is not necessary anymore.

Like in computer simulations, which you see on these pages, everything is linked by design. We just need to activate some links. Any inexpensive, reliable and children-proof method to report to the board and to display to the users several states (OK, just two or three) would do. Even one button and one LED light per link.

Sure enough, there is plenty of such solutions, but they are not cheap and children-proof. Likely, the best one would be to assemble layouts of passive mechanical elements blocking, deflecting and reflecting light. Next step, which was discussed in ROBOPEGS, would be computer vision. Any camera, found in a modern telephone, would do the trick. The desired layout can even be drawn.

I briefly mentioned two other design rationales elsewhere: to simulate a social medium and to make it impossible to build computer from FIREPEGS. Strangely, they often yielded the same decisions. If you read the next two subchapters and follow those leads, you may understand why human intellect amassed in Facebook and Twitter is so brilliantly fruitless. It does not look like they are going to stop global warming, find a cure or fix Washington, does it?

Irrationale 2: BLINKER

Attempt to explain FIREPEGS as a technology phenomenon.

Let me tell you something important first. I don't quite know what are the social media because I am staying away from them. My reasons are strictly personal, but at the time when everybody is expected to register in the database and submit computer-readable illustrated self-reports several times a day, my avoidance must seem suspicious. You may think I am hiding from the government, or am not "computer-savvy" at all. Click here if you want me to explain.

Anyway, the analogy with social media was too tasty to ignore, and it might help to explain FIRIPEGS. But who could be the members of my social network?

The obvious answer was fireflies, and it was not fair. Fireflies are smarter. They know that nets are for catching them, and they learned to send out their signals without those helpful spiders. They don't even need power outlets to charge their batteries.

To model means to simplify. Suppose there are fireflies just smart enough to pursue happiness, and flashing their colors makes them happy.

Now I could explain: I take this social medium - the board - and populate it with unhappy fireflies of assorted colors. They are desperate to display themselves. They only need a cause.

I am the superuser soaring above my unhappy fireflies in the cloud, ready to watch the big picture, which they don't even know they make. But first, I set up the links.

Wait, aren't they are supposed to link themselves?

Remember, as a social medium operator I have the business model, even if an imaginary one. I am getting paid for messaging fireflies. In the first approximation only my messages count. Fireflies can all be computer-generated fakes, but even if some of them are real, it does not matter what they do in their spare time.

From my position in the cloud I am linked to everybody. I can hit any firefly, or many of them at once, with my high priority 0 ticks messages created from my mouse clicks. Then I turn on The Time Machine, sit back and call my clients: look guys, your advertisements work.

I can advance the model later, giving fireflies personalities, behavior, even some intellect to count with. Not too much, just enough to like. They must firmly believe that this is their network.

Back to business: setting up the links, I subscribe some unhappy fireflies to some others. It's totally up to me. Once I did it, I've got a social network. May I call it Blinker?

Subscriptions are for passing fire. Fire in this game is... well, fire it is. Fireflies want it. They can not create it. Initially, I send them fire from the cloud. Then they can pass and share it around.

Unhappy fireflies do not need fire as such. They long for it to get attention. Attention they crave, and use every opportunity to seize.

Unhappy fireflies do not maintain fires beyond the limit set through TTG. They catch attention at the moment they turn on. To catch it again, they turn off, even if they have nowhere to pass the fire. They have very limited idea of common good. Firefly waits for the fire from its providers, turns on to blink its color, lets the fire available to its subscribers, if any, and shuts off. This is life.

Unhappy fireflies do not care why their neighbors fire up, there they are located and how many of them went on. All chances to get on are the same to them, except for the fact that every incoming fire has a wait number attached to it. Upon reception of a fire, firefly has to count ticks down to zero before glowing. You've seen them doing this.

There can be many reasons for delays. Some providers may impose embargo, or their fires may just take time to process. Suppose you blink on scientific journal and on football score. Whatever the cause, a quicker gratification will always be preferred.

Irrationale 3: TURING SHMURING

FIREPEGS is not computer. No, no, no!

My next rationale was: make it impossible to use FEREPEGS to build a computer. Unfortunately, about computers I know even less than about social networks. My experience with central processors is negligible and heavily outdated. I loosely understand that a board of firepegs may have unlimited number of states because it's size is not limited, and if somebody will be able to use it to build a Turing machine or an equivalent device, FEREPEGS is a computer, period.

I don't understand how to prevent such development or how to prove that it is impossible. Such prove is, probably, not possible itself, but I am not sure. I could only follow my uneducated intuition.

In the beginning it sort of helped, or, at least, provided some consolation. I could tell myself that it's perfectly fine that I don't see any way to build a gate in FIREPEGS. It's not digital electronics, it's just a silly game, mimicking a child's attention. Don't try to turn firepegs into integrated circuits.

With time I reached a conceptual swamp, where left was right and right was wrong. The intuition started failing me. Here is an example.

A firefly, which entered waiting state, continue receiving fires from its neighbors. Should they be ignored, or what?

The fires could have been remembered (enqueued) and used later. This seems like too brainy, both for fireflies and for their operators. Besides, who cares for yesterday's blinks? Not to mention that storing fires did not seem to be a good idea.

This said, a member of Blinker social network would not want to miss an opportunity to become happy earlier. Blink instead of wait, and you may get another chance. A shorter wait must interrupt a longer wait. An equal or longer wait must be indeed ignored.

No-computer line of intuition suggested: ignoring new signals would effectively turn firepeg into a gate, and gates are required to build computer.

Now what if firefly is happily glowing yet? Should it catch another fire?

At first I thought it would be inhuman to make fireflies work while they are happy. My no-computer intuition was against humanization of fireflies, but I convinced it that there would be no breach of unusability because every firefly had the same TTG. They still do.

Besides, a gate would be something that I could open, close and hold at will. A glowing peg is much less. It would only skip some fires. And, as I was accumulating solutions, I realized that I already knew how to suppress fires for some predefined time, and this did not help me to build Turing Machine.

When I started warming up to the idea of per-peg or per-fly TTG, I came across another consideration. There were good reasons to believe that fireflies got excited, had fun and became happy for the first tick only. Ongoing glowing could have been even boring for them. Hence, interrupting glowing to open firefly for another moment of happiness appeared perfectly ethical.

I hope I said enough. You now know that my rationales, while not entirely groundless, were not rational.

But then, it was a game. I cared much more about rationalization.

Regarding Turing Machine, I thought the tape would be the most challenging part and tried to make it. The only illustration to this chapter demonstrates two registers. They can be as long as needed (provided that the board is big enough). Diagonal placement is to allow more connections. Even with that, I could barely fit all I wanted. On plyboard it would be easy.

I could only use phase coding of the most straightforward kind. The initial code, which I set up with the mouse clicks, is 0011100011 or 1100011100, depending on what do you think is 0. The empty or blank state is stable for the whole register only. Otherwise it gets filled. Hence it makes no sense. To make it perfectly clear, the cells (bits) oscillate between SW and NE

Blue firepegs are oscillators, storing the code. Green tracks shift the code (slowly but surely). Red tracks blank the register, and it inevitably receives the code from another one. The yellow (intermittently visible) tracks are controls, synchronizing the action.

The name of the record is Tape. Below is the synopsis.


SW register starts loaded with the code. NE register starts blank and receives the copy of the code. I let them oscillate for 6 ticks and initiate a shift in NE. The code slides in the direction from NW to SE, dropping one bit. Follows 6 more ticks, then the second shift. Consequently, 2 bites are lost. In 15 ticks after the end of the second shift the control circuitry activates the red track, blanks NE and lets it get a copy of the original code from SW.

Another 6 ticks, then 3 shifts in SW. The code moves from SE to NW, and there are 6 ticks between the shifts. In 15 ticks the control circuitry delivers the blow blanking the spoiled code and allowing SW to obtain the saved copy from NE.

This project reassured me that building a Turing machine of fires is hardly possible yet. But if I had much bigger board, slightly better layout editor and more experience with synchronous systems, who knows.


My wish list.

Hope somebody is already thinking about modifications. Trust me, I have the long list of them, and found most to be harmful or ill-motivated.

We are pre-wired to improve things, making them easier to understand and operate, but why do it to a game? Consider chess: would not it be sweet to allow knights to move straight if necessary?

Some other mods are just redundant. FIREPEGS design program already offers unnecessary functions. Instead of functionality I could add connectivity. Often, we can build slow links, cascading the fast links, etc.

In the first chapter I told you that I wanted to keep the interface immediate, and I still do. I want the design and the status of the system to be available at a single glance. This leaves little or no room in the central square. Currently, firepegs have no text to show when they are idle. They could show their local pivate TTGs then. Yet running or paused firepeg would show remaining TTG while glowing. I am still not sure if I want private TTG, even though it is very easy to implement.

Links are much more inviting. They can be differentiated. Again, the list of options is more or less obvious. For example, I could allow links to extinguish fire (together with infinite TTG, this can be just what the doctor ordered to build computer). Or what if some links would forward TTG? Or color? Or completely exchange identities between the source and the target peg, hence allowing to alter the picture? Did I mention giving the links some memory, so they could hold the fires if the target is not available?

Here are few modifications, which I hold high in my wish list.

Geometrically correct timing (an option). The time to pass a 1-tick diagonal link must be equal to 1.4142135623 7309504880 1688724209 6980785696 7187537694 8073176679...

Two-color pegs. Well, they are two-colors, but one color is always gray. If I let the pegs have their own idle colors, this would allow to change the visible layouts to some degree. Modification seems very easy. That's why I did not get to implement it yet.

Picture stickers everywhere. Is not worth talking, really, but currently if I put a sticker on the peg, The Time Machine would eat it up in a tick.

Zero Time To Glow (zTTG) pegs may be a special case of private TTG. Such pegs would never display their colors, so I make them glow when they wait. Unlike the regular firepegs, zTTG pegs have 2 states.

Zero TTG is different from zero ticks delay because firepegs disseminate the fire as they switch from waiting to glowing state. Zero TTG peg glows for certain number of ticks, then shuts off and immediately fires up it's zero TTG neighbors. The links are the same. Zero TTG pegs and the regular pegs can exchange fire.

You may think that zTTG are downright better. They can form a display to move pictures. The chains of zTTG pegs are much easier to track, especially for small children. They are just simpler, after all.

Unfortunately, zTTG are also more prone to racing, they reveal The Time Engine and drive it into infinite loops. Two relaxation periods make the regular 3-state firepegs nicer in many ways.

You probably did not think about it, but, after much playing and tweaking, the regular firepegs were made kids-proof. They don't let me down anymore when I connect and torture them wildly. From time to time I don't understand what my own layout is doing. Invariably, I find that this is just my stupidity. I am not a spider kind of man, able to think for many flies at once.

Regarding zTTG firepegs, I can plug the holes with the rules, but I am not ready to rationalize the resulting behavior. I just need some time to come to terms with my neural network.

Lastly, I want stackable links. The function can be hold-on or fire-back. Either way, the fire would go forth and back, much in a way the flow of control reaches through the stack and returns. If you know computer programming, you probably got me already. If you don't, it's just too much talking for a demo.

Very briefly, suppose you call somebody and do not disconnect until this person allows you to go, or you request a call back when something is done. Now imagine such interactions stack up. Any number of people may be waiting for each other on the phone, until the last one lets them disconnect one after another. Or there may be a wave of callbacks.

For firepegs this can mean that a whole chain is glowing until the last peg's TTG expires, and then the links turn them off in reverse order applying their respective delays back. Or the chained pegs pass the fire from the beginning to the end, then shut off, and then pass the fire back from the end to the beginning.

The visual effects, produced with the stackable links and with the private TTG bigger than one, can be easily faked with additional pegs (plyboard, superpegs, etc). Yet I don't know how to imitate zero TTG, not to mention that intuition demands such pegs to be simpler.

I want stackable links because of their educational value. The record named Reciprocal was made to explain what I mean.


I only wanted to pull those triangles in and out in a reciprocal kind of motion. Gray lines pop up because without stackable links there is no way to do reciprocal motion in FIREPEGS, unless by faking it hiding those pullers inside a plyboard. The wave of changes just don't go back in time. There could be ways to fake reciprocation in one level, but I could not find them yet.

There is absolutely nothing wrong about it because in FIREPEGS there is no motion at all. The objects are firepegs, and they stay in place turning on and off. The illusion of motion emerge if the changes follow each other in time, and our time never turns back.

So, first of all, it can be just a game of faking material world like you computer display or TV do. The pegs - the pixels - do not go anywhere, but they produce illusion of motion.

Every pixel on your screen is operated by your computer, and you can do with them whatever you want. Firepegs are different, they kick each other on their own, but in the end they are programmable too. The question is, how to make or fake reciprocation through the links and kicks.

Most importantly (for me), a combination of regular and stackable flow of fire would be what we usually have and use in computer programming and call the flow of control. In fact, the linear flow, which you see in the records, happens only on very low level nowadays. At minimum, any program receives control and returns it through the stack. The game of FIREPEGS is essentially parallel, but with stackable links FIREPEGS layouts will be able to behave like a sufficiently complex single-processor computer.


The oscillating media.

The fact what Hellenic word aether was directly related to fire was probably obscured even in Antiquity. Later Greek philosophers counted fire and aether as two separate elements. Guess they would name firepegs aetherpegs. Indeed, firepegs are not hot to touch (despite the browser's ability to burn computers running my dynamical patterns). Meanwhile, Aether, through the history of science, was associated with motion, even when it was suspected to be crystallized. Guess, Ancient Greeks had no idea that heat is motion too.

For the several days I spent all the time allocated to this project, playing with Golly. Golly is a program, which transforms the patterns of cellular automata according to their rules. The most popular set of rules is so-called Game of Life, or GoL.

GoL was made public in 1970, and reached USSR, where I was born and lived as long as it existed, almost immediately. The vehicle was Scientific American magazine. The intellectual atmosphere back then was substantially different. Science was considered to be the most important driving force. Compare Scientific American now and then, if you did not notice how the world has changed.

Anyway, at the time I learned about GoL, I often commuted by trains at off-peak times, always having graph paper with me. I did not have access to computers, even though they were available.

Soon I found myself playing GoL in a way invented by American mathematician Robert Wainwright. I began with the space covered with some stable pattern with minor impurity, typically just one added peg, and watched how the universe was corrupting.

For example, the pattern of 2x2 squares placed 1 step apart will exist forever unchanged. Introduce a spoiler cell on a crossroad, and the pattern will repair itself. Put a spoiler cell anywhere else, and the pattern start burning. It's not destruction though. Some low density material is always left behind, and it's stable, even if oscillating.

Last time I was on the kitchen computer until TLG came from preschool and kicked me out just when I was going to send a squad of gliders in a pattern of oscillators. Minutes later I saw her scribbling her name (in cursive) and burning it.

I gave up because I did not really have time to play. I just wanted to compare FIREPEGS with the classical cellular automata one more time. Those were another thing, which I did not want. Cellular automata were not in my design rationales list only because I had no idea how to avoid them.

Firepegs are more complicated than classical cellular automata, which makes them manageable. They can lend themselves to a game of challenges, as you could see. GoL is a game by name only.

Simple layouts in FIREPEGS generally behave as expected. Multiple intersecting paths become mischievous, and the difficulty of predicting and understanding them seem to be superficially similar to those human are facing in GoL, which was believed to be unpredictable.

GoL changes you forever. You understand that the whole our world, where you can leave a body resting or moving uniformly forward in a straight line, and found it one million years later still resting or moving it the same direction with the same speed, provided that it is remote enough from us not to be disturbed or observed, can be such kind of "game", and we can only know the future if we live to see it. This admitted, I don't understand how GoL can be interesting for the kids. They know too little about all the stuff we learned to predict, to appreciate unpredictability, or even to wonder how anything so simple can act so wild.

GoL allows some engineering. The devotees have discovered a number of weird "devices", which can be used to build even weirder structures, but all those contraptions are just out of this world. Or, maybe, the GoLers still don't play big enough.

FIREPEGS can be a very restricted form of so-called coupled map lattice, but I did not dig deep enough to tell. Once again, it's just a toy of many uses. I don't expect mathematics to be interested in it.

I don't know much about FIREPEGS, partially because I have barely started using the computer to explore it. My current implementation is very limited and limiting. Apparently, in FIREPEGS more can be done in less space. What's the measure? OK, let's say FIREPEGS delivers more fun per square. Which is not correct, because every firepeg occupies 9 squares.

Very early - practically as soon as I introduced Time To Glow - I remembered my experience with GoL, and tried to patternalize the space pre-coloring and pre-connecting the pegs in some regular way. Regrettably, I could not find much time to explore the fireworld in this direction, but I have something to show.

I created a number of good challenges based on emergence, and there is potential for more. Several examples are found here in the records. Waltz, for one, can be extended to infinitely big hall pre-filled with feet and controllers. Fire up one peg, and, couple after couple, the box step pattern will spread around.

The other extremity is to give every peg the same color and to pre-fill every link with the same value. Essentially, this kills FIREPEGS. The rules become the same for every peg, so the links can be disregarded. Yet, even stripped of their diversity, firepegs are different from GoL cells.

GoL is explained as a community of single-cell creatures, all alike. They can live forever if conditions are right.

Fires can represent a higher form of life. They are time-aware. Their relationships with their neighbors are more relaxed. They die and leave seeds. Consider what's going on between two mutually connected pegs. Let's suppose both links are 1 tick fast and TTG is set to 1. You click on one of the pegs and it appears. One tick later it dies, but it dropped the seed to the next spot, and now you see another fire, which has already dropped its seed back. That's how they oscillate.

For the record named Simple I made 3x3 squares where every peg is yellow and every link is 1 tick fast (the pattern of all 0s is trivial). The squares are not toruses. They are just rectangular patches.

If I fire up any peg, the square, to which it belongs, will start oscillating. Click again, and the pattern of oscillation will change. At first it seems that you can get any oscillating pattern you want, but no, some changes will be automatically corrected. Firing every connected peg at once stops the oscillation entirely.

Two-phase oscillations are boring, but there are ways to create more interesting dynamics. The record named Fancy was taken from the board with four identical sub-boards. The Northwest pattern emerged from two fires (it could also be morphed after being started from one), and it has only 4 phases. The Southeast pattern has 12. Note that only two patterns retain their initial phase. Two others walk away from it and loop elsewhere.


These patterns may look like super-challenges (and they are), but, upon closer examination, I see that I could built them on purpose. Imagine though what can be achieved framing several oscillating sub-boards as a single pattern. I even started thinking about design method and computer program to support it.

Such ephemeral dynamical patterns may give rise to a new game. The goal can be to morph an oscillation using a minimal number of touch-ups. I tried, and found that the "fancy" layout, which is rather simple, is not easy to manipulate.

The simple overconnected layouts are so easy that TLG immediately started exploiting them. I made a collection of simple 2x2 patterns for her to learn. She understood that she could avoid the toil of intelligent design, creating and shaping the wobbling jelly. I had to put forward additional conditions like you have to get this pattern using only two 1-links and two 0-links. With bigger layouts the opposite is true yet: they appear to be easier to design on purpose.


Firepegs can say something.

FIREPEGS tracks can be shaped as letters, and, in some cases, such designs can be even useful. I took the record named Four 4s from the layout, which I made because TLG developed a weird way to write this digit. Her 4's color is green.

I asked if she learned it at school. She said no, and showed me how her teacher wrote 4 (that's red).

At first I thought my way to write 4 (which is blue) was obsolete. I learned to write with dip pen, and, like every other child, carried inkwell to school and back. It turned out, mine was still the recommended way in the US too - or, rather, was then they taught cursive.

Anyway, drawing the lines from here to there, now and then, is exactly the job for FIREPEGS. I could have made my "Hello, World!" this way.

If you don't know what is "Hello, World!" you may find an extensive article in Wikipedia. Not sure why this phrase got associated with computer and programming. The intention was to make computer do something very simple. Yet printing or displaying "Hello, World!" is not a specific ability. People did it way before any kind of computer was available.

The game of FIREPEGS is not computer. Not more than Linotype machine. If it is, that's purely unintentional and accidental. Yet I can do "Hello, World!" in several interesting ways.

The record "HELLO WORLD" starts stopped. Click on GO to get it blinking Morse code, which is as close to pure time as it gets. The sequence of ons and offs, however, is produced by the spatial layout of the linked pegs. Importantly, I could have done this using 0s and 1s only, and the track would be immediately readable. The bigger numbers save space, but make the device somewhat cryptic.


The order is strictly bossial, and this is another example of multibossial control. There is only one worker: the big red square in the middle. The orange pegs commands it to turn on and it stays on during the following tick. The yellow pegs kick the orange pegs on. Every boss knows a little piece of the message, and they pass control to each other.