00:52:20 -!- Phantom_Hoover has quit (Ping timeout: 276 seconds).
00:56:47 <shachaf> a personal God quaquaquaqua with white beard quaquaquaqua outside time without extension
01:01:40 <int-e> shachaf: fungot has got you?
01:01:40 <fungot> int-e: come here, my snuggly green cutie-pie! a little you value those of your own.
01:01:51 <fungot> Available: agora alice c64 ct darwin discworld enron europarl ff7 fisher fungot homestuck ic irc iwcs jargon lovecraft nethack oots* pa qwantz sms speeches ss wp ukparl youtube
01:02:01 <int-e> (despite the source ;-) )
01:02:37 <shachaf> int-e: The problem is I had to wake up early so I only got three hours of sleep last night.
01:19:37 <b_jonas> shachaf: is the white beard outside all four simultaneous sides of time?
01:21:11 <HackEso> EARTH HAS 4 CORNER SIMULTANEOUS 4-DAY TIME CUBE IN ONLY 24 HOUR ROTATION. 4 CORNER DAYS, CUBES 4 QUAD EARTH. Bible A Lie & Word Is Lies. Navel Connects 4 Corner 4s. God Is Born Of A Mother - She Left Belly B. Signature. Your dirty lying teachers use only the midnight to midnight 1 day (ignoring 3 other days) Time to not foul (already wrong) bible time. Lie that corrupts earth you educated stupid fools.
01:27:46 -!- oerjan has quit (Quit: Nite).
01:31:26 -!- nyeto has joined.
01:36:59 -!- nyeto has left.
01:40:26 -!- imode has quit (Ping timeout: 276 seconds).
02:43:55 <esowiki> [[Metatape]] https://esolangs.org/w/index.php?diff=66934&oldid=66920 * HactarCE * (+583) Added BCT emulator
02:44:27 <esowiki> [[Metatape]] M https://esolangs.org/w/index.php?diff=66935&oldid=66934 * HactarCE * (+0) Capitalize "Bitwise Cyclic Tag" to fix link
02:45:57 <esowiki> [[Metatape]] M https://esolangs.org/w/index.php?diff=66936&oldid=66935 * HactarCE * (+0) Change line wrapping in BCT emulator to be more A E S T H E T I C
02:59:03 -!- imode has joined.
04:41:37 -!- ArthurStrong has joined.
07:27:17 -!- imode has quit (Ping timeout: 240 seconds).
07:58:22 -!- atslash has joined.
08:35:04 <esowiki> [[Flurry]] N https://esolangs.org/w/index.php?oldid=66937 * Challenger5 * (+1840) Created page with "Flurry is a strict functional programming language created by [[User:Challenger5]] and inspired by [[Brain-Flak]]. The main difference in execution model is that there is only..."
08:35:35 <esowiki> [[User:Challenger5]] https://esolangs.org/w/index.php?diff=66938&oldid=57258 * Challenger5 * (+54)
09:02:08 -!- heroux_ has joined.
09:02:26 -!- myname has quit (Ping timeout: 276 seconds).
09:02:38 -!- myname has joined.
09:02:59 -!- heroux has quit (Remote host closed the connection).
09:03:03 -!- heroux_ has changed nick to heroux.
09:44:57 -!- Sgeo has quit (Read error: Connection reset by peer).
09:45:24 -!- Sgeo has joined.
10:45:06 -!- arseniiv has joined.
11:19:19 -!- atslash has quit (Quit: This computer has gone to sleep).
11:44:36 <esowiki> [[Pac]] N https://esolangs.org/w/index.php?oldid=66939 * CMinusMinus * (+389) Created page with "'''PAC''' is an esoteric programming language, created by [[User:CMinusMinus]], consisting of "point and click adventure" commands. {| class="wikitable" |- ! Command !! Acti..."
12:00:26 -!- arseniiv has quit (Ping timeout: 240 seconds).
12:16:51 -!- Phantom_Hoover has joined.
12:28:55 <b_jonas> is there a tetris game for keyboard where there are ten buttons in a row that set the horizontal positions of the piece directly, and doubled four buttons to set its orientation? I wonder if you could play that faster than tetris games with traditional controls
12:58:04 -!- arseniiv has joined.
13:01:45 -!- kritixilithos has joined.
13:05:25 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
13:24:08 -!- kritixilithos has quit (Ping timeout: 260 seconds).
13:38:05 -!- xkapastel has joined.
13:39:51 -!- kritixilithos has joined.
13:53:29 -!- kritixil1thos has joined.
14:10:45 <esowiki> [[Turi]] https://esolangs.org/w/index.php?diff=66940&oldid=57328 * Osmarks * (-7)
14:12:22 <esowiki> [[Turi]] https://esolangs.org/w/index.php?diff=66941&oldid=66940 * Osmarks * (+23)
14:13:08 <esowiki> [[Turi]] https://esolangs.org/w/index.php?diff=66942&oldid=66941 * Osmarks * (+1)
15:22:26 -!- atslash has joined.
15:27:03 -!- atslash has quit (Ping timeout: 264 seconds).
15:42:03 -!- arseniiv has quit (Ping timeout: 264 seconds).
15:46:05 -!- kritixil1thos has quit (Quit: leaving).
15:57:27 -!- kritixilithos has quit (Quit: leaving).
16:00:18 -!- ArthurStrong has quit (Quit: leaving).
16:07:28 -!- arseniiv has joined.
16:22:47 -!- imode has joined.
16:54:32 -!- cabat has joined.
17:27:34 -!- xkapastel has quit (Quit: Connection closed for inactivity).
18:31:17 -!- kritixilithos has joined.
18:48:05 -!- kspalaiologos has joined.
18:52:53 -!- kritixilithos has quit (Remote host closed the connection).
18:54:46 -!- kritixilithos has joined.
18:54:59 -!- cabat has quit (Ping timeout: 268 seconds).
18:57:31 -!- cabat has joined.
18:59:30 <kritixilithos> is a 2-counter machine where all the commands are ordered, eg after the execution of ADD, the instruction right below it is executed next, [specifically ADD(r) instead of ADD(r,c) and JZSUB(r,c) instead of JZSUB(r,c1,c2)], still TC?
19:00:19 <lf94> what's r, what's c
19:00:30 <lf94> jzsub <- jump if sub is zero?
19:00:41 <lf94> (subtraction result)
19:01:45 <kritixilithos> whoops should be INC and JZDEC, jzdec is jump if zero else decrement, r is register and c is command
19:02:27 -!- cabat has quit (Ping timeout: 265 seconds).
19:03:18 -!- cabat has joined.
19:04:04 <kritixilithos> because the wikipedia article on counter machine gives the instruction set as "{ INC ( r, z ), JZDEC ( r, ztrue, zfalse) }", but the esolangs article (in words) seems to imply INC(r) and JZDEC(r,c) but I can't tell
19:06:44 <imode> I don't think so, no.
19:09:05 <imode> oh, nevermind, that's absolutely TC.
19:09:40 <imode> if by JZSUB(r, c) you mean "jump to c, otherwise jump to ip+1"
19:10:52 <esowiki> [[User:CMinusMinus]] https://esolangs.org/w/index.php?diff=66943&oldid=66933 * CMinusMinus * (+8)
19:10:59 <esowiki> [[User:CMinusMinus]] https://esolangs.org/w/index.php?diff=66944&oldid=66943 * CMinusMinus * (+1)
19:12:32 -!- cabat has quit (Read error: Connection reset by peer).
19:14:14 <imode> that's how most assembly languages work.
19:24:38 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66945&oldid=66939 * CMinusMinus * (+711)
19:26:04 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66946&oldid=66945 * CMinusMinus * (+7)
19:27:12 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66947&oldid=66946 * CMinusMinus * (+54)
19:34:14 <kritixilithos> okay thanks, I'll try to figure out the details myself
19:35:12 <lf94> imode what do you think of code vs spec
19:35:37 <lf94> some say they are one in the same. Typically, I think this way, but as I think about it, it seems very wrong way to think.
19:35:42 <lf94> code is based on a shit ton of assumptions
19:35:48 <lf94> because of the underlying impl
19:35:55 <lf94> spec is just english
19:42:30 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66948&oldid=66947 * CMinusMinus * (+59)
19:43:03 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66949&oldid=66948 * CMinusMinus * (+17)
19:44:14 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66950&oldid=66949 * CMinusMinus * (-12)
19:50:47 <imode> lf94: code vs. spec? in an ideal world, they'd be one and the same.
19:51:10 <lf94> how can you say that though, when code depends on an underlying implementation?
19:51:19 <lf94> 1 = 1 can mean anything in code.
19:51:25 <imode> define underlying implementation. you obviously have a case in mind.
19:51:42 <lf94> if we used C to define a spec
19:51:58 <lf94> it wouldn't be good, because C has undefined behavior, thus the spec has undefined behavior...
19:52:07 <lf94> plus the semantics can change based on the variant of C
19:52:12 -!- kritixilithos has quit (Quit: leaving).
19:52:24 <lf94> at least when you write in english, it is direct
19:52:37 <imode> that's not how that works. just because C's standard contains undefined behavior doesn't mean the specification (reference implementation, if you will) has undefined behavior.
19:52:56 <imode> just because english has the capability to be ambiguous does not mean a specification written in english is ambiguous.
19:53:10 <lf94> right, we can be very specific and unambigious
19:53:14 <lf94> but with C it really depends
19:53:18 <imode> it really doesn't.
19:53:31 <lf94> can you think of a way to prove yourself wrong?
19:53:38 <imode> can you provide proof of your statements?
19:53:55 <imode> or even what you mean by "spec" vs "code".
19:54:22 <imode> because you have definitions that are loosely defind between people.
19:54:30 <lf94> (I am asking for you to try and break your argument against me, yourself btw XD)
19:54:50 <imode> what is my argument, exactly.
19:54:58 <lf94> spec and code are the same
19:55:10 <lf94> spec and code can be equally specific, or non-ambigious
19:55:31 <lf94> In the context of C I guess
19:55:32 <imode> it's interesting that you built that up from "in an ideal world, they'd be one and the same".
19:55:47 <lf94> If we use something like Coq - ok, then yes, I 100% agree
19:56:01 <lf94> But Coq is also like writing with your teeth
19:56:18 <imode> how about you define "spec" and "code" for me.
19:56:45 <lf94> A specification describes what should be done, how it should be done
19:56:57 <imode> congratulations, that's suddenly most codebases.
19:57:00 <lf94> Code that implements a specification is like building the machine
19:57:03 <imode> if not all of them. no, actually, all of them.
19:57:16 <lf94> I know what you are saying...
19:57:19 <imode> "what should be done" "how it should be done".
19:57:30 <imode> unless you give those things definition they mean nothing.
19:57:33 <lf94> "place the number 2 into the register a"
19:57:39 <lf94> how do you specify this in C?
19:58:06 <lf94> A spec is a blueprint
19:58:07 <imode> it depends. what is register A, what does "place the number 2" mean, what does "place X into Y" mean, etc.
19:58:16 <lf94> Code is the manifestation
19:58:39 <lf94> Maybe that's the power of a spec imode
19:58:42 <imode> your thoughts lack actual definitions to anything you're stating.
19:58:45 <lf94> It can leave some ambigiuity...
19:58:45 <esowiki> [[Chess]] https://esolangs.org/w/index.php?diff=66951&oldid=23198 * CMinusMinus * (+8)
19:59:06 <imode> specifications are intended to be as unambiguous as possible. otherwise they're just "rough guidelines".
19:59:10 -!- oerjan has joined.
19:59:24 <imode> if I hand you a specification I do not expect you to take liberties unless as directed.
19:59:30 <imode> this is a human process.
19:59:42 <lf94> A lot of specs do not paint a full picture though
19:59:55 <lf94> vs code, which is the whole picture as you build it
20:00:10 <imode> read the last part of the second to last message I sent.
20:00:25 <lf94> > lack of definitions < because I'm exploring the semantics of these lol, sorry...
20:00:26 <imode> it's the same case for "implementation defined" behavior within C.
20:00:27 <lambdabot> <hint>:1:6: error: parse error on input ‘of’
20:00:35 -!- kspalaiologos has quit (Quit: Leaving).
20:00:35 <imode> no, you're just babbling.
20:00:42 <imode> there's a difference.
20:00:44 <lf94> what's wrong with that
20:01:11 <imode> don't paint "babbling" as "exploration", because nothing of what you say has any substance. what is "code" vs. a "specification". if we don't have definitions we can't have a conversation.
20:01:29 <oerjan> hm now i'm hitting that logs not loading bug
20:01:56 <lf94> imode: sorry to upset you. I will stop talking now.
20:02:10 <imode> it's not upsetting, I've just asked for some definitions. :P
20:02:32 <lf94> I don't know what the definitions are - that's basically what I'm trying to figure out...
20:02:45 <imode> start with a working definition and then tear it to bits.
20:02:56 <lf94> if spec and code can accomplish the same things, they are essentially the same, except one can do work right away
20:03:13 <imode> for instance, a specification is a set of rules governing what a conforming example of an instance of that specification should follow.
20:03:52 <imode> code is commonly defined as encoded instructions intended to be consumed by a computer or a piece of software.
20:04:06 <imode> if you ask if these two can be the same, you have to say "what does it mean for them to be the same or different".
20:04:15 <imode> they're different definitions. how can you construe them to be the same.
20:04:44 <lf94> code is a collection of instructions to be carried out by a computer
20:04:48 <oerjan> paradoxically, the difference is that a specification can leave some details unspecified
20:04:53 <lf94> spec is a collection of instructions to be carried out by a human
20:05:09 <lf94> oerjan: I said this, but imode shot it down fast :)
20:05:16 <imode> oerjan: I can leave a lot of details unspecified in code, though. such as how something is actually done.
20:05:27 <imode> of course that's pretty shallow considering you can always find out what's done commonly.
20:05:43 <lf94> The main semantic difference I see is one is read by computers and the other a human
20:05:51 <imode> code is commonly read by humans.
20:06:05 <imode> in fact it's the foundation of a couple million careers. :P
20:07:11 <oerjan> sad, miserable careers, but careers nevertheless
20:07:35 <lf94> If I write a spec in C, I have to understand C and english
20:07:45 <imode> you just have to understand C, actually.
20:07:47 <lf94> and I write a spec in English, I just have to understand English
20:07:55 <lf94> Also English is going to be around for at least 100 years
20:08:17 * oerjan thinks of Z, although he doesn't know much about it
20:08:21 <imode> I don't get where "I have to understand C and English" comes from. you just have to understand C to read a spec written in C.
20:08:21 <lf94> imode: a lot of C code uses English in comments and variables
20:08:41 <imode> lf94: tell that to C programmers who don't use english comments and variable names.
20:08:53 <lf94> a lot of C...not all
20:08:55 <imode> of which there are many in my personal circles.
20:09:08 <lf94> I'm sure you've seen C written in an APL-like style
20:09:14 <lf94> I'm definitely not talking about that.
20:09:30 <lf94> Also, Plan 9 style C sucks too
20:10:09 <imode> if I specify a virtual machine in C, and I declare that this implementation of a virtual machine is "the specification of this machine", then you should be able to take it as the specification of that machine.
20:10:11 <oerjan> https://en.wikipedia.org/wiki/Z_notation
20:10:28 <imode> substitute C for your language of choice.
20:11:05 <imode> put it to you this way: if I was handed two text files, how could I tell which one is a specification.
20:11:28 <arseniiv> then you should be able to take it as the specification of that machine => reference implementation, yeah
20:11:28 <lf94> Right...by whoever tells you...
20:11:29 <imode> Z is good. TLA+ is good.
20:12:02 <lf94> The nice thing about an English spec though is that it's tech agnostic
20:12:04 <imode> arseniiv: pretty much what I'm getting to.
20:12:21 <imode> what does that have to do with technical specifications written in it?
20:12:52 <lf94> Because you don't need to depend now on things with their own specs
20:13:02 <lf94> spec rabbit hole
20:13:13 <imode> you have to introduce new terms, some of which you may have imported from other piece of literature, which may depend on other pieces...
20:13:32 <imode> just because you have adopted a vocabulary does not mean there's not a chain of documents that defined that vocabulary.
20:13:43 <arseniiv> I like taking math examples when I think about interfaces or specs or something, though I don’t know a way to define loose spec following in general
20:13:48 <lf94> There is some research project in this discussion. :p
20:14:17 <arseniiv> for example, a field; field axioms are an interface, or a spec, and concrete fields are its implementations
20:14:18 <imode> lf94: here's a challenge. I hand you two text files, you build me a decider to determine which one's the specification.
20:14:29 <lf94> undecidable obviously
20:14:34 <lf94> it's whatever you tell me is
20:14:39 <imode> correct. so why are you trying to approximate it.
20:14:56 <imode> you are confusing a technical issue with a human one.
20:14:59 <lf94> so I guess now the conversation changes
20:15:04 <lf94> are english or code specs better?
20:15:24 <imode> and why do we have to have a "better".
20:15:48 <imode> an underspecified specification can exist regardless of language.
20:15:58 <imode> a nonconforming implementation can exist regardless of language.
20:16:11 <lf94> are english or code specs better for long term archival of instructions to build something?
20:16:47 <arseniiv> but if we have, say, a finite field? this is too not a concrete thing, it could be another spec, but it clearly “implements” a field spec
20:16:56 <imode> 1. why archival. 2. can you expect humans to be able to read either language in 10,000 years? 3. is the result even runnable in 10,000 years?
20:17:56 <imode> I can have some paper tape containing the baudot encoded specification of a piece of software. it does not mean that 1. someone will be around to read it. 2. a machine is available to decode it. 3. a human will be around to read it. 4. hardware will be present to run the result.
20:19:00 <imode> 1 and 3 are different. 1 pertains to anything that has consciousness and the ability to read symbols. 3 pertains to humans and human languages specifically.
20:19:01 <lf94> "why archival" is like "why exist"
20:19:15 <lf94> archival so it can exist again, if it a useful tool.
20:19:28 <lf94> 2. i definitely expect english to be read in 10,000 years.
20:19:37 <imode> what is so useful a tool that it cannot last through ages on its own.
20:19:54 <lf94> an obscure one :)
20:20:08 <imode> we have not stopped using hammers. they are useful tools. I am not aware of an "archival grade hammer".
20:20:09 <lf94> what do you mean by 3
20:20:30 <lf94> the spec of a hammer fits in your brain though
20:20:36 <lf94> literally one look at a hammer -> bam you have the spec
20:20:49 <imode> aha, you've come across a clue.
20:21:00 <lf94> all code is logically complex though.
20:21:07 <imode> that's an odd presumption.
20:21:08 <lf94> it's a big "problem"
20:21:26 <imode> have you ever written a piece of code that you could in good conscience throw away.
20:21:45 <lf94> all code I've written is basically "thrown away".
20:21:52 <lf94> I think the only code that isn't worth throwing away is like, assembly
20:22:01 <kmc> a lot of code is written to be thrown away and then isn't
20:22:04 <kmc> and just grows like a katamari
20:22:11 <arseniiv> <lf94> are english or code specs better for long term archival of instructions to build something? => as the other time, I’d suggest the examples are the king. If we have a language and many various means to illustrate its structure and semantics even just internally, some one could understand it. But not without many examples. E. g. what’s the sense of this language?: { ε, ac, bc, abcc, aabccc, abbccc, aabbcccc, … } — probably
20:22:11 <arseniiv> you’ll recognize what is that “…”, but if I showed you only { ac, bc }, would you be that sure? (hopefully no)
20:22:35 <imode> concepts that last centuries are ones simple enough to be rediscovered at a glance by common humans.
20:23:06 <imode> either as self-evident consequences of the universe we live in or as incredibly popular ideas that never fell out of following.
20:23:40 <lf94> so concepts mean more than specs?
20:23:54 <lf94> mean more / are more valuable
20:24:07 <lf94> I would say that makes specs even more valuable
20:24:31 <imode> the concept of a turing machine has lasted a century in about 10 or more years.
20:25:23 <lf94> but a turing machine has a spec
20:25:32 <imode> a turing machine is a concept. it has a definition.
20:25:45 <lf94> a spec is a just a giant definition isnt it
20:26:01 <lf94> a definition is usually short, in the common sense
20:26:17 <imode> "to be called a square, a rectangle's sides have to be equal in length."
20:26:23 <arseniiv> so concepts mean more than specs? => personally I’d say it depends. A concept may be pretty vague and work, which means there are noncanonical choices to be made to make it a complete spec but any of that choices would make a useful thing exchangeable with things resulted from other choices
20:26:44 <imode> I'd say that's a specification for a square.
20:26:47 <lf94> ok so let me ask this then
20:26:59 <arseniiv> for example should the tape of TM be infinite in all directions or just in one?
20:27:03 <lf94> would you rather write a spec in code, or in english, knowing it has to last the next 150 years?
20:27:10 <imode> arseniiv: just one. as defined by turing.
20:27:46 <imode> I'd say code. because I have a runnable example of it. but why not _both_.
20:27:58 <lf94> You can do both of course
20:28:06 <imode> I have an english description of Mode, I have a Go description of Mode, I have a C description of Mode.
20:28:12 <arseniiv> imode: hm I should have picked another thing to illustrate my argument then
20:28:15 <lf94> Having many descriptions is probably the best
20:28:25 <imode> if you wanna last years the key is redundancy.
20:28:31 <imode> if you wanna last centuries the key is virality.
20:29:42 <arseniiv> . o O ( if you wanna last millenia then no luck )
20:29:52 <lf94> Thank you imode for the discussion :)
20:30:10 <arseniiv> (hm there should be something closer to million years)
20:30:13 <lf94> Based on this, I would build an English spec as a generalization of the thing I'm building
20:30:19 <imode> np. if I had to offer a piece of advice, don't focus on building the monolith from 2001. build things that are so small they're universal and portable, then evangelize the fuck out of them.
20:30:26 <imode> the things you write are transient. the good bits are in them somewhere.
20:30:34 <lf94> So it would be specified as I build, since you encounter problems as you build
20:31:05 <lf94> That's a good idea you know
20:31:19 <esowiki> [[Pac]] https://esolangs.org/w/index.php?diff=66952&oldid=66950 * JonoCode9374 * (+1520) /* Links */
20:31:28 <lf94> or specs so small they really are just definitions of many things
20:31:34 <arseniiv> OTOH gluing different standalone programs is the part I’m least comfortable with
20:31:48 <imode> if it's small enough you can throw it away and rewrite it from memory it's probably worth keeping.
20:35:43 <imode> one has to eventually realize they're going to die eventually. and short of inscribing the details of their thoughts/software/language/etc on a chemically stable medium orbiting a planetary body with a stable orbit, the things you do have to carry on to the next generation, and the one after that... etc.
20:43:16 <imode> lf94: question, what motivated your line of questioning?
20:45:02 <imode> https://github.com/narenratan/jonesforth_arm64_apl this is nuts.
20:49:51 <imode> lf94: didn't you say you wanted an APL-style language that maps neatly to assembly and has first-class functions and comprehension syntax?
20:55:03 <lf94> imode: what motivated me is writing software right now is a big mental hurdle because of human reasons
20:55:14 <lf94> i want to write things that last
20:55:24 <imode> what human reasons?
20:55:25 <lf94> the only lang I see this is true of is anything in C
20:55:47 <lf94> I just cant get over that a lot of shit I write is just going to rot
20:56:17 <imode> what have you written?
20:59:39 <lf94> Most of the stuff of value I've written in JS
21:00:13 <imode> what're the things you value?
21:00:19 <lf94> base64 over irc; steganographic program to hide text in text; a level viewer
21:00:33 <lf94> things that have actual use as tools
21:00:52 <lf94> https://github.com/lf94
21:06:42 <imode> and why will they rot?
21:07:24 <imode> you seem to have written a good many useful things, I don't know why you think they'll "rot".
21:09:36 <lf94> I dunno, I expect none of this to work after 20 years.
21:09:44 <lf94> _Maybe_ some Rust stuff.
21:09:52 <imode> can you give me a justification as to why you think that.
21:10:21 <imode> the technology required to run the things you wrote isn't exactly uncommon.
21:10:29 <imode> complex. but not uncommon.
21:10:52 <imode> along with that, a lot of this is certainly transcribable to a new language.
21:23:16 <imode> have kids, teach them to maintain your code. easy way.
21:25:07 <imode> I should build a Mode-to-WASM transpiler.
21:25:21 <imode> cash in on the eventual hype.
21:40:41 -!- andrewtheircer has joined.
21:45:40 <imode> is it on the wiki.
21:46:01 <andrewtheircer> you have a 2d table with circles standing up -- wheels
21:46:34 <andrewtheircer> a wheel hitting a wheel perpendicular to itself will make it drop
21:48:49 -!- Taneb has quit (*.net *.split).
21:48:49 -!- zemhill_________ has quit (*.net *.split).
21:54:07 -!- Taneb has joined.
21:54:07 -!- zemhill_________ has joined.
22:09:32 <lf94> imode the hype has come and gone
22:12:59 <imode> I could probably just generate assembly using Mode at this point...
22:13:48 <imode> maybe I should toy with that over the week.
22:15:09 <imode> having multiple targets is going to be a little challenging. I guess, anyway. the same forms are gonna be generated regardless of the architecture.
22:16:05 <imode> dup drop swap last new zero one add subtract while repeat equal less
22:16:11 -!- andrewtheircer has quit (Remote host closed the connection).
22:17:04 <arseniiv> once I had an avatar which depicted all reserved words of a language
22:17:43 <arseniiv> BTW I really like your idea with {}
22:17:52 <arseniiv> what does # do and where is `self`?
22:18:24 <imode> but it can also be 'halt', if you start each process as having its identifier in the queue.
22:18:52 <arseniiv> polymorphism of specifications
22:18:55 <imode> so 16 commands either way. 'halt' is unneeded: you can always phrase things so that termination is at the end.
22:19:15 <imode> yeah, I'm trying to specify "core" vs. "extended" command sets.
22:19:22 <imode> I have a theory that ,1[] is all you need.
22:20:26 <lf94> imode target subleq
22:20:37 <lf94> one instruction set computer
22:20:55 <lf94> this is actually one of my goals
22:20:59 <lf94> when i make a lang
22:25:47 <arseniiv> I like that I liberated myself from μ-recursion when generalizing Minsky machine
22:30:46 <arseniiv> now maybe we need a good name for the operator
22:30:46 <arseniiv> x :: (as -> b) -> (as -> b -> b) -> (as -> c) -> (as -> b -> c) -> b
22:30:46 <arseniiv> x z s q f args = search (z args) where
22:30:46 <arseniiv> search i = if f args i == q args then i else search (s args i)
22:31:58 <arseniiv> something like <find-first-or> maybe
22:33:39 <lf94> Or do what the js community is doing, using ?
22:33:58 <lf94> object.prop?.inner?.innerinner?
22:34:04 <arseniiv> I meant -or as a suffix there :D
22:35:21 <arseniiv> there’s no or, if the value doesn’t occur in the range of `f args`, we loop forever
22:36:19 <lf94> no, better: find-or-floop
22:36:23 <lf94> (floop -> forever loop
22:36:44 <arseniiv> this is one of the ways to add TC to a set of operations on several inductive types
22:37:02 <arseniiv> μ operator doesn’t generalize nicely
22:37:03 <lf94> add looping: turing complete, right?
22:37:47 <arseniiv> when I generalized MM, I saw there were many noncanonical choices made
22:38:26 <arseniiv> this had an effect so that I want to evangelize generalized MM somewhere :P
22:38:48 <lf94> I'm not familiar with what MM is - is it that counting machine?
22:39:13 <lf94> I've really had subleq machine stuck in my head for the past week.
22:39:30 <arseniiv> actually kritixilithos had mentioned it earlier today, I mean not a generalized one
22:40:02 <arseniiv> lf94: oh sorry I’m conflating two frameworks now
22:40:33 <arseniiv> when talking about that `x` operator, I talked about generalized recursive functions
22:40:47 <lf94> > generalize recursive functions
22:40:49 <lambdabot> • Variable not in scope: generalize :: t0 -> t1 -> t
22:40:49 <lambdabot> • Perhaps you meant ‘generate’ (imported from Lambdabot.Plugin.Haskell.E...
22:40:55 <lf94> what is that exactly
22:40:56 <lambdabot> error: Variable not in scope: butts
22:40:59 <lf94> or is this just fancy talk
22:41:05 <lambdabot> Weyl says: In these days the angel of topology and the devil of abstract algebra fight for the soul of every individual discipline of mathematics.
22:41:06 <lf94> for a function that can iterate over any x
22:41:26 <lf94> map: [T] -> [Q]
22:41:31 <lf94> something like that
22:42:11 <b_jonas> arseniiv: isn't that basically a pointer machine though?
22:42:18 <arseniiv> lf94: like simple recursive functions, which is a definition of computability for functions on N, but the generalized ones take on any finite set of algebraic types
22:42:44 <lf94> sorry all that went over my head
22:42:48 <arseniiv> b_jonas: which one, { INC, JZDEC }?
22:42:55 <b_jonas> you know, one that has registers that point into algebraic structures allocated on the heap, can construct new algebraic structures with their fields filled from registers, test between variants, have arbitrary control
22:43:06 <lf94> > computability for functions on N <
22:43:09 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)
22:43:10 <b_jonas> arseniiv: the generalized Minsky Machines
22:43:17 <lf94> what does this really mean
22:43:23 <arseniiv> lf94: I’m to blame to, I conflated two things I had thoughts about and hadn’t even noticed it quickly
22:43:49 <lf94> "N" <- natural numbers?
22:43:49 <arseniiv> lf94: I’ll better give a link, wait a sec
22:44:00 <lf94> ok what I said then sounds right
22:44:09 <lf94> map: [T] -> [Q]
22:44:27 <lf94> loop: [T] -> ???
22:44:33 <arseniiv> one of the formulations: https://en.wikipedia.org/wiki/%CE%9C-recursive_function
22:46:11 <arseniiv> though I like a variant I saw in Manin’s book on computability, it allows several results as well as arguments, adds function concatenation and makes some things more natural. Though I extended on it after all too :o
22:47:28 <arseniiv> b_jonas: yeah, if there is any exposition on those I’ll be glad if someone points me to it, I don’t want to claim anything already invented
22:47:44 <lf94> arseniiv: i'm still confused :v
22:47:56 <lf94> This stuff is written as if someone reading is reading it as a reference...
22:48:21 <lf94> right now I'm interpreting this as some peano number stuff
22:48:27 <arseniiv> I hope someone will find a better link. Hm
22:48:31 <lf94> so the numbers are defined via induction
22:48:44 <arseniiv> though here we already need them defined
22:48:45 <lf94> but I'm very confused about the goal here
22:48:54 <lf94> or the generalization
22:49:00 <lf94> is the generalization just saying, we can do more than numbers?
22:49:13 <arseniiv> the goal is to define all computable functions in that simple inductive manner
22:49:16 <lf94> (natural numbers)
22:49:28 <arseniiv> <lf94> is the generalization just saying, we can do more than numbers? => yeah
22:49:52 <lf94> so we are saying generalized u-recursion is turing complete?
22:49:54 <lf94> because it can make any program?
22:49:56 <arseniiv> for example we can formulate it for binary strings, or natural numbers + lists of them
22:50:10 <lf94> you know what i mean
22:50:31 <lf94> we can define any computable function :D
22:50:38 <lf94> very very cool
22:50:40 <arseniiv> yeah, it can, as the regular one is its instance
22:51:03 <arseniiv> (as I’m breaking with μ for x)
22:51:50 <arseniiv> they don’t need to have extra stuff, only constructors and destructors
22:52:43 <arseniiv> constructors like INC and CLR which should be explicit when we generalize, and destructors like JZDEC, again it would become more complex unfortunately
22:52:56 <lf94> "machines are prettier", like lambda calc vs turing machine?
22:53:15 <arseniiv> in this case I’m on the side of λ
22:53:26 <lf94> but you said 'machines are prettier'
22:53:28 <arseniiv> TM is too complex compared with MM, for me
22:53:53 <lf94> I like the simplicity of lambda
22:53:58 <imode> something tells me that 01[] is suitable for turing completeness.
22:53:58 <lf94> but it's not for free
22:54:15 <lf94> imode: there is a actual competition to determine the smallest turing machine
22:54:20 <lf94> symbols:states
22:54:25 <lf94> I think the smallest is 2:3 or something
22:54:33 <lf94> arseniiv: those are the best :)
22:54:36 <imode> don't see how that's relevant.
22:54:49 <lf94> imode: because you can verify if having 4 symbols is enough.
22:55:05 <imode> not without actually, y'know, doing it.
22:55:10 <arseniiv> but imode’s machine is the other sort of machine
22:55:12 <lf94> I mean I guess 1 symbol is enough
22:55:44 <imode> 0 enqueues a 0, 1 enqueues a 1, [ dequeues a symbol, and if it's 1, advances 1 instruction, otherwise it skips past the matching ].
22:56:25 <lf94> (I'm incorrectly mixing shit - sorry again)
22:56:43 <imode> though I'm trying to figure out how to, for example, encode a 'not': something that detects a 1 and enqueues a 0, and detects a 0 and enqueues a 1.
22:56:58 <imode> [0] would be the former.
22:57:44 <lf94> where does the input come from
22:57:47 <lf94> where does it go
22:57:54 <lf94> at the beginning?
22:58:04 <lf94> (input)(program) ?
22:58:05 <imode> it's a queue machine. read above.
22:58:23 <imode> if I do 0<not code> I expect a 1 in the queue.
22:58:30 <imode> if I do 1<not code> I expect a 0 in the queue.
22:59:01 <imode> you can say "if I dequeue a 1, then enqueue a 0." but you can't say "if I dequeue a 0, then enqueue a 1".
22:59:28 <imode> [0] would take a 1 and spit out a zero.
22:59:31 <arseniiv> hm suddenly I remember a question. Once I thought up an extension to DFAs to make a bunch of those I worked on smaller: an “ε” transition which was run only if all others couldn’t, without consuming an input symbol. Since then I realized it’d be better to call that an else-transition, and the DFA an else-DFA, as it’s not like NFA/ε-NFA at all, and it translates to a DFA quite trivially. Now, does it have maybe a better-known
22:59:42 <imode> actually it has to be [00]
23:00:04 <lf94> imode: but what about encoding anything past the closing ]
23:02:05 <imode> 0 [00]1[10] maybe?
23:02:19 <lf94> [0][1] ? but your "[ deques" comment is throwing me off
23:02:24 <imode> the first [00] consumes the enqueued value and does nothing. it then enqueues a 1.
23:02:33 <arseniiv> imode: are […] still the loopy brackets or something else?
23:02:37 <imode> arseniiv: loopy, yeah.
23:02:56 <imode> [ dequeues a value and, if it's a 1 symbol, enters the loop.
23:02:59 <imode> otherwise it skips it.
23:02:59 <arseniiv> though I’m not clever atm anyway
23:03:42 <lf94> given we put 1 on stack: [0][1] -> 0[1] -> 0
23:04:14 <lf94> this is too brain bending :D
23:04:15 <imode> given a 0, the first [00] consumes the enqueued value and does nothing. it then enqueues a 1, which fires the next loop, which enqueues a 1.
23:05:11 <imode> should actually be [00]1[01]
23:06:55 <imode> given a 1, it dequeues a 1, enqueues a 0, then enqueues a 1, which fires the loop, enqueues a 1, and then terminates..
23:07:04 <imode> yeah I don't think 01[] is a valid command set. hm.
23:07:34 <imode> I guess this would kind of fall under BF instruction minimization but for queue automata.
23:13:12 <imode> hm... what about concurrency primitives?
23:15:29 <imode> the pi calculus is interesting, but I never worked out how it does loops.
23:17:43 <kmc> imode: there's a 'replication' combinator written as !P
23:17:53 <imode> I'm unsure as to how it works.
23:18:32 <kmc> !P == !P | !P
23:18:46 <imode> infinite forks, I guess?
23:18:46 <kmc> or P | !P rather
23:19:04 <kmc> in other words if P is blocking on a read, and gets one, then another P is immediately spawned
23:19:14 <kmc> i had fun making this http://mainisusuallyafunction.blogspot.com/2011/09/lambda-to-pi.html
23:19:35 <kmc> and it discusses this
23:19:41 <imode> neat! I'm reading it now.
23:19:51 <kmc> though I'm not 100% sure I got it right
23:20:08 <kmc> i'm proud of thinking up the compilation from lambda calculus myself
23:20:20 <kmc> there is a lot of esoprogramming-ish stuff on that blog if you enjoy that
23:20:37 <kmc> man, it's been a while
23:20:38 <imode> I'll bookmark and add to my reading list, thanks.
23:20:41 <kmc> I wrote that article more than 8 years ago
23:20:46 <kmc> I was a very different person in many ways
23:20:55 <imode> I've been wanting to build a concatenative version of a process calculus.
23:22:04 <arseniiv> <kmc> i had fun making this http://mainisusuallyafunction.blogspot.com/2011/09/lambda-to-pi.html => oh, interesting. Will read tomorrow!
23:22:23 <arseniiv> technically today but after some sleep
23:23:24 <imode> how is looping expressed in your formulation of it, kmc?
23:23:25 <arseniiv> hm is there a typed π-calculus?
23:23:58 -!- b_jonas has quit (Remote host closed the connection).
23:24:12 <kmc> imode: when a process blocks it forks an the parent returns
23:24:20 <kmc> if the parent is a replicate then it will respawn
23:24:23 <kmc> i think that's how i did it
23:24:26 <kmc> like i said it's been 8 years
23:26:35 <kmc> yeah from reading the code, that looks right
23:26:39 <kmc> run env (Rep p) = forever (run env p)
23:27:01 <kmc> arseniiv: there may be a typed version
23:27:06 <kmc> but in the most basic version there is only one type
23:27:08 <kmc> (channels)
23:27:12 <imode> so !x(y).0|`x<1>.0
23:27:29 <imode> the left half of the fork would block.
23:27:31 <kmc> the only thing you can send through a channel is another channel
23:28:05 <imode> so how do you construct channels, then...?
23:28:15 <imode> oh, right, that v syntax.
23:28:39 <imode> so !x(y).0|`(vy)x<y>.0
23:29:16 <imode> what does this mean? I intend it to mean "the first process will replicate itself for every request".
23:30:39 -!- arseniiv has quit (Ping timeout: 264 seconds).
23:40:01 <imode> so that repeatedly forks.
23:42:44 <imode> seems grossly unspecified..
23:47:10 <imode> the pi calculus seems to be an imperative calculus anyway. each of the statements can be seen as an instruction.
23:47:30 <imode> so I doubt it'd be far off to use [] and {}.
23:54:59 <imode> how in the world do you form an if statement in the pi calculus. o_O
23:55:45 <kmc> imode: first you need to decide on an encoding for bools
23:56:20 <imode> what's a common one?
23:56:24 <kmc> it could for example be: recv x, recv y, recv z, send z to x if T or to y if F
23:56:26 <kmc> i don't know
23:56:31 <kmc> i haven't studied pi calculus much
23:56:39 <kmc> I pulled that out of my ass just now based on church numerals
23:56:51 <kmc> slash church booleans
23:56:55 <imode> I feel like you could eliminate [].
23:57:04 <kmc> and indeed if you take church bools and run them through my lambda-to-pi thing then i think they'll work like that
23:57:27 <kmc> since i implement functions as a process that recieves arguments and a continuation channel and sends the result to the continuation channel
23:59:03 <imode> T could be x(a).y(b).z(c).`z<a>.P
23:59:37 <imode> T could be x(a).y(b).z(c).`c<a>.P
23:59:54 <imode> and F could be x(a).y(b).z(c).`c<a>.P