Here is my contact information.
Do you see the FIREPEGS app yet? If you don't, please right-click on this link, and ask your browser to open it in a new window.
FIREPEGS is a toy design system, which turns computer into a dynamical pattern machine. That's nothing new because computer, on all levels, from the logic gates to the simplest apps, is a dynamical pattern machine. What makes FIREPEGS different, is accessibility. In my experience a 4 years old could understand the basics and build the networks, which are the visual programs.
You may remember from school that patterns are important, nice and helpful. Well, the patterns of FIREPEGS are not your school's patterns. First, they are much more complex than schools allow students to learn, because the educators grossly underestimate their student's mental abilities. Next, the patterns in FIREPEGS are not friendly, just like patterns in real life. What made teachers think that patterns are friendly? I have a theory, it's just not for now. If you are dealing with real life patterns, you know how treacherous they are.
Last but not least, the patterns in FIREPEGS are dynamical, and this is an entirely different subject, which most people just never get a chance to learn. Dynamical patterns are everywhere, like time itself. It's not an appropriate topic for a help app either, but look at your body, your car, your job, the place where you live. Or take nature. Life is a bunch of dynamical patterns. Our planetary system is practically made out of them.
There are many ways to explain FIREPEGS, and only one story to tell. At the beginning of 2012 I started playing a daily game with one little girl. She was two years old back then. We had two toy sets, soft rubber Lauri's pegboards with horrible "tall stacker" pegs. I was building something on mine, and she was trying to follow me on hers.
By summer, this new quest had merged with an old one. My other child went to school and learned to hate math, very much like her brother had five years earlier. I understood that I was facing a double challenge - not only to make math learnable, but also to make the modern kids teachable - and with the little girl I started at the right time.
Eventually, I thought I'd made very good progress in both directions (I've done much better since then), so I decided to make this experience public. After sorting out my stuff, I realized that it falls into 6 projects, so I made 6 demo websites. FIREPEGS was a by-product at first, but then I decided it's a project of it's own.
That was my goal from the very beginning: to make a very simple and easy to use tool to lead a child through building layouts of colors, spot by spot, which meant, peg by peg. Here is the link to my first demo web-site. It's a one-pager. You may quickly scroll through it and look at the illustrations to see what I am trying to tell you about.
Playing with the little girl, I had layouts of colors in mind, and I was revealing them, sticking the pegs in the board one by one. On a computer-simulated pegboard, I could prepare the whole layout and link the pegs to each other, so they would pass the rights to display their hidden colors as a state-changing tokens. A state, which spreads around, lighting the things up, is a fire. That was FIREPEGS.
To let the tracks of fire branch off, I added the bigger wait times. The fire might follow from peg to peg, say, one step per second, leaving a slow link behind. When the longer wait time would expire, the fire would reach through this link, and start hopping along another track.
My first firepegs were glowing forever. To restart the pattern, I had to reset the board. It took several days to realize that by limiting the glow time I could make firepegs available for firing up again, and create self-restarting patterns. If you are interested, please look for some important details after the chapters about controls.
I discovered another way to explain FIREPEGS, as I realized that the board is a social medium, and the links define a social network. The members are sad creatures, who live to seek happiness, and they are only happy while they blink their colors. Refining the rules, I was mimicking Twitter. This whole thing could have been called Blinker.
FIREPEGS was created as a helper app for MAKE THEM MAD. For those, who grew mad enough, FIREPEGS offers new levels of challenges. Even in this early and limited functionality prototype, some free linking problems are easy for 5-year-olds, and some are hard for their parents.
There are many subjects in FIREPEGS. It can be math or biology, behavior or automation, neuroscience or informatics, electronics or management, but FIREPEGS is not quite like any of them. It captures and represents something that all those areas have in common: space, time and causality. The models are very simple at this time, but I have plans.
One aspect seems to be the most important: FIREPEGS is an abstract discrete toy for the digital world, in which schools still teach our children as if they are going to be navigators, gunners or fortress builders.
The most frequently offered extracurricular computer activity appears to be computer animation. Remember Scratch? Move 10 steps, play a pre-recorded drum beat. Why 10 steps? Because animation is continuous to the core. Pixels are just a nuisance.
In FIREPEGS your steps are 1 pixel long (firepegs are pixels, aren't they?). You build a track and loop it without any statements because FIREPEGS is a visual programming system.
Electronics and computer programming are my most familiar subjects. I could not resist including a chapter about FIREPEGS' connection to them in this help app.
The board, in many forms, is the most important device, empowering our civilization. Remember how many computer games were created for alphanumeric display terminals. They were pegboards, 24x80 pegs in size.
What you see on the boards are not just color pattern. They are numerical patterns. And networks are natural-born controllers. FIREPEGS would gladly play music note by note, like ancient clocks or music boxes (sorry, no music in the browser), or move pictures and dolls, creating animated scenes. Or turn on the water.
Bar external links, you could have arrived at this page from the main FIREPEGS app or from one of the interactive lessons. This help file is for the main app. The lessons were functionally limited, but, as far as I remember, nothing was added. The slightly changed main app was also embedded in the challenger app.
Albeit being usable, FIREPEGS software is not a finished product yet. This said, the main app is like an integrated development environment. In READY mode you build your networks, in GO! mode you run the patterns, in SET mode you debug and prepare them to run. If you have ever used any juvenile painting program, you already know how to set up the colors and the wait numbers on the links.
FIREPEGS has no way to know how to start your pattern. You either fire up the first firepegs in SET mode and switch to GO!, or you go straight to GO! and click on some firepegs when the time is ticking. Otherwise, your pattern will never start.
A lot depends on you background. If you did not get what I just wrote - integrated development environment and stuff - just take the interactive lessons and come back. The lessons are quick and easy. But wait, the next chapter may be all that you need.
Look at the picture. It shows the board in the READY mode. I added the red arrows to highlight the links. In the real app you see only the numbers.
Firepegs are the rounded squares on the rectangular board. Every firepeg is divided into 9 little squares. The central little square defines a secret color, which firepeg reveals as it fires up. The eight small squares around the center are the links. The numbers on the links are the wait times.
When firepeg fires up, it displays its color and sends the fire through the links to its neighbors as a message: "Wake up, count N ticks, and then you may display your color." N is the number on the link, and the ticks are the signals from the computer timer.
Firepegs are made to crave fire because they want to display their colors. In the beginning you fire up some firepegs, clicking on them. They send the firing up messages to their neighbors, and the neighbors do the same.
Firepegs can fire up each other in turns, making loops of fire. Technically, this is known as feedback. With properly organized feedbacks, a dynamical pattern may restart itself and loop "forever".
Step-by-step Instructions
I assume you can see both the FIREPEGS app and this page. If you can't, please right-click on the following link , and tell the browser to open it in a new window.
The Design Cycle
You start in the READY mode, changing one of the pre-loaded patterns or building a new one. When you are ready, you can switch to the SET, or straight to the GO!. SET is useful if you want to inspect your firepegs in action using the TICK control, or if you need to fire up many pegs before starting the timer.
Remember, nothing is going to happen on the board without a fire. If there was no fire before you switched to GO, you can always start it.
To save your network, use the edit TXT button. There is a chapter about it.
To debug your network, switch to ST mode, choose what to show, click on the TICK button, watch firepegs talking and firing up and try to figure out how to make them do what you want. To edit your network, return to the READY mode. Use the OFF button if you want to shut down the fires.
FIREPEGS is very simple and easy to control. I avoided many temptations, staying away from pop-up menus and property sheets. You can grasp the situation on the board and around it in full, without clicking anywhere.
Your first question must always be, which mode is selected? The mode selector is the second from the left. The leftmost control OFF is a momentary switch. It has no state to take into account.
The mode can be READY, SET or GO!. This option defines what you see and what you can do. Every mode has a different set of controls. Below you see all three sets side by side.
The GO! and SET control bars are practically the same, except for the timer TICK area in the middle. In SET mode, it's a button. You click on it to make FIREPEGS clock tick, or, if you prefer, to advance time by one step.
In the GO! mode, FIREPEGS ticks on its own. The timer TICK area is not clickable. It either blinks, or, if the speed is too high, remains bluish-gray. Consequently, in SET mode, the speed control does not do anything, but its value passes to GO! mode, where it actually works.
In both modes, you have the glow time control, which sets it for all the pegs on the board. I thought that would be enough to demonstrate how glow time works and what it can do for the patterns without changing the networks. In future versions, the glow time may become a part of the network because the firepegs will be redesigned to have their own glow times.
In all modes, there is the edit TXT control, which starts a text editor. You can use it to send text messages to the browser. You can't miss the text editor: it's a large black rectangle overlapping the board. In this help app, it has a chapter of its own.
Finally, in both modes you have the show control, which is very useful for understanding why your patterns don't run as you want, or if they really run as you want.
The mode READY control bar is different from the first two. Like everywhere else, you have the OFF, the mode and the text editor controls. The speed, the glow time and the show controls are missing. Instead, you've got the paint firepegs, the color all, the wait (for setting up the wait time numbers on the links), and, finally, the new board controls.
Before going from mode to mode and from control to control, please learn one little thing. In FIREPEGS packages it may look different and hide in different places. You may click on it at any time to get rid of annoying tooltips.
no tipsIn a standalone FIREPEGS app this control is not available. You may click on the edit TXT control and turn tooltips on and off calling the functions tipson() and tipsoff() respectively.
That's how your controls look in GO! mode. They are not functional, but you may point and click on them.
The OFF button puts all the board's population to sleep, killing all the fires and preventing all the waiting firepegs from firing up. Only you can bring such a sleeping community to life. The button also serves as a shortcut to the READY mode.
This section is about the mode GO!. In this mode you can not change the network and the timer is running, making firepegs act. If you click on firepegs, they fire up immediately. The board pays no attention to your interactions with firepegs.
In the mode GO!, the timer TICK indicator blinks as FIREPEGS clock ticks. If the blinking rate is too high, the indicator glows steadily.
Use the speed selector to change the number of ticks per second. A tick is a set of signals, that the board sends to its firepegs, telling them to change. The bigger speed number, the faster your pattern will change.
The glow time control defines the number of ticks, during which firepegs glow after firing up. You can adjust it with the < and > buttons, or you may just type in the value and hit the ENTER key. Try to increase the glow time while running a simple dynamical pattern. Double click to make firepegs glow forever. Double click again to return to the previous finite time.
The edit TXT control brings up the text editor. There is a chapter on it in this help app.
The show selector has 3 options. At FIRES, firepegs display only their colors. At STATES, you see the layout of colors and the network of links, plus the numbers in the central squares: 0 for the sleeping state, 1 for waiting and 2 for glowing. At COUNTERS, the sleeping firepeg has nothing to count. A waiting firepeg has gray links, but it's center tells how many ticks are left before firing up. A glowing firepeg tells how many ticks it has yet to glow.
That's how your controls look in SET mode. They are not functional, but you may point and click on them.
This section is about the mode SET. In this mode you can't change the network. The timer is not running and the firepegs are idle. You can use the TICK button to advance the time and watch the show step by step.You can also fire up some firepegs and set up parameters before switching to the mode GO!.
The timer TICK button makes FIREPEGS clock tick. Use it to advance system time by hand.
The speed selector was explained in the mode GO! section. In mode SET you may use it to prepare the board for running your pattern.
There are two ways to get to the READY mode: you can use the mode selector or the OFF button. The mode selector preserves the fires, or, technically speaking, the states of the pegs. The OFF button cancels the fires and the waiting states. That's why you may want to use it even if you are in the READY mode yet.
In the READY mode you set up your networks, laying out the color and setting up the links. Support for this important activity in FIREPEGS is meager at best. An object-oriented network editor would do miracles, but I don't have it, and I don't think it would make sense to develop one before I get FIREPEGS out of the web browsers.
All I can offer is editing firepegs and links one by one - tens, hundreds, even several thousand clicks at worst. Only the JavaScript interface and an external text editor can provide some relief.
Good thing, the one by one activity is easier than knitting. You pick a color and click on every peg you want to have it. You pick a wait time and click on every link you want to bear it. That's up to 9 clicks for every firepeg. Usually much less.
As long as the board exists in the browser tab, every firepeg remembers its former color and every link remembers its former wait time number. You may click to change a color or a number at any time. The former former value will be lost, and the current value will become the former value. However, if you click on a firepeg or a link with the color or the wait number they currently have, the program assumes that you want to get the old value back, and tries to restore it. I call this feature quick fix.
Another little convenience is the color All button. Remember though, that it's interplay with quick fix can be unwanted. Suppose you have a fresh board where some firepegs are yellow and some are still gray. If you try to color them all yellow, the yellow ones will revert to their former color (probably, gray). The easiest way out can be ordering a new all-gray board and coloring it all yellow.
If you want a multi-color board, consider coloring it all one color, then set up the other colors peg by peg.That's how your controls look in READY mode. They are not functional, but you may point and click on them.
This section is about the mode READY. In this mode you build the networks, creating the boards, changing the colors and the wait times. This mode is timeless.
The paint firepegs is a color selector. The selected color sticks to your mouse pointer until you select another one. When you click on the central squares, the color passes to firepegs. Quick fix works.
The color ALL button splashes the selected color all around the board. Quick fix works.
The wait control selects a wait time number in ticks. The selected number sticks to your mouse pointer until you select another one and passes to the links when you click on them. Tilde "~" means infinity (such a link is, in fact, a firewall). Increment "++" makes an existing number 1 bigger every time you click on it. Mysteriously, it turns ~ into 0.
Use the new board control to select the size of the board. The program requests your confirmation and creates it immediately. The label new board is another control. Click on it if you want a new board of the same size. Please understand that the new board comes with a new set of firepegs. All you current and former colors and wait times will be lost.
The edit TXT button is present on the control bar in every mode. Click on it to pop up one of those simple text editors, widely used to compose messages to owners of the websites, you know, limited to 200 characters, but they never get answered anyway.
Unlike it's siblings, this text editor is black, and the text size limit is rather big. I don't remember exactly how big, but certainly enough to write a Hello from FIREPEGS letter to somebody.
Inside the black patch you have only four controls: RUN, NETWORK SCRIPT, SELF-STARTING SCRIPT and CLOSE.
CLOSE closes the text editor. Next time it will not remember a thing.
RUN sends all the content of the editor to JavaScript, which is lurking inside every web browser. JavaScript may bark something back. Its response will appear on top of the content after the short magic word "//". If you see "// No reply.", it's a good sign. I don't think anybody has ever gotten a kind word from JavaScript. No bad words is a good news. Actually, the best you can get, but it does not mean JavaScript did what you wanted. Most likely, it did something unexpected, but could not find what to scold you for.
If you have nothing to tell JavaScript yet, try the other two controls.
The NETWORK SCRIPT control dumps a textual description of your design into the editor. It tells the size of the board, the color of every peg and the wait time number on every link. The format is very obvious and easy to use. Essentially, it's an ASCII picture of the board. The network below supports the 2x2 pattern named Around.
init(2,2); load( '~~~:~~~:'+ '~Y1:~Y~:'+ '~~~:~1~:'+ '---+---+'+ '~1~:~~~:'+ '~Y~:1Y~:'+ '~~~:~~~:'+ '---+---+'+ '');
The SELF-STARTING SCRIPT control produces the same description with additional information and wrapping. Note the magic words //. Before them there are my messages to JavaScript, after them - my messages to you. The magic word // requires JavaScript to read only the first part.
function around(){
init(2,2);
load(
'~~~:~1~:'+
'~Y1:~Y~:'+
'~~~:~1~:'+
'---+---+'+
'~1~:~~~:'+
'~Y~:1Y~:'+
'~~~:~~~:'+
'---+---+'+
'');
mode('2'); // select the mode SET
ttg(1); // select the glow time 1 tick
tps(2); // select the speed 2 (2 ticks per second)
pegs[0][0].ton(); //fire up the top left firepeg
mode('3'); // select the GO! mode!
};
The wrapper starts from "function around(){" and ends at the letter "}". Because of it, JavaScript will not execute this script after you click on RUN, but can add it to the other pre-built scripts, link it to the app's page and click on the link to run the pattern. I am not writing how exactly to do this only because I am not sure if anybody is going to need this information. But just in case, it's up to you to rename the function before using it.
If you RUN a network script, it destroys your current network and furnishes a new one. You may copy such script and save it in a text file somewhere, then use it to recover the network.
Let me avoid discussing JavaScript's growing ability to work with files on our computers. Suffice it to say, I could have developed a better way to save and retrieve the networks. I just thought it would be a waste of time, and not a small one.
I always wanted to use FIREPEGS as a stepping stone to learning electronics and computer programming, and I used even earlier prototypes than this as teaching tools. The black screen prevented me from developing the graphical user interface. Why spoil the students, indeed? I started adding new functions through what I came to call spells. Most of them I had to trim off while preparing the code for publishing. Some, however, survived. For example, to fire up every peg and enjoy your layout in its full glory, cast this:
allon()
My next project CODEPEGS grew around the concept of spells.
Developing firepegs, I found that my naive understanding of space was not what I thought it is. Or, rather, I have never thought about it before. This is way too heavy an issue for a help app. Lousely speaking, FIREPEGS in its present condition offers two perceptions: walking along trails and looking around.
The "walking along the trail" model came directly from my observations of my first student playing with the material pegboards and pegs. Before she turned three, she could follow me along the trails, building complicated layouts, and she taught herself surprisingly much. Presented with complete layouts without the guiding trails, she can't copy some of them even now.
The trail must be meaningful though. This whole pegboarding business would not stand one simple question: why wouldn't you guys just scan the board and replicate whatever it has? The raster is just a trail, after all.
The only answer I have is: I tried and failed. More than once. Even if I placed a ruler between the lines of pegs, human children refused to follow me because I was not making sense.
This made me think (finally), and soon I realized that my old brain was not much different from TLG's. Mine was more skilled and beaten into performing mechanical work, but I hated scanning and I loved to deal with contours and shapes just like she did. We are bound to develop the abilities, that we naturally have.
What you see in the "linked to lead" networks - think of Bird, which you probably saw - are precisely the trails, walked step by step.
What we see when as walk, are interplaying color spots, or shapes. In FIREPEGS they are usually built through 0 ticks links, and linked into trails of shapes. Waves, for example, is two trails of diagonal bars.
The board is really a torus. Every firepeg does have eight neighbors. I am planning to warp the board in several ways, to make it multilayer, and even fully 3-dimensional.
Time in FIREPEGS appears as the messages, or signals. Let's admit, this is our favorite way to be time aware, too.
The unit of time is one tick. With every tick, the board sends the series of messages to every firepeg. Firepegs hear them and ask themselves: am I sleeping? I'll keep sleeping then. Am I waiting to turn on? I'll make my wait counter one smaller and check to see if it became equal to 0. If it is, I'll fire up. Or am I glowing? There is another counter for this.
The control named speed ties ticks to seconds. When it changes, every timing parameter measured in ticks changes automatically.
There are only two kinds of such parameters in this prototype: the glow time and the wait time. The glow time is one and the same for every peg, but every peg counts it separately. In future versions I will probably allow individual glow times.
Every link may have its own wait time, or delay. It is important to know that the links do not count the wait times, they only pass them to the pegs. The pegs (the ones that wait) do the counting. The answer to every question "why" is: I made a deliberate decision on every rule to make FIREPEGS as simple as possible.
The timer on your computer's motherboard ticks all the time. The operating system transmits the timing signals to the programs that ordered them. One such program is the web browser. The browser hosts FIREPEGS software, which hosts the board. The board, in turn, orders the timing signals to pass them to firepegs. The board stops ordering the timing then it switches away from the GO! mode. In the SET mode, however, it lets you issue the fully functional ticks by clicking on the TICK button
Between the ticks, nothing happens in FIREPEGS. Without the ticks, you can only fire up the pegs. They will not turn off, and the fires will not propagate.
The ticks are like oxygen for the fires, but without a fire the ticks have nothing to do. You send the first fire from the cloud, in which you are hiding.
Every firepeg has 8 links to its peers and one invisible link to you. That's exactly how "social" networks are set up. The raison d'etrebehind any of them is that the spidermen are everybody's biggest friends. You have the power to message and ignite every member of your board.
If you did not fire up any pegs before switching to the GO! mode, your board will stay gray. You have to deliver the first fire, and you do it simply by clicking on the right firepeg. In the SET and the GO! modes, you can click and fire up firepegs at any time. In READY mode, your clicks change firepegs instead of firing them up.
The fired up firepeg start glowing immediately, and it kicks its neighbors through the links. The neighbors remember their wait numbers and start counting down with every tick. After the given number of ticks, they fire up.
If there is nothing on the link (which means, the wait time is equal to infinity) the kick is ignored. It's not a hack, but a normal part of firepegs' psychology. They live to display their secret colors. They can't do it without a fire, and fire they desire. If a firepeg received a firing up signal and entered a waiting state, it drops it and takes a smaller wait time whenever possible.
Counting down from infinity, you get infinity every time. In scripts and on the controls I use tilde (~) sign to denote it. Displaying the boards, I simply draw the infinitely delaying links as empty. You may assume they all are counting down from infinity since the time started ticking, and this infinite wait can be interrupted at any moment. A promise of quicker gratification prevails.
The glowing time cannot be interrupted. The glowing firepegs ignore incoming fires. The variable glow time was experimental at first. Then I decided to keep it, and kept the rules, too. Consequently, by increasing the glow time, you can smother every fire on the board. In the future, I may give firepegs their own glow times and change its handling.
A glowing firepeg becomes available for firing up immediately at the tick, that shuts it off. This allows you to keep firepegs glowing. Such a forced glow, however, is different from the one that occurs under a longer glow time. A forced-to-glow firepeg sends out the fires every time it fires up.
To keep firepegs glowing without stopping, or to fire up a track of firepegs at once, you need zero ticks wait times.
Every self-restarting and self-repeating dynamical pattern is at least one oscillation. The simplest of them occur when you mutually link two firepegs, like the central yellow and the top left orange firepegs are linked in the picture. Those who know electronics may recognize multivibrator (this would be close, but not quite right, because the FIREPEGS device has 3 states).
FIREPEGS learners may assume that they can create a two-way track, linking a one-way track backward. Frustratingly, this plan does not work. Firepegs, linked back and forth, and given something to blink about, start a conversation. If they are well connected, they can keep the whole board on fire. Long before the social networking era, this phenomenon was called flaming.
Zero ticks links do not oscillate. You may link the tracks both ways, and the shapes on the board in every possible way. This would let you fire up the whole thing, sending a fire from either end, or from any point on the border.
Once you've learned how to fire firepegs from JavaSript, you might assume that programming can solve any challenge. It can - sort of. You can also run faster on a bicycle, and you can certainly surpass the greatest movie manipulating the pixels. FIREPEGS player, by the way, simply goes through the lists of states, tick after tick.
In CODEPEGS I was musing about teaching computer programming by hooking up the board as an input-output device. FIREPEGS, as of this demo, cannot do many of those tricks. However, directly programming tracks and shapes must be rather challenging because of their parallel nature.
A much less traumatic approach for beginners can be to leave FIREPEGS to do the timing and supplement the functions, fired by FIREPEGS events. In fact, I added such a hookup and used it in developing this demo package.
On the other hand, the computer screen was merely the easiest way to build the prototype of FIRIPEGS. Not sure if this is going to happen, but I want to create a standalone or tethered device, like a Lauri's pegboard with lights and links. Touch screens do not deliver much of the experience essential for small kids.
For the big kids, a firepeg can become an electronic component, compatible with standard integrated circuits. I don't allow myself to think in this direction. It's too enticing.
I have to think about programming, though, because I am doing it. In FIREPEGS you program computer, period. You build chains and loops, you use source code, you run it, you face plenty of unexpected consequences, and you debug. You even reverse engineer. And you are rewarded, I hope, with something more attractive than letters and numbers.
High on my wish list are two modifications: 0-glow links to make the board behave like a CCD device, and stackable links, able to forward the fires, keep them, and shut them off in the order in which they were turned on. Last but not least, in this demo implementation, the board is a part of the web page. I use this fact in CODEPEGS.
I'm not sure if you know yet, but I provide the interactive lessons. They are crude, but they teach.
The most comprehensive helpful document is the FIREPEGS ebook. It explains many patterns and the inner working of the program. It also tells how I would enhance FIREPEGS if I had such an opportunity. Below are some direct links.
The origin of FIREPEGS, the structure of the elements and their behavior.
The easy patterns - from Around to Complexity.
The most detailed explanations of the reasons behind the design decisions.
The chapters telling something about (but not entirely devoted to) the further evolution of FIREPEGS:
And not to be forgotten: The ancient history of this project.
Thank you for reading. That's all!