Welcome to my blog! My name is Alejandro del Río and I am an engineer & entrepreneur from Guadalajara, México. I write about technology, startups and code.

faa5971
Wed Sep 9 15:23:33 2015 -0600
File-renaming
6a7b43c
Wed Sep 9 17:08:30 2015 -0600
Fix-image-link
20a3ae6
Fri Sep 18 19:19:53 2015 -0600
Added-websockets-article-por-change-on-artificial
3992fe0
Mon Sep 21 01:08:06 2015 -0600
Final-fixes-to-articles
4b52c6d
Thu Oct 1 22:13:11 2015 -0600
Update-eng.md
a0d2b46
Thu Oct 1 22:14:50 2015 -0600
Update-eng.md
189b16b
Wed Nov 4 22:42:29 2015 -0600
Enable-artificial-blog-post
47326ba
Sun Nov 8 23:08:24 2015 -0600
Update-eng.md
2f362b4
Wed Apr 27 23:49:56 2016 -0700
Fix-image-links-broken-when-moving-to-git-powered-articles
0556996
Wed Apr 27 23:53:07 2016 -0700
Fix-missing-GIFs
6bc464a
Wed Apr 27 23:55:34 2016 -0700
Add-missing-chessboard-images
d6e022b
Mon Feb 12 12:02:06 2018 -0600
Update-subdomain-with-nginx

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game will be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. In an attempt to find an “self-replicating machine” Conway drastically simplified the an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call a living cells from now on. If there is a living cell on the board that grid square is considered to be alive, if there is not living cell then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we end up with the next generation which looks like this:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could use my simulator at alife.adelriosantiago.com.

That’s it! With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname! As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game will be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. In an attempt to find an “self-replicating machine” Conway drastically simplified the an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call a living cells from now on. If there is a living cell on the board that grid square is considered to be alive, if there is not living cell then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we end up with the next generation which looks like this:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could use my simulator at alife.adelriosantiago.com.

That’s it! With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname! As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game will be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. In an attempt to find an “self-replicating machine” Conway drastically simplified the an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call a living cells from now on. If there is a living cell on the board that grid square is considered to be alive, if there is not living cell then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we end up with the next generation which looks like this:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper. Or you could simply launch my simulator at http://www.adelriosantiago.com:7000, sadly this time I couldn’t create a submain for it (like simulator.adelriosantiago.com) as WebSockets don’t play well with Reverse Proxies.

That’s it! With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname! As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper. Or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of how these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper. Or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of how these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons have very simple rules, here is a simple example of how these mathematical models work:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons follow a few set of simple rules, here is an example of how these rules:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons follow a few set of simple rules, here is an example of how these rules:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons follow a few set of simple rules, here is an example of how these rules:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons follow a few set of simple rules, here is an example of how these rules:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the finished project looks like:

Click on the image to load the simulator and play with it creating some structures, don’t forget to set your nickname and invite a friend! Note that this time I couldn’t create a subdomain for it (like simulator.adelriosantiago.com) since WebSockets don’t play well with Reverse Proxies…

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…

eng 5 2015

Collaborative artificial life

I have always been fascinated with artificial life and so I decided to make my own real-time collaborative cellular automaton in Node.js. More specifically I wanted to bring the magic of real-time collaboration to the Conway’s Game of Life so that every single user that loads the game would be interacting with the same board.

The Game of Life was created by the British mathematician John Horton Conway. He wanted to find a “self-replicating machine”. Conway drastically simplified an earlier automaton by John von Neumann which contained several complex rules. The Conway’s model appeared on the page 120 of the 1970’s issue of the Scientific American and made him instantly famous.

Most of the cellular automatons follow a few set of simple rules, here is an example of how these rules:

Let’s say we have a chessboard grid and a bunch of pawns which we will call living cells from now on. If there is a living cell on the board that grid square is considered to be alive. If its empty then that square is considered to be dead. These two states are can be easily represented on a computer by using the binary system, so that the equivalence ends up being 1 for a living cell and 0 for a dead cell.

Now image that you randomly throw 5 living pawns on the 8x8 board and you end up in the following pattern:

This is called the generation 0, to compute the next generation we will follow these 4 rules:


1.- Any living cell with fewer than two live neighbors dies, as if caused by under-population.

2.- Any living cell with two or three live neighbors lives on to the next generation.

3.- Any living cell with more than three live neighbors dies, as if by overcrowding.

4.- Any dead cell with exactly three living neighbors becomes a living cell, as if by reproduction.


By applying these simple rules we can calculate the next generation:

And then,

And so on, if you keep iterating you will notice that successive generations will make the pattern move away from where it started. This pattern will eventually perish when it reaches the border of the chessboard.

There are several, many, many structures that create different results. You can try them on a real chessboard, a piece of paper, or you could simply launch my simulator at http://www.adelriosantiago.com:7000.

That’s the beauty of artificial life. With some really simple rules you end up having an living ecosystem (or an artificially living ecosystem to be precise).

This is how the automata looks like:

As stated previously, note that the app is real-time collaborative, every user is actually seeing and interacting with the same board, I made it this way to see how it evolves with time, I plan to leave running this project running for a looong time…