←2008-01-10 2008-01-11 2008-01-12→ ↑2008 ↑all
00:00:02 <oklopol> i was first gonna written elliot, but then realized you're definitely a double geminate guy
00:00:38 <oklopol> heh
00:00:38 <oklopol> today, i heard of a person with my name
00:00:43 <oklopol> a guy said their teacher had said to the class she'd called for some tech assistance, and i had answered.
00:00:50 <ehird`> (happy tomorrow GMT)
00:01:04 <oklopol> (said "an old student" and my name)
00:01:18 <oklopol> (not sure it's me, but quite close, for i'm an old student of hers)
00:01:25 <oklopol> i didn't get a call though.
00:01:40 <ehird`> oklopol: they were going to ask for your help but then saw oklotalk
00:01:42 <ehird`> :)
00:04:22 -!- CakeProphet has quit (Connection timed out).
00:04:27 -!- CakeProphet__ has changed nick to CakeProphet.
00:04:35 -!- Jontte has quit ("Konversation terminated!").
00:05:10 <oklopol> :D
00:05:14 <ehird`> QUIZ
00:05:20 <ehird`> find a language where this does what you'd expect
00:05:21 <ehird`> 3=4
00:05:36 <oklopol> that one esolang, you mean?
00:05:45 <oklopol> i'd expect it's an always-failing proposition
00:05:58 <oklopol> i don't remember the name now, but the language is fun
00:07:51 <ehird`> no
00:07:56 <ehird`> it should actually redefine 3 as 4
00:08:04 <ehird`> x = 3
00:08:05 <ehird`> 3 = 4
00:08:09 <ehird`> x // => 4
00:08:11 <ehird`> 3 // => 4
00:08:17 <ehird`> 3 + 1 // => 5
00:08:29 <ehird`> 4 - 1 // => who knows?
00:08:47 <ehird`> 4 - 1 // => 4, probably, since 3 is now 4
00:09:57 <oklopol> 3 is now 4, but 4 is still 4
00:10:01 <oklopol> at least in the esolang
00:10:11 <ehird`> yes
00:10:15 <ehird`> 3 // => 4
00:10:18 <ehird`> 4 // => 4
00:10:25 <oklopol> yeah, so 4-1=3
00:10:26 <ehird`> 4 - 1 // => this would be 3, but 3 is now 4, so: 4
00:10:27 <oklopol> oh.
00:10:29 <oklopol> 4 of course :)
00:10:44 <ehird`> :D
00:13:45 <ehird`> esolangs aren't innovative anymore, just reinventions :(
00:16:56 -!- CakeProphet_ has quit (Connection timed out).
00:17:59 <oklopol> nah
00:18:30 <oklopol> i think i've invented quite a lot of new stuff.
00:18:43 <oklopol> for example...
00:18:57 <oklopol> have i mentioned GRAPHICA, HAVE I EVER MENTIONED GRAPHICA?
00:19:17 <ehird`> no. never.
00:21:26 <oklopol> :----)
00:24:06 <ehird`> fibonacci in graphica=
00:24:25 <oklopol> it's not tc yet.
00:24:32 <oklopol> or then it is, not sure
00:24:45 <ehird`> fibonacci is a simple rewrite rule
00:24:46 <ehird`> no TC needed
00:25:26 <oklopol> i guess you could just Fib m n :: m n <-> Fib m+n m
00:25:43 <ehird`> fibonacci's rewrite rules are very simple:
00:25:46 <oklopol> oh, wait
00:25:57 <oklopol> i guess you could just Fib m n :: m <-> Fib m+n m
00:25:57 <ehird`> (A → B), (B → AB)
00:26:00 <ehird`> start with A
00:26:04 <ehird`> then it's in unary.
00:26:37 <ehird`> or (B → BA).
00:26:52 <oklopol> mm
00:27:41 -!- CakeProphet__ has joined.
00:29:14 <ehird`> "A"->"B";"B"->"AB";"A"
00:29:19 <ehird`> doesn't work, though, in CRTL
00:29:29 <ehird`> because the rules get removed, and the A rule effects the "B"->"AB"
00:31:59 <oklopol> well, you can use my program though
00:32:47 <oklopol> also, you can attach a type tag there, to make sure rules apply in the right order and to the right data
00:39:17 <GreaseMonkey> A->B , B->AB | B->AB , AB->BAB ?
00:39:28 <GreaseMonkey> or A->B, B->BB?
00:41:26 <ehird`> A-B, B->AB
00:41:34 <ehird`> oh
00:41:35 <ehird`> you mean in my prog
00:41:41 <ehird`> "A"->"B";"B"->"AB";"A"
00:41:47 <ehird`> "B"->"BB";"B"
00:41:49 <ehird`> "BB"
00:41:56 <ehird`> so, "A"->"B";"B"->"AB";"A" outputs "BB" and exits
00:42:05 <oklopol> ehird`: what was wrong with my fibonacci?
00:42:22 <ehird`> oklopol: ?
00:42:30 <oklopol> the one i gave hours ago
00:42:35 <ehird`> show
00:43:37 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b),a;("fib"->"1")->"1"
00:43:50 <ehird`> let me step through that.
00:43:52 <ehird`> uh
00:43:53 <ehird`> you have ,
00:43:57 <ehird`> , is not CRTL.
00:43:58 <ehird`> QED
00:44:00 <oklopol> well yeah, that was for output
00:44:03 <oklopol> you can forget about that one
00:44:11 <ehird`> show me a new one then
00:44:16 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"1")->"1"
00:44:23 <ehird`> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"1")->"1"
00:44:57 <ehird`> ("fib"->"1")->"11"
00:45:06 <ehird`> [end]
00:45:10 <oklopol> hmm
00:45:21 <oklopol> why doesn't rule 1 apply a second time? :\
00:45:25 <oklopol> rules are one use?
00:45:30 <ehird`> because it's removed from play
00:45:33 <oklopol> didn't know that
00:45:42 <oklopol> then the language is pretty useless, huh?
00:45:57 <oklopol> i mean, you can do a fixed number of rewrites
00:46:37 <ehird`> nope, because you can do things like this:
00:46:49 -!- CakeProphet has quit (Connection timed out).
00:47:05 <ehird`> hmm
00:47:08 <ehird`> ok then
00:47:11 <ehird`> let's apply it multiple times.
00:47:15 <ehird`> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"1")->"1"
00:47:21 <ehird`> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"1")->"11"
00:47:31 <ehird`> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"11")->"111"
00:47:41 <ehird`> (("fib"->a)->b)->(("fib"->b)->a~b);("fib"->"111")->"11111"
00:47:42 <ehird`> yeah, that works
00:47:47 <ehird`> ok, now make it do output :P
00:48:00 <oklopol> well, only possible with ","
00:48:07 <oklopol> or something equivalent
00:48:17 <ehird`> nope, i'm pretty sure you can do it
00:48:22 <ehird`> let's try...
00:48:22 <oklopol> no way to make a new tuple -> no way to do infinite outputs
00:48:33 <ehird`> what about if we leave outputted strings in place.
00:49:02 <oklopol> well... then it's possible again, but perhaps a bit ugly, i'll try
00:49:55 <oklopol> actually... hmm
00:51:16 <ehird`> oklopol: ("fibo"~x)->... may help
00:53:22 <oklopol> (("fib"->a)->b)->(("printed"->b)->a~b);
00:53:22 <oklopol> (("printed"->a)->b)->a~"|"~b
00:53:22 <oklopol> a~"|"~b->(("fib"->a)->b)
00:53:22 <oklopol> ("fib"->"1")->"1";
00:53:31 <oklopol> best i could think of
00:53:41 <ehird`> example output?
00:53:48 <oklopol> that'll print 1|1, 1|11, 11|111, 111|11111
00:53:50 <oklopol> i think.
00:53:56 <ehird`> so it generates statements like:
00:53:58 <ehird`> "1|11";
00:54:04 <oklopol> you see i need to parse the values back after printing them
00:54:07 <ehird`> with no other expression in that statement?
00:54:30 <oklopol> generates what i said, but s/","/newline, i guess
00:54:58 <ehird`> i mean in the code.
00:55:07 <oklopol> hmm?
00:55:36 <oklopol> oh, printed is redundant...
00:56:04 <oklopol> (("fib"->a)->b)->b~"|"~a~b;
00:56:04 <oklopol> a~"|"~b->(("fib"->a)->b)
00:56:04 <oklopol> ("fib"->"1")->"1";
00:56:42 <ehird`> now put that on the CRTL wiki and i'll update the spec so that it's true :P
00:56:46 <oklopol> :D
00:56:49 <ehird`> by the way, does that rely on any kind of evaluation order?
00:56:56 <oklopol> no, i don't think so
00:57:21 <ehird`> yay
00:57:45 <oklopol> but, the problem is, after you do output, you cannot (using my way of coding) output any less than *everything* you're gonna need in further computation
00:58:10 <oklopol> because printing is done by encoding the program state into a string, and then parsing the string into a tuple again.
00:58:11 <oklopol> oh
00:58:33 <oklopol> it actually relies on the fact a string is only output once, then tried the substitutions again
00:58:49 <oklopol> but this is a given, for otherwise *any* output you do could happen *any* number of times
00:58:57 <oklopol> and what's with the *emphasis*
00:59:34 <ehird`> yeah, that's right
00:59:39 <ehird`> http://esoteric.voxelperfect.net/wiki/CRTL#Evaluation updated
00:59:56 <ehird`> I'll add your fibonacci.
01:01:03 <ehird`> ok, added
01:01:06 <ehird`> I think it's turing complete.
01:01:26 <GreaseMonkey> ah...
01:01:38 <GreaseMonkey> ehird`: what's your lang called?
01:01:44 <ehird`> GreaseMonkey: CRTL...
01:01:57 <ehird`> Constantly Rewriting Term Language
01:02:18 <ehird`> oklopol: "," is not needed now yeah?
01:02:38 <ehird`> btw: a good excersize would be a dupdog interpreter.
01:03:54 <oklopol> well, "," would just be nice, since you would have tc output :-)
01:03:59 <oklopol> if you know what i mean
01:04:11 <ehird`> no, i don't
01:04:32 <ehird`> let's assume that CRTL is turing complete, are you saying it can't output every string as a result of a calculation?
01:04:43 <oklopol> yes.
01:04:49 <GreaseMonkey> ok.
01:04:54 <oklopol> in case there's no better way than what i'm using.
01:05:27 <oklopol> just like bf couldn't output every string if . printed "printing: <char>"
01:05:32 <oklopol> it'd still be tc.
01:06:52 <oklopol> i guess a better example is, utm cannot do output, but i'm fairly sure it's tc!
01:09:05 <ehird`> yeah i get it
01:09:15 <ehird`> oklopol: got any more elegant solutions than ,?
01:10:18 <oklopol> hmm, i'm wishing a way to do without it would pop in my head...
01:11:15 <oklopol> hmmm... "," is non elegant why?
01:11:27 <ehird`> dunno
01:11:45 <oklopol> i mean, you can't pattern match on rules with free variables anyway, so there's a definite distinction between data and rewriting rules...
01:11:57 <oklopol> well
01:12:06 <oklopol> i mean, in some cases.
01:12:21 <ehird`> hmm
01:12:23 <ehird`> i can add '
01:12:24 <ehird`> quote
01:12:31 <ehird`> to pattern match on free vars.
01:12:41 <oklopol> yeah, metalevels ftw!
01:13:28 <oklopol> but, i still think "," would be nice, otherwise you'll just have a fixed set of rules... and that's just too static!
01:13:42 <ehird`> ok.
01:45:27 -!- Corun has quit ("This computer has gone to sleep").
02:05:19 <ehird`> back
02:05:42 <ehird`> oklopol: i will add quoted = "'" name | "'" quoted
02:05:48 <ehird`> oklopol: but this makes programs = data
02:05:54 <ehird`> so propose a , that doesn't differenciate
02:06:01 -!- CakeProphet__ has quit (Read error: 110 (Connection timed out)).
02:08:35 <ehird`> oklopol: ping
02:09:17 <oklopol> o
02:09:44 <ehird`> so yeah, do that :P
02:09:48 <oklopol> :)
02:10:11 <oklopol> well, there's one that i can think of at least, but it's a bit complex.
02:10:16 <ehird`> tell me.
02:11:14 <oklopol> a rule A -> B, C is considered two separate rules A -> B; A -> C when it's pattern matched on, the "," just means the two rules are always applied both
02:11:41 <oklopol> then it could be pattern matched on
02:12:28 <ehird`> A -> B; A -> C is pretty nonsensical
02:12:43 <ehird`> if A->B is run first the program becomes A -> B; B -> C
02:12:50 <ehird`> the other way around, C -> B; A -> C
02:13:27 <ehird`> so, suggest an elegant solution that makes sense :D
02:13:48 <oklopol> that was not a way to convert a rule with "," to one without it
02:13:57 <oklopol> that's impossible
02:14:08 <ehird`> okay
02:14:10 <ehird`> then explain
02:14:12 <oklopol> it'd be A->B; A->C; when pattern matched on.
02:14:34 <oklopol> when it's used as the pattern, it'd be a special pattern thatmakes two tuples from one input tuple.
02:14:37 <oklopol> *that makes
02:14:55 <ehird`> so pattern matching doesn't reflect what you see in the source...
02:14:59 <ehird`> no: i don't like that.
02:15:43 <oklopol> then you can just add the new operator ","
02:16:09 <oklopol> the problem is, that makes it useless to have data and program flow integrated when the feature is not used
02:16:29 <ehird`> sorry i think you'll have to come up with something a lot nicer :)
02:16:30 <oklopol> actually....
02:16:31 <ehird`> i suggest:
02:16:35 <ehird`> a,b
02:16:37 <ehird`> err
02:16:38 <ehird`> ok
02:16:46 <ehird`> foo->(bar,baz)
02:17:04 <ehird`> foo->bar, but appends "baz" to the end of the program and maybe-outputs it
02:17:19 <oklopol> actually i don't think "," as an operator would be that bad
02:17:43 <oklopol> so
02:18:22 <oklopol> "a","b"->"c" would consume an "a" and a "b" and create a "c"
02:18:34 <oklopol> then it'd be a bit more generic
02:18:54 <ehird`> ok, write a fibonacci-outputs-in-unary-without-weird-extra-state
02:18:56 <ehird`> using that
02:18:57 <ehird`> :-)
02:19:06 <oklopol> umm...
02:19:15 <oklopol> it'd work with what i originally had
02:19:23 <oklopol> i can find it again
02:19:36 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b),a;("fib"->"1")->"1"
02:19:49 <ehird`> oh
02:19:52 <ehird`> so it still does the weird thing
02:19:56 <ehird`> ok, how about
02:20:08 <ehird`> ok wait
02:20:19 <ehird`> in your example, oklopol
02:20:21 <oklopol> the weird thing?
02:20:21 <ehird`> the a
02:20:23 <ehird`> where does it go?
02:20:27 <ehird`> after the match? or at the end of the program
02:20:36 <ehird`> if at the end of the program, then that's my foo->(bar,baz) semantics
02:21:01 <oklopol> the way i see it, ";":s in the program code separate entries in a tuplespace, which is unordered
02:21:11 <oklopol> so i don't really think "where a goes in the code"
02:21:28 <oklopol> but in the case the tuplespace can be assumed unordered, in the end? doesn't matter
02:21:40 <ehird`> so
02:21:44 <ehird`> x->(y,z)
02:21:55 <ehird`> replaces x with y, and introduces z into the program space.
02:22:04 <oklopol> well, with your semantics, yes
02:22:13 <ehird`> what's your semantics for x->(y,z)
02:22:23 <oklopol> oh, well, actually, that's my semantics, sorry :)
02:22:25 <ehird`> also oklopol you keep missing out the final ;
02:22:32 <oklopol> indeed i do, but i know it's there.
02:22:37 <oklopol> noticed myself too
02:22:45 <ehird`> should i remove the need for it?
02:23:10 <oklopol> hmm... perhaps, ";" seems more like a separator than a delimiter to me
02:23:27 <oklopol> it's used as both, so i don't think it matters.
02:23:34 <oklopol> actually
02:23:40 <oklopol> if you have it be a separator
02:24:00 <ehird`> oklopol: on the LHS, what does (a,b) do?
02:24:03 <ehird`> e.g. in (a,b)->c
02:24:04 <oklopol> then a ";" in the end of a program means the string "", possibly, which is printed, as a nop
02:24:23 <oklopol> it finds something matching a and something matching b, and returns c in the tuplespace
02:24:37 <oklopol> a and b will share variables in pattern matchin
02:24:38 <oklopol> *g
02:25:10 <ehird`> oklopol: ...?
02:25:19 <oklopol> hmm?
02:25:22 <ehird`> (a,b)->c "find both a and b, and replace them with c?"
02:25:32 <oklopol> yes.
02:25:39 <ehird`> but that's totally different from your RHS , semantics
02:25:43 <oklopol> no
02:25:44 <ehird`> it's not related
02:25:47 <ehird`> ok then i guess
02:26:09 <oklopol> wait, i'll clear my thoughts a bit
02:26:23 <ehird`> oklopol: remember that it would find ALL as and Bs
02:26:24 <oklopol> it's really annoying to think when the text appears a minute after i've written it
02:26:28 <ehird`> because replacements replace EVERYTHING they can find
02:27:05 <oklopol> you can think of the "replace all" thing as "replace one, repeat"
02:27:19 <oklopol> in which case matching multiple tuples at the same time is okay.
02:27:44 -!- helios24_ has joined.
02:28:28 -!- helios24 has quit (Read error: 113 (No route to host)).
02:28:52 <oklopol> basically, a rule (comma-separated tuples)->(comma-separated tuples) means "repeatedly find a set of tuples that match left side, put their free variables to corresponding vars in the right side, remove all left-side tuples, add all right-side tuples"
02:29:19 <oklopol> this works like expected for comma-separated lists with just one element == like before.
02:29:59 <oklopol> that was not a fully formal explanation for i am very sleepy, i can maybe give you an example if you didn't get it
02:30:26 <oklopol> "a"->"b"; "a"; ==> "a"->"b"; "b";
02:30:33 <oklopol> the case where only one tuple on both sides
02:30:45 <ehird`> oklopol: OH! how do you match a,b pairs????
02:30:54 <oklopol> left side ("a") was removed from the tuplespace
02:30:54 <ehird`> (OH DEAR YOU LOSE.)
02:31:01 <oklopol> right side was added
02:31:04 <ehird`> Also you can't nest ,s
02:31:09 <ehird`> So blahhh your semantics suck.
02:31:18 <oklopol> k
02:31:23 <ehird`> :P
02:31:58 <oklopol> sure you can nest them, actually
02:32:15 <ehird`> how
02:33:10 <ehird`> ...
02:33:50 <oklopol> (a,b->"c")->("d"->a,b); "a","b"->"c"; "d"; => (a,b->"c")->("d"->a,b); "d"->"a","b"; "d"; => (a,b->"c")->("d"->a,b); "d"->"a","b"; "a"; "b"; and modify semantics so that strings are gc'd (and thus printed) once nothing matches on them
02:34:09 <oklopol> sorry, lag addes a few minutes to my response time
02:34:11 <oklopol> *adds
02:34:27 <ehird`> umm that makes no sense :D
02:34:35 <ehird`> also i don't want to remove strings once nothing matches on them
02:34:37 <ehird`> :(
02:35:04 <oklopol> well, your language ;-)
02:35:15 <ehird`> i'm going to remove , for now until we can think of a sane way to do this stuff :P
02:35:30 <oklopol> (my semantics are perfect though :))
02:35:39 <oklopol> (uhhh, touch them)
02:35:49 <ehird`> ?
02:36:09 <oklopol> (parens are there so you know to ignore it)
02:37:24 <ehird`> yeah
02:37:25 <ehird`> but
02:37:28 <ehird`> (uhhh, touch them)
02:38:13 <oklopol> a comma-separated list is not hard to match. it's a linear rise in complexity, if you allow patterns in the left side to match the same tuple
02:38:38 <oklopol> a,b->"b";"a" ==> a,b->"b";"b"
02:39:14 <ehird`> oklopol: yes but nesting them makes not a lot of sense
02:39:38 <ehird`> I think what we need is an implementation of the current spec first
02:39:41 <ehird`> and then think about it
02:39:49 <ehird`> what language would be best suited for it though?
02:40:04 <ehird`> we need to do parsing, loads of mutability on the program, and lots of pattern matching
02:40:12 <oklopol> well, "," would only have the special property on the topmost level, otherwise it'd just be a separator
02:40:19 <oklopol> which already is how "->" works.
02:41:14 <oklopol> what about "(uhhh, touch them)"? a request to touch the semantics to feel how soft they are.
02:41:18 <oklopol> hmm
02:41:19 <oklopol> not soft
02:41:40 <oklopol> something.
02:41:50 <ehird`> anyway!
02:41:51 <ehird`> implementation.
02:42:07 <oklopol> imple pimple!
02:42:22 <oklopol> i can make one quite quickly in python, but i'm trying to change language
02:42:31 <oklopol> to scheme
02:42:40 <ehird`> wise choice :-)
02:42:46 <ehird`> yeah python would be good for the mutability, but yeck
02:42:50 <ehird`> haskell might actually be good
02:42:54 <ehird`> but parsing will be a bitch.
02:43:07 <ehird`> parsec doesn't like paren := (expr) where expr has an option of paren
02:43:11 <ehird`> can't figure out why oh well
02:43:35 <oklopol> hmm, i think parsing is fairly straightforward
02:43:51 <ehird`> i guess
02:44:01 <oklopol> in haskell you mean
02:44:01 <oklopol> ?
02:44:07 <oklopol> sorry
02:44:11 <ehird`> yeah.
02:44:13 <oklopol> when i asked you hadn't answered.
02:44:17 <ehird`> parsec - haskell parsing library
02:44:20 <ehird`> and yeah. i had. :P
02:44:22 <oklopol> yeah
02:44:24 <ehird`> i know you have lag though
02:44:35 <faxlore> parsec rules!
02:44:36 <oklopol> yep, "lag", my xchat is broken.
02:44:47 <ehird`> oklopol: really the perfect language would be CRTL heh :|
02:44:54 <oklopol> haha, indeed :P
02:45:14 <ehird`> it's like, when haskell was first formalized
02:45:25 <ehird`> 'shit guys implementing this is gonna be HELL'
02:45:38 <ehird`> 'well you could use monads and polymorphic type classes generalizing over pattern matchers...'
02:45:45 <ehird`> 'yeah but that's what we're trying to implement'
02:46:00 <oklopol> :)
02:46:44 <oklopol> most of crtl is fairly straightforward, the problem is if you want efficiency, you need to keep a conceptual separation of data and program
02:47:10 <oklopol> not that anything could ever be hard in python... god i miss python :-)
02:47:15 <oklopol> stopped using it earlier today
02:47:30 <ehird`> yes it is very unelegant but has that extra ZAM which scheme lacks
02:47:48 <oklopol> indeed, and i kinda like the ZAM
02:47:50 <ehird`> oklopol: for mutable things like this (i.e. not elegant, pattern-weaving and folding algorithms) maybe you should check out haskell
02:47:58 <ehird`> i've actually found its mutability to be nice.
02:48:06 <oklopol> i know haskell
02:48:08 <oklopol> somewhat.
02:48:21 <oklopol> i never fully understood monads :-)
02:48:42 * oklopol is a rare case!
02:48:53 <faxlore> ZAM = expressive type system?
02:49:12 <oklopol> no, python has that not.
02:49:13 <ehird`> faxlore: python has one of them?
02:49:18 <faxlore> no..
02:49:23 <faxlore> neither does scheme
02:49:24 <ehird`> oklopol: i figured out monads a while ago
02:49:26 <oklopol> well, you know... ZAM
02:49:30 <ehird`> oklopol: forget about 'do'
02:49:33 <ehird`> and think about it like this
02:49:44 <oklopol> i never actually tried that hard
02:49:54 <ehird`> (do a <- b; c) is (b >>= (\a -> c))
02:49:58 <oklopol> hoped i'd just get them eventually...
02:50:01 <ehird`> (do a; b) is (a >> b)
02:50:05 <oklopol> yeah
02:50:06 <ehird`> then, what happens is
02:50:12 <ehird`> "a" recieves the monad as an implicit perameter
02:50:15 <ehird`> and returns the 'new monad'
02:50:18 <oklopol> yeah
02:50:30 <ehird`> in >>, that just means the monad b gets is what a 'returned' as the monad
02:50:51 <ehird`> in >>= the RESULT that a returns is passed to the function, which also gets its implicit monad changed to what a's monad became
02:51:01 <oklopol> so monads have an implicit part and an explicit part
02:51:08 <ehird`> yeah, kind of
02:51:11 <ehird`> and the way e.g. IO works
02:51:23 <oklopol> in m >>= l, the explicit one is what is given to l
02:51:25 <oklopol> as a param
02:51:36 <oklopol> return lifts it back on the implicit param
02:51:37 <faxlore> (>>=) = flip concatMap -- :D
02:51:40 <oklopol> on the "monad"
02:51:42 <ehird`> is that the monadic values 'bubble up' into functions all of which must have the IO monad themselves (let's ignore unsafePerformIO for now) and then the runtime system at the top does the evil
02:51:57 <ehird`> oklopol: yeah, remember though that when you do "return x" in a monadic function that's one of two return values
02:52:00 <ehird`> that's the "real return value"
02:52:04 <ehird`> the monad is "implicitly" passed on
02:52:22 <oklopol> yeah
02:52:29 <ehird`> and now you understand how monads can be stateful: they're implicitly passed around (obviously the implementation is a hell of a lot more efficient than that, haha ;))
02:52:53 <ehird`> see now that wasn't hard was it :-)
02:52:59 <oklopol> i guess i kinda understood that already
02:53:08 <oklopol> i just feel there's still something missing :-)
02:53:10 <oklopol> oh, right
02:53:17 <faxlore> should read the monad transformers
02:53:17 <oklopol> can you formalize a>>b again?
02:53:35 <faxlore> http://uebb.cs.tu-berlin.de/~magr/pub/Transformers.en.html
02:53:35 <oklopol> what a returned... what's a?
02:53:49 <ehird`> ok,
02:53:53 <ehird`> a is an exprsesion
02:53:54 <ehird`> b is an expression
02:54:22 <ehird`> a runs on the current monad, then we continue onto executing b with a new monad containing all the stuff a did to it.
02:54:30 <ehird`> note: that evaluation order is *well-defined*
02:54:32 <ehird`> a, then b
02:55:00 <ehird`> a >>= b is the same, except b must be a function, and a's return value is passed to b as an argument
02:55:15 <oklopol> right. doesn't sound hard really..
02:55:54 <oklopol> faxlore: i'll read that
02:56:13 <ehird`> faxlore: iirc that's confusing
02:56:15 <ehird`> :-)
02:56:15 <faxlore> I liked it
02:56:17 <ehird`> can't remember
02:56:20 <faxlore> And found it very clear
02:56:39 <ehird`> oklopol: basically you could convert any program using monads to non-monads
02:56:46 <faxlore> it mighht be a different paper
02:56:48 <ehird`> instead of a function doing "return x", you do
02:56:53 <ehird`> "(x, myNewMonad)"
02:57:01 <ehird`> the rest im sure you can figure out yourself.
02:58:44 <oklopol> i guess it's the list monad that always scared me :)
02:58:57 <faxlore> list monad is easy!!!
02:59:01 <faxlore> (>>=) = flip concatMap -- :D
02:59:02 <faxlore> lol
03:01:44 <ehird`> list monad...?
03:02:21 <faxlore> do x <- [1,2,3] ; y <- "flub" ; return (x,y)
03:02:56 <oklopol> hmm
03:03:09 <oklopol> does that do a cartesian product?
03:03:20 <ehird`> faxlore: what about it though
03:03:25 <faxlore> dunno
03:03:31 <faxlore> example of list monad
03:03:37 <oklopol> what does that do?
03:03:39 <ehird`> i don't see what the list monad can do
03:03:40 <faxlore> it does do cartesian product
03:03:44 <ehird`> why does it exist
03:03:54 <faxlore> list monad is nondeterministic choice monad
03:04:02 <ehird`> uh-huh?
03:04:26 <oklopol> hmm
03:04:50 <oklopol> faxlore: elaborate
03:04:53 <faxlore> well you can do lots of useful list operations using monadic procedures someone else wrote
03:05:07 <faxlore> I think it's just that... lists are obviously a monad, so there is an implementation
03:05:13 <faxlore> as with Maybe etc
03:05:14 <ehird`> but why monads
03:05:18 <ehird`> why are lists monads
03:05:38 <faxlore> because return and (>>=) have clear monadic definitions?
03:05:50 <faxlore> (for lists)
03:06:14 <faxlore> I mean all list comprehensions are is use of the list monad
03:06:36 <ehird`> :|
03:06:44 <faxlore> huh?
03:07:37 <oklopol> the syntax [...] is defined in the list monad?
03:07:42 <oklopol> i mean, the list syntax
03:07:46 <faxlore> no
03:07:53 <oklopol> oh!
03:07:57 <oklopol> list comprehensions...
03:07:58 <faxlore> you could define your own list type using Nil and Cons, then write a monad for it
03:08:46 <oklopol> indeed, cartesian product is kinda essential
03:09:19 <oklopol> when done lazily
03:12:25 <ehird`> "(It should be noted that it was rougly at this point that Pressey reached one of the peaks of his so-called "referential" period, in which he was apt to provide "commentary" on his own work, in the form of interjections or asides, as if from the perspective of a historian from a much later era. Such pretentious interruptions were generally not well received, except perhaps by the occasional loser such as yourself.)"
03:16:02 <oklopol> where?
03:17:26 <ehird`> see catseye.tv
03:17:29 <ehird`> *tc
03:17:35 <ehird`> it's in the spec for the latest-released language
03:27:37 <ehird`> random thing:
03:27:40 <ehird`> you know Banana Schemes?
03:27:46 <ehird`> well, you can implement Scheme-omega, kinda.
03:28:09 <ehird`> introduce a third boolean value, maybe
03:28:13 <ehird`> which has two values attached to it
03:28:24 <ehird`> (constructed by (maybe a b) but that's not neccessary)
03:28:35 <ehird`> now,
03:28:47 <ehird`> (H x code) -> (maybe #t #f)
03:29:18 <ehird`> (if (maybe A B) C D) -> "if A and B, C. otherwise, if (not A) and (not B), D. otherwise, (maybe C D)"
03:29:28 <ehird`> or similar
03:29:40 <ehird`> then, if you want, implement a graphical program showing a tree of all possibilities
03:30:12 <ehird`> ofc no console output is assumed it would still be possible with it but you'd have to pick one path before any branch wants to do input
03:30:19 <ehird`> in case you might not want that input
03:30:20 <ehird`> or whatever
03:30:27 <ehird`> er
03:30:28 <ehird`> console INPUT
03:32:59 <oklopol> i'd use haskell, but it just feels like cheating...
03:33:07 <oklopol> perhaps i should move to asm
03:33:24 <ehird`> oklopol: why would that be cheating?
03:33:25 <ehird`> haskell is cool :D
03:33:29 <ehird`> BUT ANYWAY
03:33:33 <ehird`> comment on my banana scheme.
03:33:36 <ehird`> implementaiton. idea.
03:35:03 <oklopol> dunno, it's just too good...
03:35:23 <oklopol> i'm beginning to realize programming would be a bit easier if i had a debugger...
03:36:02 <oklopol> i mean, i do debugging by printing stuff as i go, then reading the output.
03:36:35 <oklopol> works fine with python because i don't really make mistakes... but it's kinda hell doing scheme...
03:37:19 <faxlore> hmmm
03:37:26 <faxlore> Why do you make less mistakes in python than scheme"?
03:39:13 <ehird`> oklopol: ummm it's simple.
03:39:17 <ehird`> oklopol: use your REPL.
03:39:25 <ehird`> your REPL is a debugger, develop all your stuff in there.
03:40:47 <oklopol> it does not support moving the cursor left, i don't really feel like using it
03:41:28 <ehird`> thats your implementations fault.
03:41:29 <Slereah> Heh. Iszero is equivalent to not.
03:41:32 <ehird`> change implementaiton.
03:41:42 <Slereah> Or... maybe not.
03:41:52 <Slereah> There's a nuance!
03:42:06 <ehird`> oklopol: either embrace scheme's development strategy and use a good impl
03:42:09 <ehird`> or don't use scheme
03:42:22 <ehird`> there is no debugger because it would be redundant
03:42:28 <oklopol> faxlore: i make less mistakes in python because i've coded a lot in it..
03:42:35 <faxlore> ah ok
03:43:01 <oklopol> ehird`: you mean i should test my functions before i've written the whole program?
03:43:06 <oklopol> yeah, right!
03:43:12 <ehird`> of course.
03:43:19 <ehird`> that's what you're meant to do
03:43:24 <ehird`> don't like it, don't use scheme.
03:43:48 <oklopol> guess i need to make a debugger myself if there's none
03:43:58 <ehird`> no
03:44:00 <ehird`> the repl is the debugger.
03:44:03 <ehird`> anyway bye for today
03:44:05 -!- ehird` has changed nick to ehirdsleep.
03:48:21 <oklopol> i can write 200 lines of python and it works right away, if i can't learn to do the same with scheme, there was no point in the language change anyway
03:48:47 <oklopol> but true, i guess i have to test my functions... that does feel like cheating though
04:07:11 <faxlore> ehird`: did you write a bf interpreter in haskell?
04:07:24 * faxlore (wants one)
04:10:25 <oklopol> would it take long to write one yourself in haskell?
04:11:00 <faxlore> no
04:34:24 * faxlore is going to run every BF program
04:34:34 <faxlore> (Except ones that obviously dont terminate or take input..)
04:56:16 -!- puzzlet has quit (Remote closed the connection).
04:56:23 -!- puzzlet has joined.
06:56:29 -!- Slereah has quit.
07:34:40 -!- Jontte has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:49:54 -!- GreaseMonkey has quit ("Hi Im a qit msg virus. Pls rplce ur old qit msg wit tis 1 & hlp me tk ovr th wrld of IRC. Man who run behind car get exhauste).
10:51:13 <SimonRC> in old fortrans, 3=4 would change all constant 3s in a program into 4s, because constants were often implemented as variables that started with a particular value.
10:52:56 <SimonRC> faxlore: what do you mean by "every"?
10:53:01 <SimonRC> and why?
10:56:36 -!- Corun has joined.
11:01:11 <SimonRC> Corun: as in co-routine?
11:01:24 <Corun> Nope
11:01:46 <Corun> As in an abbreviation of Corundum, :-)
11:32:43 -!- faxlore has quit ("If there are any aliens, time travellers or espers here, come join me!").
12:14:45 -!- Hiato has joined.
12:15:01 <Hiato> Wassup :)
12:15:56 <Hiato> Oklopol: could you please explain your Fibonacci programme in CTRL, I don't understand it
12:16:09 <Hiato> *CRTL
12:18:32 -!- Corun has quit ("This computer has gone to sleep").
12:28:47 -!- jix has joined.
12:40:37 -!- Hiato has left (?).
12:49:13 -!- Corun has joined.
13:04:39 -!- johnl has joined.
13:26:00 -!- sebbu has joined.
13:37:57 <Corun> WOO Happy leet o clock UK!
13:40:07 -!- Corun has quit ("This computer has gone to sleep").
13:57:39 -!- bencoder has joined.
14:02:45 -!- bencoder has quit.
14:04:53 -!- Jontte has quit ("Konversation terminated!").
14:06:13 -!- Slereah has joined.
14:06:30 <Slereah> Well, I'm on Linux now.
14:06:33 <Slereah> Hope it's worth it.
14:08:42 <SimonRC> surreal, yet fun: http://www.larry.denenberg.com/Knuth-3-16/
14:21:49 -!- RedDak has joined.
14:34:11 -!- oerjan has joined.
15:05:05 -!- UnrelatedToQaz has joined.
15:06:18 -!- UnrelatedToQaz has quit (Client Quit).
15:10:33 -!- SimonRC has quit (Read error: 110 (Connection timed out)).
15:16:33 <bsmntbombdood> uuuuh
15:16:37 <bsmntbombdood> isn't knuth still alive?
15:16:47 <oerjan> last i heard...
15:17:02 <oerjan> anyone said something else?
15:17:50 <oerjan> wikipedia agrees
15:18:24 <bsmntbombdood> http://www.larry.denenberg.com/Knuth-3-16/concrete-math.html
15:18:37 <bsmntbombdood> "...even during his lifetime"
15:21:32 * oerjan points to the copyright notice ;)
15:29:52 -!- jix has quit (Nick collision from services.).
15:30:02 -!- jix has joined.
15:46:16 -!- Corun has joined.
15:50:19 -!- ais523 has joined.
15:50:34 -!- timotiis has joined.
15:51:32 <ais523> bsmntbombdood: it is a little known fact that Knuth once worked on INTERCAL
15:53:56 * ais523 has a nasty habit of continuing conversations that took place when they weren't there
15:59:16 <ais523> and oerjan: your Unlambda program is now in the official distribution as an example program (see for instance http://packages.debian.org/sid/i386/intercal/filelist)
16:03:38 <ais523> unlambda.i.gz in that list was written by Oerjan, tpk.i.gz was co-written by Knuth
16:04:11 -!- Slereah has quit ("Konversation terminated!").
16:04:52 <oerjan> what's tpk?
16:05:11 <oerjan> yay, fame
16:06:18 <ais523> tpk is a simple test program that he wrote in several languages, I think to compare their performance
16:06:29 <ais523> it was kind of tricky in INTERCAL, as might be expected
16:06:44 <ais523> I think it might be because it's a floating-point program, but I'll have to check
16:08:45 <ais523> see http://www.cs.fit.edu/~ryan/compare/ for the program in many other languages (unfortunately, that list doesn't include the INTERCAL version)
16:10:38 <oerjan> i found knuth's page on it
16:11:43 <ais523> and of course, the whole compiler was written by Eric Raymond in the first place, so there's more fame-by-association stemming from there
16:12:44 -!- Slereah has joined.
16:12:52 <oerjan> actually i think esr already linked to my interpreter
16:13:59 <ais523> I have a question about d in Unlambda, by the way
16:14:09 <ais523> normally `xy evaluates y first, then x
16:14:11 <oerjan> aye?
16:14:22 <oerjan> no
16:14:25 <ais523> sorry, I meant normally `xy evaluates x first, than y
16:14:43 <ais523> does ``dxy always evaluate y before x no matter what the value of x?
16:14:52 <oerjan> yep
16:15:12 <ais523> I ask because I was writing an Unlambda to Underload compiler
16:15:20 <ais523> I got it to handle everything except c, with that definition of d
16:15:41 <ais523> I then accidentally deleted it, but I can still remember most of the concepts and will get around to rewriting it some time
16:16:05 <ais523> and in the process, I discovered that there were an infinity of options between lazy and eager evaluation
16:16:22 <oerjan> probably
16:16:47 <ais523> basically, you could set the eagerness of an expression, and when an operator operated on two expressions, the more eager was evaluated first
16:17:05 <oerjan> incidentally, d is the only function that you can test for without applying it
16:17:26 <ais523> how is that done?
16:17:41 <Slereah> By the way, is it actually a good idea to use an input "combinator" with lazy evaluation?
16:17:57 <oerjan> if you do ``dxy where x and y both raise some continuation
16:18:24 <ais523> but if the d isn't a d, it will be evaluated before x or y, and so will be applied
16:18:33 <oerjan> then d raises the one in y, every other function raises the one in x, and the actual function is never applied
16:18:55 <Slereah> So far, it mostly gets copied everywhere without much control!
16:18:59 <oerjan> well by applied i mean applied to an argument with any possible effects
16:19:27 <oerjan> not including evaluation of the expression that becomes the function
16:19:32 <ais523> oh, because counterexamples like `.ai aren't atoms and so couldn't be given as arguments to the d-tester in the first place
16:19:50 <ais523> because in standard Unlambda, the d-tester couldn't itself be lazy
16:20:02 <oerjan> something like that
16:20:16 <ais523> my compiler actually worked on Underload, Unlambda or a hybrid, so I called the resulting language Underlambda
16:20:43 <ais523> in that language, lazy functions other than d can exist
16:21:08 <ais523> you could imagine a lazy version of v, for instance, that throws away its argument without even evaluating it in the first place
16:21:27 <ais523> oh, and I almost ended up inventing monads again, when trying to figure out the behaviour of .
16:22:13 <ais523> I'm still disappointed that there's no way to translate ``sii into Haskell
16:22:35 <ais523> although I'm amused that other combinators can be identified purely by their data type
16:22:42 <oerjan> without a newtype that is
16:23:11 <ais523> I'm trying to learn Haskell without any documentation, so language features are kind of hard to figure out
16:23:30 <ais523> I think there ought to be a standard datatype f -> f -> f -> f -> ... ad infinitum, though
16:23:31 <oerjan> o_O
16:23:43 <ais523> because infinite datatypes are a great concept
16:23:52 <oerjan> except that would never give any actual result
16:24:09 <oerjan> f -> m (f -> m ...) is more useful
16:24:10 -!- SimonRC has joined.
16:24:51 <ais523> oh, of course, in Haskell it would need a second data type to be able to produce side effects
16:25:18 * ais523 needs to continue a third conversation from when they weren't here now that someone else has joined
16:25:32 <ais523> SimonRC: assigning to constants is possible in modern versions of INTERCAL too
16:25:44 <ais523> although C-INTERCAL protects you from that unless you turn on a command-line option in the compiler
16:26:33 <ais523> you can even do it without putting constants on the LHS of an assignment if you're careful
16:26:57 <ais523> as in .1 <- '.1/#1'$#1
16:27:17 <oerjan> i think someone mentioned f -> m (f -> m ...) on #haskell the other day, called it a monadic stream or something
16:28:33 <ais523> does Haskell support call/cc?
16:28:51 <oerjan> Control.Monad.Cont
16:28:53 <ais523> if it does, then adding monadic streams might allow for an Unlambda -> Haskell compiler
16:29:10 <oerjan> sure
16:29:19 <ais523> but an Unlambda -> C (via Underload) compiler would be more impressive
16:29:34 <ais523> ehird` and I are working on half of that each
16:30:12 <ais523> d is easy when you have two laziness levels, but for c the only thing I can think of is writing an Underload self-interpreter, but with continuations added
16:30:42 <ais523> it shouldn't be too hard if one list is used for the program and another for the stack
16:31:12 <ais523> but instead of the usual ((a)((b)((c)((d)... form of list, give a third element in each tuple that specifies whether the list has ended or not
16:31:18 <ais523> so that appending to the end of a list is possible
16:31:41 <ais523> normally, Unlambda and Underload lists are infinite (you have to specify a function for filling out the end of the list once the programmed portion is reached)
16:32:04 -!- Mony has joined.
16:32:41 <oerjan> i've pondered using the special property of d to terminate lists, never implemented it
16:33:15 <Mony> iop all
16:33:16 <ais523> this gives me some ideas for an esoteric OS
16:33:29 <ais523> my idea was that everything in the OS sohuld be a function
16:33:56 <ais523> which would lead to simple implementations of things like symlinks, hardlinks, and even copy-on-write copying (a feature that I've found myself wanting in an OS before)
16:34:24 <ais523> unfortunately, I thought that such an OS would be inherently insecure
16:34:39 <ais523> but the special properties of d - and of laziness levels in general - may be a way around that
16:35:02 * ais523 is a big fan of the way languages like Unlambda and Underload can synthesize things like arithmetic out of basically nothing
16:37:46 <oklopol> mörning all
16:38:12 <oerjan> vening
16:38:37 <oklopol> i love winter
16:38:47 <oklopol> it's dark when i go to sleep, and dark when i wake up!
16:38:52 <oerjan> starting snowing here again today
16:39:23 <ais523> it mostly rains here in the UK, although I think it was snowing for a bit yesterday
16:39:34 <AnMaster> I hate winter, it is dark most of the day
16:39:39 <AnMaster> and cold
16:39:40 <oklopol> i have no idea whether there's snow outside :)
16:39:49 <ais523> I like winter for the coldness, but not for the darkness
16:39:52 <oerjan> it's been a while since the last time, the ice was nearly gone
16:39:57 <AnMaster> I do, because of streetlights, but only because of them
16:40:04 <ais523> although I suppose the two are kind-of correlated...
16:40:04 <AnMaster> and: no snow
16:40:17 <AnMaster> I hate winter for coldness and darkness
16:40:18 -!- slereah_ has joined.
16:40:59 <oklopol> i guess i'll go read something, keep the flag in the pole or something ->
16:41:52 <ais523> !daemon ul bf http://pastebin.ca/raw/367774
16:42:00 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
16:42:17 <ais523> anyway, the principle of lazy Underload is to write a combinator that would normally be x as (^x)
16:42:48 <ais523> and Unlambda's `ab translates to ((^b))((^a))^^
16:43:01 <ais523> (which can of course be optimised)
16:43:23 <ais523> the ^ at the start makes the combinator eager rather than lazy
16:43:48 <ais523> and often has to be followed by an Underload a to get the nesting levels right
16:47:52 -!- puzzlet has quit (Remote closed the connection).
16:47:53 <ais523> !ul ((^))((^(test)S))^^
16:47:57 <EgoBot> test
16:47:59 -!- puzzlet has joined.
16:48:17 <ais523> or for an expression like ``.ai`.bi:
16:48:45 <ais523> (((^))((^(b)S))^^)(((^))((^(a)S))^^)^^
16:49:06 <ais523> !ps
16:49:09 <EgoBot> 2 ais523: ps
16:49:16 <ais523> !ps d
16:49:17 <EgoBot> 1 ais523: daemon ul bf
16:49:19 <EgoBot> 2 ais523: ps
16:49:24 <ais523> !ul (((^))((^(b)S))^^)(((^))((^(a)S))^^)^^
16:49:27 <EgoBot> ab
16:49:51 <ais523> now, to do a d combinator, instead of evaluating the argument with ^, you append a ^ to it so it's evaluated later
16:50:03 <ais523> but you also have to prepend ^a to it so that the resulting promise is eager not lazy
16:50:18 <ais523> so for instance, ``d`.ai`.bi is
16:50:43 <ais523> !ul (((^))((^(b)S))^^)((((^))((^(a)S))^^)(((^a)~*(^)*))^^)^^
16:50:45 <EgoBot> ba
16:50:58 <ais523> ...and the laziness criteria are satisfied
16:51:08 <ais523> so that's how d is compiled into Underload
16:56:49 <ais523> i, ., s, and k have already been done (although they need minor modification for the new method), that's how d is done, v is easy due to the ! instruction, and so it's only c that now needs to be implemented for an Unlambda 1 compiler, unless I've missed something
16:59:35 -!- ais523 has quit.
17:02:32 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
17:05:34 -!- RedDak has joined.
17:20:11 -!- Hiato has joined.
17:20:21 -!- puzzlet has quit (Remote closed the connection).
17:20:28 -!- puzzlet has joined.
17:30:05 * SimonRC has an idea...
17:30:12 <SimonRC> a hash-consed filesystem
17:30:44 <SimonRC> every time you write a sector to disk, you check if there is an identical sectore there already, and if so just link to it
17:30:56 <SimonRC> inodes can handle this already, I think
17:31:32 <SimonRC> at a random guess, I say that zfs has this feature already as an option
17:35:29 -!- Jontte has joined.
17:37:26 -!- ais523 has joined.
17:38:19 -!- oerjan has quit ("Good night").
17:39:10 <ais523> SimonRC: that sounds like the copy-on-write filesystem I suggested earlier
17:40:43 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
17:40:49 -!- puzzlet has joined.
17:47:53 -!- puzzlet_ has joined.
17:59:33 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
18:12:44 -!- Hiato has left (?).
18:15:14 -!- puzzlet_ has quit (Remote closed the connection).
18:15:20 -!- puzzlet has joined.
18:17:50 -!- Corun has quit ("This computer has gone to sleep").
18:28:26 -!- Mony has quit (" bye all ;)").
18:36:40 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
18:38:51 -!- oklopol has joined.
18:43:38 -!- puzzlet has quit (Remote closed the connection).
18:43:44 -!- puzzlet has joined.
18:50:07 -!- biosh0ck has joined.
18:54:54 -!- faxlore has joined.
18:55:38 -!- biosh0ck has left (?).
18:56:41 -!- Hiato has joined.
19:02:45 <Hiato> For anyone interested: I reverted the grid size in ACRONYM from infinitely large to 128x128. There is a reason for this, and it is documented in the spec http://rafb.net/p/Hn966345.txt (as ehird` is now ehirdsleep , I'm not sure if he'll get this message but hey...
19:02:55 <Hiato> )
19:03:18 -!- MichaelRaskin1 has joined.
19:03:30 <oklopol> Hiato: what is that?
19:03:51 <Hiato> it's the ACRONYM spec (finilised, except for typos and such like)
19:04:01 <oklopol> the reason
19:04:07 <Hiato> oh, woops, sorry
19:04:14 <oklopol> documented in the spec, yet
19:04:20 <oklopol> but it's soooo long
19:04:24 <oklopol> *yes
19:04:25 <Hiato> sure
19:05:00 <Hiato> it is that given that any specific cell can hold an arbitrary integer, using prime bases we can store simulated values of other cells using exponents
19:05:07 <oklopol> indeed
19:05:08 <Hiato> ie say we want to simulate 3 celss
19:05:26 <Hiato> we would go 2^a x 3 ^b x 5^c
19:05:40 <Hiato> where a, b and c are the values of the 3 simulated cells
19:05:52 <Hiato> and via prime facotrisation, we can recover those alues
19:05:59 <Hiato> *factorisation
19:06:43 <faxlore> hey I like this idea
19:06:55 <Hiato> I'm glad, I thought that I thought of it
19:07:06 <faxlore> can you make a single celled brainfuck?
19:07:10 <Hiato> but it turned out that the concept was there before :(
19:07:16 <Hiato> well, no, not entirelt
19:07:19 <Hiato> for one reason
19:07:29 <Hiato> in bf, you need other cells to do factorisation
19:07:36 <Hiato> so a 3 cell bf, yes
19:07:38 <Hiato> :D
19:07:45 <Hiato> *entirely
19:08:10 <ais523> is a 2 cell bf possible?
19:08:18 <Hiato> hrmm... not sure about that
19:08:20 <ais523> that's probably enough for * and /
19:08:26 <Hiato> as copying takes an extra cell
19:08:28 <ais523> which allow you to store any number of counters in the one cell
19:08:41 <Hiato> aha, yes, if you have / and *
19:08:45 <Hiato> being non-destructive
19:08:47 <Hiato> then yes
19:08:55 <Hiato> you can do it with 2 cells
19:08:57 <Hiato> :D
19:09:05 <ais523> implementing / non-destructively might be difficult, but I think it's possible
19:09:47 <oklopol> umm... isn't it a register machine or something if you have a brainfuck with just a few states?
19:09:51 -!- ais523 has quit ("have to go").
19:09:51 <oklopol> *cells
19:09:55 <oklopol> oh, damn
19:09:59 <Hiato> yes, that is the tricky part, though there is really a simple way to do it, just say that / will be used as such /+++++ meaning divide the current cell by 5 and store the tresult in the other cell
19:10:09 <Hiato> damn
19:10:26 <Hiato> oklopol: yes, it's close to a 2 counter machine
19:10:33 <Hiato> but with infinite states :D
19:10:41 <oklopol> hmm?
19:10:46 <Hiato> if it can store arbitrary integers
19:10:57 <Hiato> though, I see it as a trivial derivation of BF
19:11:16 <Hiato> actually, perhaps not...
19:11:29 <Hiato> maybe this is worth writing up, what do you think oklopol?
19:11:41 <oklopol> do it yesuyes
19:11:43 <oklopol> !!
19:11:45 <EgoBot> Huh?
19:11:48 <Hiato> ok
19:11:49 <faxlore> lol
19:12:14 <Hiato> names?
19:12:22 <Hiato> twofuck?
19:12:24 <Hiato> :P
19:12:25 <oklopol> oh fuck... why did i eat... now i'm watching simpsons again :)
19:12:33 <oklopol> i was actually doing something before this
19:12:41 <Hiato> hah, lol :)
19:13:04 <Hiato> hrm.. wait
19:13:10 <Hiato> in a bounded storage nachine
19:13:23 <Hiato> is a programme considered a finite automaton?
19:13:35 <oklopol> umm...
19:13:42 -!- Corun has joined.
19:13:46 <oklopol> depends what you mean by that
19:13:57 <Hiato> well, I maent in terms of terminology
19:14:00 <oklopol> the actual program is always a fsm
19:14:00 <Hiato> purely
19:14:02 <Hiato> *meant
19:14:03 <oklopol> i mean
19:14:09 <oklopol> it's finite.
19:14:11 <Hiato> oh, ok sure
19:16:59 <oklopol> only 840 pages to read this weekend, i guess i can watch a few simpsons more.
19:17:10 <Hiato> ROFL :D
19:17:23 <Hiato> Blah, there is a problem
19:17:32 <Hiato> how do you factorise with only 2 cells
19:17:39 <Hiato> to get only a specific prime base
19:17:48 <Hiato> elimimate the rest and then subtract?
19:17:57 <Hiato> the rest of the bases that is...
19:18:04 <faxlore> this is reminding me of fractran actuall
19:18:09 <faxlore> Hiato have you seen it
19:18:20 <Hiato> what, fractran?
19:18:25 <Hiato> nope
19:18:26 <faxlore> ( http://www.esolangs.org/wiki/Fractran )
19:18:28 <oklopol> indeed
19:18:32 <Hiato> I don't know what that is
19:18:37 <faxlore> so cool :p
19:18:42 <oklopol> you just need enough cells to simulate modulus
19:18:43 <Hiato> roger
19:18:53 <oklopol> which is... 4?
19:18:56 <Hiato> 3
19:19:03 <faxlore> btw
19:19:08 <Hiato> 1 for copying, then 2 for subtraction
19:19:08 <oklopol> yeah, but you need one for the current number
19:19:12 <faxlore> Should I add my fractran interpreter?
19:19:13 <faxlore> (*{~1 i.~[@(=<.)@:*)
19:19:16 <oklopol> hmm
19:19:22 <oklopol> faxlore: what lang?
19:19:24 <faxlore> J
19:19:27 <Hiato> yeah, go for it faxlore
19:19:32 <oklopol> i need to learn that...
19:19:36 <Hiato> ditto
19:19:39 <oklopol> is there a nice tutorial or something?
19:19:41 <faxlore> It's a beautiful lang
19:19:49 <faxlore> Yeah there
19:19:50 <faxlore> is
19:19:52 <oklopol> i'd prefer K but can't find a tutorial for that either
19:20:00 <faxlore> oh I didn't look at K yet
19:20:10 <oklopol> i did find an interpreter, but couldn't install it :)
19:20:36 <faxlore> http://www.jsoftware.com/jwiki/Guides/Getting_Started
19:20:37 <Hiato> ooh fractran is crazy
19:20:44 <faxlore> There are quite a lot of books online
19:24:07 <Hiato> blah
19:24:11 <Hiato> you where right oklopol
19:24:17 <Hiato> you need 4 cells to factorise
19:24:38 <Hiato> and it is also very difficult if you don't know what the bases' exponents are
19:24:38 <oklopol> i'm always right
19:24:46 <Hiato> can think of an easy way to do it right now...
19:25:01 <Hiato> oh, wait
19:25:05 <Hiato> DUH
19:25:27 <Hiato> you, as the programmer will always need to know what values you are simulating/ the range of the values
19:25:37 <oklopol> hmm
19:25:39 <oklopol> ?
19:25:39 <Hiato> and this you can make deductions about the rest....
19:25:49 <Hiato> ie, say you are simulating 2 cells
19:25:52 <Hiato> wait
19:26:00 <Hiato> nevermind, you can only ever have 1 unknown
19:26:24 <Hiato> but anyway, say you are simulating 2 cells, in 2^a x 3^b
19:26:32 <Hiato> and you want to find out b's value
19:27:17 <Hiato> all you need to do is (assuming a is known) subtract 2 a times, and presto, you are left with 3^b, from which you subtract 3 and increase the other cell
19:27:25 <Hiato> meaning you only need 3 cells
19:28:06 <Hiato> but, if there are >1 unknowns , you need 4 cells
19:28:16 * faxlore (has made an addition to http://www.esolangs.org/wiki/Fractran then)
19:28:56 <oklopol> subtract 2 2 times?
19:29:27 <Hiato> no, not entirely, because say you had the value 2^3 x 3^b
19:29:30 <Hiato> and you want b
19:29:45 <Hiato> but you don't know what the value of the power of 2 is
19:30:01 <Hiato> there is no way that with two cells you can derive it, or even three
19:30:25 <oklopol> indeed.
19:30:42 <oklopol> but i think there are some definite mathematical results on exactly this...
19:30:45 <Hiato> no, wait, there is
19:30:50 <oklopol> i mean, how many registers you nee
19:30:51 <oklopol> d
19:30:58 <Hiato> -[-[blah]]
19:31:11 <Hiato> would subtract 2 while the value was greater than or equla to 2
19:31:14 <Hiato> indefiniately
19:31:16 <Hiato> woohooo
19:31:27 <oklopol> yeah, mod2
19:31:32 <Hiato> yip :)
19:31:35 <Hiato> 3 cells !
19:31:41 <oklopol> unfortunately we don't need modulo here :<
19:31:45 <oklopol> we need division.
19:31:47 <Hiato> true,,,
19:31:56 <Hiato> yes, thouhg that is the fun part
19:32:01 <Hiato> say you want b
19:32:49 <Hiato> -[-[ ]] two remove all the twos then -[-[-[>+<]]] to divide by 3
19:32:54 <Hiato> easy as PiR^2
19:33:15 <Hiato> actually
19:33:37 <Hiato> no wait, -[-[-[+++[--->+<]]]]
19:33:39 <Hiato> that is better
19:34:07 <Hiato> that is assuming that you'are not sure if it is > 3
19:34:10 <Hiato> otherwise
19:34:16 <Hiato> [--->+<]
19:35:42 <oklopol> indeed, a program will only use a finite set of divisors
19:35:54 <oklopol> so you can hardcode them like that
19:35:55 <Hiato> yip, so no worries
19:35:59 <faxlore> hm.....
19:36:07 <Hiato> or, you could 'soft' code them
19:36:09 <faxlore> What's the point in dividing by 3
19:36:24 <Hiato> ie, dividing by the amount in the other cell
19:36:25 <faxlore> when you do that.. you'd have to check the first prime number that's been incremented
19:36:33 <bsmntbombdood> :D
19:36:37 <Hiato> faxlore: deriving th value stored
19:36:51 <Hiato> no, you wouldn't
19:36:56 <Hiato> as this is user end coding
19:37:03 <Hiato> so
19:37:16 <Hiato> all that needs to happen is to dervie a value, you cancel out all the rest
19:37:16 <faxlore> hi bsmntbombdood
19:37:20 <Hiato> and then divide
19:37:24 <faxlore> I wrote a program that lists every BF program
19:37:36 <Hiato> yeah hi bsmtbombdood
19:37:38 <faxlore> I just need a way to run them all...
19:37:45 <Hiato> faxlore: how's is that possibel :)
19:37:47 <Hiato> *possible
19:38:27 <faxlore> Hiato, well I think if I try to evaluate the elements of the list concurrently I can not get stuck.. but I don't know how to code that
19:38:36 -!- MichaelRaskin1 has left (?).
19:38:57 <oklopol> faxlore: basically you need to save a program as a tuple (code, ptr, tape)
19:39:06 <faxlore> That's exactly what I have :D
19:39:10 <faxlore> (in a different order)
19:39:19 <oklopol> well, there you have it then
19:39:25 <Hiato> yeah, that sounds like the right thing to do
19:39:28 <faxlore> ohh yeah.. I don't need concurrency
19:39:35 <faxlore> I can just step all the elemts
19:39:48 <bsmntbombdood> http://angryflower.com/paulvk.html
19:39:49 <faxlore> I mean , step every item < item 1, step every < item 2, .. etc
19:40:00 <oklopol> just have the function you are evaluating the programs with take another param to specify how many steps to evaluate.
19:40:02 <faxlore> removing ones that got finished (what's the finished state of a program ccalled)
19:40:31 <oklopol> halting state?
19:40:39 <faxlore> gonna code this now :D
19:40:50 <oklopol> sounds awesome actually :)
19:41:09 <Hiato> indeed
19:41:12 <faxlore> oklopol: It is for my BF contest
19:41:23 <Hiato> can't wait to see what all of BF evaluates to :P
19:41:52 <oklopol> hehe
19:41:57 <faxlore> I should get some shortest programs with this
19:42:06 <Hiato> definitely
19:42:11 <oklopol> hehe
19:42:13 <oklopol> fun idea
19:42:20 <Hiato> though be prepared to stare at the screen for a long time :D
19:42:26 <faxlore> indeed :p
19:42:28 <oklopol> have an online deposit where people can send results of programs run
19:42:35 <Hiato> awesome
19:42:36 <Hiato> !
19:42:39 <EgoBot> Huh?
19:42:42 <faxlore> lol
19:43:05 <oklopol> hmm
19:43:12 <oklopol> might be interesting to do for something like K
19:43:36 <Hiato> yeah, great experiment, but it would take ages to compile anything substantail in terms of results...
19:43:47 <Hiato> *substantial
19:43:56 <oklopol> well, perhaps not K
19:43:58 <oklopol> cise!
19:44:28 <oklopol> there's at least multiple sorts with 7 characters in Cise
19:44:46 <Hiato> cool, I haven't heard of it before though
19:45:17 <oklopol> i've just shown the few examples on this channel
19:45:26 <oklopol> i can show them again perhaps
19:45:33 <Hiato> yeah, please
19:45:35 <oklopol> merge sort:'/,)#<
19:45:35 <oklopol> quicksort:/2;A b:C,',JnB
19:45:35 <oklopol> bubblesorta:B,',\#<A,JnA
19:45:35 <oklopol> factorials:1::Il,)&*
19:45:46 <faxlore> What's that!
19:45:46 <faxlore> sad
19:45:51 <Hiato> woow, that's hellish powerful
19:45:52 <oklopol> there are a few things you can change in the mergesort and it works still
19:46:04 <faxlore> *wow
19:46:10 <oklopol> just a list of list operations and parsing inference (PATENT PENDING)
19:46:15 <oklopol> oh
19:46:21 <oklopol> parsing via type inference
19:46:47 <faxlore> Does an Implementation exist?
19:46:48 <oklopol> it has some interesting concepts
19:46:52 <oklopol> oh, lord no
19:46:55 <faxlore> :D
19:46:58 <oklopol> it takes a while to parse even manually :)
19:47:04 <Hiato> hah :D
19:47:05 <oklopol> i mean
19:47:18 <oklopol> you have currying + polish notation with implicit nesting
19:47:31 <oklopol> there's an exponential growth in possible parsings
19:47:32 <Hiato> shame :P
19:47:41 <oklopol> the leftmost working one is chosen always
19:48:01 <oklopol> usually type inference seems to result in exactly one working program for a piece of code
19:48:10 <oklopol> assuming you only have short statements
19:48:21 <oklopol> "," and ";" are separators
19:48:57 <faxlore> Can you break down '/,)#< ?
19:49:35 <oklopol> A,B;D,E is a function that takes a value, called the current value, it's run through the function A, then the result is run through B, the result of which is pattern matched on C, the result of which again is sent to D to give the result
19:49:40 <oklopol> i think so
19:49:40 <oklopol> wait
19:49:58 <Hiato> ... woow
19:50:29 <oklopol> '/,)#< "'" means evaluate expression on the right, getting a list as result, map current function recursively to each sublist
19:50:35 <oklopol> / is the split function
19:51:00 <oklopol> it takes a list and a number and splits into that many segments (in seqments of the same length)
19:51:16 <oklopol> the current value is given as a param to the statement
19:51:31 <oklopol> so the first statement is "'/_" where _ is the param
19:51:57 <oklopol> everything has a default value, for splitting a list the number of splits is of course "2"
19:52:14 <oklopol> because if you split, naturally you split in half instead of into 500 pieces or something.
19:52:28 <oklopol> now, another interesting point
19:52:45 <oklopol> many list algos terminate on small lists and work as identity
19:52:55 <oklopol> in case a function encounters an error, it's the identity.
19:53:13 <oklopol> a list of one element is not split, it throws an error.
19:53:27 <oklopol> so we have the base case for recursion here, encoded in the language
19:53:45 <oklopol> okay, so the first statement divided the list in two and recurtsed
19:53:48 <oklopol> *recursed
19:53:49 <faxlore> That's mad
19:53:52 <oklopol> let's look at the second one
19:53:54 <Hiato> agreed
19:54:37 <oklopol> )#< <<< this gets the result, now here we have the function )#, which is a pretty specific function
19:54:47 <oklopol> it takes a function and a list of lists
19:55:17 <oklopol> and it always gives the function a list of all the heads of the input lists
19:55:54 <oklopol> and puts the result on the result list, removing the matched head from the list whose head matched
19:56:21 <oklopol> for "<" == min function for lists
19:56:33 <oklopol> and an input list of two lists
19:56:44 <oklopol> it basically does the "merging" of mergesort
19:57:02 <oklopol> this was as generic as i could get without actually having && be sort or something
19:57:07 <oklopol> (incidentally, && is sort.)
19:57:19 <oklopol> (so K wins here... unless i shorten that :))
19:57:34 <oklopol> oh, i've changed it to St
19:58:19 <oklopol> many choices for function names are pretty arbitrary, i'll of course put in shorter names for stuff that is often needed, once i know what is
19:59:09 <oklopol> unfortunately i haven't really done much on this (although it for some reason still has quite a lot of features)
20:00:19 <oklopol> my intention was to make a language that's doesn't have much possibilities for extending the language, and not much abstraction possibilities either, perhaps even not tc, but a *lot* of list support
20:00:33 <oklopol> actually
20:00:39 <oklopol> i think i made a brainfuck interp
20:00:50 <oklopol> ;I,;mc,[]{"[]"},=}!!b->"+"+mC1"-"-mC1">"+C1"<"-C1{;X}Wh=mC0=}X??b this one
20:01:14 <oklopol> it doesn't use much currying, so i'm fairly sure the long statement in the end would parse
20:01:36 <oklopol> hmm... why the fuck haven't i commented that in any way xD
20:07:17 <Hiato> well, it's possible to do (the primes things) with only two cells, but three new commands
20:07:27 <Hiato> or in three cells, with two new commands
20:07:33 <Hiato> or in four cells, with no new commands
20:08:02 <Hiato> although four cells nearly defeats the purpose
20:10:11 <Hiato> wait
20:10:15 <Hiato> I migth be horribly wrong
20:11:16 <oklopol> faxlore: do you have a bf in J?
20:11:37 <faxlore> no
20:15:46 <oklopol> what, cise has gotos :D
20:15:55 <oklopol> interesting read this interp...
20:16:09 <oklopol> i remember nothing, have to guess what it does
20:21:30 <oklopol> at least it seems to be correct
20:21:48 <Hiato> yes, ok, I do need 4 cells without any added symbols... :(
20:22:01 <oklopol> oh, god, i'm still here...
20:22:04 <oklopol> leaving! ->
20:22:04 <Hiato> 3 cells with one new command
20:37:35 <Hiato> meh
20:37:37 <Hiato> I need help
20:37:55 <Hiato> how would you set up the condition in BF of while >= 3 ??
20:41:45 <Hiato> ie, to do a modulus...
20:51:41 <Hiato> [ [-[-[-[>[-]+>]<<+>>]<<+>>]<<+>>] < [-<--->>] <<]
20:51:51 <Hiato> is as close as I can get, but it will mess up on the last cycle
20:53:09 <Hiato> faxlore, oklopol, bsmntbombdoodm, EgoBot, pikhq, somebody, anybody....
20:53:32 <Hiato> (it's a modulus 3)
20:54:37 <Hiato> (*bmsntbombdood)
20:57:50 <faxlore> I don't know :(
20:57:57 <faxlore> You could try stuff off http://esolangs.org/wiki/Brainfuck_algorithms#x_.3D_x_.3C.3D_y
20:58:05 <Hiato> thanks
20:58:13 <faxlore> I never wrote much BF...
20:58:17 <faxlore> just generating it
20:58:19 <Hiato> same
20:58:22 <Hiato> diito
20:58:28 <faxlore> this is tricky though :S
20:58:29 <Hiato> epsecially optimal text to bf
20:58:31 <Hiato> :)
20:58:40 <faxlore> my program ended up with lots of nonsense words in it and didn't work
20:58:48 <faxlore> Hiato: Really? Plesae give me any programs which do this
20:58:48 <Hiato> mine works fine
20:58:53 <Hiato> sure
20:58:55 <Hiato> am..
20:58:59 <Hiato> where can I upload
20:59:01 <faxlore> I have quite a few but I want to get as many as possilb
20:59:17 <faxlore> rafb.net/paste
20:59:30 <Hiato> mine calculates to the letter the most compact way of doing it, using one algorithm ofcourse
20:59:31 <Hiato> sure
20:59:36 <Hiato> it's in delphi though...
20:59:52 <faxlore> Hiato I don't think that's possible
21:00:05 <Hiato> what, that it's in delphi, or calculation
21:00:09 <faxlore> lol
21:00:24 <faxlore> The smallest possible BF program to print a given string
21:00:40 <faxlore> Which is .. the reason I try to implement it :P
21:00:44 <Hiato> well, it's by no means the smallest
21:00:48 <Hiato> well, it might be close
21:00:54 <Hiato> but the smallest within the logic I use
21:00:58 <Hiato> which you'll see
21:01:00 <faxlore> ahh right cool
21:01:05 <Hiato> http://rafb.net/p/Asa5t442.txt
21:01:09 <Hiato> there you are
21:01:13 <Hiato> should work with FPC too
21:01:16 <faxlore> I can always take new algorithms and then take the min for it
21:01:22 <faxlore> so any new algorithms improve the overall
21:01:26 <Hiato> aha
21:01:46 * faxlore saves to read later :D
21:01:52 <Hiato> :)
21:01:57 <Hiato> I'll upload an example
21:02:08 <Hiato> to show you what it does
21:02:47 <Hiato> http://rafb.net/p/5rXz5d37.txt
21:02:49 <Hiato> there you are
21:02:57 <Hiato> step through it to understand what it is doing
21:03:01 <Hiato> though it should be obvious
21:03:13 <faxlore> mm I know this pattern ":)
21:03:24 <Hiato> haha lol :D
21:03:45 <faxlore> I need to make lots of measurements and put up a webpage
21:03:54 <Hiato> yip, that would be awesome
21:03:59 <Hiato> and have some competitions
21:04:14 <Hiato> like shortest code for four cells, six, two etc
21:04:30 <Hiato> PS: use mode 1 on my algorithm, not mode 2.
21:04:37 <Hiato> Mode 2 is oudated and works stupidly
21:04:44 <Hiato> *outdated
21:04:56 <oklopol> Hiato: what's that bf program?
21:05:34 <Hiato> which one, the one on nopaste is a demostration of my algorithm and an explination
21:05:45 <Hiato> the other is somethiong that I am struggling with : modulus
21:05:51 <Hiato> *demonstration
21:05:59 <Hiato> *ssomething
21:06:06 <Hiato> typos :(
21:06:40 <oklopol> http://rafb.net/p/5rXz5d37.txt this baby
21:06:55 <Hiato> yeah
21:07:02 <Hiato> that's the explination of my algorithm
21:07:07 <Hiato> created by my algorithm
21:07:18 <Hiato> algorithm of text to BF that is
21:07:23 <oklopol> should i run it to understand?
21:07:26 <oklopol> umm...
21:07:29 <Hiato> yes
21:07:34 <Hiato> and, if you have the time
21:07:44 <Hiato> step through the first four .'s to understand it better
21:07:50 <Hiato> otherwise just run it
21:09:17 <oklopol> ah, that indeed is a nice algorithm
21:09:24 <Hiato> thanks :D
21:09:44 <oklopol> you could make it a bit better by identifying commonly used letters and putting them on the tape every now and then or something :-)
21:10:26 <oklopol> oh, right, i have to work on muture tonight
21:10:27 <Hiato> amm.. it already does that. It takes all the letters used in the text, and stores them on the tape, in ASCII order (ascending)
21:10:40 <Hiato> then iterates up and down displaying them in the correct order
21:10:45 <Hiato> muture?
21:11:26 <oklopol> would be awesome to get it to produce brainfuck text or solve the problem "how many knights can appear on a chessboard without threatening each other"
21:11:38 <oklopol> threaten is prolly not the word, i don't know chess terms in english
21:11:56 <Hiato> yes, threatening each other is the right word :)
21:12:09 <Hiato> what do you mean BF text?
21:12:18 <oklopol> brainfuck text would need either making the language tc or letting you insert python functions though
21:12:27 <oklopol> !bf_text_gen thing
21:12:29 <EgoBot> Huh?
21:12:30 <oklopol> !bf_txt_gen thing
21:12:31 <Hiato> aha
21:12:32 <oklopol> !bf_textgen thing
21:12:33 <EgoBot> Huh?
21:12:35 <EgoBot> Huh?
21:12:35 <oklopol> !bf_txtgen thing
21:12:37 <oklopol> !!!
21:12:39 <EgoBot> Huh?
21:12:40 <oklopol> :D
21:12:42 <Hiato> lol
21:12:43 <faxlore> !huh
21:12:45 <EgoBot> Huh?
21:12:45 <Hiato> wtf?
21:12:50 <Hiato> !Hello
21:12:51 <faxlore> Hhahaha
21:12:51 <EgoBot> Huh?
21:12:55 <Hiato> ROFL
21:13:01 <EgoBot> 60 +++++++++++++[>+++++++++>++++++++>><<<<-]>-.>.+.<------.>--. [100]
21:13:07 <Hiato> but seriously, wtf?
21:13:12 <oklopol> ?
21:13:32 <Hiato> is EgoBot a bot or what?
21:13:43 <oklopol> xD
21:13:45 <faxlore> Huh?
21:13:51 <Hiato> Duh?
21:13:54 <Hiato> no really
21:14:02 <oklopol> ofc it's not a bot
21:14:14 <Hiato> so why is he being so weird
21:14:17 <Hiato> !weird
21:14:19 <EgoBot> Huh?
21:14:33 <oklopol> he's a weird genius
21:14:38 <oklopol> never really talks
21:14:43 <Hiato> Yeha
21:14:51 <Hiato> and what's with the code that says thing
21:14:52 <Hiato> ?
21:14:52 <oklopol> just does amazing feats when asked to
21:15:05 <Hiato> EgoBot, please fix my modulus problem
21:15:09 <oklopol> generating bf code for that, just like yours
21:15:17 <oklopol> except with a different algo
21:15:31 <Hiato> woot
21:15:45 <Hiato> !bf_text_gen Hello, World!
21:15:47 <EgoBot> Huh?
21:15:56 <Hiato> !bf_text_gen Hello, World!
21:15:58 <Hiato> !bf_text_gen Hello, World!
21:15:59 <EgoBot> Huh?
21:16:01 <EgoBot> Huh?
21:16:02 <oklopol> !bf_txtgen Hello, world!
21:16:07 <Hiato> why won't he obey?
21:16:09 <Hiato> :P
21:16:11 <oklopol> he will
21:16:13 <oklopol> don't rush
21:16:38 <Hiato> roger
21:16:44 <Hiato> what other commands are there
21:16:45 <Hiato> ?
21:16:45 <EgoBot> 119 +++++++++++++++[>+++++>++++++++>+++++++>+++<<<<-]>---.>>----.+++++++..+++.>-.------------.<<-.>.+++.------.--------.>+. [292]
21:16:51 <oklopol> thank you, EgoBot
21:17:02 <Hiato> and which language is this puppy written in? :)
21:17:20 <oklopol> EgoBot only talks when immibis is here
21:17:26 <oklopol> don't know why
21:17:29 <Hiato> I see...
21:17:33 <Hiato> who made it?
21:17:36 <oklopol> i think EgoBot has a crush on him or something
21:17:44 <Hiato> lol
21:17:50 <oklopol> i don't understand your question! (grEGOrr)
21:18:04 <Hiato> Aha, woops
21:18:10 <Hiato> :D
21:18:21 <oklopol> umm.. GlassBot?
21:18:24 <oklopol> did i miss something?
21:18:34 <Hiato> yes, that is weird that he talks when immibis is here
21:18:46 <oklopol> !glass oko
21:18:49 <EgoBot> OK
21:18:53 <oklopol> ? :D
21:18:55 <Hiato> say wa?
21:19:00 <oklopol> !glass oko
21:19:03 <EgoBot> OK
21:19:08 <Hiato> what is oko?
21:19:16 <Hiato> !glass Hello World
21:19:19 <EgoBot> OK
21:19:23 <oklopol> "oko" is a basic oko
21:19:24 <Hiato> right....
21:19:33 <Hiato> which is what?
21:19:50 <oklopol> well, you know, the basic unit of okoing.
21:20:08 <oklopol> (except i guess the new standard would define that as "o")
21:20:09 <Hiato> yes, I am familiar with that (????)
21:20:15 <oklopol> :)
21:21:53 <oklopol> http://www.vjn.fi/210.htm
21:22:13 <oklopol> sorry, for some reason not all the articles on out awesome page have been indexed by google! :o
21:22:29 <Hiato> :(
21:22:32 <Hiato> :P
21:23:38 <Hiato> Hrmm... I fail to see.... WHY THIS HASN'T CAUGHT ON WVERYWHERE :P
21:23:41 <Hiato> *everywhere
21:23:57 <Hiato> naah, but really, surely oklotalk needed some attention....
21:23:58 <Hiato> ;)
21:25:33 <oklopol> wow, 96 articles
21:25:47 <oklopol> have to get to a hundred tonight
21:25:54 <oklopol> now reading ->
21:25:57 <Hiato> okokokokokokokokokoko
21:25:58 <Hiato> okokokokokokokokoko
21:25:58 <Hiato> okokokokokokokoko
21:25:58 <Hiato> okokokokokokoko
21:25:58 <Hiato> okokokokokoko
21:25:58 <Hiato> okokokokoko
21:26:00 <Hiato> okokokoko
21:26:02 <Hiato> okokoko
21:26:04 <Hiato> oko
21:26:06 <Hiato> o
21:26:12 <Hiato> Heh, enjoy
21:27:13 <Hiato> Oklopol, please oh pretty please translate your site into english ;)
21:27:35 <faxlore> okokokokok
21:29:04 <Hiato> DORK & DOOMED ADVENTURES CARD GAME is awesome :D
21:29:06 -!- Hiato has left (?).
21:29:13 -!- Hiato has joined.
21:39:36 -!- Hiato has left (?).
21:41:29 -!- puzzlet has quit (Remote closed the connection).
21:41:32 -!- puzzlet has joined.
22:04:15 <oklopol> *our awesome page
22:24:55 -!- Hiato has joined.
22:25:51 <Hiato> how can ehird` still be asleep ??!
22:25:58 <Hiato> I need his BF genius...
22:26:15 * Corun has BF genuis
22:26:21 <Hiato> OK!
22:26:31 <Hiato> Right Corun, can you help me?
22:26:43 <Corun> Possibly
22:26:54 <Hiato> It's as good as a yes ;)
22:26:58 <Hiato> Ok, here is my problem..
22:28:20 <Corun> I'm a bit rusty with bf, but I've done plenty in the past
22:28:31 <Hiato> I need to move the IP to a fixed location, but, it can reside in one of two places, ie this is one possibility 1 x 2 0 where x is a number and the IP is at the 0, or it could be 1 0 1 0 where the IP is at the 1st zero
22:28:34 <Hiato> either wau
22:28:35 <Hiato> *way
22:28:57 <Hiato> I would like to move it, irrespective of position, to a specific place (I don't care where)
22:29:11 <Hiato> +>>+++++[<+++++++>-]
22:29:11 <Hiato> <[ [-[-[-[>[-]++>] <<+>>] <<+>>] <<+>>] < [-<--->>] <<]
22:29:14 <oklopol> Hiato: 1. not my page, i'm a part-owner 2. a lot of the content is in english 3. you can't know how awesome dork & doomed is, for the rules are currently in english
22:29:29 <oklopol> but i'll translate them some day, possibly
22:29:42 <Hiato> for this programme (it's trying 35 modulus 3)
22:30:39 <Hiato> oklopol: 1. Aha, sorry ;) 2. Yes, true, I know I was quick to jump to conclusions, but the articles that I saw where part finish 3. I'm not sure I understand what you are saying
22:30:51 <oklopol> Hiato: just have content of tape be every second cell, and put a 0 where you need to go, and 1's everywhere else
22:30:55 <Hiato> So, Corun, is it curable?
22:31:01 <Corun> I... have no idea
22:31:09 <Hiato> ... meh :(
22:31:22 <oklopol> oh, IP
22:31:27 <oklopol> that's of course impossible
22:31:35 <Corun> Er.. Maybe my BF is off.. But, "IP"?
22:31:47 <Hiato> Instruction Pointer
22:31:55 <Hiato> blah, it's probably wrong terminology
22:32:00 <Hiato> the thingy on the Tape, the head
22:32:05 <Corun> Ah. Ok, everything makes much more sense
22:32:08 <oklopol> memory pointer possibly
22:32:11 <oklopol> instructions are the code.
22:32:23 <Hiato> true... woops :(
22:32:25 <oklopol> Hiato: *are currently in finnish
22:32:42 <Hiato> aha
22:32:45 <Corun> Well, then, you can't do it :-)
22:32:49 <Hiato> makes more sense now, then I agree
22:32:49 <oklopol> anyway, i told you how to solve the problem already, unless i misunderstood you
22:32:53 <Hiato> Corun: NOOOOOO.....
22:33:04 <Hiato> yes, I got it
22:33:08 <oklopol> good
22:33:21 <Hiato> but I hoped for divine intervention :P
22:33:32 <Hiato> in which case, oklopol, you have proven yourself wrong
22:33:34 <Corun> I'm currently running a haskell program which generates and runs bf :-)
22:33:42 -!- RedDak has quit (Remote closed the connection).
22:33:55 <Hiato> as it is impossible to do the 1 cell simulation using 4 cells
22:33:58 <oklopol> Corun: the competition faxlore is doing?
22:33:58 <Hiato> you need five....
22:34:09 <Hiato> Awesome stuff Corun
22:34:12 <Corun> He didn't tell me it was a competition, he just said "fix my code"
22:34:15 <Hiato> what does it make?
22:34:16 <Corun> :-)
22:34:18 <oklopol> oh :D
22:34:22 <Hiato> lol :D
22:34:37 <Corun> :-P What competition, then?
22:34:42 <Hiato> so oklopol, so much for never being wrong eh :P
22:34:44 <faxlore> Corun I'm sure you know the competition
22:34:47 <oklopol> i thought faxlore mentioned something like that
22:34:49 <faxlore> Corun, For example, you entered it
22:34:52 <Hiato> he did
22:34:52 <faxlore> :p
22:35:02 <Corun> Oh, the string program generating one?
22:35:02 <oklopol> :D
22:35:07 <faxlore> yes
22:35:10 <faxlore> this is slightly different
22:35:15 <Corun> What is it this time?
22:35:49 <faxlore> well instead of taking a string and printing a short program.. we get a dictionary of strings with shortest programs
22:36:00 <oklopol> again ->
22:36:32 <Corun> Generate an entire dictionary of shortest programs?
22:37:01 <Corun> My old program would take, like, seconds per word... It would take ages :-)
22:38:26 <Corun> So, why are you making this program, then?
22:39:01 <Corun> Oh, balls, I just realize that program I pasted you isn't quite right
22:40:16 <Corun> Oh, maybe it was
22:40:59 <Hiato> ok, returning briefly yet inconspicuously to my BF problem +>>+++++[<+++++++>-] <[ [-[-[-[>[-]++>] <<+>>] <<+>>] <<+>>] < [-<--->>] <<] : How would one make it possible?
22:41:12 <Hiato> or if not, then how would one do a modulus
22:41:22 <Hiato> (in as few cells as possible)
22:42:55 <faxlore> Hiato.. What are you doing with that?
22:42:59 <faxlore> modulus?
22:43:04 <Hiato> yes
22:43:07 <Hiato> modulus 3
22:43:15 <Hiato> 35 modulus 3 = 2
22:43:23 <Hiato> the programme should say
22:43:34 <faxlore> ok I understand
22:43:50 <Corun> Seems like the sort of thing that bf would be good at...
22:44:20 <Corun> !bf +++++++++++++++[->+++++>++>+++++++>++++++++>++++>+++<<<<<<]>--.>++.>-----.>---.-------..+.<<.>>>--.>++.
22:44:23 <EgoBot> I dunno :/
22:44:28 <faxlore> haha
22:44:58 <Hiato> lol
22:45:47 <Hiato> !bf >>++++[<++++++++>-]>++[<+++++++++++++++++++++++>-]>+++++++[<++++++++++++>-]<[>+>
22:45:48 <Hiato> +<<-]>>[<<+>>-]<+++++++++++++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++[>+>+<<
22:45:48 <Hiato> -]>>[<<+>>-]<++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++
22:45:48 <Hiato> [>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<
22:45:48 <Hiato> <+>>-]<+[<]>>>.>>>>>.>.>>>>.<<<<<<<<<<<<.>>>>>>>.<<<<.>>>>>>>>>.<<<<<<<<<<<<.>>>
22:45:49 <Hiato> >>>.>>>>.>>>.<<<<<<<<<<<<<.>>>>>>>>>>>>>.<<<.<<<<<<<<<<.>>>>.>.<<<<<.>>>>>>>>>>>
22:45:50 <Hiato> .<.>>..<<<<.<<<<.>>>>>.<<<<.<<<<....
22:46:17 <Corun> !bf +++++++++++[->++++++>+++>++++++++++>+++++++++<<<<]>.>>+.+++++.-.<-.>.++.>.++++++++.
22:46:21 <EgoBot> Bots suck
22:46:22 <Hiato> blah, I don't think egoBot likes multilines
22:46:30 <faxlore> !huh
22:46:33 <EgoBot> Huh?
22:46:37 <faxlore> :DD
22:46:43 <Corun> Heh
22:46:50 <Hiato> !bf >>++++[<++++++++>-]>++[<+++++++++++++++++++++++>-]>+++++++[<++++++++++++>-]<[>+>+<<-]>>[<<+>>-]<+++++++++++++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<<+>>-]<++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<<+>>-]<+[>+>+<<-]>>[<<+>>-]<+++[>+>+<<-]>>[<<+>>-]<+[<]>>>.>>>>>.>.>>>>.<<<<<<<<<<<<.>>>>>>>.<<<<.>>>>>>>>>.<<<<<<<<<<<<.>>>>>>.>>>>.>>>.<<<<<<<<<<<<<.>>>>>>>>>>>>>.
22:46:53 <EgoBot> This has got t
22:47:11 <Hiato> hrmm... he didn't finish the sentence
22:47:29 <Hiato> !Huh?
22:47:31 <EgoBot> Huh?
22:47:50 <Corun> !bf +++++++++++[->+++>++++++++>++++++<<<]>---.>++.++++.<-.>>.<-.+++.---.
22:47:53 <EgoBot> Z^B]`]
22:48:01 <Corun> Oops
22:48:03 <Hiato> !d
22:48:05 <EgoBot> Huh?
22:48:09 <Hiato> he spoke for me
22:49:00 <Corun> !bf ++++++++++++++[->++>+++>++++>+++++++><<<<<]>+++++.>>>.++++.<<<-.>+............>>-----------.<<++.>++++++.<--......>.<........>.<..........>--...>++.<++.<+++.>.<---.+++.>.<.
22:49:03 <EgoBot> !bf ++++++++++++[->++++++>++++++++>++++++++++<<<]>.>+.>.
22:49:14 <Hiato> Wicked :D
22:49:17 <Corun> Aww... No fun.
22:49:25 <Corun> He doesn't respond to his own messages :/
22:49:41 <Hiato> lol
22:49:50 <Hiato> sucks actually :(
22:50:04 <Hiato> !bf >>++++++[<+++++++++++>-]<[>+>+<<-]>>[<<+>>-]<+++++++++++++++++++++++++++++++>>++++++++[<+++++++++++++>-]<[>+>+<<-]>>[<<+>>-]<++++[<]>.>>>.<<.>.
22:50:07 <EgoBot> Blah
22:50:11 <Hiato> exactly
22:50:24 <Hiato> He knows how I feel.... it's uncanny.... :P
22:50:37 <Corun> !bf +++++++++++++[->+++++>++++++++<<]>+.>++++.-----------.+++++++.
22:50:39 <EgoBot> Blah
22:50:41 <Corun> Mine's shorter :-P
22:50:44 <Hiato> yip
22:50:52 <Hiato> but, mine is shorter for longer things
22:50:57 <Hiato> and I'll prove it
22:51:04 <Corun> Oh?
22:51:09 <Hiato> you do the Mandelbrot Set
22:51:12 <Hiato> using your algo
22:51:23 <Hiato> and I'll do it using mine, then we compare
22:51:26 <Corun> Er, well, I'd need an ascii mandelbrot set
22:51:34 <Hiato> as is provided by me
22:51:37 <faxlore> use the output of mandel.b
22:51:39 <Hiato> 1 sec
22:51:41 <Hiato> exactly
22:51:42 <faxlore> mandelbrot.b
22:51:44 <Corun> Though, that's not exactly a great example of some text...
22:51:49 <faxlore> Yes it is
22:51:58 <faxlore> It's so compressed
22:52:03 <faxlore> compared to the complexity of the output
22:52:24 <Corun> But but but, what if his is shorter? I need an excuse, just incase it happens
22:52:31 <Hiato> http://rafb.net/p/NJOzUw38.html
22:52:33 <Hiato> there you go
22:52:50 <Hiato> with line numbers, run it, capture the output, and use your algo
22:52:55 <Hiato> lol
22:52:56 <Hiato> :D
22:53:35 <faxlore> hey
22:53:41 <faxlore> that's not manbelbrot.b
22:53:43 <Hiato> yes...
22:53:46 <Hiato> isn't it?
22:53:50 <faxlore> it might output the same text
22:54:00 <Hiato> I know
22:54:09 <Hiato> I said it's Poor man's mandelbrot
22:54:11 <Hiato> :P
22:54:15 <faxlore> for comparison http://www.menuetos.net/mandel.txt
22:54:21 <Hiato> Pasted as Plain Text by Hiato [ Remove line numbers | Show as plain text | Create new paste ] Description: Poor mans Mandelbrot
22:54:31 <Hiato> I never claimed it to be mandel.b
22:54:38 <Hiato> I just captured the output from it though
22:55:25 <Hiato> faxlore...
22:55:58 * faxlore is trying to write %3 >_<
22:56:12 <Hiato> thanks :)
22:57:28 <oklopol> -[>+<-[>+<-[>--<]]]> or something?
22:57:41 <Hiato> hrmmm?
22:57:58 <oklopol> if you remove transformations of the cell above
22:58:11 <oklopol> whoops
22:58:25 <faxlore> hey I think I did it
22:58:31 <faxlore> yeah just like oklopol
22:58:35 <Hiato> really?
22:58:36 <faxlore> >+++++[<+++++++>-]< 35#
22:58:36 <faxlore> [>+<-
22:58:36 <faxlore> [>+<-
22:58:36 <faxlore> [>+<-]]>---<]
22:58:38 <oklopol> except mine has a bug
22:58:41 <Hiato> show show
22:58:42 <oklopol> but the idea is right.
22:58:42 <faxlore> the output is 3 - 35%3
22:58:44 <Hiato> cool
22:58:52 <faxlore> so I get 1 instead of 2
22:59:03 <faxlore> I'm not sure how to fix it
22:59:11 <oklopol> simple
22:59:12 <faxlore> oops
22:59:20 <faxlore> I meant [>+<-]]>---<]>
22:59:22 <faxlore> for the last line
22:59:24 <oklopol> so simple i won't even tell ya
22:59:49 <oklopol> (reverse the operations and have an initial value)
23:00:21 <faxlore> hmm actually I could be wrong
23:00:37 <Corun> Ok, mine's, er, generating
23:00:47 <oklopol> let's see...
23:00:47 <Hiato> sure Corun
23:00:58 <Corun> I dunno how long it'll take
23:01:01 <Corun> Shouldn't be too long, though
23:01:05 <Corun> I've done big things with it before
23:01:08 <Corun> A few minutes I guess
23:01:11 <Hiato> if you (faxlore) or oklopol crack this
23:01:18 <Hiato> I will be ver so grateful
23:01:22 <oklopol> ah, there's a minor problem
23:01:25 <Hiato> sure Corun
23:01:29 <oklopol> it will never get off the inner loop
23:02:00 <Hiato> yes, I had a similar problem, but then found that it went to far if it skipped certain parts....
23:02:17 <oklopol> [>+<-[>+<-[>--<-<]]>]
23:02:39 <oklopol> i'll just fire an interp, too tired for this
23:03:11 <Hiato> oklopol, I'm not sure your code is functional....
23:03:52 <oklopol> hmm... shouldn't be this hard :D
23:04:01 <Hiato> Haha
23:04:05 <faxlore> grr!
23:04:35 <Hiato> exactly
23:04:56 <Corun> http://rafb.net/p/pnWQUD68.html
23:04:57 <Corun> Er, oh
23:05:40 <Hiato> Corun
23:05:48 <Hiato> could you please column wrap that at 80
23:05:53 <Hiato> so we can compare :)
23:06:02 <Hiato> and its not C++ :P
23:06:31 <Corun> -rw-r--r-- 1 Corun Corun 12536 11 Jan 22:53 mb.bf
23:06:31 <Corun> -rw-r--r--@ 1 Corun Corun 8610 11 Jan 23:06 mymb.bf
23:06:34 <oklopol> finally
23:06:35 <oklopol> >>+++++++[>+<-[>+<-[>--<-<<]]>>]
23:06:35 <Corun> :-P
23:06:42 <oklopol> sorry, i did some utter failing here
23:06:54 <Corun> mb is yours, mymb is mine :-)
23:07:22 <Hiato> blah
23:07:26 <Hiato> ok you win :(
23:07:29 <Hiato> well done :D
23:07:48 <Corun> I spent loads of time on it, ages ago
23:07:50 <oklopol> [>+<-[>+<-[>--<-<<]]>>]< Hiato: starting from the moduled number, this puts the right value in the next cell
23:07:55 <oklopol> uses 4 cells though :\
23:08:07 <Hiato> :(
23:08:13 <Hiato> but Hey very well done :D
23:08:16 <oklopol> uses 4 cells and leaves in a fifth cell...
23:08:16 <Hiato> congratulations
23:08:17 <Hiato> LD
23:08:20 <Hiato> :D
23:08:24 <faxlore> ahh
23:08:26 <Hiato> blah
23:08:27 <faxlore> wow, well done
23:08:29 <Hiato> no worries
23:08:31 * faxlore couldn't get it!
23:08:45 <oklopol> 0 0 8! 0 0 -> 0 0 0 2 0!
23:08:48 * Hiato couldn't either
23:08:52 <Hiato> awesome
23:09:17 <oklopol> before being totally awed, test for yourself, i always fail at everything
23:09:20 <oklopol> now some reading ->
23:09:24 * faxlore tested it :p
23:09:38 <Hiato> yes, it workd
23:09:40 <Hiato> *works
23:17:47 <Hiato> oklopol
23:18:04 <Hiato> I don't know why you did something strange there, but it only uses 2 cells now: [>+<-[>+<-[>--<->]]<]
23:18:46 <Hiato> well 3 really
23:18:53 <Hiato> but because it lands in it
23:19:10 <Hiato> after the loop
23:23:08 <Hiato> oh and PS: Now it is possible to do a 3 cell version
23:23:10 <Hiato> I think
23:25:53 <Hiato> hrmm.. well, you can do a three cell version, it just means that you won't be able to raise anything after the first number, you'll have to multiply
23:26:01 * tesseracter waves at pikhq
23:26:16 <pikhq> ;(
23:27:05 <tesseracter> pikhq: this is scary. cross
23:28:38 <Hiato> no, wait, you need 3 cells...
23:28:40 <Hiato> *4
23:31:10 -!- puzzlet has quit (Remote closed the connection).
23:31:13 -!- puzzlet has joined.
23:31:38 <Corun> !bf ++++++++++++++++[->++>++++++>+++++++><<<<]>>++.++++.<.>+++.>+++.<<.>------.++.+++++++..>++.<.-----------.>---.<<+.
23:31:41 <EgoBot> bf is cellular!
23:32:29 <tesseracter> EgoBot supports bf? tell me more!
23:32:46 <Hiato> !bf_txtgen Yip
23:33:03 <Corun> !bf +++++++++++[->+++>++++>++++++++>+++++++++>++++++++++>+++++++++++><<<<<<<]>>>-.>++.>--..<<<.<-.>>>>>.<+++.>----.<<<<<.>>>-.>.<<<++++++++++++++.<.+.>>>--.++++.<<<-.>>++++.>>>--.<.--.<-.<<<.>>>---.++++.<++.<<.>>++++.>>+.<--.<<<.>>>+++++.>>+.<<<<<.>>>>>--.+++.<.>--.<<<<<.>>>.>>+.
23:33:05 <EgoBot> Well, you do: !bf [some bf] and it runs it
23:33:15 <EgoBot> 52 +++++++++++++++[>++++++>+++++++>><<<<-]>-.>.+++++++. [95]
23:33:28 <Hiato> !bf +++++++++++++++[>++++++>+++++++>><<<<-]>-.>.+++++++.
23:33:31 <EgoBot> Yip
23:36:56 <tesseracter> !bf_txtgen /me
23:37:19 <EgoBot> 51 ++++++++++++[>++++>+++++++++>><<<<-]>-.>+.--------. [84]
23:37:48 <faxlore> !bf +[+.]
23:37:51 <EgoBot>
23:38:23 -!- EgoBot has quit (Excess Flood).
23:38:31 <tesseracter> pwnd :-(
23:38:33 -!- EgoBot has joined.
23:40:31 <Hiato> hhaha lol :D
23:48:48 -!- Corun has quit ("This computer has gone to sleep").
23:58:18 <tesseracter> experiment.
23:58:26 * tesseracter waits.
←2008-01-10 2008-01-11 2008-01-12→ ↑2008 ↑all