00:00:15 <nfd> you could do it by specifying machines that get exactly one tuple from the bag (removing it) and adding exactly one afterwards
00:02:06 <nfd> if the machines are at least as powerful as lambda expressions, the result should be turing complete
00:04:39 <nfd> input would then simply be adding tuples to the pool--whether that's at the beginning or at runtime doesn't matter
00:05:03 <nfd> and committing one specific value to the pool (eg. the empty tuple?) kills all the machines
00:07:02 <nfd> yeah, like linda
00:07:35 <nfd> the trick is that you only get extremely simple machines
00:07:38 <imode> I've experimented with tuple-based rewriting. I got as far as implementing arithmetic before stopping. I used pattern matching and variable binding.
00:09:15 <imode> code was specified as tuples as well.
00:09:28 <imode> so you had this one amorphous bag that could be distributed amongst machines.
00:09:40 <nfd> what were your limits on variable binding? i'm imagining something like this
00:10:01 <nfd> ("val" a b c d) -> ("out" a b c "5")
00:10:25 <nfd> i think with a linda-like bag that this is probably turing complete
00:10:45 <nfd> yeah. it sounds like a super easy proof
00:10:48 <imode> https://ptpb.pw/urGZ/python so here's where.. I left off.
00:10:52 <nfd> but i'm not gonna claim it is until i do it
00:11:03 <imode> line 301 is where the code starts.
00:11:20 <imode> the language I was implementing was assembly-like in nature.
00:11:47 <imode> each "line" had the ability to reference other lines and contain the result of its executed command.
00:11:54 <nfd> pretty sweet!
00:12:26 <imode> so you could translate things like "Foo X Bar" to `match` commands by saying "okay, I need a tuple with Foo in the first place and Bar in the third place.`
00:13:41 <imode> and then the resulting tuple would be dragged from storage, stored as a match, and then you could fetch another tuple like `Bar X Baz`, using the previous result's second column as a constraint (because they use the same variables in the "macro language").
00:13:45 <nfd> gonna have to give this a close read
00:14:10 <imode> it's pretty weird and I have about 30 revisions of it going back to february of last year.
00:14:34 <imode> obviously not completed and it looks friggin' terrible.
00:15:22 <nfd> i'm thinking about doing a super-minimal version of this for kicks, now
00:16:00 <nfd> i guess i just specified the entire syntax in that one message up there
00:16:01 <imode> try it! the concept is pretty minimal as-is: match and assert are the only required commands for pattern matching and assertions.
00:16:35 <imode> match queries the tuple store and grabs things from it in a constrained manner, assert either adds or removes tuples.
00:17:01 <nfd> just have to decide if i wanna do it in racket (for its dsl features) or haskell
00:17:02 <imode> it'd be trivial to construct things like addition, trees, lists and arrays...
00:17:18 <nfd> neither of which i know super well
00:17:37 <nfd> but i guess my favorite way to learn a language is to use it to write a language
00:17:40 <imode> do it in a language you know well _first_. :P
00:18:36 <nfd> probably not a bad idea, haha
00:18:58 <nfd> i do know a bit of scheme and a bit of haskell. not like i'm operating totally blind here
00:19:20 <imode> thing is, tuplespace stuff like this is really powerful as a paradigm. you could compile a prolog-like language (like what I was attempting) down to it.
00:19:32 <shachaf> nfd: are you nvd's evil twin twh
00:19:46 <imode> then turing completeness is as trivial as implementing a TM.
00:20:22 <nfd> shachaf: haha, you tell me. afraid i don't know them
00:20:25 <nfd> i'm new to this chan
00:20:38 <nfd> not really new to esolangs
00:21:46 -!- trout has joined.
00:23:46 <imode> damnit nfd, you have me looking through my old code again.
00:24:19 <HackEso> nvd is what Taneb calls himself when he wants to feel professional.
00:25:14 -!- variable has quit (Ping timeout: 256 seconds).
00:26:13 -!- XorSwap has joined.
00:29:16 <nfd> so, say each machine fetches one tuple
00:30:32 <nfd> would it be more fun to make each machine output exactly one tuple or zero, one, or two tuples
00:31:09 <nfd> if we take option two, we could add output/termination side effects
00:31:22 <XorSwap> if each machine takes one tuple and puts one tuple, that's not concurrent at all
00:32:08 <nfd> doesn't need to be actually concurrent to be conceptually threaded
00:33:39 <nfd> but if we want to make it actually concurrent, all we need to do is spawn one thread per machine
00:33:50 <nfd> if the tuple bag does its job, we get semaphores for free
00:36:21 <XorSwap> so wait am I getting this right, there's only a finite number of processes?
00:44:38 <nfd> yeah. at most one process/thread per machine. each () -> () statement completely specifies one discrete machine
00:45:14 <nfd> might be worth implementing this in C and pthreads first, actually
00:46:50 <nfd> so if you want multiple hardware threads working on one task at the same time, you just specify the same machine twice
00:48:14 <nfd> (which, frankly, would be a bizarre choice unless you have well-optimized matching)
00:51:27 <nfd> hah, i should write a specification for this before i get implementing
00:51:27 -!- clog has joined.
00:53:49 -!- variable has joined.
00:56:53 -!- trout has quit (Ping timeout: 276 seconds).
01:04:17 <imode> tuple rewriting without variable binding is an interesting concept.
01:04:57 <imode> same way that string rewriting would.
01:05:08 <imode> only with disjoint segments of a larger string.
01:08:07 <imode> my question I posed earlier still stands, though. all of this is just a variant of rewriting. it's either rewriting or automata. I've yet to see a truly unique form of computation.
01:09:17 <XorSwap> erlang's concurrency model is the most unique one I know of
01:09:46 <imode> the actor model? I have seen absolutely no formal treatment of it.
01:10:22 <imode> I've just seen vagueness. abstract descriptions. no concrete model to speak of. I tried reading the original (now very scarred and scratched) paper to no avail.
01:10:54 -!- XorSwap has left ("the creeping crawling chaos will return.").
01:10:57 <imode> I tried pursuing it as an alternative to process calculi, but stopped short because I couldn't find a damn description outside of "there are actors, they communicate via mailboxes."
01:10:57 -!- XorSwap has joined.
01:12:17 -!- Remavas has quit (Quit: Leaving).
01:12:42 <imode> I guess it's a bit of NIH. that there's no real other category of computational models.
01:13:27 -!- MDude has quit (Ping timeout: 240 seconds).
01:13:40 -!- arseniiv has quit (Ping timeout: 260 seconds).
01:15:03 <XorSwap> imode: not concurrent, but here's some food for thought https://suhr.github.io/obsc/
01:26:11 -!- trout has joined.
01:29:00 -!- variable has quit (Ping timeout: 245 seconds).
01:39:09 <imode> that's not really much of a variant, though. stack languages aren't really unique (well, they were for a while...)
01:40:45 <XorSwap> the notion of multiple types of concatonation as well as a haskell-style type system for one is interesting
01:41:23 <imode> right, but it's just all a variant of rewriting to me. I can't feel impressed by it anymore. :(
01:42:03 <XorSwap> I mean, any turing complete system can be turned into term rewriting
01:43:08 <imode> less term rewriting and more just general rewriting.
01:44:10 <imode> like, are there any models of computation that _aren't_ just a variant of a rewriting system, or an automata? even so-called exotic MoCs fall down to rewriting over some kind of structure.
01:45:33 <imode> I have my doubts but that is one of the more unique ones. dataflow in general is.
01:45:49 <imode> I've been working on reducing it to a string rewriting system.
01:45:57 <XorSwap> do you know anything about verilog?
01:45:58 <imode> based on signals and channels.
01:46:05 <imode> yeah, a lot of it. same stuff.
01:46:08 -!- trout has quit (Quit: Found 1 in /dev/zero).
01:46:43 <imode> the problem is a paradigm like that can either be taken at face-value or reduced to something in the two categories of rewriting or automata.
01:46:51 <XorSwap> I get the feeling that if you spend time reducing things to rewrite systems you're gonna start seeing more things as rewrite systems
01:47:20 <imode> I did the same thing with TMs and various other turing-equivalent automata.
01:47:42 <imode> most paradigms to me can't stand on their merits enough without referring to something in those two categories.
01:47:56 <imode> I'm almost desperate for one that breaks that trend for me.
01:48:32 <imode> breaks down to term rewriting. weird, I know.
01:49:03 <imode> everything in the language is represented as term trees.
01:49:13 <imode> you can even manipulate rules as first-class citizens.
01:49:16 <imode> with some difficulty.
01:49:33 <imode> so it becomes a somewhat unique variant of term rewriting, but still in the category of rewriting.
01:49:44 <XorSwap> at that point you've just made an interpreter in a term rewriting language
01:50:16 <imode> that's the kind of thing I'm talking about. there's always some kind of easy reduction.
01:50:59 <XorSwap> if you're counting interpreting as an easy reduction then every turing complete thing can be reduced to term rewriting
01:51:43 <imode> again, not even terms. just abstract rewriting systems. graphs, trees, strings, multisets..
01:52:02 <imode> the same goes for automata.
01:52:36 <imode> the paradigms that I've seen just aren't enough to stand on their own without referring to some aspect of either category.
01:52:52 <imode> hence why you'll see every language standard reference some abstract machine (automata) or reduce to a rewrite theory (rewriting, obviously).
01:53:10 <imode> it's almost crying out for a third.
01:53:15 <XorSwap> my point is just that if you're looking for something that can't be turned into rewriting somehow all that's left is the stuff above turing complete which you can't really use in the real world
01:54:07 <imode> right, I'm not looking for that. automata and rewriting can be interchanged with some difficulty in either direction. I'm looking for something that stands as some kind of third category to the two already present.
01:55:06 <imode> dataflow is a decent candidate. I don't know of any others. I thought various process calculi were the answer, but they just reduce to term rewriting (by some clever conventions).
01:55:38 -!- xkapastel has quit (Quit: Connection closed for inactivity).
01:56:47 <XorSwap> the game of life would also be a rewrite system but I also know of continuous game of life https://arxiv.org/pdf/1111.1567.pdf
01:56:52 <imode> then again, I don't really know many formal treatments for dataflow. I don't know of any real well-defined models of computation.
01:56:58 <XorSwap> don't know if it's turing complete though
01:57:21 <imode> I can't imagine what the proof would look like. I'd imagine it'd be impressive.
01:59:55 <imode> I guess it's just a nagging doubt in my head that I'll probably need to silence. that "we can't have all of this figured out yet!"
02:03:28 <XorSwap> well the only other models I can think of can't be implemented in the real world so that's all I got man
02:03:57 <imode> I don't expect an easy out. :P
02:05:11 <XorSwap> if you're into parsing at all there's parsing with derivitives
02:05:57 <imode> I saw that posted somewhere a while back. I'll probably look into it tonight.
02:09:26 <imode> eh. this only applies to context-free languages?
02:09:48 <imode> looks like it. looks interesting anyway.
02:10:48 <XorSwap> are there parsers out there doing context sensitive grammars?
02:12:07 <imode> there are parsers out there doing unrestricted grammars. :P
02:12:26 <imode> whether they stop parsing is the real question...
02:13:00 <imode> fun fact: perl's grammar is unrestricted. at least I read that somewhere.
02:13:48 <imode> well, templates are turing complete. I guess template evaluation is undecidable?
02:14:22 <imode> though I guess I can throw that under parsing.
02:15:14 <XorSwap> see I just find it fun knowing that it's possible to take the taylor series of a grammar
02:16:02 <imode> wow. my interest is piqued.
02:19:56 <imode> I should revisit formal language theory.
02:54:47 -!- MDude has joined.
02:55:05 <shachaf> https://en.wikipedia.org/wiki/Operator-precedence_parser#Alternative_methods
02:55:13 <shachaf> This FORTRAN I trick for operator precedence is too good.
03:02:48 -!- oerjan has joined.
03:23:49 <imode> that is a beautiful hack.
03:58:17 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
03:59:42 -!- sprocklem has quit (Quit: []).
04:05:54 -!- sprocklem has joined.
04:10:01 -!- doesthiswork has quit (Quit: Leaving.).
05:08:09 -!- XorSwap has quit (Ping timeout: 268 seconds).
06:14:38 <esowiki> [[Brainfuck implementations]] https://esolangs.org/w/index.php?diff=56138&oldid=56122 * Asdf * (+1075) /* Normal implementations */
06:15:00 <esowiki> [[Brainfuck implementations]] https://esolangs.org/w/index.php?diff=56139&oldid=56138 * Asdf * (-1075) /* Normal implementations */
06:18:16 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56140&oldid=54620 * Asdf * (+271)
06:18:56 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56141&oldid=56140 * Asdf * (+39) /* How can I paste my own code on this wiki? */
06:21:08 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56142&oldid=56141 * Asdf * (-2) /* How can I paste my own code on this wiki? */
06:25:41 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56143&oldid=56142 * Asdf * (-1) /* How can I paste my own code on this wiki? */
06:26:10 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56144&oldid=56143 * Asdf * (-17) /* How can I paste my own code on this wiki? */
06:31:48 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56145&oldid=56144 * Asdf * (+57) /* How can I paste my own code on this wiki? */
06:33:23 <esowiki> [[Brainfuck implementations]] https://esolangs.org/w/index.php?diff=56146&oldid=56139 * Asdf * (+119) /* Normal implementations */
06:36:13 <esowiki> [[Brainfuck implementations]] https://esolangs.org/w/index.php?diff=56147&oldid=56146 * Asdf * (+40) /* Normal implementations */
06:37:24 -!- oerjan has quit (Quit: Nite).
06:39:03 -!- ProofTechnique[m has quit (Ping timeout: 260 seconds).
06:40:13 -!- SoniEx2 has quit (Ping timeout: 260 seconds).
06:41:50 -!- SoniEx2 has joined.
06:46:48 -!- ProofTechnique[m has joined.
06:53:31 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56148&oldid=56145 * Asdf * (+10) /* How can I paste my own code on this wiki? */
06:56:20 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56149&oldid=56148 * Asdf * (+36) /* How can I paste my own code on this wiki? */
06:57:59 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56150&oldid=56149 * Asdf * (+117) /* How can I paste my own code on this wiki? (I didn't violate others' copyright) */
07:18:42 -!- S_Gautam has joined.
07:48:14 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=56151&oldid=55851 * Asdf * (+319) /* C */
07:56:06 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=56152&oldid=56151 * Asdf * (+383) /* C */
07:57:06 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=56153&oldid=56152 * Asdf * (+13) /* C */
07:59:39 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=56154&oldid=56153 * Asdf * (+49) /* C */
08:01:26 <esowiki> [[Deadfish]] https://esolangs.org/w/index.php?diff=56155&oldid=56154 * Asdf * (+54) /* C */
08:02:44 -!- moei has quit (Read error: Connection reset by peer).
08:03:16 -!- moei has joined.
08:19:12 -!- AnotherTest has joined.
08:23:14 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56156&oldid=56150 * Asdf * (+59) /* How can I paste my own code on this wiki? (I didn't violate others' copyright) */
08:38:24 -!- impomatic has joined.
09:27:19 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
09:27:24 <int-e> the trouble is that to put code under CC0 it either has to be public domain (or CC0) or have the right to relicense it (basically, be the author)
09:28:45 <int-e> So... how does one prove authorship pseudonymously? :P
09:33:05 <izabera> create a fake identity, pretend to be real, publish under that name
09:43:18 <nfd> ahhhhhh law
09:43:22 <nfd> never gets old
09:59:27 <int-e> huh, I'm now adding an answer to a question by asdf on ais523's talk page... that seems weird :)
09:59:42 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56157&oldid=56156 * Int-e * (+1027) /* How can I paste my own code on this wiki? (I didn't violate others' copyright) */
09:59:50 <int-e> but I have no better idea.
10:05:03 <esowiki> [[Special:Log/newusers]] create * PlatinumDotEXE * New user account
10:12:57 -!- imode has quit (Ping timeout: 240 seconds).
10:15:44 <esowiki> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=56158&oldid=56052 * PlatinumDotEXE * (+443)
10:24:41 <esowiki> [[OISC]] https://esolangs.org/w/index.php?diff=56159&oldid=55455 * PlatinumDotEXE * (+45) /* List of OISCs */
10:31:18 <esowiki> [[User talk:Ais523]] M https://esolangs.org/w/index.php?diff=56160&oldid=56157 * Int-e * (+11) /* How can I paste my own code on this wiki? (I didn't violate others' copyright) */ typos
12:50:37 -!- AnotherTest has quit (Ping timeout: 260 seconds).
13:00:31 -!- doesthiswork has joined.
13:07:48 <esowiki> [[OISC]] https://esolangs.org/w/index.php?diff=56161&oldid=56159 * Impomatic * (+87) /* List of OISCs */
13:35:11 -!- quintopia has joined.
13:38:00 -!- arseniiv has joined.
13:41:10 -!- XorSwap has joined.
13:44:01 -!- xkapastel has joined.
13:46:11 -!- XorSwap has quit (Ping timeout: 256 seconds).
13:50:12 -!- S_Gautam has joined.
13:51:05 -!- S_Gautam has quit (Client Quit).
13:51:23 -!- S_Gautam has joined.
14:08:44 -!- AnotherTest has joined.
15:15:59 -!- S_Gautam has quit.
15:19:35 -!- XorSwap has joined.
15:31:53 -!- Remavas has joined.
15:32:38 -!- Remavas has quit (Remote host closed the connection).
15:43:23 -!- Remavas has joined.
15:44:05 -!- Remavas has quit (Remote host closed the connection).
16:02:30 -!- Remavas has joined.
16:02:41 -!- Remavas has quit (Remote host closed the connection).
16:03:50 -!- Remavas has joined.
16:04:04 -!- Remavas has quit (Remote host closed the connection).
16:10:14 -!- Naergon has quit (Ping timeout: 276 seconds).
16:16:49 -!- erkin has joined.
16:17:09 -!- erkin has quit (Remote host closed the connection).
16:20:19 -!- erkin has joined.
16:21:58 -!- XorSwap has quit (Read error: Connection reset by peer).
16:51:35 -!- imode has joined.
17:00:10 -!- XorSwap has joined.
17:06:34 -!- XorSwap has quit (Ping timeout: 268 seconds).
17:13:34 -!- S_Gautam has joined.
17:19:01 -!- XorSwap has joined.
17:30:37 -!- XorSwap has quit (Ping timeout: 260 seconds).
17:33:39 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=56162&oldid=56137 * BoutonIA * (+11) /* B */ Add BSoD
17:34:54 -!- Phantom_Hoover has joined.
18:14:34 -!- Remavas has joined.
18:17:11 -!- Naergon has joined.
18:27:12 -!- Phantom__Hoover has joined.
18:28:08 -!- Phantom_Hoover has quit (Ping timeout: 256 seconds).
18:41:34 -!- MDead has joined.
18:42:10 -!- ldm has joined.
18:44:45 -!- MDude has quit (Ping timeout: 264 seconds).
18:46:31 -!- MDead has quit (Ping timeout: 256 seconds).
18:51:58 -!- Remavas has quit (Ping timeout: 264 seconds).
18:52:43 -!- Remavas has joined.
19:53:57 -!- XorSwap has joined.
19:55:06 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
20:00:36 -!- Naergon has quit (Ping timeout: 265 seconds).
20:01:43 -!- MDude has joined.
22:10:20 -!- arseniiv has quit (Ping timeout: 255 seconds).
22:19:22 -!- AnotherTest has quit (Ping timeout: 260 seconds).
23:50:09 <esowiki> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=56163&oldid=56160 * Ais523 * (+326) /* How can I paste my own code on this wiki? (I didn't violate others' copyright) */ yes you did
23:52:19 <esowiki> [[OISC]] M https://esolangs.org/w/index.php?diff=56164&oldid=56161 * Ais523 * (-6) /* List of OISCs */ you don't use = together with += or -= in most languages; in this case, though, -- is probably clearer