00:30:53 <lament> lalala
00:51:58 <pgimeno> graue: any progress on the automated DB backup?
01:36:28 <graue> i'm waiting for lock tables permission
01:36:39 <graue> supposedly it can be provided to me
02:16:34 <graue> http://esoteric.voxelperfect.net/db/latest.sql.bz2
02:18:37 <graue> it should now update on sundays at about 00:01 UTC, maybe a little later
02:19:50 <malaprop> great
02:20:22 * malaprop sets up a mirroring script.
02:20:31 <malaprop> How about svn dump?
02:23:25 <graue> um, just check it out
02:23:42 <malaprop> So you want me to start hassling you again as soon as someone commits a revision, eh? :)
03:17:46 -!- calamari has joined.
03:18:21 <calamari> hi
03:18:38 <GregorR> Hullo
03:36:10 -!- kipple has quit (Read error: 110 (Connection timed out)).
03:59:56 <malaprop> graue: latest.sql.bz2 seems to be 0 bytes in length
04:05:28 <graue> does it?
04:05:31 <graue> brb investigating
04:06:13 <graue> funny, it's 449514 bytes on the server
04:06:31 <malaprop> I do 'wget http://esoteric.voxelperfect.net/db/latest.sql.bz2' and get http 200 but 0 bytes.
04:06:48 -!- CXI has quit (Connection timed out).
04:07:04 <graue> yeah, me too
04:15:37 <graue> try http://esoteric.voxelperfect.net/db/latest.sql.gz
04:16:17 <malaprop> still 0b
04:16:47 <graue> really? works for me
04:17:19 <malaprop> Really, from two different systems.
04:18:57 <graue> well, seeing as how it works fine for me, i can't do anything about that
04:19:45 <malaprop> Are you trying from that machine itself?
04:21:53 <graue> no, i am not
04:23:14 <GregorR> Works fine for me.
04:24:28 <malaprop> doesn't work even from a new, third host
04:26:36 <malaprop> ah, hm, .gz works but .bz2 is 0b?
04:26:45 * malaprop didn't notice the changed extension at first.
04:27:31 <graue> ah, that's why i gave you a url :)
04:27:59 <malaprop> It looked the same at first glance, heh. Why gz instead of bz2?
04:29:27 <graue> because gz files don't get served as 0 bytes
04:30:09 <GregorR> lol
04:35:42 <malaprop> I've got a cron job and simple page set up, I'll post to the mailing list after dns propagates a bit.
05:16:26 -!- malaprop has quit ("quit").
05:27:44 <calamari> esoshell wiki writing testbed: http://lilly.csoft.net/~jeffryj/cgi-bin/miniwiki.cgi
05:34:22 -!- Keymaker has left (?).
05:50:12 <graue> what does that do, just change itself?
06:04:50 <calamari> graue: yeah.. it's handy because I can access it from lilly.csoft.net while testing out the wiki file i/o
06:05:28 <calamari> since Java has those security restrictions
06:05:32 <graue> ah, i see
06:08:16 <calamari> graue: I still haven't decided on the format.. what do you think of what I just added?
06:09:02 <graue> works i guess
06:09:17 <calamari> not very pretty, though :)
06:09:33 <graue> you will have to escape < into &lt;
06:09:50 <calamari> even inside pre?
06:09:56 <graue> yeah
06:10:05 <graue> how else do you think "</pre>" works?
06:10:11 <calamari> heheh
06:11:44 <calamari> that might get annoying for authors typing in programs by hand, or pasting them in
06:12:29 <graue> most text editors have find and replace
06:13:20 <calamari> aha.. mediawiki takes care of that for us
06:13:31 <graue> hmm, a brainfuck and html polyglot would be fun
06:13:49 <graue> except that it's not possible because html has to have < before any >s
06:13:58 <GregorR> <!-- -->
06:14:12 <GregorR> You can put < and > in those, just not -->
06:14:25 <graue> that < will be illegal in brainfuck since it goes to cell -1
06:14:29 <calamari> graue: I might not understand.. I did <pre> <<< </pre>  and mediawiki translated the < to &lt;
06:14:39 <graue> calamari, cool
06:15:01 <graue> what if you do <pre> <b> </pre>?
06:15:32 <calamari> works fine
06:15:40 <graue> interesting
06:16:07 <calamari> I guess the only restriction is that the file couldn't contain </pre>
06:16:37 <calamari> I'm not sure that's such a big deal :)
06:16:50 <graue> nope
06:17:04 <GregorR> Damn, that first < think is a real toughy XD
06:17:22 <GregorR> If you started with >++ you'd be fine, but that may make it unhappy ... it would probably be illegal HTML, technically.
06:18:56 <calamari> GregorR: I'll be stripping off the <pre> and </pre> before bf sees it
06:20:16 <GregorR> calamari: I was referring to the HTML-BF polyglot
06:21:27 <calamari> GregorR: aha :)
06:42:05 <calamari> graue: http://esoteric.voxelperfect.net/wiki/Help:Editing  has no help documents.. is this a work in progress?
06:42:49 <graue> calamari, how did you get there?
06:43:46 <calamari> graue: any edit page, click down at the bottom where it says (Editing Help) opens in new window
06:44:00 <calamari> err, have the parens wrong.. but that's the idea :)
06:45:53 <calamari> http://esoteric.voxelperfect.net/wiki/Help:Contents   also
06:46:04 <calamari> that's any page click "Help" on the left 
06:56:56 -!- CXI has joined.
07:05:57 <graue> god what is with all the redundant pages
07:06:27 <graue> i made an Esolang:Help, but Help:Editing and Help:Contents should just be the same thing
07:09:28 <graue> i redirected the other two now
07:16:07 -!- calamari_ has joined.
07:16:18 <calamari_> re's :)
07:21:13 <calamari_> graue: http://esoteric.voxelperfect.net/wiki/User_talk:Calamari
07:21:13 <calamari_> better, worse?
07:21:13 <graue> cool, it works
07:21:29 <graue> you can make user subpages
07:21:39 <graue> e.g. "User:Calamari/esoshell_tests"
07:21:41 <calamari_> argh, I messed up that link on the help page
07:21:52 <calamari_> oh yeah?  I'll have to try that :)
07:22:16 <graue> oh god, man, you didn't read the page you were editing!
07:22:32 <graue> it clearly states that that section is called "External resource", not "External Links" :)
07:22:40 <calamari_> graue: lol
07:24:46 <calamari_> oops, conflict 
07:28:07 <calamari_> btw, can only admins revert pages? or is revert just a cute name for copying & pasting the old page back in?
07:32:13 <graue> revert is a cute name for changing a page back by whatever means, yes
07:32:33 <graue> however, admins get a convenient link to do this automatically, when looking at a diff
07:32:39 <graue> all it does is make it faster for them
07:33:00 -!- calamari has quit (Connection timed out).
07:38:09 <calamari_> hehe, having those file extensions is probably unnecessary :)
07:38:50 <calamari_> maybe a description area would be helpful too
07:39:35 <calamari_> I need to go to bed.. feel free to improve upon the current design
07:40:10 -!- calamari_ has quit ("Leaving").
07:54:41 -!- graue has left (?).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:15:41 -!- sp3tt has joined.
09:21:37 <sp3tt> Is it possible to do division in bf?
09:22:01 <puzzlet> i think so
09:22:54 <sp3tt> It should be possible using the same code as multiplication...
09:23:00 <lament> sp3tt: brainfuck is turing-complete
09:23:02 <lament> so yeah, it is :)
09:23:36 <lament> just need to know the algorithm...
09:24:45 <sp3tt> >+++++[<+++++++++>-] 5 * 9
09:25:25 <puzzlet> iteratively subtracting until the number goes down to 0, and counting how many subtraction has been done?
09:25:38 <sp3tt> <[--------->>+<-<]
09:26:09 <sp3tt> That would divide by nine, but how do you handle situations where there is a remainder? I.e where x % y != 0.
09:26:18 <lament> [-[-[-[-[-[-[
09:26:24 <puzzlet> yeah
09:26:38 <lament> but it's better to write a general algorithm
09:26:42 <lament> to divide X by Y
09:26:47 <lament> where X and Y are two numbers on the tape
09:27:06 <sp3tt> True.
09:28:11 <lament> implementing the algorithm is left as an exercise for the reader.
09:29:05 <sp3tt> Google search for brainfuck division turns up German wikipedia.
09:29:45 <sp3tt> Heh. I wrote a 5 page PDF about brainfuck (in Swedish) leaving Hello world as an exercise for the reader :)
09:30:32 <puzzlet> I have discovered a truly remarkable implementation, which this margin is too small to contain.
09:30:56 <lament> it certainly doesn't sound hard. just keep subtracting.
09:31:25 <lament> or store your numbers as rationals :)
09:31:35 <lament> then division is the same as multiplication
09:32:24 <sp3tt> One could write a nested loop, subtracting one until the cell contains 0.
09:32:56 <sp3tt> When the loop has subtracted one Y times, add one to a third cell.
09:33:20 <sp3tt> And when the loop is finished, calculate the remainder in some way.
09:34:18 <lament> the remainder will just sit there
09:34:24 <lament> in whatever cell you were using for subtraction
09:46:03 <sp3tt> That would require a check to see if y > x
10:11:55 -!- starling has joined.
10:12:39 -!- starling has quit ("pop").
10:39:17 -!- kipple has joined.
11:08:08 <pgimeno> moin
11:24:33 <kipple> hola
11:32:36 -!- sp3tt has quit (Read error: 104 (Connection reset by peer)).
11:58:11 -!- Keymaker has joined.
11:58:21 <Keymaker> rgrg
12:02:59 <kipple> is that finnish for "hello"?
12:03:58 <fizzie> No, that would be "hei" or something.
12:04:14 <fizzie> "tervehdys", perhaps, although that's closer to 'greetings'.
12:04:39 <kipple> you say "hei" in Finland as well?
12:04:54 <fizzie> Uh, yes.
12:05:19 <kipple> In Norway too
12:06:33 <fizzie> It is an useful greeting when mingling with swedish-speaking folks, since their "hej" is pronounced quite similarly.
12:09:35 <fizzie> Away to eat now. ->
12:14:16 <Keymaker> ah. hei kipple!
12:14:35 <kipple> hei
12:14:39 <Keymaker> heh
12:15:16 <Keymaker> i found interesting site; http://freesound.iua.upf.edu/
12:15:20 <Keymaker> it has allkinds of sound samples
12:15:29 <kipple> well, that was a nice small Finnish/Norgwegian polyglot conversation :)
12:16:22 <Keymaker> haha
12:30:02 <kipple> Keymaker: nice link
12:30:21 <pgimeno> very nice, Keymaker! reminds me of the free images site... http://www.openclipart.org/
12:31:18 <kipple> thanks pgimeno! I like
12:38:22 <pgimeno> np, enjoy the world of free resources :)
12:38:57 <Keymaker> nice
12:39:21 <Keymaker> :) there's good machine sounds etc on that page.. that's what i was looking for and finally found a nice source :)
12:39:33 <Keymaker> i'll try to get something done with some samples
13:03:45 <kipple> Keymaker: what kind of software do you use for making music
13:08:32 <Keymaker> i use buzz tracker
13:08:37 <Keymaker> it's really cool imho
13:08:40 <Keymaker> totally freeware
13:09:06 <Keymaker> the only bad thing is that there is so much stuff that i don't know what to do
13:09:26 <Keymaker> it's filled with allkinds of things and options
13:09:40 <Keymaker> and audacity for sample stuff
14:07:43 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
14:10:14 -!- puzzlet has joined.
14:16:24 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
14:39:23 -!- puzzlet has joined.
14:51:51 <Keymaker> ok that's enough musicing for today.
14:52:04 <Keymaker> i lose my nerver
14:52:10 <Keymaker> *nevers
14:52:13 <Keymaker> fck
14:52:18 <Keymaker> *nervers
14:52:21 <Keymaker> *nerves
14:52:28 <Keymaker> can't tpye
14:52:37 <pgimeno> too nevrous? :)
14:52:37 <puzzlet> bad keyboard?
14:52:43 <Keymaker> :)
14:52:52 <Keymaker> yes
14:53:06 <Keymaker> the keyboard's fine
14:53:34 <Keymaker> i'll go to eat. then i'll switch to linux. then me comes back.
14:53:40 -!- Keymaker has quit ("I've seen this déjà vu before..").
14:57:50 -!- Keymaker has joined.
14:58:26 <Keymaker> rgh. so it is true: if you eat too much candy before the actual food you don't feel like eating the actual food
14:59:32 <puzzlet> you finished eating in 5 minutes?
14:59:46 <Keymaker> no. i brought the dinner here again :)
15:01:51 <Keymaker> i'll listen some prodigy. i hope i could make their kind of music a bit.. it's so crazy :)
15:11:38 <Keymaker> i added bf-hacks to esowiki brainfuck links
15:11:46 <Keymaker> hopefully nobody minds
15:27:56 <Keymaker> i added two small sample programs to thue oage
15:27:59 <Keymaker> *page
15:28:08 <Keymaker> they should be correct, although i didn't test
15:43:38 <kipple> you forgot to log in before editing... :)
15:44:07 <Keymaker> aaaaaaaaargh
15:44:16 <Keymaker> frrrrrgh
15:45:02 <Keymaker> maybe the wiki should be editable for users only?
15:45:35 <Keymaker> oops, iirc 'editable' means something that can be eaten :)
15:45:50 <Keymaker> or perhaps not
15:45:52 <kipple> no, that's edible
15:45:55 <Keymaker> yes
15:46:01 <Keymaker> just remembered that
15:46:08 <Keymaker> i wonder what i'm thinking today
15:46:13 <Keymaker> i've been all crazy
15:46:15 <Keymaker> :)
15:46:26 <Keymaker> well, too bad the wiki isn't edible
15:47:02 <kipple> only the chef programs
15:47:11 <Keymaker> :)
15:48:56 <Keymaker> i'll try to think more about the snack language i was planning
15:49:00 * Keymaker thinks
16:03:14 -!- malaprop has joined.
16:10:20 <Keymaker> yes!
16:11:12 <Keymaker> i think i got some idea
16:11:12 <Keymaker> time to write good ol' python
16:15:05 <Keymaker> is 'snack' good name? any other idea for a language that deletes it's own code?
16:15:27 <malaprop> Keymaker: SourceSafe
16:15:35 <Keymaker> :D
16:15:55 <Keymaker> or well, it doesn't delete the actual source from hard drive
16:15:58 <Keymaker> (too bad!)
16:16:04 <Keymaker> but from memory
16:46:58 -!- cpressey has quit (brown.freenode.net irc.freenode.net).
16:48:03 -!- cpressey has joined.
16:51:04 -!- cpressey has quit (brown.freenode.net irc.freenode.net).
16:52:35 -!- cpressey has joined.
17:01:07 <Keymaker> question:
17:01:31 <Keymaker> if stack is empty, should popping return error or zero/empty/do nothing?
17:02:12 <malaprop> Pretty arbitrary. I've seen both commonly.
17:02:17 <Keymaker> yeah
17:02:55 <kipple> do something completely different!
17:03:16 <Keymaker> empty stack returns random value?
17:03:22 <kipple> hehe
17:03:30 <Keymaker> that could be nice
17:03:39 <kipple> or start popping the source code :)
17:03:42 <Keymaker> would add some random flavour to the language
17:03:51 <Keymaker> well source is popped all the time ;)
17:03:59 <kipple> print 99bob
17:04:04 <Keymaker> heh
17:04:16 <Keymaker> then that could be written with one instruction..
17:04:24 <kipple> random could be nice
17:04:28 <Keymaker> yeah
17:04:37 <kipple> if there is another way of checking if the stack is empty
17:05:04 <Keymaker> not yet
17:05:17 <Keymaker> i'm still planning while writing the interpreter
17:05:45 <kipple> maybe you could have an boolean operator that checks if a number is 'random' :D
17:05:52 <Keymaker> heh
17:06:22 <Keymaker> btw; would reversible stack be okay for two stacks?
17:06:26 <Keymaker> like there is one stack
17:06:36 <Keymaker> but instruction '/' could reverse it
17:06:50 <Keymaker> and that way the other side of the stack could be popped and pushed etc..
17:07:05 <kipple> that would be a nice instruction
17:07:10 <Keymaker> yes
17:10:12 <kipple> interesting contest: http://www.brainhz.com/underhanded/
17:10:26 <kipple> (might be slashdotted any moment now)
17:11:19 <Keymaker> hehe
17:55:27 <malaprop> kipple: Yes, is now on Slashdot.
17:55:48 <kipple> I know, that's where I found it
17:59:18 <malaprop> ah, I read your comment to say it was yours or a friends and you were waiting for /. to post a story on it
18:00:23 <kipple> ah. No. I was waiting for the server to go down from the slashdot effect. Which it hasn't :)
18:03:59 <Keymaker> malaprop
18:04:06 <Keymaker> how to reverse string in python?
18:06:49 <malaprop> "foo"[::-1]
18:07:08 <malaprop> So you slice the whole thing with a negative step, basically.
18:07:17 <Keymaker> ah cheers
18:07:19 <Keymaker> works
18:11:45 <Keymaker> snack is progressing!
18:14:40 <kipple> any code examples?
18:15:21 <kipple> mmm. Python looks cool. Maybe I'll use that for my next esolang
18:16:25 <Keymaker> not yet
18:16:29 <Keymaker> hopefully later tonight
18:16:31 <Keymaker> and yeah
18:16:43 <Keymaker> python is my favourite "real" language thesedays
18:16:44 <malaprop> kipple: Python rules. :)
18:16:50 <Keymaker> i found it out few days ago
18:16:54 <Keymaker> :)
18:17:18 <Keymaker> in python strings and stacks and stuff like that is so easy that it's idea for esolang interpreter writing
18:17:24 <Keymaker> *ideal
18:17:44 <malaprop> Keymaker: Heh, have you used list comprehensions at all? They're my favorite new idiom.
18:17:55 <Keymaker> hmm no i don't think so
18:17:57 <Keymaker> what are those?
18:18:22 <malaprop> Say you have a list full of objects that you want to do a common operation on. Instead of writing
18:18:28 <malaprop> for x in list:
18:18:35 <malaprop>     x.foo()
18:18:38 <malaprop> you can write:
18:18:45 <malaprop> [x.foo() for x in list]
18:18:51 <Keymaker> :)
18:19:06 <malaprop> which gets really handy when you do stuff like "\n".join([x.toXML() for x in list])
18:19:11 <Keymaker> yeah
18:20:17 <Keymaker> i selected to this language that popping empty stack returns nothing
18:20:32 <Keymaker> and probably make the random feature for memory stack
18:20:42 <Keymaker> this language has two stacks
18:20:50 <malaprop> oh, conditionals are also handy: [x.foo() for x in list if x.bar > 2]
18:21:00 <Keymaker> :)
18:48:57 -!- comet_11 has joined.
18:50:01 -!- CXI has quit (Read error: 104 (Connection reset by peer)).
18:56:44 -!- graue has joined.
19:00:03 <pgimeno> phew! finished the first part of the Malbolge article
19:00:11 <Keymaker> cool!
19:00:14 <Keymaker> is it up?
19:00:57 <pgimeno> yeah
19:01:05 <pgimeno> http://www.esolangs.org/wiki/Malbolge
19:01:22 <Keymaker> cool, i'll read it now!
19:01:35 <pgimeno> it's just a language description at the moment
19:01:54 <Keymaker> ok
19:07:05 <Keymaker> good work
19:07:20 <pgimeno> thanks
19:07:41 <pgimeno> is it easy enough to understand?
19:07:52 <Keymaker> yeah, i guess
19:08:01 <Keymaker> all but the code samples :)
19:08:10 <pgimeno> hehe, indeed
19:09:26 <pgimeno> even 'reading' the normalized version requires external help (a trace is helpful)
19:09:34 <Keymaker> heh
19:10:26 <kipple> so, Keymaker, when is the Malbolge quine done?
19:10:32 <Keymaker> uhhh
19:10:40 <Keymaker> :)
19:10:53 <Keymaker> thanks heaven i haven't even thought that
19:11:26 <pgimeno> hehehe
19:11:39 <Keymaker> (nor digital root calculator!)
19:11:41 * pgimeno considers about offering a prize
19:11:51 <pgimeno> <graue> http://esoteric.voxelperfect.net/db/latest.sql.bz2
19:11:52 <pgimeno> <graue> it should now update on sundays at about 00:01 UTC, maybe a little later
19:12:01 <pgimeno> so can it be announced to the mailing list?
19:12:23 <malaprop> I'd guees so. Mention that I'm doing backups.
19:12:56 <pgimeno> Keymaker: you may want to add the digital root program to http://www.esolangs.org/wiki/Popular_problem
19:12:59 <kipple> I'll set up a cron job as well
19:13:00 <malaprop> oh, and it's .gz, not .bz2
19:13:07 <Keymaker> that would be cool pgimeno
19:13:17 <Keymaker> although dunno how popular that is
19:13:23 <Keymaker> but it's worth being popular ;)
19:13:25 <pgimeno> malaprop: well, I managed to download the .bz2 without problems
19:13:35 <pgimeno> maybe an apache caching issue or something
19:13:53 <Keymaker> i'll add it
19:13:58 <malaprop> huh, and now I can get it
19:14:21 <kipple> graue: which of the archives is the one that gets updated?
19:16:56 <pgimeno> the null program is not a quine in malbolge: it crashes the reference interpreter due to a(nother) bug
19:17:17 -!- slobo has joined.
19:17:38 <pgimeno> hi slobo
19:19:10 <pgimeno> that nick sounds reminiscent of a not very fast language
19:20:42 <slobo> hi
19:20:44 <slobo> ?
19:21:12 <Keymaker> hi
19:21:45 <pgimeno> http://en.wikipedia.org/wiki/SLOBOL_programming_language
19:22:57 <slobo> lol, didn't know this :)
19:23:41 <pgimeno> :)
19:25:28 <pgimeno> brb, taking down one bottle of beer from the wall
19:26:08 -!- slobo has left (?).
19:27:00 <Keymaker> :)
19:27:05 <Keymaker> how many left?
19:27:49 <pgimeno> too few
19:28:10 <Keymaker> "go to store and buy some more"
19:28:20 <Keymaker> :)
19:29:44 <pgimeno> the counter is still in 4
19:29:59 <Keymaker> ok
19:38:21 -!- calamari has joined.
19:38:34 <calamari> hi
19:38:45 <Keymaker> hi
19:38:55 <Keymaker> ok here it is: http://www.esolangs.org/wiki/Digital_root
19:41:18 <kipple> anyway, if anyone wants to try and implement the Song with real hardware (or should I say liquid-ware?), here is the place to do it: http://www.mommsen-eck.de/
19:41:45 <kipple> you wont have to drink the same kind twice :)
19:41:58 <Keymaker> :)
19:42:35 <kipple> though you might get some run-time errors, I think...
19:42:43 <Keymaker> i have a feeling any hardware couldn't get past 50 bottles before serious malfunction
19:43:02 <Keymaker> or well, past 20
19:43:12 <kipple> well, I think the way to do it would be with parallell processing
19:43:21 <Keymaker> :)
19:44:05 <calamari> ahh, didigtal root is the division by 3 test 
19:44:19 <Keymaker> hm?
19:44:40 <calamari> that's the way you can tell if a number is divisible by 3
19:44:50 <calamari> (besides actually doing the division)
19:44:52 <Keymaker> ah
19:44:59 <Keymaker> i didn't know that
19:45:02 <Keymaker> cool
19:45:03 <calamari> so if it comes out to 3, 6, or 9, it's divisible
19:45:09 <Keymaker> yeah
19:48:27 <calamari> I should add a page to the bf giving algorithms, like division for sp3tt
19:48:41 <Keymaker> that could be nice
19:49:14 <pgimeno> N.B. the digital root is also a test for divisibility by 9 (if it comes out to 9)
19:50:31 <calamari> pgimeno: cool, didn't know that one :)
19:50:41 <calamari> does it work for 6 as well?
19:50:47 <pgimeno> nope
19:51:00 <pgimeno> for 6, check that it's even and it's divisible by 3
19:51:22 <calamari> right, because 2*3=6
19:51:30 <pgimeno> yup
19:51:37 <calamari> so now we know the /18 rule :)
19:51:44 <pgimeno> sure :)
19:52:58 <pgimeno> also, if a number's last two digits can be divided by 4, then it's divisible by 4; if it's also divisible by 3, then it's divisible by 4*3=12
19:53:42 <malaprop> pgimeno: I don't think that works for 144.
19:53:51 <malaprop> oh, whole number div 3? ya, ok
19:54:21 <pgimeno> 144=4*4*9, quite more complex
19:54:40 <pgimeno> (requires that the last four digits can be divided by 16)
19:58:08 <pgimeno> this regexp tests divisibility by 4 (if I've made no mistake): ^[0-9]*([13579][26]|[02468]?[048])$
20:01:59 <pgimeno> no, it does not work
20:03:36 <pgimeno> ^([0-9]*[13579][26]|[0-9]*[02468][048]|[048])$ should work (there was a problem with the ? above)
20:08:46 <Keymaker> would these instructions be good:
20:09:10 <Keymaker> 'i' to increase memory stack's top value by 1
20:09:28 <Keymaker> 'I' (big 'i') to increase memory stack's top value by 10
20:09:47 <Keymaker> and 'd' and 'D' to decrease by 1 and 10
20:10:19 <Keymaker> but i wouldn't like to use letters
20:10:27 <Keymaker> better think something else..
20:11:05 <Keymaker> or should i use the befunge way? polish notation (was it called that)?
20:11:54 <Keymaker> like 99* would push 9 to stack and then 9 to other stack and then pop them and multiply them and then push the result
20:12:05 <malaprop> Keymaker: ya, that's rpn
20:16:54 <Keymaker> grhhh. i just use the gooood ol' + and - stright from brainfuck :)
20:17:03 <Keymaker> nobody needs more than that
20:21:26 <Keymaker> hmm
20:21:29 <Keymaker> what should i do:
20:21:36 <malaprop> Keymaker: How about have integer literals repeat? So + adds 1 to top of stack, and +9 adds ten.
20:21:48 <Keymaker> that could be nice idea
20:22:03 <Keymaker> but i decided that using the "loop" system i have is easy enough :)
20:22:42 <Keymaker> i was about to ask that i probably should use good ol' byte as memory 'cell' size?
20:24:13 <lament> i hate bytes
20:24:18 <lament> be original
20:24:21 <lament> use base 9 or sometihng
20:24:25 <Keymaker> hmm
20:24:28 <malaprop> Be a man, use unicode.
20:24:34 <Keymaker> NOOOOOOOOOOOOOOOOO
20:24:37 <lament> and yeah
20:24:40 <Keymaker> :)
20:24:42 <lament> puzzlet will kill you if you don't use unicode
20:24:55 <lament> do you really want to be mauled by a mob of angry koreans?
20:24:58 <pgimeno> is there still no language using balanced trinary?
20:25:12 <Keymaker> don't make me use bits..
20:25:18 <lament> pgimeno: that would be surprising
20:25:28 <lament> pgimeno: wasn't there an actual computer using balanced trinary
20:25:38 <pgimeno> no idea
20:25:58 <pgimeno> is there?
20:26:14 * pgimeno googles
20:26:52 <lament> well, there was a ternary computer
20:27:00 <lament> i have no idea if it was balanced ternary or some other kind
20:27:05 <lament> it was made in russia
20:27:16 <lament> iskra or something?
20:27:20 <Keymaker> :)
20:27:35 <lament> no, probably something else
20:28:06 <Keymaker> http://www.computer-museum.ru/english/setun.htm
20:28:11 <lament> yeah
20:28:27 <pgimeno> wow
20:28:35 <Keymaker> indeed
20:28:38 <lament> yeah
20:28:40 <Keymaker> never heard of this
20:28:55 <lament> very little actual detail in that article
20:29:25 <Keymaker> maybe it's some soviet secret
20:29:27 <lament> i wonder why there aren't more ternary machines
20:29:44 <lament> the article seems to list a bunch of unilateral advantages
20:34:00 <pgimeno> does setun use balanced ternary? I haven't seen that
20:36:15 <Keymaker> i'll take a small break from developing esolang -- and go to program in thue :)
20:36:31 <Keymaker> i probably come back later
20:36:37 -!- Keymaker has left (?).
21:13:14 <calamari> http://www.esolangs.org/wiki/Brainfuck_algorithms
21:15:11 <calamari> argh.. I wasn't logged in.. 
21:15:41 <calamari> it seems to random forget I'm logged in.. I blame my browser
21:24:20 <pgimeno> there's a timeout
21:24:52 <pgimeno> if you refresh any page you reload the timer
21:25:57 <calamari> can that be disabled?
21:26:41 <calamari> brb
21:26:43 -!- calamari has quit ("Leaving").
21:39:00 -!- calamari has joined.
21:39:01 <calamari> re's
21:40:13 <pgimeno> calamari: I don't know if that can be disabled; I learned the trick after noticing the disconnections
21:40:45 <pgimeno> I've just read your page; very nice
21:41:09 <pgimeno> it's good to have 'stock' algorithms instead of reinventing the wheel each time
21:42:23 <pgimeno> one comment though
21:43:24 <pgimeno> I've noticed that the PRNG works modulo 65536, but LCGs modulo a power of 2 suffer from a "nonrandomness disease"
21:44:36 <pgimeno> in the best case, the lowest bit just toggles from 0 to 1 on each iteration, and the next one just cycles like this: 0, 0, 1, 1
21:45:29 <pgimeno> (sorry for the ping, I wanted to make sure you weren't disconnected)
21:46:20 <pgimeno> the alternative is to use a prime modulus, and 65537 is just nice because it allows for period 65536
21:46:45 <pgimeno> it will complicate the algorithm, though
21:48:29 <pgimeno> A = 75, B = 74 make V always < 65536 (that's the PRNG used in the Speccy, incidentally)
21:49:41 <pgimeno> (sorry if I'm being a bit picky here, PRNGs are an area of my interest)
21:51:26 <calamari> pgimeno: I used the numbers from the book listed.. they investigated many different combinations of numbers to come up with those
21:51:53 <fizzie> modulo-2^n LCGs are quite common, though, aren't they? Knuth uses a modulo-2^35 one.
21:52:23 <pgimeno> yeah, but e.g. the low bit of the high byte has period 256
21:52:25 <calamari> pgimeno: I'd love to see a better solution (especially if it's simpler!) :)
21:52:48 <pgimeno> (in the period-65536 generator I mean)
21:53:03 <pgimeno> calamari: no, it won't be simpler :)
21:54:05 <pgimeno> fizzie: Knuth also warns against using the low bits in LCGs modulo powers of 2; he recommends using multiplication to get a number in a given range
21:54:10 <calamari> I'm still working on putting up my array code, but it will take longer because I need to make sure it's right :)
21:54:39 <calamari> array code is always so complicated 
21:55:36 <fizzie> That's the usual rand(3) manpage warning.
21:55:59 <pgimeno> that problem disappears with a prime modulus LCG
21:57:24 <pgimeno> (though maximum period for prime M is M-1, not M)
21:58:54 <fizzie> (Hmf, glibc's rand() apprently isn't a LCG.)
22:00:06 <pgimeno> I've learnt to never trust standard library's PRNGs anymore :)
22:01:41 <pgimeno> that way you can make reentrant generators, predictable results, better period guarantees...
22:02:23 <pgimeno> and of course better randomness guarantees
22:02:39 <pgimeno> do you know Kyodai Mahjongg?
22:03:27 <pgimeno> in that game there are lots of board numbers that generate exactly the same board
22:04:34 <pgimeno> just because the period is insufficient and the generation method is a RN hog
22:06:50 <pgimeno> calamari: maybe the book authors just didn't consider a modulus other than 65536
22:07:04 <calamari> perhaps
22:07:15 <calamari> it's been a long time since I coded that up
22:07:42 <calamari> it seemed to work fine.. I checked it out in basic first to see what kinds of numbers were produced
22:08:15 <pgimeno> and you didn't notice that they were alternatively odd/even? :)
22:08:25 <calamari> they weren't
22:08:48 <pgimeno> well, did you print the values of V?
22:09:09 <calamari> if you're assuming that the produced random # is16-bits wide, thats an error.. I'm only using 8 bits of it
22:09:35 <pgimeno> oh ok. that's the high byte then, right?
22:09:41 <calamari> I don't recall
22:10:02 <calamari> looks like it (from the bf)
22:10:16 <pgimeno> it must be, otherwise it would be odd/even
22:10:56 <calamari> feel free to post an improved algorithm.. then everyone can benefit
22:11:10 -!- starling has joined.
22:12:03 <pgimeno> might do, if I clean my to-do list a bit first :)
22:13:09 <calamari> hehe
22:13:15 <calamari> there, I clarified the rng a bit
22:13:29 <calamari> now it says 0-255 and hight byte
22:13:40 <pgimeno> nice
22:14:03 <calamari> ok, back to arrays.. afk :)
22:14:08 <pgimeno> :)
22:16:35 <starling> I know this is probably the wrong place to ask...
22:17:01 <starling> Esoteric certainly, but... maybe not in the brainfsck style.
22:17:50 <malaprop> Are the perl and c malbolge interpreters equivalent?
22:18:53 <starling> Is there a language out there that doesn't treat text special unless explicitly marked as such?
22:19:03 <malaprop> special?
22:19:13 <starling> Yeah, like "as a variable" or "as a keyword" or something.
22:19:43 <starling> The only language I can think of really (or not really) is perl's print <<EOT;
22:19:52 <malaprop> PHP requires a $ in front of all variables; Perl requires $ in front of scalars and @ for hashes.
22:20:57 <starling> But you can't have unquoted text that isn't meaningful, at least in Perl.  The compiler won't know what to do with 'em.  Thus the <<EOT; thing.  :p  Was wondering if something more rigorous existed.
22:21:04 <malaprop> ahhh
22:21:14 <malaprop> brainfuck
22:21:42 <starling> Nah, all of brainfuck's 5 letters are treated special.  :)
22:21:53 <malaprop> Fine then: cat
22:22:18 <starling> Can't explicitly mark text as special with cat...
22:22:42 <malaprop> Ah, think I got it: Python's docstrings.
22:23:12 <starling> docstrings, are those parsed at all?
22:23:34 <malaprop> Look at doctest, ya.
22:23:45 <malaprop> Alternately, Knuth's literate programming.
22:24:09 * starling nods.
22:26:33 <pgimeno> <malaprop> Are the perl and c malbolge interpreters equivalent?  <- I don't really know; the C interpreter has some caveats
22:27:13 <pgimeno> but in general you can expect that programs with characters in the printable ASCII range will work the same
22:27:24 <pgimeno> I've written a Python one (and a debugger)
22:31:50 <pgimeno> starling: even Perl (or sh) makes the EOT string special
22:32:10 <pgimeno> or do you mean "user decidable"?
22:32:56 <starling> Well, user decidable I suppose.  I suppose it's possible to make the end of file to act as EOT in some cases.
22:33:26 <pgimeno> sh is one
22:34:06 <starling> It's just I'm trying to write a screenplay, and I have to invent my own language for it.  Wanted some functionality, without worrying about every word possibly being variable expanded.
22:34:38 <starling> The only extant formats I can find are all 'output' formats, with margin lengths and font and such.
22:36:10 <pgimeno> Python docstrings don't fit there very well, if I understand the problem correctly
22:36:38 <pgimeno> don't C comments fit?
22:36:41 <starling> Yeah, perl's <<EOT\netcEOT\n thing might work... 
22:37:08 <pgimeno> or C #if 0 ... #endif ?
22:37:18 <starling> No, because sometimes I do need to have stuff evaluated, like to mark-up or do logic.
22:38:35 <pgimeno> and doesn't */ evaluate /* help?
22:39:05 <starling> Oh... Yeah that... might actually work.
22:39:46 <starling> I suppose it's also necessary to be able to juggle blocks of text around as atoms.  Hmm...
22:39:52 <pgimeno> it's kind of like when in PHP you write: <?php do something; ?>
22:40:16 <pgimeno> maybe php fits your needs
22:40:24 <pgimeno> I'm using it as a preprocessor
22:40:46 <starling> *nods*  I don't know PHP, but it might work good.
22:41:43 <pgimeno> php outputs text until it encounters <?php in which case it starts processing commands until ?>, then it begins outputting text again
22:41:53 -!- Keymaker has joined.
22:41:56 <Keymaker> hello
22:42:01 <pgimeno> hi Keymaker 
22:42:06 <Keymaker> hi
22:42:07 <starling> Right-o.
22:42:14 <Keymaker> good work calamari
22:42:37 <Keymaker> not sure what kind of array code you're writing there
22:42:49 <Keymaker> but simple array is easy
22:42:49 <Keymaker> +++++++++ what value?
22:42:49 <Keymaker> > ++++++++++++++++++++++ where?
22:42:49 <Keymaker> [
22:42:49 <Keymaker> >>>[>>]+[<<]<-
22:42:49 <Keymaker> ]
22:42:51 <Keymaker> <
22:42:53 <Keymaker> [
22:42:55 <Keymaker> > >>>[>>]<+<[<<] <<-
22:42:57 <Keymaker> ]
22:43:23 <Keymaker> that code moves the "what value?" value to "where?" memory place
22:43:41 <Keymaker> each location uses two bytes; one for movement and one for storing
22:44:05 <Keymaker> this is, for byte-implementation
22:44:26 <Keymaker> but the same code would work even if the cell size is more than byte
22:44:39 <Keymaker> (on those implementations that i don't prefer)
22:46:09 <calamari> keymaker: I'm doing x(y)=z and x = y(z)
22:46:32 <calamari> But, you could add that as a simiplified case :)
22:46:39 <Keymaker> ok
22:46:58 <Keymaker> what kind of array is this your new array?
22:47:07 <Keymaker> is there any size limit?
22:47:49 <Keymaker> as well, your random code is clever
22:47:52 <calamari> size limit depends on cell size
22:47:56 <Keymaker> never heard of that
22:48:00 <Keymaker> ok
22:48:01 <calamari> keymaker: thanks :)
22:48:05 <Keymaker> :)
22:48:15 <Keymaker> oh i mean like how long the array is
22:48:22 <calamari> yeah that's what I mean too
22:48:23 <Keymaker> like can you set x(4999999) = 3
22:48:39 <calamari> yes, if your cells can hold the value 4999999
22:49:07 <Keymaker> ok.. so the max is with 1 byte-implementation x(255)?
22:49:11 <calamari> yes
22:49:14 <Keymaker> 'ok
22:49:24 <Keymaker> my code basically does that
22:49:33 <Keymaker> or well, it does that
22:49:34 <Keymaker> :)
22:49:42 <Keymaker> it wouldn't be hard to add
22:49:46 <Keymaker> it to get the value
22:49:58 <calamari> I've saved my changes 
22:50:03 <Keymaker> ?
22:50:14 <Keymaker> changes?
22:50:18 <calamari> could you add your sections and save changes so I can work in my little corner without a conflict
22:50:27 <Keymaker> sure
22:50:54 <Keymaker> do you want me to add my stuff to esowiki?
22:50:55 <calamari> what will it be, x = y(_constant), x(_constant_)=y ?
22:51:09 <Keymaker> my code?
22:51:14 <calamari> also, be sure to specify where the pointer ends up
22:51:20 <Keymaker> yes
22:51:44 <calamari> see the one array code I put for an example of what I mean
22:51:46 <Keymaker> i'll do this: i'll write the stuff on txt
22:51:58 <Keymaker> and later, for example tomorrow, add it when you're edited the wiki
22:52:05 <calamari> okay
22:52:06 <Keymaker> or something like that
22:52:11 <Keymaker> i have no reason to hurry :)
22:52:14 <malaprop> brb
22:52:16 -!- malaprop has quit ("leaving").
22:52:29 -!- malaprop has joined.
22:52:41 <Keymaker> if i do detailed work i may add it to my site as well
22:53:22 <Keymaker> but what i could do is to convert some of those algorithms of your to non-wrapping implementation ;)
22:53:24 <malaprop> I think I'll write a Malbolge quine
22:53:31 <Keymaker> :)
22:53:33 <Keymaker> go ahead
22:54:30 <pgimeno> what can I offer if you manage to do that? hmm...
22:55:10 <Keymaker> 99 bottles of beer?
22:55:12 <calamari> pgimeno: more bf algorithms :)
22:55:20 <Keymaker> :)
22:55:26 <pgimeno> yeah, that makes sense, Keymaker
22:56:00 <pgimeno> malaprop: if you write a Malbolge quine I'll reward you with 99 bottles of beer
22:57:26 <pgimeno> malaprop: are you really interested in Malbolge? I want to write sections about practical Malbolge coding
22:58:04 <malaprop> My interest in Malbolge is not deep.
22:58:18 <pgimeno> ok
22:58:31 <Keymaker> calamari: reversing data would be nice there as well. we could probably use that 50-byte entry of bfcc #1 if we asked the author's (bertram) permission.
22:58:51 <malaprop> I'm going to go think about this on the train to visit some friends; I'll be AFK the next 24hish.
22:59:06 <Keymaker> :)
22:59:26 <pgimeno> have you read Lou Scheffer's article? it's a good introduction
23:00:17 <pgimeno> when his ideas are put into practice other issues surface though
23:00:42 <pgimeno> bbl
23:02:33 -!- starling has left (?).
23:04:55 <calamari> keymaker: ok.. array code should be up if you want to add things :)
23:06:00 <Keymaker> ok
23:07:41 <Keymaker> here should be code that 'returns' NOT(x)
23:07:42 <Keymaker> +++++++++++++++++++++++++++ THIS IS X
23:07:42 <Keymaker> [>+>+<<-]>>[<<+>>-]
23:07:42 <Keymaker> +++++>>>
23:07:42 <Keymaker> +++++[<+++++[<+++++>-]>-]<<
23:07:42 <Keymaker> [<++>-]<<
23:07:44 <Keymaker> [>-<-]>[<+>-]<<
23:07:57 <Keymaker> the first cell is x
23:08:06 <Keymaker> and the second cell will get the value not(x)
23:08:19 <Keymaker> the original x will remain in the first cell
23:09:16 <calamari> why not put it in the wiki rather than paste it here?  :)  btw, I already have a not function listed
23:09:46 <Keymaker> but isn't that for wrapping version?
23:09:54 <calamari> yeah.. this is non-wrapping? cool
23:09:57 <Keymaker> yes
23:10:01 <Keymaker> that's why i wrote this
23:10:02 <Keymaker> :p
23:10:24 <Keymaker> i'll add it there..?
23:10:31 <calamari> if it's possible to normalize it (use variable names instead of > and <, please do so
23:10:50 <calamari> that way it becomes much more reuseable
23:11:06 <Keymaker> hmm.. sorry, i don't know how to convert to those :\
23:11:18 <calamari> that's okay.. I'll try to do it 
23:11:24 <Keymaker> good :)
23:11:28 <Keymaker> they confuse me too much
23:11:45 <Keymaker> here's the memory layout (if i remember it correctly):
23:11:50 <Keymaker> oh wait
23:11:58 <Keymaker> it's no use, since it change during execution
23:12:38 <calamari> that's the probelm with bf algorithms, isn't it.. no documentation, and can't remember how it works :)
23:13:31 <calamari> makes me glad that I was able to preserve mine somewhat with the variable naming format
23:13:34 <Keymaker> hehe. but here is what it does: take copy of x, make one cell 255, decrease 255 by that copy x's value, then move not(x) to second cell
23:13:57 <Keymaker> heh
23:18:02 <calamari> so whats the shortest way to make 255? 16*16-1?
23:18:54 <Keymaker> dunno
23:19:00 <Keymaker> i used 5*5*5*2
23:19:11 <Keymaker> +5
23:19:12 <Keymaker> :)
23:22:19 <Keymaker> but notice on 1-byte, non-wrapping implementation you can NOT do 16*16 :)
23:22:23 <calamari> how's this: http://www.esolangs.org/wiki/Brainfuck_algorithms
23:22:31 <calamari> aha
23:22:36 <calamari> that is true
23:22:49 <calamari> so I need to fix it again :)
23:23:17 <Keymaker> the 5*5*5*2+5 way is quite good imho
23:23:29 <calamari> 17*15
23:24:11 <Keymaker> that's easy, but long :)
23:24:11 <calamari> except that neither of us seem to understand it :)
23:24:43 <calamari> can you show me just the code where you set a cell to 255?
23:24:51 <Keymaker> ok
23:24:57 <Keymaker> +++++>>>
23:24:58 <Keymaker> +++++[<+++++[<+++++>-]>-]<<
23:25:04 <Keymaker> first place 5
23:25:12 <Keymaker> go three right
23:25:19 <calamari> thanks
23:25:28 <Keymaker> and so on :)
23:26:03 <Keymaker> probably best would be if you'd just convert my original code to that tutorial form :)
23:26:50 <calamari> there is what I get:
23:26:53 <calamari> >[-]+++++++++++++++[<+++++++++++++++++>-]
23:26:53 <calamari> [-]+++++>[-]>[-]>[-]+++++[<+++++[<+++++>-]>-]<<
23:27:07 <calamari> your code (when properly zeroed) is actually a bit longer 
23:27:22 <calamari> maybe some of the [-] can be skipped?
23:27:51 <calamari> actually wait, I missed on on mine
23:28:02 <calamari> [-]>[-]+++++++++++++++[<+++++++++++++++++>-]
23:28:07 <Keymaker> :)
23:28:20 <calamari> still shorter tho :)
23:30:23 <Keymaker> your code leaves cells with values on the memory
23:30:39 <Keymaker> adn on which cell the x should be?
23:31:12 <calamari> I don't understand your question
23:31:15 <Keymaker> oh wiat
23:31:22 <Keymaker> nothing notghin nothing!!
23:31:31 <Keymaker> i just ran the two lines you posted
23:31:39 <Keymaker> and thought that that isn't working at all :D
23:31:45 <Keymaker> now i see it's comparing
23:32:14 <Keymaker> yes, your way is shorter if cells must be cleared first
23:32:43 <Keymaker> algorithms page is probably assuming the codes can be run at any time?
23:32:46 <calamari> yeah
23:32:51 <Keymaker> ok
23:33:04 <calamari> is neg = not + 1  going to wrap ?
23:33:17 <Keymaker> no idea
23:33:30 <calamari> ie neg(10)=-10, not(10)=-11, so -11+1 = -10
23:33:49 <Keymaker> no idea still!
23:33:54 <calamari> hehe 
23:33:58 <Keymaker> :)
23:34:36 <calamari> ahh lets see, not(0)=255, 255+1=0.. oops
23:34:58 <calamari> I could make 0 a special case
23:35:04 <Keymaker> ?
23:35:08 <Keymaker> i can't understand this at all
23:35:20 <Keymaker> what does "x = -x" do?
23:35:47 <Keymaker> in values that can't be negative?
23:36:08 <calamari> good question.. mnaybe it makes no sense to even bother
23:36:22 <Keymaker> it's on the esowiki..
23:36:39 <calamari> that's because it works well when cell wrapping is allowed
23:36:42 <calamari> 255 = -1
23:37:06 <Keymaker> i don't think it's really useful, sorry :)
23:37:12 <Keymaker> mainly because there is no sense :)
23:37:12 <calamari> so if x = 1, the code x=-x gives -1
23:37:19 <Keymaker> yes
23:37:29 <calamari> you've never used -x in a program you wrote?
23:37:33 <Keymaker> no
23:37:46 <calamari> well, sometimes in math you need it :)
23:38:07 <Keymaker> but assuming i have brainfuck implementation, 1-byte and non-wrapping
23:38:18 <calamari> then you don't need it
23:38:21 <Keymaker> and i want -(33)
23:38:25 <calamari> but non-wrapping isn't a given
23:38:48 <calamari> a lot of bf programmers (including myself) are okay with wrapping
23:39:02 <Keymaker> :]
23:39:14 <calamari> so let's just leave the non-wrapping version off, because you're right, it makes no sense
23:39:21 <Keymaker> ok :)
23:39:25 <Keymaker> agree!
23:39:50 <calamari> heheh
23:40:05 <Keymaker> btw, is the line between wrapping and non-wrapping version of not(x) necessary?
23:40:10 <Keymaker> it makes reading hard
23:40:13 <calamari> I should rewrite == and != to use 1 = true instead of 255
23:40:28 <calamari> keymaker: nope, that must be an accident on my part
23:40:35 <Keymaker> ok :)
23:40:39 <Keymaker> i can write other of them
23:40:47 <Keymaker> which one do you want == or != ?
23:41:04 <calamari> do you understand the code? :)
23:41:15 <Keymaker> not esowiki code
23:41:19 <Keymaker> but pure brainfuck, yes
23:41:23 <calamari> okay :)
23:41:30 <calamari> I can do both, it won't take long
23:41:37 <Keymaker> well, ok then
23:44:23 <Keymaker> what 'x = x and y (boolean)' does?
23:44:44 <calamari> okay done 
23:44:50 <Keymaker> ok
23:44:50 <calamari> x = x && y 
23:44:54 <pgimeno> for the record, according to http://www.iwriteiam.nl/Ha_bf_numb.html you need at least 30 instructions for 255
23:45:49 <Keymaker> ok
23:46:05 <Keymaker> i mean it does something with bits?
23:46:11 <Keymaker> (&&)
23:46:45 <Keymaker> AND 'gate'?
23:47:29 <calamari> keymaker: if you're familiar with c, it is the && operator
23:47:37 <Keymaker> i'm not
23:48:06 <calamari> keymaker: examples:  1 == 2 returns 0,  5 == 5 returns 1
23:48:23 <Keymaker> ah
23:48:26 <Keymaker> i'm stupid
23:48:30 <calamari> this is useful for things like if()
23:48:32 <Keymaker> i was thinking at byte level
23:48:33 <Keymaker> yes
23:48:34 <Keymaker> this
23:48:37 <Keymaker> 00110
23:48:41 <Keymaker> 10010
23:48:46 <Keymaker> 00010
23:48:48 <Keymaker> :)
23:48:50 <calamari> ahh, yeah, that's bitwise
23:48:54 <Keymaker> i mean bit level
23:49:14 <calamari> I've writeen those, too.. I 'd forgotten ! :)
23:49:36 <pgimeno> smallfuck comes handy at those :)
23:49:46 <Keymaker> :)
23:49:49 <Keymaker> indeed
23:49:52 <calamari> yeah, I'd bet it does
23:50:07 <calamari> interesting how it can be more powerful and less at the same time
23:50:15 <Keymaker> :)
23:50:49 <Keymaker> i should write some smallfuck program (using some i/o extension)
23:51:52 <pgimeno> Boolfuck may be what you're looking for
23:51:54 <Keymaker> naturally without using any bf-->sf stuff
23:53:16 <calamari> bitchanger is smaller, but not symmetric
23:53:39 <calamari> so you don't really win anything.. just less symbols
23:53:44 <Keymaker> :)
23:53:48 <Keymaker> how did you invent it?
23:53:59 <calamari> keymaker: driving down the freeway I came up with the answer :)
23:54:30 <pgimeno> heh, the eureka effect
23:54:33 <calamari> I didn't know about any other bit bf's 
23:54:58 <Keymaker> lol
23:55:00 <calamari> my goal was to simplify bf so that it could be wired with transistors
23:55:10 <Keymaker> :)
23:55:17 <calamari> didn't happen, of course
23:57:27 <pgimeno> with TTL circuits, I hope
23:58:05 <pgimeno> nm
23:58:15 <Keymaker> rgh.
23:58:23 <Keymaker> well, seems i didn't go night photographin'
23:58:35 <Keymaker> better continue being here, then
23:59:25 <Keymaker> gotta go tomorrow, or going crazy
23:59:45 <Keymaker> anyways, i'll switch to linux once again, will be back soon.
23:59:47 -!- Keymaker has quit ("I've seen this déjà vu before..").