00:02:24 <Corbin> Is this turing-complete? http://bitgrid.blogspot.com/2005/03/bitgrid-in-25-words-or-less.html
00:04:01 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
00:04:50 -!- Lord_of_Life has joined.
00:07:23 -!- feoh has changed nick to Guest2673.
00:07:24 -!- Guest2673 has quit (Killed (molybdenum.libera.chat (Nickname regained by services))).
00:07:32 -!- scjosh7 has joined.
00:07:34 -!- feoh has joined.
00:08:10 -!- scjosh has quit (Read error: Connection reset by peer).
00:08:10 -!- scjosh7 has changed nick to scjosh.
00:11:12 <int-e> wtf does "One lookup table per neighbor" mean
00:13:47 -!- jix has quit (Ping timeout: 256 seconds).
00:14:21 -!- APic has quit (Ping timeout: 256 seconds).
00:15:47 -!- jix has joined.
00:16:27 <Corbin> I'm still looking for details. http://bitgrid.blogspot.com/2010/06/introducing-bitgrid-sim-version-003.html links to Google's old forge. (Remember when Google ran a forge and then destroyed it and 404'd everything? Good times.)
00:17:25 <int-e> Oh I guess I get it. On each cycle, ech cell on the grid receives four inputs and produces four outputs for the neighbours according to a lookup table (FPGA style). That link seems to confirm that...
00:18:13 <int-e> So there's an awkware parity phenomonon (if you color cells in a checkerboard, information in white cells can never affect information in black cells)
00:19:11 <int-e> But since the LUTs are per cell... this should be able to simulate arbitrary clocked circuits with some polynomial slowdown
00:20:00 * int-e waves hands
00:22:23 <int-e> To keep things esoteric... maybe a GoL unit cell is a good target.
00:23:20 <int-e> (That is, a bitgrid unit cell that simulates a GoL cell)
00:23:24 <Corbin> Hm. That's a little tricky, actually, since we have to add the diagonals.
00:24:28 <int-e> A challenge? :P
00:26:19 -!- APic has joined.
00:28:19 <int-e> it does seem rather awkward to work with... I think mostly because the cells being stateless
00:30:03 <Corbin> I can't figure out how to pack the diagonal cell information into the spare three bits. There must be a trick to it.
00:30:58 <int-e> "spare three bits"
00:31:52 <chibi> 3 bits == 8 possibilities yeah?
00:33:48 <chibi> And you have eight neighbors...hm
00:34:57 <chibi> but if you have more than 1 live neighbor, that kind of naive implementation falls apart
00:36:09 <chibi> If you only are working with diagonals though, then you have 4 neighbors
00:37:31 <chibi> but that's still 4^2 possibilities? I think?
00:37:44 * chibi brain is made of cotton stuffing
00:39:03 <Corbin> I was assuming that one bit would go to the direct neighbors. And Conway's rule can be encoded in the LUT. All that's missing is some way of iteratively packing up diagonal neighbors and propagating them.
00:42:32 <int-e> Here's an alternative way of thinking about this: https://int-e.eu/~bf3/tmp/bitgrid.png ...we have a grid (of bits, black and white cells). Each circle represents one of the bitgrid cells. On even generations, the red circles fire... replacing the four bits that they touch by four new ones (a function 2^4 -> 2^4; 16^16 possibilities). On odd generations, the blue circles fire in the same way.
00:43:29 <int-e> This is half of the state... there's a second such evolution with different bits on the grid and red circles firing on odd generations, blue circles firing on even generations.
00:45:13 <int-e> I think disentangling those two independent parts of the state should help, even if the 45 degree shift in perspective may be a bit confusing.
00:58:04 <int-e> Hmm. To represent those rules, maybe x 4x4 grid of 2x2 results is appropriate? It'll be hard to read in any case. But it should be better than those checkboxes that disconnect related entries.
01:05:51 <int-e> Hmm... I'm afraid this will get annoyingly big.
01:14:16 <int-e> oh, maybe mot
01:14:18 <int-e> not
01:40:15 -!- chibi has quit (Remote host closed the connection).
01:55:52 -!- b_jonas has joined.
01:59:02 <b_jonas> is there a theorem where it's impossible to create a successful dynamically typed language, because if one would become popular, people always corrupt it with some just-in-time compilers that compile it as if it were typed to optimize and with language extensions to add static types?
02:05:59 <zzo38> I don't know of any such theorem
02:06:27 <zzo38> Although I had heard of similar thing that there will be a problem that will be if it is popular
02:11:06 <b_jonas> so far it's happened to at least python and javascript
02:13:25 <zzo38> Yes, it is
02:43:17 -!- utoneq has quit (Ping timeout: 246 seconds).
03:14:49 -!- utoneq has joined.
03:22:46 -!- utoneq has quit (Ping timeout: 268 seconds).
03:28:43 -!- utoneq has joined.
03:32:03 <shachaf> Melvar: I would not want to write "modify var (\x -> x + 1)", or probably even "modify var (+1)", rather than "var += 1".
03:32:32 <shachaf> Anyway, I was referring to a specific language feature they'd discussed before sort of similar to this.
03:39:44 -!- shikhin has quit (Quit: Quittin'.).
03:41:39 -!- shikhin has joined.
03:42:36 -!- shikhin has changed hostmask to ~shikhin@offtopia/offtopian.
03:43:14 <Melvar> Oh, apologies for going off on a tangent then. Just noting that it’s an alternate way to make especially the example with multiple @ on the rhs work with potentially more flexibility and less special syntax.
03:50:29 -!- utoneq has quit (Ping timeout: 246 seconds).
03:54:11 <b_jonas> calm down, nobody is trying to take away your +=s
03:56:47 <Melvar> @type (+=)
03:56:48 <lambdabot> (MonadState s m, Num a) => ASetter' s a -> a -> m ()
03:57:07 <Melvar> There it is.
03:57:36 -!- utoneq has joined.
03:57:51 <b_jonas> hmm, maybe we need an april fools proposal to remove the += operator from C++. nobody is using it anyway now that we can just write std::replace_with(&var, std::bind(std::plus, std::_1, 1)); instead of x+=1;
03:58:23 <b_jonas> sigbovik is this Friday by the way
03:59:54 <b_jonas> though I think it would be std::exchange_with instead of std::replace_with
04:08:20 -!- utoneq has quit (Ping timeout: 246 seconds).
04:15:49 -!- utoneq has joined.
05:10:49 -!- utoneq has quit (Ping timeout: 248 seconds).
05:25:28 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
05:56:56 -!- Lord_of_Life has joined.
06:24:22 -!- fowl2 has joined.
06:25:53 -!- fowl has quit (Ping timeout: 246 seconds).
06:25:53 -!- fowl2 has changed nick to fowl.
07:01:06 <esolangs> [[User:Conor O'Brien/Compilers/Quartic]] M https://esolangs.org/w/index.php?diff=94462&oldid=53455 * Conor O'Brien * (+1) typo fix
07:44:40 -!- Sgeo has quit (Read error: Connection reset by peer).
07:53:17 -!- Guest12 has joined.
07:56:35 -!- Guest12 has quit (Client Quit).
08:24:56 -!- __monty__ has joined.
09:24:33 <esolangs> [[Special:Log/newusers]] create  * YoavLavi *  New user account
09:27:26 <esolangs> [[Esolang:Introduce yourself]]  https://esolangs.org/w/index.php?diff=94463&oldid=94442 * YoavLavi * (+146) Introduction
09:27:53 <esolangs> [[Language list]]  https://esolangs.org/w/index.php?diff=94464&oldid=94412 * YoavLavi * (+13) 
09:30:02 <Corbin> b_jonas: FWIW the part of Python that makes the JIT (PyPy) is not really connected to the part that makes static types (MyPy). I'm not completely sure, but I think that JS JITs are the same way, not really using TypeScript.
09:30:42 <esolangs> [[Melody]] N https://esolangs.org/w/index.php?oldid=94465 * YoavLavi * (+156) Created page with "[[Category:Languages]] {{infobox proglang |name=Melody |author=[[Yoav Lavi]] |year=[[:Category:2022|2022]] |files=<code>.melody</code>, <code>.mdy</code> }}"
09:32:08 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94466&oldid=94465 * YoavLavi * (+47) 
09:34:02 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94467&oldid=94466 * YoavLavi * (+179) 
09:35:07 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94468&oldid=94467 * YoavLavi * (+0) 
09:35:41 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94469&oldid=94468 * YoavLavi * (+37) 
09:37:27 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94470&oldid=94469 * YoavLavi * (+875) 
09:38:33 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94471&oldid=94470 * YoavLavi * (+25) 
09:39:11 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94472&oldid=94471 * YoavLavi * (-900) 
09:40:50 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94473&oldid=94472 * YoavLavi * (-1) 
09:41:14 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94474&oldid=94473 * YoavLavi * (+1) 
09:41:35 <esolangs> [[Melody]]  https://esolangs.org/w/index.php?diff=94475&oldid=94474 * YoavLavi * (-1) 
10:16:24 -!- dyeplexer has joined.
10:42:22 -!- ais523 has joined.
10:54:20 -!- definitelya has joined.
11:12:00 <esolangs> [[Linguarcana]]  https://esolangs.org/w/index.php?diff=94476&oldid=94435 * FrankPujo * (+902) 
11:12:37 <esolangs> [[Linguarcana]] M https://esolangs.org/w/index.php?diff=94477&oldid=94476 * FrankPujo * (+0) 
11:25:36 <esolangs> [[Linguarcana]]  https://esolangs.org/w/index.php?diff=94478&oldid=94477 * FrankPujo * (+317) 
11:40:29 <esolangs> [[Melody]] M https://esolangs.org/w/index.php?diff=94479&oldid=94475 * PythonshellDebugwindow * (+93) Add categories and stub
12:51:51 -!- dyeplexer has quit (Ping timeout: 260 seconds).
12:54:15 <esolangs> [[Linguarcana]] M https://esolangs.org/w/index.php?diff=94480&oldid=94478 * FrankPujo * (-14) 
12:56:46 -!- razetime has joined.
13:10:46 -!- tech_exorcist has joined.
13:38:38 <esolangs> [[BEN++]] N https://esolangs.org/w/index.php?oldid=94481 * ChuckEsoteric08 * (+726) Created page with "'''BEN++''' is language by [[User:ChuckEsoteric08|ChuckEsoteric08]] that based on game "My Talking Ben". ==Commands== {| class="wikitable" |- | yes || increments cell under th..."
13:42:31 <int-e> Hmm. So I have a GoL evaluation function in 40-ish bitgrid cells
13:43:40 <int-e> Now I "just" have to route the signals. (I can deal with corners and diagonal adjacency; the tedious part will be to synchornizing the path lengths)
13:48:09 <Soni> hmm, can you make a programming language where everything is fields?
13:49:00 <Soni> everything must be algebra, everything must be infinitely refactorable 
13:49:28 <Soni> code built for editing
13:49:50 <Soni> programming language built for refactoring 
13:50:39 <int-e> . o O ( it's refactoring all the way down. you never actually run the code. )
13:50:42 <Soni> yes we know about math and calculus but like, those are too pure 
13:51:06 <Soni> how do you dx/dt an io function, y'know?
13:51:30 <int-e> of course that's getting dangerously close to metaprogramming. or substitution calculi... like the lambda calculus...
13:51:45 <int-e> Soni: easy. I don't :P
13:52:14 <Soni> dprint/dt
13:52:28 <Soni> :p
13:52:38 <int-e> continuous time is an illusion anyway
13:53:35 -!- sprout_ has quit (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.).
13:54:03 -!- sprout has joined.
14:07:11 -!- dyeplexer has joined.
14:16:57 -!- ais523 has quit (Quit: quit).
14:24:25 -!- Sgeo has joined.
14:51:32 <Corbin> Soni: Those are four different questions!
15:15:43 <int-e> great... I have 8 signals arriving at the gate simultaneously.
15:16:18 <int-e> now for the hard part :-P
15:17:23 -!- razetime has quit (Ping timeout: 250 seconds).
15:18:28 <int-e> (the output signal has to be routed as well... and it will cross the other signals. crossing is easy in principle, but I need to modify the paths a little bit for that to work out...
15:26:12 <b_jonas> and you need to send the output signal 8 ways
15:27:18 -!- razetime has joined.
15:27:26 <b_jonas> I'm still proud about my silly perl game of life evaluator
15:30:04 <b_jonas> https://www.perlmonks.com/?node_id=1008395 and https://codegolf.stackexchange.com/a/112163
15:30:29 <int-e> b_jonas: righ. but duplication is also not a big deal
15:30:33 <int-e> *right
15:31:17 <int-e> The problem is notation :P
15:32:10 <int-e> What I have looks like this... http://paste.debian.net/1236899/ ...each symbol denotes a different bitgrid cell
15:32:35 <int-e> the output (unrouted) is produced by the *
15:36:15 <int-e> I should probably make this a bit bigger
15:49:41 <int-e> hmm is there a script with a mirrored Z?
15:49:50 <int-e> (like И is a mirrored N)
15:51:37 <int-e> I guess '5' is an option.
15:54:11 <int-e> Or S, duh.
16:16:33 -!- perlbot has quit (Read error: Connection reset by peer).
16:17:59 -!- simcop2387 has quit (Read error: Connection reset by peer).
16:20:43 -!- tech_exorcist has quit (Quit: updating).
16:22:06 -!- simcop2387 has joined.
16:22:36 -!- perlbot has joined.
16:34:11 -!- tech_exorcist has joined.
17:06:36 -!- razetime has quit (Ping timeout: 240 seconds).
18:05:30 <int-e> phew. http://paste.debian.net/1236909/
18:09:51 <int-e> Or, more usefully, https://gist.github.com/int-e/c1b40dbed8a39a20dfc1d94fc25226b2 (includes Haskell code to actually do something with that cell...)
18:12:46 <int-e> Corbin: So I claim to have a GoL unit cell for that bitgrid thingy.
18:19:28 <river> s
18:19:30 <int-e> only 5 hours for routing
18:19:35 <int-e> :/
18:19:39 <int-e> (so tedious)
18:21:50 <int-e> The thing is... you'd expect the hard part to be the evaluation function (9 bits input, horrible circuit, blah)... but actually the circuit becomes very regular if you start with a sorting network for the 8 neighbours (the = stands for a comperator in the network) and after that it's just 3 more boolean operations.
18:22:21 <int-e> And after that it's all about timing.
18:29:15 <int-e> maybe there's a simpler way... there's ~1M possible cell functions and I'm only using a dozen or so...
18:43:37 -!- dyeplexer has quit (Ping timeout: 248 seconds).
18:47:58 <Corbin> int-e: Wow, nice work. While I couldn't replicate your construction, I'm convinced that Bitgrid (as we understand it) is Turing-complete. Very cool.
18:49:37 -!- chibi has joined.
18:51:30 <int-e> well, given an infinite grid of them (with a periodic setup, in the case of that unit cell)
19:18:26 -!- simcop2387 has quit (Read error: Connection reset by peer).
19:18:26 -!- perlbot has quit (Read error: Connection reset by peer).
19:20:43 -!- perlbot has joined.
19:23:16 -!- simcop2387 has joined.
19:57:25 -!- definitelya has quit (Quit: h).
20:18:11 -!- Lord_of_Life_ has joined.
20:18:53 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
20:20:55 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
21:23:19 <esolangs> [[Parse this sic]]  https://esolangs.org/w/index.php?diff=94482&oldid=94460 * Digital Hunter * (-18) /* Roman numerals */ shorter one
21:23:32 -!- tech_exorcist has quit (Quit: Disconnecting).
22:07:14 -!- utoneq has joined.
22:22:09 <b_jonas> so what's this bitgrid thing? the wiki doesn't seem to tell
22:22:34 <b_jonas> `? bitgrid
22:22:37 <HackEso> bitgrid? ¯\(°​_o)/¯
22:22:44 <int-e> http://bitgrid.blogspot.com/2005/03/bitgrid-in-25-words-or-less.html
22:23:42 <b_jonas> hmm
22:23:50 <int-e> As far as we can make out... the idea is that you have a grid of cells; on each cycle, each cell receives a bit from each of its four neighbours, and uses a lookup-table to compute outputs to those neighbours for the next cycle
22:23:50 -!- utoneq has quit (Ping timeout: 246 seconds).
22:23:57 <int-e> each cell has its own lookup-tables
22:24:16 <int-e> so it's a bit FPGA like, but terribly inefficient when it comes to data transport
22:25:32 <b_jonas> yeah, it's hard to cross signals that way
22:25:53 <int-e> Nah, you just make a cell that copies bits from one side to the opposite side
22:26:09 <int-e> (each output has its own lookup-table; I wasn't clear about that)
22:26:09 <b_jonas> huh?
22:26:18 <b_jonas> oh, there are separate outputs?
22:26:19 <b_jonas> I see
22:26:23 <b_jonas> that's a bit better
22:27:32 <int-e> So.. if you play around with this a bit you'll notice that the state is separated into two parts that never interact; if you color the cells in a checkerboard fashion, bits sent from white to black cells determine the bits sent from black to white cells on the next cycle, and vice versa
22:28:08 <b_jonas> yeah
22:28:31 <int-e> So you can restrict the analysis to having bits sent from white to black cells on one cycle, and from black to white cells on another. Turn things by 45 degrees and you get something like https://int-e.eu/~bf3/tmp/bitgrid.png
22:29:23 <int-e> (blue circles and red circles are the white and black cells; the grid can hold the bits. On even cycles, the red circles modify the 4 bits they touch; on odd cycles, the blue circles do the same.)
22:29:50 <int-e> That view is what I'm actually using for my unit cell.
22:30:56 -!- utoneq has joined.
22:32:48 <int-e> It's still weird, but not having two non-interacting worlds at the same time helps, I think.
22:36:17 <int-e> Corbin: what did you mean by "replicate"?
22:38:58 <Corbin> int-e: I mean that I tried to work it out for myself, got confused, and gave up. But I'm impressed by how far you got.
22:39:40 <int-e> I almost ran out of unicode symbols :-P
22:42:32 <int-e> http://paste.debian.net/1236909/ (many of these are visual, operating on 2x2 square: X swaps opposite bits; ↺ rotates the square left, Z is a 4-cycle that follows the Z and then jumps back from the bottom right to the top left... S is the opposite. half-arrows move one bit on the side the hook is on. And so... I think that about covers it except for = (comparator), & (logical and), | (logical...
22:42:38 <int-e> ...or) and * (not-and), with flow form left to right...)
22:43:24 <int-e> The main point of the gist was to have those things actually defined, https://gist.github.com/int-e/c1b40dbed8a39a20dfc1d94fc25226b2#file-bitgrid-hs-L7-L41
22:45:15 <int-e> (but I guess it won't make sense unless you also know how to visualize those functions)
22:55:48 -!- __monty__ has quit (Quit: leaving).
23:03:04 -!- utoneq has quit (Ping timeout: 268 seconds).
23:26:08 -!- utoneq has joined.