A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
_,,,^..^,,,_ (phone)
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
On 2023-01-16, at 12:00 PM, karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak.
Have you never seen the BitBLT based version Dan Ingalls wrote a gazillion years ago? It used to be in the Squeak image, or at least I feel pretty sure it was.
Oh, wait! It was written up in the Byte81 issue, so see https://archive.org/details/byte-magazine-1981-08/page/n181/mode/2up?view=th... and the following pages.
tim -- tim Rowledge; tim@rowledge.org; http://www.rowledge.org/tim Klingon Code Warrior:- 8) "By filing this bug you have questioned my family honor. Prepare to die!"
On Mon, Jan 16, 2023 at 12:55 PM tim Rowledge tim@rowledge.org wrote:
On 2023-01-16, at 12:00 PM, karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak.
Have you never seen the BitBLT based version Dan Ingalls wrote a gazillion years ago? It used to be in the Squeak image, or at least I feel pretty sure it was.
Oh, wait! It was written up in the Byte81 issue, so see https://archive.org/details/byte-magazine-1981-08/page/n181/mode/2up?view=th... and the following pages.
That still computes every cell in every generation, even if pretty efficiently.
Simulations of this magnitude use the HashLife algorithm which memoizes groups of cells in quad trees and can skip multiple generations ahead. Don't think I've seen that implemented in Smalltalk.
A while ago I fell down a rabbit hole exploring how the OTCA Metapixel life cell worked (the Lisp CPU gates and wires are constructed from cells using non-traditional life rules, implemented on that meta cell).
Meta life inception: https://www.youtube.com/watch?v=4lO0iZDzzXk
Fascinating.
Vanessa
Here is a version of Dans Game of Life that almost work ;-P Some methods have changed names and I'm not sure about the BilBlt combinations rules used.
Best, Karl
On Mon, Jan 16, 2023 at 9:55 PM tim Rowledge tim@rowledge.org wrote:
On 2023-01-16, at 12:00 PM, karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak.
Have you never seen the BitBLT based version Dan Ingalls wrote a gazillion years ago? It used to be in the Squeak image, or at least I feel pretty sure it was.
Oh, wait! It was written up in the Byte81 issue, so see https://archive.org/details/byte-magazine-1981-08/page/n181/mode/2up?view=th... and the following pages.
tim
tim Rowledge; tim@rowledge.org; http://www.rowledge.org/tim Klingon Code Warrior:- 8) "By filing this bug you have questioned my family honor. Prepare to die!"
On Wed, Jan 18, 2023 at 11:33 AM karl ramberg karlramberg@gmail.com wrote:
Here is a version of Dans Game of Life that almost work ;-P Some methods have changed names and I'm not sure about the BilBlt combinations rules used.
Best, Karl
Here's one that does work. Took the liberty to reorder things a bit so I could better understand what it does.
Vanessa
On Mon, Jan 16, 2023 at 9:55 PM tim Rowledge tim@rowledge.org wrote:
On 2023-01-16, at 12:00 PM, karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak.
Have you never seen the BitBLT based version Dan Ingalls wrote a gazillion years ago? It used to be in the Squeak image, or at least I feel pretty sure it was.
Oh, wait! It was written up in the Byte81 issue, so see https://archive.org/details/byte-magazine-1981-08/page/n181/mode/2up?view=th... and the following pages.
tim
tim Rowledge; tim@rowledge.org; http://www.rowledge.org/tim Klingon Code Warrior:- 8) "By filing this bug you have questioned my family honor. Prepare to die!"
The attached version (in two methods) is three times faster. I followed Dan's suggestion in the Byte article and removed useless carry operations.
I also extended the margin for the counting forms, so that borders act as permanent white walls (see how gliders turn into squares when hitting a border).
Stef
Very cool :-D
Best, Karl
On Thu, Jan 19, 2023 at 1:10 PM Stéphane Rollandin lecteur@zogotounga.net wrote:
The attached version (in two methods) is three times faster. I followed Dan's suggestion in the Byte article and removed useless carry operations.
I also extended the margin for the counting forms, so that borders act as permanent white walls (see how gliders turn into squares when hitting a border).
Stef
On 2023-01-19, at 4:10 AM, Stéphane Rollandin lecteur@zogotounga.net wrote:
The attached version (in two methods) is three times faster. I followed Dan's suggestion in the Byte article and removed useless carry operations.
Interesting; on a Pi4 displaying via VNC I time it at 55mS for a generation + the magnify, display, and screen update. Without the magnify it's only 4mS. At 500@500 with no magnify it takes 20ms/gen.
tim -- tim Rowledge; tim@rowledge.org; http://www.rowledge.org/tim Strange OpCodes: BA: Branch Approximate
Attached is a Morph for playing with the #nextGeneration method.
Usage:
(BitBltLifeMorph over: 150@120) openInHand
The yellow button menu allows edition (you can hand-paint the cells), and basic control of the speed and magnification.
Stef
Hi Vanessa, don't you find it difficult to understand? I mean, I do not understand how it goes from the rules of the game (*) to that code... I can not map that implementation to the rules of the game... Can someone explain to me or point me to a paper/description of why that implementation works?
I did two implementations of the game a long time ago. One that goes over the board twice and another that goes only once. These implementations try to be as declarative as possible. For example, the one that passes over the board twice is: nextGeneration aliveCells := self cellsToSurviveOnNextGeneration union: self cellsToResurectOnNextGeneration
The one that passes over the board once is: nextGeneration aliveCells := self boardCellsSelect: [ :aCell | self shouldBeAliveOnNextGeneration: aCell ]
aliveCells is a Set of the alive cells of the game. I think you can deduce what the other messages do. Of course it is not as performant as Dan's implementation... If someone can direct me to some info or explain to me why Dan's implementation works I will appreciate it.
Thanks! Hernan
(*) I use the definition of https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
On Thu, Jan 19, 2023 at 5:54 AM Vanessa Freudenberg vanessa@codefrau.net wrote:
On Wed, Jan 18, 2023 at 11:33 AM karl ramberg karlramberg@gmail.com wrote:
Here is a version of Dans Game of Life that almost work ;-P Some methods have changed names and I'm not sure about the BilBlt combinations rules used.
Best, Karl
Here's one that does work. Took the liberty to reorder things a bit so I could better understand what it does.
Vanessa
On Mon, Jan 16, 2023 at 9:55 PM tim Rowledge tim@rowledge.org wrote:
On 2023-01-16, at 12:00 PM, karl ramberg karlramberg@gmail.com
wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak.
Have you never seen the BitBLT based version Dan Ingalls wrote a gazillion years ago? It used to be in the Squeak image, or at least I feel pretty sure it was.
Oh, wait! It was written up in the Byte81 issue, so see https://archive.org/details/byte-magazine-1981-08/page/n181/mode/2up?view=th... and the following pages.
tim
tim Rowledge; tim@rowledge.org; http://www.rowledge.org/tim Klingon Code Warrior:- 8) "By filing this bug you have questioned my family honor. Prepare to die!"
I can not map that implementation to the rules of the game... Can someone explain to me or point me to a paper/description of why that implementation works?
There is the Byte paper, around https://archive.org/details/byte-magazine-1981-08/page/n205/mode/2up?view=th...
The figure there shows how ancilliary forms are used to count, in parallel, the number of neighbors for each point in the pattern.
For each direction in the Moore neighborood, the pattern is shifted and these eight shifted grids are combined together.
This is an addition in base two, and we need to count up to eight, so the algorithm uses three forms (nbr1, nbr2 and nbr4) to store the corresponding bits, and two other forms (carry2 and carry4) to store the bits carried from one bit to the next (so here from nbr1 to nbr2, and from nbr2 to nbr4), just as you need to do when performing an addition by hand.
The last step (the last four lines in #nextLifeGeneration from the Byte paper) generates the next pattern from nbr1, nbr2 and nbr4. The rules of the Game of Life are encoded here in the successive combination rules, in a nifty and quite obfuscated way that I did not even tried to comprehend.
Stef
Thanks! I see now how it works, thank you.
Hernan.
On Sat, Jan 21, 2023 at 5:48 AM Stéphane Rollandin lecteur@zogotounga.net wrote:
I can not map that implementation to the rules of the game... Can someone explain to me or point me to a paper/description of why that implementation works?
There is the Byte paper, around
https://archive.org/details/byte-magazine-1981-08/page/n205/mode/2up?view=th...
The figure there shows how ancilliary forms are used to count, in parallel, the number of neighbors for each point in the pattern.
For each direction in the Moore neighborood, the pattern is shifted and these eight shifted grids are combined together.
This is an addition in base two, and we need to count up to eight, so the algorithm uses three forms (nbr1, nbr2 and nbr4) to store the corresponding bits, and two other forms (carry2 and carry4) to store the bits carried from one bit to the next (so here from nbr1 to nbr2, and from nbr2 to nbr4), just as you need to do when performing an addition by hand.
The last step (the last four lines in #nextLifeGeneration from the Byte paper) generates the next pattern from nbr1, nbr2 and nbr4. The rules of the Game of Life are encoded here in the successive combination rules, in a nifty and quite obfuscated way that I did not even tried to comprehend.
Stef
On Sat, Jan 21, 2023 at 00:48 Stéphane Rollandin lecteur@zogotounga.net wrote:
I can not map that implementation to the rules of the game... Can someone explain to me or point me to a paper/description of why that implementation works?
There is the Byte paper, around
https://archive.org/details/byte-magazine-1981-08/page/n205/mode/2up?view=th...
The figure there shows how ancilliary forms are used to count, in parallel, the number of neighbors for each point in the pattern.
For each direction in the Moore neighborood, the pattern is shifted and these eight shifted grids are combined together.
This is an addition in base two, and we need to count up to eight, so the algorithm uses three forms (nbr1, nbr2 and nbr4) to store the corresponding bits, and two other forms (carry2 and carry4) to store the bits carried from one bit to the next (so here from nbr1 to nbr2, and from nbr2 to nbr4), just as you need to do when performing an addition by hand.
The last step (the last four lines in #nextLifeGeneration from the Byte paper) generates the next pattern from nbr1, nbr2 and nbr4. The rules of the Game of Life are encoded here in the successive combination rules, in a nifty and quite obfuscated way that I did not even tried to comprehend.
Stef
Right. You basically need to understand how binary counting works at a logic-gate level, to be able to comprehend the neighbor counting code.
Typically that logic is invisible. I love this mechanical version:
You can see the bits (the big 0s and 1s). The carry is the little latch sticking out to the left, and it gets set whenever a bit flips from 1 to 0, which means the next bit has to flip.
The “bit + carry” logic is called a “half adder”, you can google that, but basically it generates the next bit and carry from the previous bit and carry using two logic operations, an XOR for the bit and an AND for the carry.
With that understanding, Dan’s explanation in the Byte article might make more sense – it does the XOR and AND for all pixels at the same time.
The 3 bit result count is then used to determine if a cell should be born, survive, or die. Again, logic ops do that for all pixels at once.
The Life rule is that cells with 2 or 3 neighbors survive, any with fewer or more neighbors die, and any empty cell with 3 neighbors is born.
To implement that rule with minimal logic, we restructure it a bit
A live cell will be there in the next generation if (1) the cell is alive AND has 2 neighbors (2) OR has 3 neighbors (independent of itself being alive or not) (3) BUT it must not have 4 or more neighbors
(1) is implemented as “self AND 2s” because the 2s bit is only set for 2, 6 and 7 neighbors (010, 110 and 111 in binary), and we deal with the >= 4 neighbors case in (3) (2) is implemented as “self OR (1s AND 2s)” because those bits are only set together for 3 and 7 neighbors (011 and 111 in binary), and we deal with the 7 neighbors case in (3) (3) is implemented as “self AND NOT 4s” which kills any remaining 6 and 7 neighbor cells (4, 5, and 8 neighbor cells wouldn’t have made it to this step anyways because their lower bits look like 0 and 1 neighbors: 100, 101, and 000)
This also explains why we don’t need to count to 8. With 3 bits we can only count to 7, if we add one more to 7 we get 0. But in Life this is fine because both cells with 8 and 0 neighbors have the same result.
Hope that helps, Vanessa
Hi Vanessa! Yeah thank you for the explanation, pretty clear. I understood the algorithm after reading the article and looking at it with a co-worker He did some refactorings that will share for sure
Hernan
On Sun, 22 Jan 2023 at 19:56 Vanessa Freudenberg vanessa@codefrau.net wrote:
On Sat, Jan 21, 2023 at 00:48 Stéphane Rollandin lecteur@zogotounga.net wrote:
I can not map that implementation to the rules of the game... Can someone explain to me or point me to a paper/description of why that implementation works?
There is the Byte paper, around
https://archive.org/details/byte-magazine-1981-08/page/n205/mode/2up?view=th...
The figure there shows how ancilliary forms are used to count, in parallel, the number of neighbors for each point in the pattern.
For each direction in the Moore neighborood, the pattern is shifted and these eight shifted grids are combined together.
This is an addition in base two, and we need to count up to eight, so the algorithm uses three forms (nbr1, nbr2 and nbr4) to store the corresponding bits, and two other forms (carry2 and carry4) to store the bits carried from one bit to the next (so here from nbr1 to nbr2, and from nbr2 to nbr4), just as you need to do when performing an addition by hand.
The last step (the last four lines in #nextLifeGeneration from the Byte paper) generates the next pattern from nbr1, nbr2 and nbr4. The rules of the Game of Life are encoded here in the successive combination rules, in a nifty and quite obfuscated way that I did not even tried to comprehend.
Stef
Right. You basically need to understand how binary counting works at a logic-gate level, to be able to comprehend the neighbor counting code.
Typically that logic is invisible. I love this mechanical version:
You can see the bits (the big 0s and 1s). The carry is the little latch sticking out to the left, and it gets set whenever a bit flips from 1 to 0, which means the next bit has to flip.
The “bit + carry” logic is called a “half adder”, you can google that, but basically it generates the next bit and carry from the previous bit and carry using two logic operations, an XOR for the bit and an AND for the carry.
With that understanding, Dan’s explanation in the Byte article might make more sense – it does the XOR and AND for all pixels at the same time.
The 3 bit result count is then used to determine if a cell should be born, survive, or die. Again, logic ops do that for all pixels at once.
The Life rule is that cells with 2 or 3 neighbors survive, any with fewer or more neighbors die, and any empty cell with 3 neighbors is born.
To implement that rule with minimal logic, we restructure it a bit
A live cell will be there in the next generation if (1) the cell is alive AND has 2 neighbors (2) OR has 3 neighbors (independent of itself being alive or not) (3) BUT it must not have 4 or more neighbors
(1) is implemented as “self AND 2s” because the 2s bit is only set for 2, 6 and 7 neighbors (010, 110 and 111 in binary), and we deal with the >= 4 neighbors case in (3) (2) is implemented as “self OR (1s AND 2s)” because those bits are only set together for 3 and 7 neighbors (011 and 111 in binary), and we deal with the 7 neighbors case in (3) (3) is implemented as “self AND NOT 4s” which kills any remaining 6 and 7 neighbor cells (4, 5, and 8 neighbor cells wouldn’t have made it to this step anyways because their lower bits look like 0 and 1 neighbors: 100, 101, and 000)
This also explains why we don’t need to count to 8. With 3 bits we can only count to 7, if we add one more to 7 we get 0. But in Life this is fine because both cells with 8 and 0 neighbors have the same result.
Hope that helps, Vanessa
--
*Hernán WilkinsonAgile Software Development, Teaching & Coaching* *Phone: +54-011*-4893-2057 *Twitter: @HernanWilkinson* *site: http://www.10Pines.com http://www.10pines.com/* Address: Alem 896, Floor 6, Buenos Aires, Argentina
Try replacing the Array with a ByteArray and see if their is any performance improvement.
_,,,^..^,,,_ (phone)
On Jan 16, 2023, at 12:01 PM, karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
_,,,^..^,,,_ (phone)
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
Yes BitBlt magic is amazing. The code posted above runs with multiple frames per second even on SqueakJS.
Vanessa
On Thu, Jan 19, 2023 at 10:09 Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
working code from 2010-04-27 08:21:25. impressive!
On Fri, Jan 20, 2023 at 5:33 PM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
-- -- Yoshiki
I am pretty sure I wrote it much earlier than 2010... Some methods timeStamps are 1999 so that is more plausible.
It is cool that it runs... But Smalltalk is not modular or designed to be timeless but it still runs. That might be something we should consider what it means.
On Fri, Jan 20, 2023 at 3:42 PM Bernardo Ezequiel Contreras < vonbecmann@gmail.com> wrote:
working code from 2010-04-27 08:21:25. impressive!
On Fri, Jan 20, 2023 at 5:33 PM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
-- -- Yoshiki
-- Bernardo E.C.
Sent from a cheap desktop computer in South America.
Amazingly, the LifeMorph does load into Squeak 6:
Ah, you can even drop morphs in it and they will dissolve into Life cells! Nice touch!
There is an entry in SqueakMap BTW that could be updated (the download link is dead):
http://map.squeak.org/package/cc20b428-f480-4e59-9878-a244069f0c22/autoversi...
The date there is 2003
Stef
Great Yoshiki. The extent: method was a little wonky. Here is a suggested fix :-)
Best, Karl
On Fri, Jan 20, 2023 at 9:33 PM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
-- -- Yoshiki
Hi Yoshiki --
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
Probably due to that FPS lock in Morphic. Try enabling the preference "higher performance". I get about 100 fps for 1600x1600 on my Surface Pro 8 (11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz, 2995 MHz)
Best, Marcel
Am 20.01.2023 21:33:40 schrieb Yoshiki Ohshima yoshiki.ohshima@acm.org:
Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima <Yoshiki.Ohshima@acm.orgmailto:Yoshiki.Ohshima@acm.org> wrote: I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg <karlramberg@gmail.commailto:karlramberg@gmail.com> wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda <eliot.miranda@gmail.commailto:eliot.miranda@gmail.com> wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
-- -- Yoshiki
On Mon, Jan 23, 2023 at 12:33 AM Taeumel, Marcel Marcel.Taeumel@hpi.de wrote:
Hi Yoshiki --
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
Probably due to that FPS lock in Morphic. Try enabling the preference "higher performance". I get about 100 fps for 1600x1600 on my Surface Pro 8 (11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz, 2995 MHz)
You also need to set its stepTime to 0 so it actually updates in every frame.
Vanessa
Best, Marcel
Am 20.01.2023 21:33:40 schrieb Yoshiki Ohshima yoshiki.ohshima@acm.org: Amazingly, the LifeMorph does load into Squeak 6:
http://www.squeaksource.com/LifeGame.html
Making it 1600x1600 and it runs at 40 fps on my M1 Max Mac.
On Thu, Jan 19, 2023 at 10:09 AM Yoshiki Ohshima Yoshiki.Ohshima@acm.org wrote:
I think I once made a Morph called LifeMorph, that used the BitBlt magic Tim mentioned. That was pretty fast 20 years ago.
I can't say I have the code handy, but I do find it mentioned here for example.
https://wiki.squeak.org/squeak/2000
On Mon, Jan 16, 2023 at 12:01 PM karl ramberg karlramberg@gmail.com wrote:
Very cool. I would not volunteer to refactor that :-D
It's tricky to get high performance GameOfLife in Squeak. Here is a morph I worked on. I use an array as data structure. Each cell is an integer. Neighbouring cells alive are 0 to 8 and alive cell are 10 + neighbours.
It gets a decent framerate.
Best, Karl
On Mon, Jan 16, 2023 at 5:43 PM Eliot Miranda eliot.miranda@gmail.com wrote:
A fabulous example of Turing completeness and by far the most sophisticated Life system I’ve seen. https://woodrush.github.io/blog/posts/2022-01-12-lisp-in-life.html
The video is here:
[image: youtube-ss.png]
_,,,^..^,,,_ (phone)
-- -- Yoshiki
-- -- Yoshiki
Just amazing.
Stef
vm-dev@lists.squeakfoundation.org
-
Bernardo Ezequiel Contreras -
Eliot Miranda -
Hernán Wilkinson -
karl ramberg -
Stéphane Rollandin -
Taeumel, Marcel -
tim Rowledge -
Vanessa Freudenberg -
Yoshiki Ohshima