00:09:55 -!- pikhq has quit (Read error: 110 (Connection timed out)).
00:16:28 -!- pikhq has joined.
00:26:21 <Sgeo> pikhq, how would you react if I said that I was scrapping PSOX?
00:26:56 <pikhq> That depends: why are you scrapping PSOX?
00:27:03 <pikhq> Something better, or just fed up?
00:27:20 <Sgeo> pikhq, I'm not. I just want to know how you'd react >.>
00:27:39 <pikhq> I'd appreciate it if you're moving on to something better.
00:27:43 -!- jix has joined.
00:27:51 <pikhq> Be a bit annoyed if it was just you being fed up.
00:28:00 <pikhq> And pissed off if you were selling it to Microsoft. :p
00:28:18 * Sgeo is getting fed up with PSOX File Descriptors, tbh
00:29:20 <Sgeo> Also, I don't know what license to put it under, but that's not too relevent right now
00:30:13 <Sgeo> All this license stuff just goes over my head
00:30:36 <Sgeo> I'm a programmer, not a lawyer, dangit!
00:32:07 <Sgeo> pikhq, also, can you help make the file descriptor stuff sane?
00:33:03 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/spec/psox.txt
00:40:22 <Sgeo> grr I don't know how to implement the input pseudodomain
00:42:54 <Sgeo> I think I can do this
00:45:00 <Sgeo> "EOF status is 0x01 if there was no EOF encountered, 0x00 if there was an EOF"
00:45:04 <Sgeo> Should I reverse that?
00:54:25 <Sgeo> Ok, I finished db_input.py
00:56:34 <Sgeo> pikhq, look at this horribleness
00:56:34 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/impl/psox/db_input.py
01:08:47 <Sgeo> pikhq, you awake? Or at least capable of typing in your sleep? >.> lol
01:14:07 -!- UnrelatedToQaz has joined.
01:15:07 <Sgeo> Hi UnrelatedToQaz
01:18:50 -!- calamari has quit ("Leaving").
01:33:03 <Slereah> What if he's your long lost twin?
01:33:35 <UnrelatedToQaz> He can't be, as that would mean s/he was related to me. And s/he isn't.
01:33:47 <Slereah> Well, that's why I said "lost".
01:34:36 <UnrelatedToQaz> But it's the definition of Qazness that I am unrelated to Qaz. If a claimant to the title of Qaz was related to me, they couldn't be Qaz.
01:37:24 * oerjan found a Qaz computer virus or something when googling
01:37:47 <oerjan> good you're not related :)
01:39:41 <ihope> I think I've figured out my knot programming language, slightly.
01:40:03 <ihope> "Knot" meaning "link of unknots", which really isn't a knot at all.
01:40:47 <ihope> Though I guess they wouldn't have to be unknots... anyway, I guess ponderings are required.
01:43:19 <ihope> First, the unknots-only version, I guess.
01:44:10 <ihope> Memory consists of a single link. The only operation I can really think of right now is destroying one knot.
01:45:34 <ihope> Every knot in the link is oriented.
01:46:25 <ihope> "Reading" a knot consists of grabbing a list of all knots which must "go through" the knot and which direction they go through.
01:47:00 <ihope> Going through a knot is defined as crossing a Seifert surface of the knot. I guess that means that "must go through" would be crossing all Seifert surfaces of the knot.
01:47:57 <oklopol> i hope i'm not the only one who doesn't know what seifert surface is and will not google.
01:48:03 <oklopol> because you'll have to explain.
01:48:19 <ihope> What, doesn't everybody automatically know what a Seifert surface is? :-P
01:48:32 <ihope> A Seifert surface is just any surface whose boundary is the knot.
01:49:28 <ihope> Stick a knot in bubble solution and hopefully you'll end up with one of its Seifert surfaces. :-)
01:49:43 <oklopol> are we talking about the same kind of knots?
01:49:47 <UnrelatedToQaz> So "crossing a Seifert surface" basically means "going through the knot".
01:50:33 <ihope> As in yes to Unrelated, possibly not to oklopol.
01:50:45 <oerjan> well - anything must probably cross _some_ seifert surface
01:50:56 <oklopol> are knots the stuff that you do with rope :)
01:51:01 <UnrelatedToQaz> Is this "knot" as in "thing tied in string, rope, flax or hemp"?
01:51:08 <ihope> Indeed, but it's harder to cross all Seifert surfaces.
01:51:23 <ihope> This is a knot: http://en.wikipedia.org/wiki/Image:ThreeFoldKnot.jpg
01:52:05 <oerjan> a knot is an embedding of a topological circle in R3, iirc
01:52:26 <oklopol> graphica with the possibility to specify how the nodes are connected!
01:52:47 <ihope> Why would I be speaking of Seifert surfaces of actual knots? :-P
01:54:02 <Slereah> "Knot another knot language"
01:55:37 <oklopol> ohh... the seifert surface is the 2d surface of the knot there?
01:56:16 <oklopol> i assumed you'd think of knots are a logical structure rather than a presentation of the rope's surface...
01:56:23 <oklopol> unless i'm wrong and that's true.
01:56:32 <oklopol> in which case i'd also be right.
01:57:02 <ihope> A Seifert surface isn't the surface of a torus that's tied in a knot.
01:57:25 <ihope> This is a Seifert surface, though it's a Seifert surface of an entire link: http://en.wikipedia.org/wiki/Image:Moebiusband_wikipedia.png
02:00:25 <ihope> A trefoil knot's Seifert surface: http://www.josleys.com/show_gallery.php?galid=303
02:01:48 <ihope> And that Seifert surface has a hole in it, so I guess you can pass another knot through that hole and it wouldn't really be going through the trefoil knot, kind of.
02:03:12 <oklopol> asdf, why can't i even get anything without inventing it myself :-)
02:05:04 <oklopol> seifert surface is a *surface* though? it's a 2d (or other) plane?
02:05:24 <oerjan> surface = 2d but may be curved
02:22:40 <ihope> Hmm, I just got another idea.
02:23:10 <ihope> Instead of just a link, you have a bunch of oriented "strands" which can be open or closed. If they're closed, they
02:23:21 <Slereah> Although there's surfaces which aren't manifolds.
02:23:45 <ihope> If they're closed, they're just knots, but if they're open, they begin and end at surgery points.
02:23:53 -!- jix has quit ("CommandQ").
02:24:50 <ihope> A surgery point has two "in" slots and two "out" slots, and each may or may not be filled. If all of them are filled, the surgery point can be replaced by a crossover in either direction or... um, lemme get a picture.
02:25:03 <ihope> Removing a section of something and replacing it with something that... fits.
02:25:54 -!- Jontte has quit ("Konversation terminated!").
02:25:58 <ihope> Think of surgery points as the yellow things under this section: http://en.wikipedia.org/wiki/Knot_theory#Knot_polynomials
02:29:57 <ihope> So I guess you can create surgery points in random places, and you can create strands going between them, and you can delete the surgery points to connect the strands.
02:30:29 <ihope> I guess more pondering will definitely be required before I can turn this into a language, eh?
02:31:27 <Slereah> Well, at least I don't have any clue of how to do it!
02:32:19 <oklopol> i wonder if you could make a borromean ring with any number of rings...
02:32:31 <oklopol> i smell awesome kinetic experiment
02:32:56 <ihope> I'm pretty sure you can.
02:33:10 <oklopol> not sure whether you can make a chain reaction out of that
02:33:23 <ihope> Wikipedia is nice, isn't it? http://en.wikipedia.org/wiki/Brunnian_link
02:34:11 <UnrelatedToQaz> i suppose the chain reaction thing depends on how tight they are
02:34:49 <oklopol> i'm currently playing with continuations trying to make subtle cough tc, or at least more powerful, by creating new kinds of continuations
02:35:19 <oklopol> i'm gonna call it supercough if i find something interesting, i'm just that lame :-)
02:35:59 <ihope> http://www.google.com/search?q=supercough... >:-)
02:36:58 <UnrelatedToQaz> Oh yips, continuations. Fancy basing a language on the only Unlambda primitive I don't understand...
02:38:00 <oklopol> it's just never made that explicit...
02:39:39 <oklopol> my way to get it was to make a new notation for it and play with unlambda a bit
02:39:45 <Slereah> Finally, my FTP works again.
02:40:05 <Slereah> http://membres.lycos.fr/bewulf/Russell/BRAINFUCK%20INTERPRETER%20ON%20A%20ONE.htm
02:40:08 <oklopol> although, like always, i had to guess how it might work before i understood it
02:40:37 <oklopol> luckily, everything that is in any way meaningful seems to be inventable in a few hours of thinking
02:40:52 <oklopol> i mean, the simple kind of stuff :)
02:42:14 <UnrelatedToQaz> So a continuation is a way of storing the current state of a program?
02:43:14 <oklopol> i used a notation for a continuation, where i actually took the whole program and put it in braces with * where the value would be returned
02:43:43 <oklopol> need to see the whole state at once, or it feels too magical to be understandable
02:44:12 <oklopol> like ``cc`cc, the first `cc is evaluated first to make ``c{`*`cc}`cc
02:44:42 <oklopol> the current continuation is the place where c was called, with the knowledge about where to return if the continuation is called.
02:45:53 <oklopol> kinda. but using my notation (or some other that turns it into simple combinatorics..) you can just think of it as string transformations
02:46:30 * oerjan thought it was his notation...
02:46:34 <oklopol> i didn't understand the notation used on the unlambda page, it's prolly much better.
02:47:00 <oerjan> i added it to the Unlambda page after all
02:47:01 <oklopol> and * was from the unlambda page notation, which i did not understand.
02:47:44 <oklopol> in that case i read your notation's description, didn't understand it, and then invented it myself :P
02:48:20 <oklopol> perhaps i subconsciously got it or something, although i myself don't believe in that kinda magic.
02:48:54 <UnrelatedToQaz> incidentally, I'm writing an interpreter for a language of my own
02:49:07 <oerjan> well the * was the important part, at least as i used it in the Subtle Cough page
02:49:10 <oklopol> oerjan: the notation actually shows the whole continuation as a lambda inside the partially evaluated program?
02:49:38 <UnrelatedToQaz> in Perl. Could anyone advise me on how I'd later add - well, modules - to it?
02:50:02 <UnrelatedToQaz> There'd have to be some modification of the actual interpreter, as I see it.
02:50:18 <oerjan> well not in lambda notation
02:50:49 <oklopol> can you show me how ``cc`cc evolves?
02:51:08 <oklopol> in your notation... or is that an example on the page :P
02:51:34 <oklopol> i can't find the notation on the page anymore... i kinda suck ;)
02:52:10 <oerjan> yep, on the subtle cough page:
02:52:12 <oerjan> ``cc`cc = `(`*`cc)`cc = `(`*`cc)(`(`*`cc)*) = `(`(`*`cc)*)`cc = `(`*`cc)`cc (circular, because (`(`*`cc)*) = (`*`cc)).
02:52:46 <oerjan> that is using some shortcuts from the others i think
02:53:36 <oklopol> ``cc`cc -> ``c{`*`cc}`cc -> `{`*`cc}{`*`cc}`cc -> `{`*`cc}`cc -> ``cc`cc
02:53:51 <oklopol> i'll look more closely, it may be 100% identical
02:54:16 <oerjan> your 4th step is my second
02:54:53 <oklopol> "circular, because..." why don't you just evaluate until it becomes the original prog :\
02:55:10 <oerjan> um it never quite does i think...
02:55:21 <oklopol> is my evaluation wrong there?
02:55:50 <oklopol> {...} is a function, that when called, forgets the current context and puts the arg where the * is
02:56:00 <oklopol> i used that to represent a continuation
02:56:02 <oerjan> you are missing the evaluation of the `cc at the end
02:56:35 <oklopol> didn't think it's necessary to do that ;-)
02:56:45 <oerjan> it has to be evaluated before applying the continuation
02:57:59 -!- UnrelatedToQaz has left (?).
03:01:25 <oklopol> hehe, the only difference was the fact i used {} and you used () then :P
03:03:25 <oerjan> hm i wonder if it _does_ return properly ever, or if i recall correctly that it somehow grows while staying equivalent
03:03:51 <oklopol> i'll make an interp, and see
03:03:57 <oklopol> that's hell to do by hand.
03:04:16 <oklopol> although, i think it grows infinitely...
03:04:46 <oklopol> i'm sure someone here could just *see* it.
03:05:18 <oerjan> we were at `(`(`*`cc)*)`cc before i "cheated"
03:05:48 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:05:52 <oerjan> = `(`(`*`cc)*)(`(`(`*`cc)*)*)
03:06:22 <oerjan> =`(`*`cc)(`(`(`*`cc)*)*)
03:06:58 <oerjan> it seems to grow one extra level per iteration
03:07:34 <oklopol> but given ø-reduction, it stays the same.
03:08:52 <oklopol> i'm assuming oerjan did the ``cc`cc proof here, even though subtle cough is ihope's, am i correct?
03:09:36 <pikhq> http://www.technologyreview.com/printer_friendly_article.aspx?id=19845
03:09:53 <oklopol> (yes, i read the unlambda page; if it was there, lol :))
03:11:27 <oerjan> actually i think i started with the subtle cough proof and after i finished it i wrote the notation in the unlambda page so others might have a hope of understanding it
03:12:07 <oklopol> so, ihope comes up with a language, and you ruin it by telling him it only has 3 progs? :)
03:12:08 <oerjan> plus some ideas of how to make the notation more powerful
03:12:56 <oklopol> although, ihope was probably happier with that, than if it would just have been left without any research.
03:13:02 <oerjan> otoh i cannot prove noone else has made such a notation before in the context of lambda calculus with continuations or something
03:14:03 <oklopol> considering my notation, i'd say it's not *that* improbable
03:14:56 <oklopol> then realized there will always be just one thing arg, since further conts would be nested anyway
03:16:22 <oklopol> * is one of the chars i consider objokenish enough to be used as a value, not an operator.
03:16:46 <oklopol> the other non-ascii chars that have this property are @, and ¤
03:16:55 <oklopol> i'd seen * on the page, so i used it.
03:17:10 <oklopol> just trying to prove to myself i didn't steal your notation
03:17:18 <oklopol> what's the point? no idea.
03:19:24 <oklopol> perhaps the point is i represented it as *my* notation, which is kinda rude :P
03:21:08 <oerjan> "Bad artists copy. Great artists steal." -- Pablo Picasso
03:21:52 <pikhq> "I stand on the shoulders of giants." -- Isaac Newton (paraphrased)
03:22:11 <oklopol> "Sometimes you need to ruin it with something completely random" -- oklopol
03:22:34 <oerjan> "Argle bargle, glop glyf" -- Douglas Adams
03:22:58 <pikhq> Adams' insight never ceases to astound.
03:24:21 <Slereah> "Dragons logically follow evolution, so they would be able to wield metal" -- Kenneth Eng
03:28:06 <oerjan> hm, Zzo38 is also using continuations in his latest.
03:42:34 <oklopol> OK, i need to start reading the wiki, that language was actually a mindblowing experience :)
03:45:15 <oklopol> oerjan: did you mean continuousequation?
03:45:56 <oklopol> since it doesn't use continuations, just the word continuation
03:46:24 <oerjan> but Zzo38 is incredibly prolific...
03:46:28 <Sgeo> Why is channel awake NOW, when I need to leave?
03:47:11 <Slereah> It's a secret conspiracy against you.
03:47:25 <Slereah> Don't eat the muffin on your table.
03:48:02 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
03:48:29 <oklopol> searching for zzo: View (previous 500) (next 500) (20 | 50 | 100 | 250 | 500).
03:48:58 <oklopol> i guess... i didn't actually look what are listed there.
03:49:15 <oklopol> for a second i thought they were just the wiki pages he had authored :P
03:50:02 <oklopol> just 30, i just fail to understand the ui on the search page.
03:50:13 <Slereah> Ooooh, he did the Twoducks.
03:51:27 * Slereah tries to make some sort of unlambdaish interpreter on the Love Machine 9000
03:54:16 <oklopol> i've thought about something twoduck'ish... i'm fairly sure all my ideas exist on the esolang wiki already
03:56:27 * Slereah passes his finger over some unlambda expression, thinking "What would Turing do?"
03:57:50 <oklopol> i wonder if twodux has an interp
03:58:10 <oklopol> turing would own us all at esolangs :)
03:58:11 <Slereah> Depends. Do you have a flux capacitator?
03:58:45 <oklopol> he did a lot of code on paper, even a program that played a board game or something, or do i remember totally wrong here?
03:58:59 <oklopol> i wonder if all that code actually works
03:59:27 <Slereah> Well, back then, he couldn't just fire up his computer to try it!
03:59:45 <oklopol> indeed. this is why i wonder
04:00:24 <Slereah> I don't envy Turing and the like. Doing a Turing machine by hand is bothersome.
04:00:31 <oklopol> i mean, i rarely get a program right the first time
04:01:40 <oklopol> can you do them automatically? :-)
04:02:19 <Slereah> I wonder if he had some tape at home, and wrote symbols on it, while going "beep boop".
04:02:31 <oklopol> hmm... actually, i rarely get a program 100% correct in a normal language, but for some reason esolang programs usually work on the first attempt
04:02:38 <oklopol> most likely because i give it more thought
04:02:51 <oklopol> with python, i just write a few lines of random code every now and then
04:03:14 <oklopol> and my program is almost ready now even though i've been chatting this whole time :P
04:03:56 <oklopol> making a subtle cough interp to test my idea
04:04:23 <oklopol> and also perhaps to be able to visualize continuations a bit better in general.
04:15:49 <Slereah> Is an Unlambda combinator always made up of x primitive combinators and x-1 `?
04:21:00 <Slereah> Hm. If I get `iC, can I just erase `i from the tape?
04:24:09 <oklopol> hmm, d never makes it matter?
04:24:17 <oklopol> i don't know how d works really...
04:24:45 <oklopol> d matters, or d makes i matter?
04:24:52 <Slereah> It will probably be pretty much Lazy k with the .x combinator
04:25:21 <oklopol> yay, the interp worked on the first attempt
04:26:00 <oerjan> no i don't think d affects removing `i
04:26:22 <oklopol> i'm not doing a deepcopy everywhere where i copy the whole program into a continuation... guess i should add that, or i may get something too interesting.
04:26:57 <oklopol> can you sum up d in a sentence so i don't need to open the page again? :P
04:26:58 <oerjan> unlambda has no mutable structures
04:27:08 <oerjan> so deep copying is unnecessary
04:27:51 <oklopol> you see, when i swap '*' inside the continuation
04:28:00 <oklopol> i destroy the whole program, why not?
04:28:05 <oerjan> for an expression `EF if after evaluating E it happens to be d, then F is not evaluated
04:28:46 <oklopol> i see, it will *never* be evaluated, or when it is further applied, like ``d.xi
04:29:18 <oerjan> oh if you implement continuations like that, yes it sounds dangerous
04:30:15 <oklopol> i'm implementing them that way because i'm going to extend that a bit
04:30:25 <oklopol> so i actually want the program to be inside the continuation.
04:30:27 <oerjan> ``dFG : first evaluate G e.g. to g. then evaluate `Fg
04:31:10 -!- GreaseMonkey has quit ("Welcome to 2008. I will be your tour guide.").
04:31:27 <oklopol> oh, right, it will evaluate the d'd expression once the d expression is further applied, then, like i suggested?
04:31:46 <oklopol> okay, then i invented the d combinator.
04:32:02 <oklopol> well, learning is inventing for everyone, i guess
04:32:17 <Slereah> I discovered salt, and invented FM radio.
04:38:42 <oklopol> hehe, quite ironic the first time i actually have a need to use a continuation is when implementing subtle cough :)
04:39:20 <oerjan> well that certainly gives a minimal implementation
04:40:06 <pikhq> The *D* combinator?
04:40:15 <oklopol> oh, i'd never use call/cc for the c combinator
04:40:16 <pikhq> Care to give me a lambda expression of it?
04:41:09 <Slereah> IIRC, d isn't really a combinator
04:41:29 <oklopol> that's not what i'd've used it for, just so i could replace the whole program with the contents of the {...} without having to unwind the call stack, if i'm inside another expression when evaluating it
04:41:30 <Slereah> Combinatorial sugar or something!
04:41:39 <oklopol> well, basically the same thing, but less obvious.
04:42:42 -!- calamari has joined.
04:42:48 * oerjan was going to paste d from unl2caml but it was a bit complicated
04:43:37 <oklopol> what's the lambda expression of c?
04:44:07 <oerjan> well c isn't in lambda calculus either
04:44:48 <oerjan> s,k,i, and v are combinators though
04:45:56 <oklopol> yeah, my point was c and d are called combinators just because it's more convenient than calling them "those things unlambda has that aren't exactly combinators, but you know what i mean"
04:46:40 <Slereah> Aren't combinators functions?
04:47:01 <oerjan> but not all functions are combinators, especially impure ones
04:48:08 <oerjan> side effects, non-local control...
04:48:24 <oerjan> non-referential transparency
04:49:22 <oerjan> pure functions: evaluates a result given arguments, no other effect
04:49:39 <oerjan> giving the same arguments always gives the same result
04:54:08 <oklopol> i'm gonna call them fumbinators from now on.
04:57:07 <oklopol> how the heck do i check whether two objects are in the same memory location in python...
05:07:13 -!- oerjan has quit ("Good night").
05:09:23 <oklopol> http://www.vjn.fi/pb/p346643411.txt
05:11:23 <oklopol> i guess i should implement ø-reduction :D
05:12:31 <Slereah> Oh hell. Already a problem.
05:16:59 <Slereah> Ah yes, a marker deleted a piece of code, that's why.
05:25:23 <Slereah> A minimal one. s, k, i, .x
05:25:33 <Slereah> Maybe some other combinators for kicks.
05:26:08 <Slereah> So far I have some piece of code to at least check if the program has the right number of combinators and `
05:26:35 <oklopol> cise (bit of speccing), graphica (version 0.5), supercough (currently just an idea i haven't tested) and ...that one language (example code + lots of ideas), and 82 problems in project euler
05:26:40 <oklopol> this has been a good holiday.
05:27:17 <oklopol> what language are you using?
05:28:16 <oklopol> ohh, then it may not be that trivial :)
05:28:52 <Slereah> The idea will be to use 4 tapes.
05:30:02 <Slereah> If I encounter some other combinator than i, the tapes 3 and 4 counts the ` and primitive combinators until I'm sure to have a whole combinator, and then the evaluation is copied on tape 2.
05:31:24 <Slereah> Well, I'm not exactly sure of a simple way to use the counter either.
05:31:51 <oklopol> now... what should *i* be cooking
05:32:13 <Slereah> But well, for instance, if I have ``k(C1)(C2), C1 will be copied on the second tape.
05:32:25 <oklopol> i'll go outside, perhaps i come up with something
05:32:39 <Slereah> Because it would be complicated to rewrite the expression on one tape
05:32:59 <Slereah> Writes it on the second tape, erase the first, and copy the second tape onto the first.
05:33:53 <oklopol> yeah, or you can duplicate your code and move back and forth and do a step each time.
05:34:43 <oklopol> also, if you're doing .x, you have side-effects, so remember to change the copying head into the identity head once you've made one rewrite.
05:35:02 <oklopol> identity head just copies without evaluating, that is :)
05:35:13 <Slereah> No need. The `i is just removing `i
05:35:32 <Slereah> Or, for .x, printing x and removing `.x
05:36:40 -!- weilawei has quit (Nick collision from services.).
05:37:18 <oklopol> if you have ``a`bc`de, you can't evaluate both `bc and `de in one step
05:38:00 <oklopol> because a might apply after evaluation of `bc
05:38:49 <Slereah> Probably. But I'll try the simple way first.
05:38:56 <oklopol> because there's no referential transparency guaranteed, you have to be sure to just do one thing per step; this is why after evaluating one subexpression inside the whole thing, you need to copy it all to the next tape
05:39:07 <oklopol> well, that's not necessarily more complicated
05:39:23 <Slereah> Every step will only evaluate one combinator, oklopol
05:40:14 <Slereah> It looks at the first combinator, checks if there's enough combinators in front to evaluate it, and if there are, returns the evaluation on the second tape.
05:40:23 <Slereah> Or if not, just continues.
05:41:30 <oklopol> okay, xchat started lagging too much now
05:43:34 <oklopol> should i do a time traveling language, or a program that wraps up a given ca based on sending messages between the nodes of a graph and visualizing it by showing the messages move between the nodes?
05:44:21 <Slereah> Well, if you want, there's useful equations for it in here : http://membres.lycos.fr/bewulf/Russell/incomplete_equation.jpg
05:44:40 <Slereah> First one is useful for timetravel
05:45:54 <oklopol> i'm not sure i can use use that media.
05:46:43 <oklopol> the eyes cannot make out the text
05:47:09 <oklopol> there is some scribble in their backs
05:47:23 <Slereah> First one is general relativity
05:47:30 <Slereah> Second one is electromagnetism.
05:47:44 <Slereah> Last one is quantum mechanic.
05:47:48 <oklopol> yes, but my eyes are too distracted
05:53:32 <Slereah> Hm. I think I can probably make the interpreter with just one counter.
05:53:58 <Slereah> Starts at 1, adds 1 for every `, substract 1 for every primitive combinator
05:55:13 <Slereah> Although I probably should make the code every two cells to have some markers in here.
06:16:55 <oklopol> http://www.veling.nl/anne/lang/lambda/ i wonder how lambda calculus inspired this :D
06:25:48 <Slereah> Oh hell. Once again, the problem of a state that deals with characters!
06:38:27 <oklopol> okay, i'll stop using python for a while now, just too trivial
06:40:13 <oklopol> i'll make an interp for a small concurrent language in scheme
06:40:33 <oklopol> should finally try *using* it for something
06:41:08 <Slereah> @ ` # r # ` # ` # ` # ` # ` # ` # ` # ` # ` # ` # ` # . H # . e # . l # . l # . o # . b # . w # . o # . r # . l # . d # i # #
06:42:00 <Slereah> But it writes that code every two cells!
06:42:03 <oklopol> how many stacks are you using?
06:42:33 <oklopol> if you use 1, there should be a trivial mapping to brainfuck
06:43:22 <Slereah> I'm not so sure. Since it's based on states, not instructions, I can't think of a trivial isomorphism.
06:44:35 <oklopol> hmm... three tape code -> one tape code: take the three tapes, and make an empty cell between every two cells, then zip the cells getting [1,2,3...],[5,3,7...],[67,3,6...] -> [1,0,5,0,67,0,2,0,3,0... etc]
06:44:48 <oklopol> now, put a 1 into 2nd, 4th and 6th cell
06:45:57 <oklopol> then, when you change tape from ath tape to bth tape, move (b-a)*2 cells backwards
06:46:10 <oklopol> then find the 1 on that tape
06:46:43 <oklopol> when moving, move the one, when checking / using the value, use the number that is in the cell just left of the current cell, which should hold the 1
06:47:08 <oklopol> basically simulate multiple tapes using a separate token for show where the head is
06:47:33 <oklopol> hmm... i guess you need to have 2's in every cell *before* the head.
06:47:38 <oklopol> so you know which way to look
06:48:09 <oklopol> this can be done after you are ready of course, and if you don't wanna do it, perhaps let me, since ski->brainfuck would be great
06:48:40 <Slereah> Well, right now, I'm still on making the code pretty for the Love Machine 9000.
06:49:07 <oklopol> no hurry, it's just i've been thinking about ski->brainfuck, but i haven't gotten much done
06:49:12 <Slereah> I have one combinator/`operator every two cells on the second tape so far
06:50:04 <Slereah> Well, not exactly, but there's an empty cell between 'em all.
06:58:22 -!- calamari has quit ("Leaving").
07:04:52 <oklopol> hehe, tried making a page on esowiki, and failed badly :P
07:05:43 <oklopol> http://www.esolangs.org/wiki/YABC
07:06:17 <oklopol> i think that's tc via a not-too-trivial isomorphism to bf
07:07:01 <oklopol> but, anyone with any skill, please fix that, i can't figure out how to get the instructions on separate lines or to look nice otherwise :-)
07:13:05 <oklopol> http://www.esolangs.org/wiki/YABC lol getting closer :)
07:13:18 <oklopol> oh, right, the link isn't a fixed one
07:14:37 <oklopol> basically, you have a language with do while loops instead of while loops
07:14:56 <oklopol> and you have to make the value to jump with on the tape yourself
07:15:09 <oklopol> i think this has been discussed sometime
07:15:40 <oklopol> i mean, the do...while thing
07:16:52 <oklopol> perhaps later today i'll put something real there
07:22:34 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
07:25:31 -!- oklopol has joined.
07:27:46 <Slereah> Everything nice on the first tape. Now, to evaluate!
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:15:52 <Slereah> Well, I've seen better, but it's a start.
08:22:29 <Slereah> I'll just put the tape display on.
09:14:01 <Slereah> Now, to tackle the big un's.
09:17:21 <Slereah> What's a nice short Unlambda program with s's and k's?
09:21:06 <Slereah> Idea : Replace all s by ```kiss
09:30:41 <Slereah> Hm. Kisses would be ((se)s)
09:30:59 <Slereah> So applying a kiss to something would be (eC)(sC)
09:32:02 <Slereah> "When applied, e exits the program, possibly providing its argument as the program's result."
09:32:21 <Slereah> So kisses on some operator outputs the operator!
09:34:14 <oklopol> ``````kisses X -> ```sesX -> ``ex`sx, indeed
09:35:27 <Slereah> "Kiss your program goodbye!"
09:38:21 -!- Jontte has joined.
09:39:03 <Slereah> I'm going to have to rewrite it entirely after I'm done with this version.
09:39:09 <Slereah> It's full of redundant states.
10:35:32 -!- weilawei has joined.
12:43:36 -!- jix has joined.
13:10:21 -!- Jontte has quit (Remote closed the connection).
13:10:53 -!- Jontte has joined.
13:15:34 -!- oerjan has joined.
13:49:13 -!- SimonRC has quit (Connection timed out).
13:57:03 -!- RedDak has joined.
15:01:50 -!- SimonRC has joined.
15:29:04 -!- jix has quit (Nick collision from services.).
15:29:14 -!- jix has joined.
15:32:34 -!- RedDak has quit (Remote closed the connection).
15:32:59 -!- oerjan has quit ("Dinner").
16:44:54 -!- mtve has joined.
17:13:34 -!- Jontte has quit (Remote closed the connection).
17:14:02 -!- Jontte has joined.
17:39:28 -!- Jontte has quit (Remote closed the connection).
17:39:56 -!- Jontte has joined.
18:42:05 -!- calamari has joined.
20:18:22 -!- calamari has left (?).
21:07:32 -!- oerjan has joined.
21:11:23 -!- RedDak has joined.
21:27:10 <oerjan> oklopol: Anne Veling is male
21:33:43 <oklopol> in that case i cannot resort to the "women can't code" stereotype, and ask how lambda is related to lambda calculus
21:34:02 <oklopol> anne is a male name? where?
21:34:16 <oerjan> in holland, according to his homepage
21:34:47 <oklopol> oh holland, you crack me up!
21:34:57 <oerjan> he probably gets to point it out a lot :D
21:35:28 <oklopol> hehe, prolly, it's a female name in english, finnish and pretty much all over europa... i think
21:36:24 <oerjan> well france is worse. you know that joke about Jean Marie... they found out everything about the person except the gender
21:37:00 * pikhq wonders how a programming language can claim to be 'inspired by lambda calculus' without lambda expressions
21:37:07 * oerjan wouldn't advise telling that joke to le Pen, he thinks
21:37:29 <pikhq> http://www.veling.nl/anne/lang/lambda/
21:38:17 <pikhq> It's a fairly basic assembly kinda thing, apparently.
21:39:34 <oklopol> it does seem to be done not that seriously, i just don't get the joke...
21:42:36 <Slereah> Can I assume that a k is evaluated only if preceded by ``?
21:47:43 <Slereah> Let's see how those k states fares.
21:52:43 <oerjan> btw maybe you could use the idea from my unlambda meta-notation of having a different symbol (e.g. ') for expressions that have already been fully evaluated
21:53:21 <Slereah> I'm not sure how that works out.
21:54:26 <Slereah> "Not enough tapes. Program interrupted.
21:55:10 <Slereah> Wrong state on the end of k.
21:58:12 <oerjan> wait a moment, are you using lazy or strict evaluation?
21:58:23 <Slereah> What would be the difference.
21:58:50 <oerjan> do you evaluate the arguments of s and k before applying them?
21:59:15 <oerjan> ok then my ' suggestion is probably useless
21:59:31 <Slereah> If there's a s or k and enough arguments, it rewrites the string in the proper form on the second tape.
21:59:52 <oerjan> and you probably take the first s or k you find too :)
22:00:16 <Slereah> Unless there's not enough argument.
22:00:34 <oerjan> that's lazy, or perhaps rather call-by-name, since i assume you have no sharing among copied terms
22:00:53 <oerjan> this being string-based
22:02:07 <Slereah> # ` # ` # k # ` # i # . x ` # i # . i # # # # # # # # # # # # # # # # # # #
22:02:07 <Slereah> # # # # # # # # # # # # @ ` # i # . x # # # # # # # # # # # # # # # # # # # # #
22:07:17 -!- wooby has joined.
22:07:52 <wooby> GregorR: has c2bf seen any recent development?
22:07:56 <Slereah> Well, ``k`i.x`i.i prints x.
22:08:18 <oerjan> Slereah: um, that's a bit different from unlambda
22:08:34 <oklopol> Slereah: prints or evaluates to?
22:08:42 <oerjan> in unlambda .x prints when _applied_, not when evaluated
22:09:13 <oerjan> of course in a lazy language your way may be just as fine
22:09:31 <Slereah> You should see the code, it's full of redundant states.
22:10:10 <Slereah> http://membres.lycos.fr/bewulf/Russell/Unlambda%202.txt
22:10:30 <Slereah> Still need to deal with s and not enough argument for k.
22:12:02 <Slereah> (It might actually be shorter if the printing of characters was just the character and the combinator preceded by ., but well)
22:14:11 <Slereah> ``k````.p.e.n.i.s```.b.u.t.t -> penis
22:15:33 <Slereah> Let's see what will happen for only one argument!
22:31:13 <Slereah> Ah yes. i->erase `i only works for when i is applied.
22:31:52 <Slereah> If I have something of the form `k.x, is it reasonable to evaluate .x and change it to `ki?
22:33:22 <oerjan> it would be unusual, but your language already is...
22:33:26 <oklopol> it's reasonable if it'd be tons harder to do it like unlambda does it
22:33:50 <oklopol> ...i tried to wait for you to answer, and when i do, you answer on the same second :)
22:33:53 <Slereah> Well, I suppose it wouldn't be too hard.
22:34:14 <Slereah> I could just check if there's ` before to change it.
22:34:30 <oklopol> or just print when a .x is applied
22:34:46 <oklopol> unless you meant just that
22:35:27 <Slereah> Sort of. Although I think that with the current code, it will still print it if only .x remains.
22:35:50 <Slereah> Or maybe not if I add the ` condition.
22:36:01 <oklopol> well, if the ski part works, count me happy.
22:36:08 <Slereah> I should also add a halting condition if only i remains.
22:36:21 <oerjan> now in weak head-normal evaluation, you can just stop if your k doesn't have enough arguments
22:36:24 <Slereah> Otherwise, it will be bothersome.
22:37:27 <Slereah> So far, the halting condition is that the evaluation reach the end of the program, meaning that nothing must remain at the end.
22:37:30 <oerjan> because any program can be written such that the first primitive always is the next to be applied
22:37:49 <oklopol> oerjan: your unlambda in unlambda, does it just convert the string to an unlambda expression and then evaluate that, or do you simulate the whole thing or something?
22:38:27 <oerjan> it does an eta-expansion, essentially
22:39:02 <oerjan> expand `FG -> ``s expand F expand G
22:39:20 <oerjan> expand primitive = `k primitive
22:40:12 <oerjan> and when the result is applied to anything, it works equivalently to evaluating the original unlambda expression
22:41:06 <oerjan> although i made one exception: the e function is implemented as i, meaning that the argument passed to the expression must be e or some continuation to quit the program
22:41:23 <Slereah> Self-rewriting code puts a strain on my smile.
22:41:27 <oerjan> *implemented = expanded
22:43:46 <oerjan> this exception means that you could theoretically embed the interpreter in a larger program and have it return in the larger program when the interpreted program calls e
22:48:08 <oerjan> oh and expand F = abstraction elimination of \e -> F, essentially
22:53:36 -!- RedDak has quit (Remote closed the connection).
23:04:27 -!- tesseracter_ has joined.
23:11:03 -!- tesseracter__ has joined.
23:14:37 -!- weilawei has quit (Read error: 110 (Connection timed out)).
23:17:56 -!- tesseracter has quit (Read error: 110 (Connection timed out)).
23:22:20 -!- tesseracter_ has quit (Connection timed out).