00:01:01 <jix> there is no dp intercal package
00:01:01 * kipple is reading the lazybrain spec
00:01:38 <kipple> dp? 
00:01:46 <jix> darwin ports
00:01:55 <kipple> ah
00:02:09 <jix> automatic downloading+(patching if needed)+compilation of source code
00:02:33 <jix> there is apt-get for osx (fink) too.. but the packages are always out of date 
00:03:41 <kipple> jix: are the function's tapes local or global?
00:03:51 <jix> local
00:03:55 <jix> semi local
00:04:16 <jix> they are used for passing arguments.. but they aren't used for returning values
00:05:08 <kipple> so, whatever the function does, it does not alter the main tape? (except for the return values)
00:05:17 <jix> yes
00:05:33 <kipple> ok. the spec should be a bit clearer about that methinks
00:05:39 <jix> hmm..
00:06:14 <kipple> or perhaps not... on second reading it is quite clear :)
00:07:05 -!- graue has joined.
00:08:16 <jix> changed it a bit so that it is clear on the first reading
00:08:22 <graue> debian has the libacme-brainfck-perl package, which seems to implement brainfuck (it allows it to be mixed with perl code according to the package description)
00:09:04 -!- mathkid has left (?).
00:09:09 <graue> also, a whitespace interpreter, whitespace, is there
00:13:19 <graue> lazy brain confuses me too much
00:16:11 -!- graue has quit ("Leaving").
00:19:11 -!- graue has joined.
00:27:10 <jix> graue: why?
00:30:07 <jix> 22 commands...
00:31:28 <jix> 23
00:41:06 <Keymaker> hm
00:41:13 <Keymaker> must go
00:41:26 <Keymaker> see you on 7th or 8th. :)
00:41:36 <Keymaker> nite
00:41:40 -!- Keymaker has left (?).
00:57:01 <pgimeno> I've abandoned xhtml in favour of html4 since these M$ patents
00:57:45 -!- graue has quit (Read error: 110 (Connection timed out)).
01:01:00 <jix> Sorry! The wiki is experiencing some technical difficulties, and cannot contact the database server. 
01:01:00 <jix> Can't connect to local MySQL server through socket '/tmp/mysql.sock' (61)
01:02:06 <kipple> which wiki? the esolang wiki works fine...
01:02:14 <jix> it was down for about 20 secs
01:13:24 -!- jix has quit ("Banned from network").
01:14:56 -!- graue has joined.
01:35:05 -!- wooby has joined.
01:35:55 <wooby> ahoyo
02:00:20 -!- kipple has quit ("See you later").
02:10:19 -!- graue has quit ("Lost terminal").
02:53:02 -!- comet_11 has joined.
03:16:09 -!- CXI has quit (Connection timed out).
03:26:21 <GregorR> This stupid commercial says that they can give you any hair color, "within the physical limitations of electromagnetic waves."
03:26:25 <GregorR> I want ultraviolet hair.
03:26:30 <GregorR> WHERE'S MY ULTRAVIOLET HAIR?!
03:52:30 <wooby> i'm sure it could be managed with the right chemicals
03:52:43 <wooby> invisible wavelength hair is an interesting concept, lol
04:17:08 -!- GregorR-L has joined.
04:17:12 <GregorR-L> Gamma hair 8-D
04:17:20 <GregorR-L> "My hair gives me cancer"
04:33:04 <wooby> lol
04:33:43 <wooby> your hair could also give other people cancer
04:36:15 <GregorR-L> But would I care?  No!  I'd be too brain-cancery to care.
04:39:07 <wooby> yeah if i had elite radioactive hair i probably wouldn't care either
04:41:36 <GregorR-L> :P
04:42:15 <GregorR-L> How about radio waves?
04:42:30 <GregorR-L> When your hair flowed around, different static would be sent over the radio.
04:59:17 <wooby> it would be kind of cool to walk into a room and the TV goes bonkers
04:59:39 <wooby> "hey sonny, you dig my ku-band hair?"
05:00:03 <GregorR-L> XD
05:00:49 <wooby> so i desperately want to come up with my own esolang, but i'm idea-less
05:02:09 <GregorR-L> If I came up with an idea and gave it to you, it wouldn't be your idea.
05:02:13 <GregorR-L> So good luck ;)
05:05:45 <wooby> yeah i know! that's the kicker
05:14:55 <GregorR-L> If I knew anything about the communication between proteins, it would be awesome to make a programming language based on genetic code :)
05:16:15 <GregorR-L> "Communication" is a stretch.
05:17:02 <wooby> haha
05:17:47 <wooby> well a hack would be to implement smallfuck, using g,t,c,a as the operators
05:18:08 <wooby> programs would look cool, anyways
05:18:21 <wooby> GATTACA
05:18:46 <GregorR-L> Not authentic enough for me *shrugs*
05:19:03 <wooby> yeah me neither :\
05:24:22 <wooby> well, i'm calling it a night
05:24:37 <wooby> have to polish off some takeout and watch some law and orders
05:25:08 <wooby> g'night
05:26:24 <GregorR-L> Buhbye
06:04:04 <GregorR-L> OK, now I know how to build peptide chains ...
06:05:14 <GregorR-L> I'm still not sure how to turn that into programming :-P
06:05:30 <lament> haha
06:50:27 <GregorR-L> The function of the peptide sequences is deterministic but mind-numbingly complex.
06:54:54 -!- comet_11 has quit (brown.freenode.net irc.freenode.net).
06:54:54 -!- pgimeno has quit (brown.freenode.net irc.freenode.net).
06:54:54 -!- cpressey has quit (brown.freenode.net irc.freenode.net).
06:54:56 -!- wooby has quit (brown.freenode.net irc.freenode.net).
06:54:58 -!- lindi- has quit (brown.freenode.net irc.freenode.net).
06:54:58 -!- fizzie has quit (brown.freenode.net irc.freenode.net).
06:54:59 -!- ChanServ has quit (brown.freenode.net irc.freenode.net).
06:54:59 -!- GregorR-L has quit (brown.freenode.net irc.freenode.net).
06:55:14 -!- malaprop has quit (brown.freenode.net irc.freenode.net).
06:55:14 -!- cmeme has quit (brown.freenode.net irc.freenode.net).
06:55:14 -!- mtve has quit (brown.freenode.net irc.freenode.net).
06:55:14 -!- ZeroOne has quit (brown.freenode.net irc.freenode.net).
06:57:00 -!- ChanServ has joined.
06:57:00 -!- GregorR-L has joined.
06:57:00 -!- comet_11 has joined.
06:57:00 -!- wooby has joined.
06:57:00 -!- malaprop has joined.
06:57:00 -!- pgimeno has joined.
06:57:00 -!- cpressey has joined.
06:57:00 -!- lindi- has joined.
06:57:00 -!- fizzie has joined.
06:57:00 -!- ZeroOne has joined.
06:57:00 -!- cmeme has joined.
06:57:00 -!- mtve has joined.
06:57:00 -!- irc.freenode.net has set channel mode: +o ChanServ.
06:57:26 <GregorR-L> Well, I made a PHP genetic code -> peptide parser
06:57:26 -!- comet_11 has changed nick to CXI.
07:23:34 -!- Keymaker has joined.
07:23:39 <Keymaker> hi
07:23:47 <Keymaker> i just to came say "bye for a while"
07:23:52 <Keymaker> Bye for a while!
07:24:05 <Keymaker> see you all on 7th
07:24:12 <Keymaker> keep up to good work
07:24:15 <Keymaker> bye
07:24:17 -!- Keymaker has quit (Client Quit).
07:43:09 -!- graue has joined.
07:43:55 <graue> news flash: sort language gets name, nice website, faux-academic paper! details @ http://www.oceanbase.org/graue/sortle/
07:44:59 <GregorR-L> w00t
07:45:24 <lament> cool name
07:46:11 <CXI> Sortle
07:46:12 <CXI> From Esolang
07:46:12 <CXI> (There is currently no text in this page) 
07:46:12 <CXI> awesome :D
07:46:45 <graue> heh, well, go ahead and make it then
07:47:13 <CXI> I would if I knew anything about it
07:47:32 <graue> oh
07:47:56 <graue> i vaguely remember a programming language called GCAT that pretended to be genetic code
07:52:23 <lament> you know
07:52:33 <lament> a vaguely remember hearing something about a sorting language
07:52:47 <lament> s/^a/i
07:53:02 <lament> not sure if i'm hallucinating or not
07:53:49 <graue> there's the language Sorted!, but it doesn't seem very similar to sortle
07:54:16 <graue> Bubble? there's also Jeffry Johnston's Bubble, based on bubble sort
07:54:55 <graue> i hadn't gotten around to reading this yet, but it's described at http://lilly.csoft.net/~jeffryj/compilers/bubble/bubble.txt
07:58:13 <lament> yeah
07:58:14 <lament> that
07:59:35 <graue> is it fun? it doesn't seem to have been implemented
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:02 <lament> i have no idea
08:02:42 <lament> why are ^ and $ separate operators?
08:04:09 <graue> because i didn't realize they were exactly equivalent when i wrote the spec :)
08:04:35 <graue> i decided to maintain both of them just to see if anyone would notice
08:04:41 <graue> their implementation is the exact same
08:05:26 <lament> i noticed, can you remove one now? :)
08:06:32 <graue> maybe in commercial implementations, the difference will be that the ^ operator is licensed for noncommercial use only, and you have to pay extra to get the $ operator
08:06:39 <graue> but seriously
08:06:57 <graue> i'll replace the $ operator with something better when i have an idea for another string operator that will be useful
08:09:53 <graue> maybe the opposite of ^? "" if either string is empty?
08:12:13 <GregorR-L> OK, I need brainstorming help.
08:12:32 <GregorR-L> After I've produced peptide sequences, how should they be parsed into functional entities?
08:15:51 * GregorR-L peruses the human genome.
08:16:09 <graue> i'm blissfully ignorant as to what a peptide sequence represents in the first place
08:17:03 <GregorR-L> Amino acids are combined into peptide sequences, which in turn fold into proteins, which are the most prominant physical building blocks of life.
08:18:54 <graue> is this programming language supposed to be realistic?
08:19:05 <graue> what does a peptide sequence look like? GCAT and such?
08:19:48 <CXI> Gregor: well you just have to work out how they fold into proteins, and then use the proteins as functional entities :P
08:20:00 <GregorR-L> CXI: Wow, that's easy 8-D
08:20:05 <CXI> yeah eh? :D
08:20:14 <GregorR-L> graue: Chemically speaking, they're usually written something like this: SKPRVYASQDVR
08:20:28 <GregorR-L> That's some peptide sequence in neurons.
08:27:17 <graue> well, heck if i know
08:27:24 <graue> you're the peptide expert
08:27:54 <GregorR-L> No I'm not X-D
08:35:57 <GregorR-L> UGUCAUGUCGACGCGAGACGCGCCGUCGCACGCUUCGACUACUACUAUGCGUUCGAACUCCACCACUAA
08:35:57 <GregorR-L> CHVDARRAVARADYYYAAELHH
08:35:57 <GregorR-L> UCACGCGUUCGAGCAUCGACUACGCGUGUCGAUCGACACGUCGCAUCGAACCGCAUGAUCGAUCGAUGA
08:35:57 <GregorR-L> SRVRASTTRVDRHVASNRMIDR
08:35:57 <GregorR-L> CUCGAUCACAGUCACCGCGUCUAUUCGACCGUUCGAACGACACUCCUAUCGACGUCACCUCUCUACUAUGCUGUGCCUCGUAGCUGUACGUAG
08:35:58 <GregorR-L> LDHSHRVYSTVRTTLLSTSPLYYAVPRSCT
08:36:02 <GregorR-L> ^ A melanin concentrating hormone
08:42:11 <graue> what's the relationship between GCAT and GCAU, again?
08:42:24 <graue> is it A <-> T/U, G <-> C?
08:48:18 <GregorR-L> T -> U
08:48:25 <GregorR-L> In DNA, it's T, in RNA it's U.
08:48:47 <GregorR-L> Oh, I just answered the wrong question, didn't I?
08:49:10 <GregorR-L> a-g and c-t/u I think
08:49:39 <GregorR-L> N/M
08:49:43 <GregorR-L> It's a-t/u, g-c
09:23:53 -!- GregorR-L has quit ("Leaving").
09:24:35 <fizzie> There's http://www.wisdom.weizmann.ac.il/~udi/DNA5/scripps_short/sld019.htm and the slides after that.
09:25:21 <fizzie> Not-really-related-but-still.
09:58:11 -!- sp3tt has joined.
10:05:01 <graue> hello sp3tt
10:13:29 -!- sp3tt has quit (Read error: 145 (Connection timed out)).
10:33:29 <pgimeno> moin
10:39:09 <graue> good moining, pgimeno
10:40:40 -!- GregorR has quit (Read error: 110 (Connection timed out)).
10:45:41 <pgimeno> (np: Scrap Heap - Hiccup Jam)
11:04:40 -!- puzzlet has joined.
11:12:58 <graue> hi puzzlet
11:17:59 -!- sp3tt has joined.
11:20:29 <puzzlet> hi graue 
11:26:47 <graue> i wish C had ||= and &&= operators
11:27:53 <pgimeno> isn't |= !! enough?
11:28:10 <puzzlet> graue: maybe += and *= will do it
11:28:37 <graue> |= !! works, i guess
11:28:53 <puzzlet> what's "!!"?
11:28:58 <pgimeno> not not
11:29:02 <graue> turns a value into 0 or 1
11:29:03 <puzzlet> ah
11:29:26 <pgimeno> the lhs should be already 0 or 1 for that to work
11:29:50 <puzzlet> what was i thinking, !! works for tribit or something?
11:30:20 <pgimeno> how are troolean operations defined?
11:30:36 <pgimeno> (if George Boole saw me write that...)
11:30:51 -!- jix has joined.
11:30:55 <puzzlet> there is crazy operators for tribits in [[Malbolge]]
11:31:00 <puzzlet> operator*
11:31:01 -!- GregorR has joined.
11:31:17 <jix> moin
11:31:27 <pgimeno> moin jix, GregorR 
11:31:31 <puzzlet> joheun achim
11:31:38 <graue> troolean algebra?
11:31:49 <pgimeno> yeah
11:32:01 <graue> how does that go? true, false, or maybe?
11:32:09 <pgimeno> maybe ;)
11:32:35 <pgimeno> I have a strong preference towards balanced trinary though
11:32:54 <graue> how about analog boolean algebra; instead of false or true everything is a float from 0.0 to 1.0
11:33:12 <pgimeno> that sounds like fuzzy logic
11:33:23 <puzzlet> thats what i thought too
11:34:04 <puzzlet> how about, like GTTCAAATGGTA?
11:35:07 <graue> i swear i remember a "GCAT programming language" from somewhere
11:37:18 <puzzlet> i've seen an article about making a processor out of DNA's and RNA's
11:40:01 <puzzlet> maybe making retro-virii out of those biocomputers to infect human world will become possible ;)
12:04:33 -!- kipple has joined.
12:10:37 <graue> moin kipple
12:10:42 <kipple> hi
12:22:00 <jix> uhrg... some logic mistakes in my Lazy Brain design
12:25:35 -!- J|x has joined.
12:26:01 -!- jix has quit (Nick collision from services.).
12:26:09 -!- J|x has changed nick to jix.
12:30:15 -!- GregorR has quit (Read error: 60 (Operation timed out)).
12:32:27 -!- GregorR has joined.
12:37:16 <jix> ok.. that should work now
12:41:17 <kipple> graue: I've read the Sortle spec. it's not clear to me how to push values onto the stack.
12:41:50 <kipple> there are a list of operators that work on the stack, but I can't find how to acutally get any data on the stack in the first place...
12:42:00 <sp3tt> "Befunge and BrainF*ck are both toy languages written expressly to be perverse in some way (Befunge to be uncompilable, and BrainF*ck to be absurdly minimalist.)"
12:43:03 <kipple> says who?
12:57:31 <sp3tt> Some slashdotter.
12:57:42 <sp3tt> http://slashdot.org/comments.pl?sid=32469&cid=3504293
13:01:23 -!- sp3tt_ has joined.
13:02:52 <kipple> bah. he got a slashdot entry for a polyglot with just 4 languages?? 
13:09:55 -!- sp3tt has quit (Read error: 60 (Operation timed out)).
13:10:01 <graue> kipple, literal numbers or strings push themselves onto the stack
13:10:10 <puzzlet> he sees uncompilability as absurdness?
13:11:27 <puzzlet> every language is compilable though
13:11:38 <kipple> ok. so will the expression "12" push 12 or 1 and 2 onto the stack?
13:11:41 <graue> 12
13:12:28 <kipple> ok. so how do you separate numbers? space? comma? semicolon? (is this missing from the spec, or am I blind?)
13:13:01 <graue> terms are separated by spaces
13:13:42 <kipple> ok. you  might want to make the spec a little clearer on this...
13:14:48 <puzzlet> where is the spec?
13:16:26 -!- smart has joined.
13:16:53 <graue> http://www.oceanbase.org/graue/sortle/sortle.pdf
13:17:28 <graue> the format used is spelled out in "Source Code Format"
13:21:45 <kipple> ah, yes. there it is.
13:25:12 -!- smart has quit (Read error: 104 (Connection reset by peer)).
13:33:29 -!- GregorR has quit (Read error: 104 (Connection reset by peer)).
13:37:33 -!- sexy has joined.
13:38:04 -!- sexy has quit (Read error: 104 (Connection reset by peer)).
13:39:01 <jix> i have a 5lang polyglot
13:39:45 <kipple> me too
13:40:05 -!- GregorR has joined.
13:40:09 <kipple> but I intend to add more
13:43:36 <jix> what languages has your poly?
13:43:55 <kipple> BF, befunge, kipple, Ork and chef
13:43:59 <kipple> and yours?
13:44:07 <jix> bash perl ruby c and BF
13:44:32 <CXI> no malbolge?
13:44:41 <CXI> >:)
13:44:44 <jix> i have also a version with kipple but it doesn't work with the online interpreter (with cipple it does)
13:44:56 <kipple> what's the problem?
13:45:18 <jix> does the java interpreter ignore << ?
13:45:27 <kipple> probably not
13:45:38 <jix> cipple does because in $E=<<#&>/dev/null there is no valid command
13:45:54 <jix> and i use heredocs to seperate ruby,perl and bash code
13:46:09 <kipple> i assume my interpreter will give an invalid stack identifier error or something
13:48:57 <kipple> hmm. here's a thought: If I allow < to be used as a stack name, then this expression could be used: a<<b (a.push(<.pop()); <.push(b.pop())  )
13:49:56 <jix> cipple ignores everything that isn't valid code
13:50:21 <kipple> yeah. well the spec doesn't say anything about that, so that's ok
13:51:41 <kipple> hmm. I think I will allow ANY character as a stack name in the next version, except numbers, whitespace and #
13:51:47 <graue> i like the a<<b idea
13:55:05 <kipple> then a<+++>b  would be valid code (brainfuck/kipple polyglot would be very nice)
14:07:24 <graue> + is a number?
14:07:31 <kipple> no
14:07:33 <jix> no a stack
14:07:43 <graue> oh
14:07:47 <jix> and a command
14:07:49 <kipple> it's either a stack or an operator
14:16:36 <jix> a friend of my brother is a friend of the false inventor 
14:17:53 <graue> cool
14:19:26 <kipple> hmm. should I keep stack names case insensitive, or change to case sensitive? 
14:20:51 <CXI> oh, man
14:20:58 <CXI> I just realised a much easier way to write my regex language
14:21:29 <CXI> I can do away with function names entirely
14:21:45 <CXI> and just make it repeatedly reapply the regexes
14:22:46 <graue> kipple: i have no opinion on that at the moment
14:23:04 <kipple> not a big deal, but it might break some old programs
14:24:10 <graue> sure, do it
14:25:57 <kipple> yeah. screw backwards compatability :)
14:26:59 -!- sp3tt__ has joined.
14:27:02 -!- sp3tt__ has changed nick to sp3tt.
14:27:20 <CXI> real men don't need backwards compatibility
14:31:56 -!- graue_ has joined.
14:40:09 -!- graue has quit (Read error: 145 (Connection timed out)).
14:41:51 <sp3tt> http://slashdot.org/comments.pl?sid=32469&cid=3505272 rofl
14:44:45 -!- sp3tt_ has quit (Read error: 110 (Connection timed out)).
15:01:31 -!- graue_ has quit (Read error: 110 (Connection timed out)).
15:02:25 <CXI> chef is awesome
15:06:06 -!- graue_ has joined.
15:25:27 -!- graue_ has changed nick to graue.
16:00:56 <CXI> hmm
16:01:01 * CXI tries to figure out 99 bottles
16:01:22 <kipple> which 99 bottles?
16:01:52 <CXI> in Two Problems :P
16:01:59 <kipple> ah
16:02:02 <CXI> see, I'm not actually sure if it's turing complete
16:02:31 <CXI> basically I figured I can just make it a list of regular expressions and evaluate them in order, rewinding the list if any match
16:07:20 <CXI> ah well
16:07:24 <CXI> I made it count from 1 to 99
16:07:27 <CXI> so that's something :D
16:07:35 <CXI> but I just need to find a less braindead way of doing it
16:13:15 <sp3tt> Heh. My maths based language can print 99 bottles, but it's not pretty xD
16:13:29 <sp3tt> http://rename.noll8.nu/sp3tt/beer.math
16:14:08 <kipple> that's not bad
16:14:49 <sp3tt> :)
16:15:39 <CXI> hmm
16:16:56 <CXI> http://members.dodo.com.au/~sgentle/99.2p
16:17:04 <CXI> that only counts up to 99 :(
16:17:25 <CXI> well, technically it counts down from 99
16:17:40 <CXI> but it adds to the front of the list
16:18:52 <sp3tt> At least it proves the name fits the language.
16:19:00 <CXI> :D
16:19:16 <kipple> or maybe it should be called 99 problems
16:19:38 <CXI> heh
16:19:42 <CXI> but a bitch ain't one?
16:20:19 <CXI> (google 99 problems if you don't get it)
16:20:49 <kipple> ah. didn't know it was a song
16:52:39 <graue> i just invented and implemented a new language
16:52:43 <graue> brb, testing it
16:53:06 <kipple> wow. these languages sure keep popping up lately...
16:56:42 <CXI> haha
16:56:53 <CXI> now you see why wikipedia is so afraid of them
17:21:12 <graue> i think the interpreter works, now it's time to write hello world
17:27:11 <graue> why does "k">@>o in kipple produce 7?
17:27:17 <graue> shouldn't it produce the ascii value of k?
17:28:23 <kipple> "k">@ pushes 3 values onto @, 1, 0 and 7. @>o only pushes one value onto o, nemaly 7
17:28:32 <graue> oh, ok
17:29:19 <kipple> namely, I meant :)
17:32:47 <kipple> "k">@ (@>o) would be the way to do that
17:40:50 <graue> not "k">(@>o)?
17:41:55 <kipple> that would not work
17:42:19 <kipple> "k">( would give an error that ( is not a stack
17:42:37 <kipple> though I have considered allowing that
17:44:31 <pgimeno> CXI: are there specs for 2p already?
17:46:44 <CXI> heh, not really... I want to make sure it's turing complete first
17:47:32 <pgimeno> have you seen Thue? it's turing-complete
17:50:23 <CXI> hmm, interesting
18:17:00 -!- graue has quit ("Leaving").
18:17:12 -!- graue has joined.
18:32:40 <pgimeno> does anyone have a description of PingPong?
18:55:45 <ZeroOne> pgimeno: http://web.archive.org/web/*/http://www.inz.info/pingpong/
18:56:21 <pgimeno> wee, thanks! I tried it in the past to no avail.
18:57:00 <ZeroOne> no problem. :) archive.org is sometimes a true jewel.
18:58:26 <pgimeno> however I mean that I tried archive.org in the past but I got an error or a not found
18:59:05 <ZeroOne> oh, ok. maybe you tried some wrong address then?
19:00:04 <pgimeno> I don't know what happened
19:00:22 <pgimeno> I'm pretty sure I tried that at least twice a few weeks ago
19:01:12 <pgimeno> Wikipedia redirects to the Pong game :(
19:01:49 <GregorR> I've got an idea for my genomic programming language :)
19:02:18 <GregorR> My peptide chains will stack rather than fold, and simply based on every-other amino acid being "compatible"
19:02:44 <GregorR> Certain peptide chains will be attracted to the "output" receptor, and will cause the data on them to be output.
19:02:56 <GregorR> Same with input, except a new peptide chain will be created.
19:03:10 <GregorR> I'm still working on breaking peptide chains.
19:04:24 <ZeroOne> right :)
19:04:40 <ZeroOne> good luck with that genetic manipulation then. ;) bbl. ->
19:05:30 <GregorR> Heheh
19:07:28 <graue> damnit, the storage available to programs in my language is dependent on code size
19:07:43 <graue> i'll have to change something to fix this
19:08:41 <graue> (it took me two hours to realize that)
19:09:51 <pgimeno> graue: do you mean Sortle or the new one?
19:09:55 <kipple> how so? can't both the expressions and the expression names be of arbitrary length?
19:09:57 <graue> the new one
19:10:00 <graue> not Sortle
19:10:06 <kipple> ah, the new one :)
19:11:34 <graue> actually, if a program reads input up to EOF, it has as much storage as it wants because it can keep getting new zero bytes
19:11:39 <graue> but that's not very pretty
19:13:12 <pgimeno> what's the opinion about having all of the languages of the List of Lesser Known Languages in the Wiki, with a category just for them?
19:14:13 <kipple> pgimeno: about this wiki-category "Lesser known programming languages". what exactly do you consider lesser known?
19:14:22 <graue> well, they're jokes, right?
19:14:35 <pgimeno> graue: yes
19:14:38 <graue> if they're significant in your opinion they could go on the joke language list
19:14:49 <graue> kipple: the list is an old joke posted to usenet in the 80's
19:14:56 <graue> of languages that didn't exist
19:15:11 <kipple> ah
19:15:30 <graue> one of them, VALGOL, has since been implemented
19:15:44 <pgimeno> is there such a list already created?
19:15:49 <kipple> anyway, I think this "joke language" category has some issues
19:16:26 <kipple> while some languages are just a joke (Bitxtreme, HQ9+), some are fully functional 
19:16:41 <kipple> l33t, for instance
19:17:04 <graue> is it interesting for more than humor value to you?
19:17:23 <kipple> not really
19:17:53 <graue> so that's why it's a joke
19:18:07 <graue> HQ9+ is just as fully functional; it's been implemented
19:18:40 <kipple> well I was talking about being actually usable. 
19:20:00 <kipple> INTERCAL (and a lot of other esolangs) isn't really interesting to me for more than humor value, either
19:20:21 <pgimeno> so do you want to make a list of remarkably useable programs as opposed to a list of joke languages?
19:20:51 <kipple> no. I want ALL languages in the main list, and several categories to classify them further
19:21:01 <jix> ++
19:21:05 <pgimeno> kipple: I was asking to graue, sorry
19:21:16 <kipple> ah
19:21:17 <pgimeno> and I agree with kipple: arguably most esoteric languages are jokes
19:22:11 <kipple> and where the line between jokes and interesting languages go is highly subjective
19:23:06 <pgimeno> yeah I think that the wikipedia approach of adding a short explanation of the language together with the name is a good idea
19:23:26 <pgimeno> I thought that that was possible with categories, hence my comment some days ago
19:23:55 <pgimeno> but it turns out not to be possible, so the main list seems to be the proper place
19:25:35 <lament> well
19:25:53 <lament> i think it's reasonable to split languages into turing-complete, non-turing-complete, and unknown
19:26:15 <lament> that would filter out hq9+ which is not turing-complete
19:26:36 <graue> that's a good idea, categories for computational class
19:26:44 <kipple> I disagree. turing-completeness isn't that important
19:26:49 <lament> yes it is.
19:26:53 <kipple> i.e. ANSI C is not TC
19:26:54 <graue> of course, SMETANA and Befunge-93 are not Turing-complete, but still interesting
19:27:02 <graue> Argh! is not Turing-complete
19:27:04 <kipple> graue: exactly
19:27:04 <graue> etc
19:27:07 <lament> okay
19:27:17 <lament> s/turing-completeness/anywhere close to turing :)
19:27:18 <graue> kipple: doesn't mean it isn't a nice category idea though
19:27:32 <graue> we can have as many sets of categories as we like
19:27:48 <kipple> very true. we should have a bunch of categories
19:28:05 <lament> i still have no idea what makes smetana/befunge better than hq9+ computationally
19:28:11 <pgimeno> indeed I've added some already (Lambda calculus paradigm)
19:28:12 <lament> actually befunge is turing-complete i think
19:28:16 <graue> not -93
19:28:24 <graue> it had a limited code size
19:28:26 <kipple> you can program with smetana/befunge. You cannot program in HQ9+ ;)
19:28:31 <lament> yes
19:28:42 <cpressey> turing complete != "you can program in it"
19:29:19 <kipple> turing completeness is often overrated IMHO
19:29:50 <lament> well
19:30:03 <graue> maybe a "finite state machine with enough states to do a lot of useful things at least" category
19:30:05 <lament> "TC with memory restriction" is important
19:30:12 <lament> which is handwaving of course
19:30:24 <lament> but essentially means "as good as computers"
19:30:48 <lament> befunge and smetana can do as much computation as a computer
19:30:53 <lament> hq9+ can't
19:31:43 <graue> i still like the cat programming language: every program is a quine!
19:31:51 <graue> what category should that one go in?
19:32:47 <pgimeno> the same as HQ9+ IMO
19:33:32 <cpressey> "TC with memory restriction" = finite state automaton = lookup table, at least in terms of computability
19:33:46 <cpressey> the really interesting thing is not just computability then
19:33:58 <cpressey> but i'm not sure what it is
19:34:09 <cpressey> i've looked in the literature and there's really nothing that i could find about it
19:34:12 <pgimeno> "Useable for programming"?
19:34:16 <CXI> hmm
19:34:18 <cpressey> sure, informally
19:34:21 <cpressey> but define that?!?!
19:34:22 <kipple> useable/unuseable
19:34:24 <cpressey> :)
19:34:26 <CXI> can write 99bob in it? :D
19:34:37 <kipple> HQ9+?
19:34:38 <cpressey> can write 'n' bottles of beer, maybe
19:34:42 <pgimeno> I was just suggesting it being a Category:Useable for programming
19:34:42 <cpressey> 99 is finite :)
19:34:47 <CXI> true
19:34:59 <graue> i think it's spelled Usable
19:35:11 <cpressey> CXI: actually, no, you're right
19:35:13 <cpressey> or close
19:35:26 <cpressey> it's like, being able to write 99 bottles of beer, in less space than writing out the song literally
19:35:32 <cpressey> like a form of compression
19:35:36 <CXI> heh
19:35:37 <CXI> gzip
19:35:40 <cpressey> :)
19:35:45 <CXI> (don't laugh, there's a gzip quine)
19:36:09 <pgimeno> that's also what the malbolge program did
19:36:12 <cpressey> well, if wang tiles are a computer then...
19:37:43 <kipple> graue: I think both spellings are allowed
19:37:53 <graue> okay then
19:38:20 <kipple> at least, in smb.conf you can use both writeable and writable ;)
19:39:03 <pgimeno> my English-Spanish dict does not list "useable", so it's probably wrong
19:39:33 <jix> my dict: usable   also: useable
19:39:41 <graue> don't you hate it when you make a wonderful elegant symmetrical Turing tarpit with just the right level of pain and it turns out the storage available is limited by how many nested loops you use?
19:39:44 <kipple> yeah. dictionary.com too
19:40:00 * pgimeno throws his dict out the window
19:40:05 <jix> http://dict.leo.org/?useable
19:40:34 <graue> i hate it when that happens
19:40:43 <pgimeno> never happened to me
19:42:59 <kipple> okay: how about distinguishing between pure joke languages (HQ9+, bitxtreme etc.) and humorous, though still useful languages 
19:43:02 <cpressey> graue: sounds like a push-down automaton
19:43:47 <cpressey> a category for languages clearly intended as jokes would work, i think
19:44:05 <pgimeno> a category plus a little mention in the list, IMO
19:44:08 <lament> well, just because a language is intended as a joke, doesn't mean it can't be useful
19:44:18 <lament> (as in turing-complete)
19:44:28 <kipple> agreed
19:44:32 <cpressey> or as in us[e]able ;)
19:44:38 <lament> not that i can think of any examples at the moment
19:44:45 <kipple> INTERCAL
19:44:46 <pgimeno> cow
19:44:53 <kipple> ook!
19:44:53 <lament> well yeah, intercal
19:45:08 <graue> suppose the joke category is only for languages which both were clearly intended as jokes and have not attracted significant attention from others after their creation
19:45:10 <cpressey> the problem is this is that unless the author makes the entry, we're sort of left to try to read their minds
19:45:11 <lament> yeah, ook and the like.. i'm not even sure they deserve a mention
19:45:21 <lament> they aren't even jokes
19:45:34 <lament> it's not funny, it's sad
19:45:54 <graue> to clarify my preceding statement, significant attention as us[e]able languages :)
19:46:01 <kipple> well, I thought the Hello World program in Ook! was pretty funny the first time I saw it...
19:46:23 <cpressey> i'd actually like a rating/voting system , but that's probably beyond the scope of a wiki
19:46:33 <cpressey> like: 3 people thought this was amusiing, etc
19:46:35 <graue> i think the fact that we're whining about Ook! on irc is enough reason to document it, but it shouldn't be on the main list
19:47:33 <pgimeno> I think it could be, with an entry like this: * [[Ook!]] (joke), direct translation of [[Brainfuck]] commands
19:48:10 <pgimeno> (as well as COW etc.)
19:49:10 <cpressey> it could be in a "alternate representations" category
19:49:31 <lament> but only ook and cow would be in it
19:49:43 <CXI> doublefuck
19:49:48 <CXI> the huffman encoded BF
19:49:54 <pgimeno> heh, that opens a whole new can of worms: is Malbolge an alternate representation of Dis? is it the other way around?
19:50:02 <kipple> isn't fuckfuck one of those as well?
19:50:07 <lament> heh
19:50:08 <pgimeno> yup
19:50:20 <lament> so all alternate representations are alternate representations of brainfuck
19:50:27 <CXI> heh
19:50:32 <CXI> boolfuck
19:50:40 <lament> perhaps they could all be grouped in one article then.
19:50:40 <CXI> there's a nice list on wp: http://en.wikipedia.org/wiki/Brainfuck#Languages_based_on_brainfuck
19:50:43 <lament> yeah
19:50:57 <lament> along with smalfuck and the like
19:51:21 <pgimeno> that's a good idea, lament
19:51:23 <kipple> there is a difference in "based on" and "exactly the same" though
19:51:32 <lament> yes
19:51:49 <lament> but are there any bf-based languages that really deserve any attention? :)
19:52:17 <pgimeno> yes there are
19:52:35 <pgimeno> smallfuck for one
19:52:44 <cpressey> erm... i'm not sure i'd call the lambda calculus a "paradigm"...
19:53:03 <kipple> I think we should aim to include every esolang, even ook, fuckfuck, cow etc. but those could be bunched together in one article, referenced from the BF article
19:53:13 <graue> i agree
19:53:21 <graue> and if the most succinct way to describe it is "it's Brainfuck with a...", it belongs in that article
19:53:23 <pgimeno> cpressey: sorry, I'm not an academic, feel free to correct it
19:53:36 <CXI> yeah, I think that's a good approach too
19:54:01 <cpressey> pgimeno: ok (still reading the diffs from the past few days :)
19:54:56 <pgimeno> so the only remaining question is whether they should be listed in the main list or not
19:55:20 <pgimeno> I think they should, so that anyone looking for a particular language can find them
19:55:25 <kipple> about this "program forms" category: what exactly should be in it? only abstract concepts like the ones there now, or also things like hello world and 99bob?
19:56:17 <CXI> I think categories for the level of presence of a langauge would be nice
19:56:24 <CXI> probably measured in the amount of works there are for it
19:56:55 <CXI> spec/compiler or interpreter/sample programs etc
19:56:57 <kipple> CXI: yeah. but where to draw the line.....
19:57:08 <cpressey> also, SNUSP looks like a bf descendant and a 2-d language, should probably be in both cats
19:57:19 <CXI> well, you wouldn't necessarily have to draw any lines
19:57:46 <CXI> just have category:compiler/interpreter exists or whatever
19:58:59 <kipple> cpressey: I agree, but graue apparently disagrees.
19:59:06 <graue> SNUSP and LNUSP are both derived from PATH, so if any of them should be in the BF-derived category, all should probably be
20:00:08 <kipple> graue: the SNUSP article is written by you, right?
20:00:12 <graue> SNUSP is the most interesting of them and in its modular version it doesn't really look anything like brainfuck code, but core snusp is indeed close
20:00:14 <graue> yes
20:00:25 <kipple> well, it says: " Core SNUSP is a two-dimensional Brainfuck with a more flexible way of expressing loops"
20:00:42 <graue> well, most SNUSP programs are written in Modular SNUSP
20:00:42 <kipple> and " Core SNUSP is essentially Brainfuck with a two-dimensional control flow"
20:01:26 <kipple> CXI: how about category:implemented ?
20:03:26 <cpressey> i like category: implemented
20:03:31 <cpressey> i think
20:03:42 <CXI> yeah, that's nice
20:06:38 <CXI> man
20:06:45 <CXI> the wikipedia Chef Hello World isn't well-formed
20:06:46 <CXI> no title :D
20:07:45 <pgimeno> it's becoming apparent that there should be a list of categories to categorize each language (sorry for the repetition): joke, usable, implemented...
20:08:01 <kipple> CXI: it has a title. it's comments it lacks.
20:08:27 <CXI> mm? it doesn't have anything above "Ingredients." though
20:08:34 <CXI> oh, wait, we may be looking at different pages
20:08:40 <CXI> incidentally, this made me laugh:
20:08:41 <CXI> The following code should theoretically translate to the peptide HELLQWQRLD, (cross fingers).
20:08:41 <CXI>    TACGTACTTAATAATGTTACCGTTGCAAATCTAATC
20:09:31 <CXI> okay, yeah, the one on [[Chef programming language]] is okay
20:09:52 <CXI> I was talking about [[Hello world program in esoteric languages]]
20:10:33 <kipple> ah. I see
20:11:52 <kipple> well, now it is correct :)
20:11:58 <CXI> :D
20:12:12 <kipple> pgimeno: yes. there are a LOT of potential categories
20:13:07 <kipple> for instance: I think we should have a "stack-based" category
20:13:46 <CXI> stack-based meaning which languages?
20:14:00 <kipple> but what exactly is that? only langs with only one stack, like befunge, or including languages like Chef and Kipple?
20:14:36 <pgimeno> I think that including all; that makes it easier to look for a particular language which is stack based
20:14:44 <kipple> probably
20:15:01 <jix> languages that use stacks as its main/only data structure
20:15:11 <kipple> what do you call the brainfuck datastructure? tape?
20:15:17 <CXI> I'd call it a tape, yeah
20:15:38 <pgimeno> I'm going to write an attempt of a [[Categorization]] page
20:15:46 <jix> but there are 3 different tape types.. no ends.. one end.. 2 ends
20:15:51 <sp3tt> 99 esoteric languages on the web, 99 esoteric languages.
20:16:18 <sp3tt> You look one up and code a song in it, 98 esoteric languages on the web.
20:16:25 <jix> drink 99 bottles of beer and write a new...
20:16:34 <sp3tt> XD
20:16:42 <sp3tt> Rather 99 cans of jolt
20:17:00 <kipple> alternatively: stay up late, write a spec. 100 esolangs on the web.
20:17:09 <cpressey> "Hello, 99 bottles of beer on the world!"
20:17:45 <graue> pgimeno, make it an [[Esolang:Categorization]] page
20:17:56 <graue> meta stuff should be in the Esolang namespace since mediawiki likes it that way
20:17:59 <pgimeno> ok
20:18:01 <kipple> jix: I don't think it is necessary to be THAT specific with the cats
20:18:14 <jix> hehe.. yes..
20:18:27 <sp3tt> cpressey: that needs a quine!
20:18:39 <graue> you missed a fourth type of tape, jix, the kind that loops around
20:18:46 <jix> uh
20:18:47 <graue> unless you count that as "no ends"
20:19:08 <jix> and the one that has one end end loops at the other end
20:19:12 <sp3tt> Sugar high... Ugh.
20:19:21 <jix> like fyb
20:19:26 <graue> yes
20:19:29 <CXI> haha
20:19:32 <sp3tt> FuckYorBrane XD
20:19:35 <CXI> how about a 99bob-based language
20:19:40 <sp3tt> LOL
20:20:06 <sp3tt> A brainfuck translation with parts of the lyrics.
20:20:40 <sp3tt> On the wall, go to the store all represent different operations. XD
20:20:53 <CXI> 13 letters of "Hello, world!" on the wall, 13 letters of "Hello, world!" Take one down, pass it around, 12 letters of "Hello, world!" on the wall.
20:20:55 <kipple> CXI: yeah! it could have 99 commands. Each verse a different one
20:21:03 <CXI> :P
20:21:11 <sp3tt> lol 99 commands
20:21:31 <kipple> so you would need four lines of code to do the equivalent of a brainfuck >
20:22:05 <kipple> 99 commands in the spec. 99 commands.
20:22:09 <CXI> haha
20:24:47 <kipple> write one down and pass it some arguments. 98 commands in the spec 
20:26:40 <graue> hmm, i'm tempted to add a debugger or an assert command to this esolang of mine, but that would be cheating
20:27:37 <CXI> heh
20:27:43 <CXI> I want to write a language made entirely of asserts
20:28:06 <CXI> it just brute-forces the input until it matches all your asserts and then returns it :P
20:32:18 <cpressey> graue: i have to say, sortle's pretty neat
20:36:42 <jix> CXI: hmm prolog?
20:37:24 <jix> if you write your own naive sort function in prolog it scales O(n!*n) 
20:37:37 <jix> in the worst case
20:37:54 <cpressey> (hm, maybe "unimplemented" would be a better category than "implemented")
20:38:38 <jix> i need a language where i have a simple platform independent canvas i can draw to and get mouse events from
20:39:43 <jix> non esoteric
20:40:51 <lament> python!
20:40:56 <lament> python/tk
20:41:07 <jix> hmm ruby/tk.. but i don't know tk
20:41:31 <lament> big deal
20:41:44 <lament> don't know about ruby but python has a very good tk reference :)
20:42:09 <jix> there are ruby/tk tutorials and references
20:42:37 <lament> then stop complaining :)
20:43:05 <jix> i don't want to learn how to use tk just for a stupid canvas
20:46:15 <pgimeno> http://www.esolangs.org/wiki/Esolang:Categorization <- my first attempt
20:46:23 <graue> cpressey, sorry for the delayed reaction but cool, i'm glad you like it
20:47:54 <cpressey> graue: np... do you suspect that it (umm) "admits computation" or not?
20:48:45 <cpressey> i like that there is no strict requirement that esolangs be TC... it provides open research questions.
20:48:50 <cpressey> aura is an interesting case
20:48:51 <cpressey> too
20:50:15 <graue> i suspect that it admits computation, yes, although i haven't thought of a way to show this
20:52:21 <lament> hm, do "lesser known programming languages" have to be a category?
20:52:41 <pgimeno> well, there are quite a few and I think they deserve one
20:53:06 <graue> heh, everything's going to be in like ten categories
20:53:06 <pgimeno> but if you have a different thought you're welcome to expose it
20:53:31 <pgimeno> yeah
20:53:48 <lament> "turing tarpit" seems a problematic category
20:53:57 <pgimeno> ultimately I'd add an "esolang" category
20:54:03 <lament> hard to categorize
20:54:08 <lament> what's a tarpit and what's not
20:54:19 <lament> e.g. Lazy K could be trivially made one instruction shorter
20:54:25 <lament> by removing i
20:54:40 <lament> so it dosen't have "as few instructions as possible"
20:54:56 <jix> lament: doesn't lazy k needs i for church integers ?
20:55:19 <lament> jix: i can be represented with s and k
20:55:24 <jix> oh
20:55:55 <jix> how can you be represented with s and k? ;p
20:56:08 <CXI> lazy k? that sounds a lot like unlambda
20:56:10 <lament> ```s`kk``s`kk
20:56:20 <lament> (no that's wrong)
20:56:29 <jix> lament: how can you...
20:57:07 <jix> CXI: but unlambda has unneeded commands with side effects
20:57:14 <jix> lazy-k is side effect free
20:57:17 <CXI> so which came first?
20:57:25 <cpressey> combinatory logic came first ;)
20:57:36 <lament> pgimeno: i guess "purely functional" deserves a category
20:57:38 <CXI> is that where s/k notation came from?
20:57:49 <lament> CXI: unlambda came first
20:57:51 <cpressey> lament: there's a "functional programming" cat now
20:57:55 <pgimeno> I don't know much about functional programming
20:57:57 <cpressey> CXI: yes
20:58:02 <cpressey> pre-turing, iirc
20:58:07 <cpressey> which blew my mind
20:58:11 <lament> cpressey: yes, and also "functional paradigm" :)
20:58:23 <pgimeno> change that at will
20:58:29 <lament> one of those must die
20:58:37 <lament> but there's a difference between functional and purely functional
20:58:44 <lament> unlambda is functional
20:58:54 <pgimeno> "functional paradigm" has 0 members now, it can die
20:58:57 <lament> iota, jot, lazy k are purely functional
20:59:12 <cpressey> lament: not a difference worth categorizing on, imo... or if it is, call it "referentially transparent"
20:59:16 <lament> cpressey: sure
20:59:25 <lament> pgimeno: paradigm sounds better though :)
21:00:04 <pgimeno> I'm not sure if Thue has a different paradigm and if it's worth being included in any if so
21:00:34 <lament> well, it does
21:00:51 <lament> there's even a name for it
21:01:00 <cpressey> string-rewriting
21:01:06 <lament> string-rewriting
21:01:08 <lament> yes
21:01:23 <cpressey> rewriting languages could be their own cat
21:01:30 <pgimeno> I was tainted to include that but I was not sure as I've just said
21:01:32 <cpressey> (ignoring that any language can be described as a rewriting language :)
21:02:08 <cpressey> at some point, for categorization, you just have to go on what the author probably intended...
21:02:23 <lament> would malbolge go in "Unusable"?
21:02:31 <pgimeno> hm
21:02:41 <pgimeno> I don't think it's categorizable yet...
21:02:55 <lament> there should be category: unknown TC status
21:03:04 <lament> a very important category imo
21:03:06 <cpressey> i think ben intended "hellishly difficult" rather than purely "unusable" :)
21:03:08 <pgimeno> it's usable to some extent, but it's possible that as an FSA it has too few states
21:03:50 <pgimeno> lament: that's OK to me
21:04:06 <pgimeno> is anyone editing the Esolang:Categorization page?
21:04:18 <lament> not i
21:04:48 <lament> can turing tarpit be a subcategory of turing-complete?
21:06:21 <CXI> what's tarpit mean, anyway?
21:06:31 <pgimeno> IIRC it's a misspelling
21:06:49 <cpressey> a pit full of tar, like LaBrea :)
21:06:50 <pgimeno> I don't remember the details nor where I read about that
21:06:57 <lament> i don't think tarpit is a useful category for esolangs
21:07:00 <lament> most esolangs are small
21:07:01 <cpressey> where all the dinos got stuck...
21:07:04 <CXI> heh
21:07:09 <CXI> I know what an actual tarpit means
21:07:21 <lament> i propose to just keep turing-complete
21:07:24 <cpressey> ok :)
21:07:39 <cpressey> a turing tarpit is just "arbitrarily low # of instructions"
21:07:48 <CXI> ah, okay
21:07:49 <cpressey> for some def'n of "instruction"
21:08:08 <lament> pgimeno: what do you think
21:08:34 <pgimeno> I think that it's useful to hold Turing tarpits as a [sub]category
21:09:01 <lament> and i definitely propose we invent a word for "turing-complete with memory constraint"
21:09:04 <pgimeno> and that it's listed in the categorization list
21:09:07 <lament> and use that as a category :)
21:09:18 <pgimeno> lament: that's FSA and is there
21:09:41 <lament> but FSA sounds almost insulting
21:09:49 <pgimeno> heh
21:10:04 <lament> brainfuck is listed as a turing tarpit
21:10:19 <pgimeno> together with "Usable" it will be meaningful enough I think
21:10:39 <lament> but most brainfuck specifications make it a FSA
21:10:46 <lament> including the original one
21:10:55 <CXI> FSA?
21:11:03 <pgimeno> finite-state automaton
21:11:09 <CXI> ah
21:11:59 <lament> it's not enough to be a FSA
21:12:08 <lament> it has to be "easy to extend"
21:12:34 <lament> brainfuck, befunge, smetana can all be trivially extended to arbitrary size
21:13:38 <pgimeno> Unbound FSA?
21:13:52 <lament> but that's not a sufficient condition either
21:14:09 <lament> brainfuck without loops is a FSA, right?
21:14:39 <cpressey> even FSA's can have loops...
21:14:53 <cpressey> brainfuck without loops is, um... a tuple of integers? :)
21:14:59 <lament> yes, but a "turing-complete with memory constraint" language must have loops
21:15:08 <lament> so not all FSA qualify
21:15:27 <lament> (by loops i mean some way of making it not halt, at the very least)
21:15:30 <cpressey> lament: i would tend to agree, but (as i mentioned before) i can't find *anything* in the literature about it
21:16:01 <lament> you know your language is nowhere near TC when you can determine if a program halts with current computational resources :)
21:16:36 <lament> (and in befunge you can already write a program that won't ever halt or repeat state)
21:18:41 <lament> how about "brainfuck-complete"
21:20:12 <lament> "brainfuck-complete with upper memory bound 80 cells"
21:20:23 <lament> "brainfuck complete with arbitrary memory size"
21:21:10 <pgimeno> I'm not sure that's a serious name :)
21:21:37 <lament> how serious does it have to be? :)
21:22:34 <lament> the nice thing about it
21:22:44 <pgimeno> I'm somewhat puzzled... if an algorithm is required to stop, and a Turing machine is required to run an algorithm, and a SMETANA program can implement any algorithm... how come SMETANA is not Turing-complete?
21:22:49 <lament> is that if you say "BF-complete with upper memory bound 40"
21:23:05 <lament> and everybdoy will know approximately what class of problem it can solve
21:23:40 <jix> pgimeno: semnta can't store an infinite number states.. some algorithm require infinite states
21:23:47 <lament> jix: no
21:23:53 <jix> ok not
21:23:57 <lament> jix: no algorithm requires infinite steps
21:24:08 <lament> jix: unless it doesn't halt, in which case it doesn't matter what it requires
21:24:23 <lament> any halting algorithm can be implemented in smetana.
21:24:30 <cpressey> if you come up with an algorithm that requires n steps, i can come up with one that requires n+1
21:24:31 <lament> but you have to know memory requirements in advance.
21:24:48 <lament> smetana is brainfuck complete :)
21:25:01 <pgimeno> oh, that's a point, lament
21:25:05 <jix> btw i'm going to use ruby/tk .. seems to be very simple
21:25:40 <cpressey> pgimeno: turing machine can do more than just algorithms, it seems
21:25:51 <cpressey> turing machines can hang, algorithms can't
21:25:55 <pgimeno> I think that's THE point: given an arbitrary algorithm, you can't know in advance how much memory it will take
21:26:19 <lament> yep
21:26:43 <cpressey> the thing with "BF-complete with upper memory bound n" is that it's the same as "FSA with upper state bound m" or "lookup table with x entries"
21:26:57 <cpressey> where x >> m >> n, i imagine
21:27:22 <cpressey> er, maybe m > x actually
21:27:22 <pgimeno> nope, some FSAs can't compute certain things (e.g. Brainfuck without loops)
21:27:33 <cpressey> ?
21:27:50 <lament> cpressey: all bf-complete with upper bound languages are FSA
21:27:53 <cpressey> they *can*, they just need more states
21:27:54 <lament> cpressey: but the reverse is not true
21:28:10 <lament> or am i wrong?
21:28:24 <cpressey> what does "bf-complete" mean?
21:28:38 <lament> you can compile brainfuck to this language.
21:28:48 <lament> and run your program with memory size n.
21:29:17 <cpressey> so you are saying that: not all FSA are languages that can have brainfuck compiled into them?
21:29:32 <pgimeno> uhm, I think I'm getting cpressey's point
21:29:41 <lament> cpressey: i think so.. is that wrong?
21:29:44 <cpressey> you mean brainfuck with finite tape?
21:29:48 <lament> yes
21:29:57 <lament> (and finite cells)
21:30:00 <fizzie> I would consider "BF-complete with upper memory bound n" is more like linear-bounded automata, not a finite state automaton.
21:30:19 <fizzie> I mean, a FSA must always terminate (for finite input).
21:30:34 <lament> fizzie: hey!!
21:30:42 <lament> that's exactly what we were looking for
21:30:55 <cpressey> ok, so the claim is: exists F, F is an FSA that cannot be the result of translating a (finite-tape) brainfuck program to an FSA
21:30:58 <cpressey> ?
21:31:05 <cpressey> FSA must not always terminate
21:31:11 <cpressey> oh,m for finite input
21:31:12 <cpressey> yes
21:31:29 <lament> cpressey: it's not just that
21:31:30 <cpressey> hm
21:31:49 <lament> cpressey: it's that your language should be capable of expressing all the FSA corresponding to all the brainfuck programs with up to that memory size
21:32:30 <cpressey> lament: i'm sorry, that still sounds like "equivalent to an FSA" to me.
21:32:39 <lament> anyway
21:32:42 <lament> what fizzie said.
21:32:45 <lament> http://en.wikipedia.org/wiki/Linear_bounded_automaton
21:33:15 <graue> by the way, i'd prefer if wiki articles did not link directly to user or talk pages
21:33:23 <fizzie> As far as grammars go, linear-bounded automata (turing machine with a tape length limited to the input; what I would guess brainfuck-with-n-sized-memory) can recognize all context-sensitive grammars, IIRC. Type-1 grammars in the Chomsky hierarchy.
21:33:28 <graue> (so it is possible to mirror just the content, if anyone should later want to do that)
21:33:36 <fizzie> While finite state automata only recognize type-3 languages.
21:33:41 <cpressey> LBA sounds a lot closer
21:33:54 <lament> cpressey: but LBA seems to be equivalent to brainfuck complete :)
21:34:06 <cpressey> but LBA is already coined as a term :)
21:34:08 <lament> this is strange
21:34:17 <lament> it would seem that LBA is a subclass of FSA
21:34:22 <cpressey> i only wish there was a ref on wp
21:34:23 <lament> why aren't they?
21:34:31 <cpressey> not sure
21:34:48 <cpressey> graue: should there be entries for people (instead of linking directly to user pages?)
21:34:51 <lament> okay anyway
21:34:52 <fizzie> Why would they be? The grammars they can recognize are a superset of those FSA:s can.
21:35:06 <lament> fizzie: they have a finite number of states.
21:35:08 <cpressey> they can (e.g._ fail to halt, you mean?
21:35:16 <graue> cpressey, i suppose so
21:35:28 <lament> anyway LBA should definitely be a category
21:35:52 <jix> the language i'm writing atm is a LBA
21:35:56 <fizzie> If you want something more distinctive than just "turing-complete/not-turing-complete", why not use the chomsky hierarchy? 
21:36:00 <lament> and most of the stuff that's now in "Turing complete" should migrate to LBA... which is kindof sad :(
21:36:03 <CXI> incidentally, anyone want to see the perl script I use for Two Problems?
21:36:17 <lament> fizzie: I like that idea
21:36:25 <jix> CXI: yes
21:36:52 <jix> you implemented it in perl.. you should call it 3 problems..
21:36:56 <CXI> haha
21:37:03 <cpressey> LBA still seems not quite right... size of tape = function of input size.
21:37:14 <cpressey> this is compicated by the fact that many of these languages are interactive
21:37:30 <CXI> http://members.dodo.com.au/~sgentle/2probs.pl
21:37:39 <lament> well, IO is supposedly irrelevant to turing-completeness
21:37:40 <fizzie> Anyway, every language an FSA recognizes can easily be recognized by an LBA (so L(FSAs) is a subset of L(LBAs)), and there are languages that can't be recognized by a FSA but can with a LBA (so L(FSAs) is a _proper_ subset of L(LBAs)).
21:37:54 <CXI> heh
21:38:04 <CXI> I should really fix that eye-bleedingly horrible bit
21:38:08 <cpressey> irrelevant to computation, yes
21:38:12 <cpressey> but not to communication :)
21:38:17 <lament> cpressey: but yeah, you're right
21:38:26 <cpressey> who the heck uses computers for computations anymore?
21:38:29 <lament> but that can be a separate category
21:38:34 <CXI> heh
21:38:45 <CXI> plus if you don't output anything your program is really easy to optimise
21:39:17 <lament> CXI: not true
21:39:21 <lament> CXI: because of the halting problem
21:39:58 <pgimeno> what's "input" here?
21:40:04 <lament> CXI: consider a program that tries to express every number as a sum of two primes
21:40:15 <CXI> well, you could call a halting program an optimisation of a non-halting program
21:40:18 <CXI> and then you're safe
21:40:19 <lament> starting with 4 and going up
21:40:30 <lament> when it finds one it can't express, it halts
21:40:37 <CXI> pgimeno: syntax is 2probs.pl sourcefilename arguments
21:40:43 <lament> go and optimize that, you'll win the fields prize and get a million dollars
21:40:48 <CXI> http://members.dodo.com.au/~sgentle/99.2p if you missed it before
21:41:10 <CXI> prints numbers from 1 to 99
21:41:24 <pgimeno> CXI: sorry, I'm postponing taking a look at your prog right now (will look at it later)
21:41:38 <CXI> and also prints an error message that I've been too lazy to fix (this isn't really production-quality) :P
21:41:38 <lament> but shit
21:41:42 <lament> input is a valid point
21:42:15 <lament> nah... i don't think so.
21:42:24 <lament> you could store all input in the body of the program :)
21:42:30 <CXI> oh, right
21:42:35 <lament> and disregard IO
21:42:38 <CXI> I thought the input question was about two problems
21:42:39 <CXI> my bad :)
21:43:09 <lament> wrt to IO there're three types of languages i think?
21:43:14 <lament> four
21:43:19 <lament> no IO
21:43:22 <lament> output only
21:43:32 <lament> non-interactive IO
21:43:34 <lament> interactive IO
21:44:04 <lament> perhaps the first three could be categories
21:44:14 <sp3tt> A Swedish site sells custom badges... I'm thinking about ordering one with "hello world" in brainfuck XD
21:45:01 <jix> nah.. order "you are dumb" in bf.. if someone asks you what it means ... :D
21:45:21 <ZeroOne> cpressey: what's that language called Version you've added to the language list?
21:46:05 <ZeroOne> it's rather hard to find information about esoteric programming languages, let alone a language with that kind of name. I hope you've got its homepage address somewhere written down...
21:46:31 <sp3tt> jix: good idea.
21:47:00 <sp3tt> Need to find a program that generates brainfuck that outputs a certain string...
21:47:29 <jix> sp3tt: do it manually .. generate delta values for the string and use multiplication to shorten the code
21:47:54 <lament> okay, added IO capabilities categories
21:48:04 <pgimeno> ZeroOne: http://catseye.mine.nu:8080/projects/version/doc/version.html
21:48:36 <sp3tt> True...
21:49:00 <sp3tt> I have a BF interpreter in python around here somewhere...
21:49:12 <CXI> heh
21:49:23 <CXI> or do what I do, be lazy and generate output in binary instead
21:51:54 <CXI> a la http://bur.st/~comet/xmas.b
21:52:06 <pgimeno> yuck, /me merges lament's changes with his own ones
21:53:36 <pgimeno> NB: I preferred "cell-based" instead of "tape-based" because that way it can be applied to fungeoids et al, which in my opinion share the same idea
21:54:21 <lament> er
21:54:35 <lament> i think i just overwrote your changes again
21:54:56 <lament> if there were any
21:54:58 <graue> you can't overwrite someone's changes
21:55:08 <pgimeno> oops, I'll merge again
21:55:13 <graue> if someone has edited since you pulled up the edit form, it just gives you an edit form again
21:55:26 <lament> hm
21:55:32 <lament> then what is pgimento 'merging'?
21:55:33 <sp3tt> The program should output "Your brain is fucked" XD
21:55:36 <pgimeno> I just didn't submit
21:55:37 <lament> pgimeno
21:55:38 <lament> oh
21:55:41 <lament> anyway
21:55:50 <lament> i just killed the entire turing-completeness class of categories
21:56:49 <graue> did we decide on abolishing the Turing tarpits category or keeping it?
21:56:57 <lament> i moved that one over
21:57:01 <graue> if we keep it, it could be a subcategory of Turing-complete, which might be good
21:57:04 <lament> it has nothing to do with computational complexity
21:57:17 <lament> besides most languages in it are probably not turing-complete :)
21:57:21 <graue> so we are keeping it, though?
21:57:22 <lament> e.g. brainfuck
21:57:30 <pgimeno> why have you removed the turing completeness?
21:57:31 <lament> well, it's the only category that actually has something in it
21:57:35 <pgimeno> bf is not turing-complete?
21:57:37 <graue> Brainfuck is Turing-complete with unbounded memory, and it is usually specified as such
21:57:45 <lament> pgimeno: i replaced it with "computational class"
21:57:46 <graue> even if the original implementation didn't do it that way
21:57:58 <lament> pgimeno: turing complete/linear bounded automata/finite state automata
21:58:08 <lament> what we were just discussing for an hour
21:58:13 <pgimeno> oh, that's a renaming then :)
21:58:17 <pgimeno> ok
21:58:21 <lament> pretty much
21:58:32 <lament> but it does get rid of the amazing "usable" and "not usable" categories :)
21:58:35 <fizzie> There's pushdown automata between those two last ones, but I'm not sure there would be many languages in that one.
21:58:51 <lament> thue is a LBA of course?
21:59:08 <lament> err
21:59:09 <pgimeno> I think it's Turing-complete
21:59:12 <lament> yeah
21:59:13 <lament> nevermind
21:59:25 <lament> probably TC
21:59:38 <lament> is this classification called "Computational class"?
21:59:42 <lament> or "Computational complexity"
21:59:52 <lament> what should the category for languages of unknown class be named
22:00:14 <fizzie> I was going to utter "computational complexity" at one point, but I'm not quite sure now.
22:01:04 <pgimeno> I had written: * Usable for writing programs // ** [[:Category:Usable]] // ** [[:Category:Unusable]] // ** [[:Category:Usability unknown]]
22:01:17 <fizzie> "Computational complexity" reminds perhaps too much of time/space-complexity, which is really a different issue.
22:01:31 <graue> [[Category:Unknown computational class]]?
22:01:48 <lament> usability is different from computational class
22:01:55 <pgimeno> sounds OK
22:01:59 <lament> and i'm not sure if it's a good category anyway
22:01:59 <pgimeno> yeah, sorry
22:02:08 <lament> who are we to decide what's usable :)
22:02:13 <lament> just ask any sane person
22:02:19 <lament> none of the languages on the wiki are usable :)
22:02:26 <fizzie> I did connotation-mapping (read: googled for it) and came up with pages about P != NP, so perhaps the '-- class' is better.
22:02:36 <pgimeno> unusable is HQ9+ etc.
22:02:59 <pgimeno> malbolge is usability unknown
22:03:11 <pgimeno> as is sortle
22:03:23 <lament> that's also reflected in its computational class
22:03:33 <lament> i.e. it's not an LBA
22:03:46 <fizzie> The computational class for HQ9+ would be something even more restricted than FSA, wouldn't it?
22:03:48 <cpressey> graue: how about "open research questions" or similar?
22:04:02 <graue> that's fine too
22:04:10 <lament> then you would have to specify each time
22:04:11 <lament> what exactly the question is
22:04:18 <lament> there're different research questions
22:04:21 <cpressey> fizzie: i would imagine so
22:04:33 <cpressey> lament: it's just a category
22:04:40 <lament> HQ9+ has infinite states :)
22:06:38 <fizzie> I seem to recall some pushdown-automata-like language (single stack, no other real storage), but now I've forgotten it. How is befunge classified, btw? At least '93 has that 80x25 fixed size limit...
22:07:00 <cpressey> fizzie: b93 = pda afaik
22:07:06 <cpressey> no proof
22:07:10 <lament> does LBA have to have arbitrarily big storage?
22:07:29 <cpressey> lba tape size is a function of input size (according to wp)
22:07:37 <cpressey> so, um
22:07:37 <cpressey> maybe
22:07:39 <lament> so yes
22:07:40 <cpressey> definitive maybe
22:07:40 <lament> okay
22:07:48 <lament> hrm :(
22:07:55 <lament> then LBA is not a very good description at all :(
22:08:11 <cpressey> no, it's not
22:08:23 <lament> fuck.
22:08:26 <cpressey> a brainfuck program can do something to an infinite input with only a finite tape
22:08:39 <cpressey> "do something" = turn a's into b' or whatever
22:08:46 <lament> yeah
22:08:53 <fizzie> Well, it's a good description as far as grammars recognizable by the language are considered, but it's perhaps not a very good measure for real-world things.
22:09:09 <lament> brainfuck-complete then? :)
22:09:34 <cpressey> heheheh BANCStar!  i remember BANCStar (DIMLY...)
22:10:12 <lament> how do you distinguish between a language like brainfuck that can turn all a's to b's
22:10:17 <lament> and a language that can't do anything else? :)
22:11:01 <fizzie> As far as real-world uses are considered, most people want more than a "yes/no" answer from their programs, too, so Chomsky hierarchy (which is about the strings accepted by the program) probably isn't that good a category.
22:11:02 <cpressey> lament: that appears to be an open research question :)
22:11:26 <lament> fizzie: yeah :(
22:11:37 <lament> well
22:11:42 <lament> we have to be fair to no-IO languages
22:11:48 <lament> smetana, iota, jot
22:12:21 <pgimeno> I've just made a few changes: moved Turing tarpits as a subcategory of Turing complete, added String-rewriting paradigm, and usability (Usable by default; otherwise [[Category:Unusable for programming]] and [[Category:Usability unknown]])
22:12:53 <sp3tt> I understand why brainfuck is named brainfuck <.<
22:12:59 <cpressey> damn, boo-yah
22:13:04 <fizzie> You could cheat and classify as Turing-complete all languages that are "turing-complete if not a simple memory space restriction of K, the changing of which would not change the language semantics _that_ much", but that's horribly unexact.
22:13:05 <cpressey> i ought to design and implement that someday
22:13:06 <lament> perhaps" usable for programming" is the best classification after all
22:13:25 <lament> fizzie: that's what i proposed
22:13:30 <lament> fizzie: "brainfuck-complete"
22:13:55 <lament> which is actually pretty exact if you specify brainfuck cells to contain 8 bits or whatever
22:14:03 <cpressey> i still think it (somewhat uninterestingly) comes down to a compression problem
22:14:27 <cpressey> a TM with a 1000-symbol tape is a FSM, but it is a much more compact representation
22:14:58 <cpressey> now, *why* it is a more compact representation - that is an interesting question
22:15:06 <lament> no kidding
22:15:19 <cpressey> every programmer seems to intuitively understand why, but where's the bloody formalism?
22:15:25 <fizzie> It's not really a FSM. (There's the halting thing, for one -- it can do state transitions without consuming input.)
22:15:35 <cpressey> ok, "FSM that might not halt"
22:15:41 <lament> man
22:15:47 <lament> these chomsky things are completely useless
22:15:48 <cpressey> or something close
22:15:53 <lament> as are the original turing things
22:15:57 <lament> because of their notion of "input"
22:16:38 <sp3tt> Sigh. I can't even construct a simple loop in bf.
22:16:47 <lament> sp3tt: +[]
22:16:51 <sp3tt> >++[<----->-]<.
22:17:08 <sp3tt> That should decrease the current memory cell with ten, right?
22:17:09 <cpressey> link for BogusForth seems to be dead
22:17:23 <fizzie> Assuming the next memory cell was zero, apparently.
22:17:48 <lament> okay screw it, let's just keep "usable" :)
22:17:57 <lament> and have the category:usable itself be an "open research question" :)
22:17:59 <pgimeno> BF-complete was already used by Fraans Faase, btw
22:18:10 <lament> well, there you go
22:18:11 <pgimeno> s/Fraans/Frans/
22:18:15 <lament> it's a natural way to classify things :)
22:18:48 <fizzie> Does brainf*ck specify any limitations to program length, btw? 
22:18:54 <pgimeno> but not in that sense I'm afraid
22:19:09 <pgimeno> not that I know, fizzie
22:19:13 <ZeroOne> should we have some Template:Stub like in Wikipedia? we could use one to mark articles that only have one sentence or so.
22:19:15 <lament> fizzie: no
22:19:18 <fizzie> Befugne (93) would (probably) not be brainf*ck-complete, then.
22:19:28 <lament> fizzie: yes.
22:19:36 <lament> so that's still a crappy definition :)
22:19:53 <lament> "brainfuck-complete with memory and code restriction" just doesn't sound very good
22:19:56 <pgimeno> ZeroOne: looks like a good idea
22:20:31 <lament> how about HQ9+ complete :)
22:21:02 <lament> well, not HQ9+, but have a list of problems that a language should be able to do
22:21:14 <lament> the only side effect is allowing a language that does nothing but those problems
22:21:15 <cpressey> "code restriction" opens up a whole new can of worms
22:21:46 <lament> but apart from that, it seems pretty good..
22:21:49 <cpressey> i'm much happier just leaving all the contentious stuff uncategorized, btw.
22:22:05 <lament> it will also give people things to do
22:22:20 <lament> implement the "qualification" programs in all the languages :)
22:23:09 <cpressey> what are our "qualification" programs?
22:23:15 <cpressey> 99 bob?
22:23:19 <lament>  definitely :)
22:23:38 <fizzie> I always write a befunge interpreter, but perhaps that's not a good idea. :p
22:23:38 <cpressey> what does it qualify the language for?
22:23:55 <cpressey> maybe "99bob-complete"
22:23:55 <jix> 99 bob using substaction and looping
22:24:06 <lament> well, 99 is not a great program
22:24:11 <ZeroOne> pgimeno: ok, here's the template in action: http://esoteric.voxelperfect.net/wiki/Ale
22:24:14 <fizzie> You probably can use an "approved by esowiki" stamp on the marketing brochures after that.
22:24:16 <cpressey> for some def'n of "subtract" and "loop" i suppose :)
22:24:25 <lament> but still
22:24:51 <pgimeno> cool, ZeroOne 
22:24:52 <lament> a bunch of math problems... number factorization.. sorting..
22:25:14 <lament> none of it is relevant mathematically speaking
22:25:45 <lament> but in real world terms, it means a lot when something like Chess was implemented in befunge
22:25:56 <fizzie> Heh, and will we specify for how large inputs do these qualification programs need to work? The befunge qsort is pretty limited, for example, since all the data must fit on the playfield.
22:26:41 <pgimeno> lament: TPK may be what you're looking for
22:26:55 <fizzie> Your (plural you) use of the "we" pronoun is contagious.
22:26:57 <pgimeno> http://www.cs.fit.edu/~ryan/compare/
22:27:11 <graue> i don't think the stub template is a good idea
22:27:19 <graue> it makes the site look messy and unfinished
22:27:29 <graue> just let stubs be stubs and if someone cares they'll be expanded
22:27:36 <lament> fizzie: note however that you can implement the actual algorithm in befunge
22:27:51 <lament> or, for example, in smetana
22:28:53 <pgimeno> graue: the intention is to have a more or less detailed description of each language, not just a quick overview like now, right?
22:29:25 <lament> and it's just that really
22:29:30 <lament> it's not about the size of input
22:29:31 <graue> yes, but that'll happen when it happens
22:29:36 <lament> it's about being able to write non-trivial code
22:29:38 <graue> making the pages look a mess isn't going to speed it along
22:30:17 <lament> why is there so little math in all of this :(
22:30:59 <pgimeno> graue but it would be good to create the sensation that the intention is detailed descriptions, and without the stub notice it seems like they're more or less complete
22:31:27 <cpressey> i like stub template
22:31:38 <cpressey> although, it's not necessary
22:31:39 <graue> almost everything is a stub now
22:31:45 <cpressey> yeah
22:31:54 <cpressey> it's fairly clear that more info can be added
22:32:00 <pgimeno> yeah, but it would seem as if the intention is to have just short descriptions
22:32:05 <cpressey> and if no one does, well, we live
22:32:18 <lament> consider the following language:
22:32:19 <cpressey> we could add a note in the list
22:32:23 <lament> it's "seemingly turing-complete"
22:32:28 <lament> it has no interactive IO
22:32:30 <cpressey> "longer descs wanted!" etc
22:32:36 <pgimeno> cpressey: yes, that's another way
22:32:41 <lament> when a program terminates, if the state is "hello world", it gets changed to ""
22:32:55 <lament> Is this turing-complete?
22:33:17 <lament> no matter what i do i can't get it to output hello world
22:33:48 <cpressey> lament: i've come across that before (actually ben did)... it seemed like a representation problem
22:33:57 <cpressey> you can output hello world in e.g. binary ascii
22:34:27 <cpressey> i think it came up because ben thought the original wierd couldn't output ascii 0
22:34:42 <cpressey> which it could, but it still raised an interesting question
22:35:03 <cpressey> say (eg) the alphabet of symbols you can write is a subset of those that you can read
22:35:10 <cpressey> is that turingmachine still tc?
22:35:20 <jix> it is
22:35:26 <cpressey> i'd think so too
22:35:27 <jix> because a turingmachine is always tc
22:35:34 <cpressey> (unless the subset is like the null set or something)
22:35:36 <pgimeno> you only need 0 and 1
22:36:14 <cpressey> right, which makes me wonder about judging turing tarpits based on # of symbols (they can all be encoded in e.g. unary even, if you ignore the problem of "telling where the program stops")
22:36:20 <lament> ok, i officially give up and advocate to use "usable"/"unusable"
22:36:53 <pgimeno> heh
22:36:59 <lament> tarpits are just small languages
22:37:12 <cpressey> yup
22:37:14 <lament> actually do they have to be small?
22:37:17 <pgimeno> cpressey: any file can be coded in unary
22:37:18 <lament> i thought the requirement was
22:37:27 <lament> "everything is possible, but nothing of interest is easy"
22:37:40 <graue> that's the derivation
22:37:45 <lament> hehe
22:37:53 <graue> the meaning is "a Turing-complete language with few symbols/instructions"
22:38:47 <pgimeno> yeah, "turing tarpit" is not well defined
22:39:04 <lament> it can't be
22:39:23 <lament> there's nothing magical about tarpits vs non-tarpits
22:39:32 <pgimeno> it's more like a definition by enumeration of the currently accepted TTs
22:39:56 <lament> yep
22:40:53 <cpressey> pgimeno: yes, the "problem" is "where does it stop?"  (i'm not saying it's a "real" problem... just that it might be, depending on how you look at things)
22:41:11 <lament> the problem with the TC stuff is that everybody uses TC to mean "almost TC"
22:41:32 <cpressey> nod
22:41:40 <pgimeno> cpressey: stop in what sense? I don't get you here; if you have a file you know where it stops, and if you have a binary number you also do
22:41:41 <lament> eg on the smallfuck page
22:41:45 <lament> "Like Brainfuck, Smallfuck is Turing-complete. Provided you have an implementation that can initialize memory cells arbitrarily before running the program and print out their content when the program ends, you can use Smallfuck to make any kind of calculation."
22:41:47 <pgimeno> err s/binary/unary/
22:41:53 <cpressey> or, there's a bald claim to TC with no proof
22:42:19 <lament> when smallfuck is explicitly defined to have some memory limit
22:42:21 <cpressey> TC and implementations shouldn't mix
22:42:57 <cpressey> pgimeno: how do you know how it stops without having either a) a terminator symbol (which is not the same as your unary symbol) or b) a file size (which is stored how?)
22:43:40 <pgimeno> cpressey: yeah, I agree about the terminator symbol; but translation to a file is made by storing the number with a '1' prepended
22:44:15 <pgimeno> i.e. a one byte file is the digit 1 plus the 8 bits of the file
22:44:16 <cpressey> pgimeno: i don't quite follow - is '1' the file size?
22:44:27 <cpressey> oh
22:44:28 <lament> yet i keep having a feeling there's SOME sort of math behind this :(
22:44:33 <cpressey> but can you stor *that* in unary?
22:44:37 <cpressey> lament: me too
22:44:41 <cpressey> shrug
22:44:56 <lament> open research :)
22:45:30 <pgimeno> cpressey: you can store in unary e.g. 257 which is 100000001, meaning the file with the ASCII character <SOH>
22:47:10 <pgimeno> but you need a terminator char if you use unary anyway
22:47:26 <cpressey> oh, ok - if you have a max file size (which all real filesystems do,) yes, i can see that
22:47:47 <pgimeno> why a max file size?
22:48:11 <sp3tt> Ok, Brainfuck totally rocks, pwns, and is teh shit!
22:48:12 <pgimeno> that's "the EOF problem" which also rises in compression theory
22:51:06 <cpressey> pgimeno: a max file size?  well... all i meant was that in practice, you don't use bignums ;)
22:51:23 * cpressey sees an "esoFS" approaching on the horizon :)
22:51:28 <pgimeno> oh ok
22:51:30 <pgimeno> haha
22:51:41 <sp3tt> ++++++++++[>+++++++++<-] >-.>++[<+++++++++++>-]<.++++++.---.>++++++++[<---------->-]<--.>++++++++[<++++++++>-]<++.>++[<++++++++>-]<.>++[<-------->-]<-.++++++++.+++++.>++++++++[<---------->-]<++.>++++++++[<+++++++++>-]<+.>++[<+++++>-]<.>++++++++[<---------->-]<---.>+++++++[<++++++++++>-]<.>+++[<+++++>-]<.>++[<--------->-]<.++++++++.------.-.>++++++++[<-------->-]<---.
22:51:43 <sp3tt> w00t
22:52:03 <pgimeno> calamari was working in one for his shell
22:52:53 <sp3tt> That prints "Your brain is fucked!"
22:53:01 <jix> lol esoFS
22:53:14 <sp3tt> Esoteric filesystem? LOL
22:53:23 <sp3tt> Chef-FS, imagine that.
23:03:10 <graue> i've been thinking of writing up an Esoteric Software License for interpreters i write
23:03:29 <graue> viral licenses have been done, but not polymorphic viruses!
23:03:57 <lament> hahaha
23:13:11 <sp3tt> XD A badge with green text on black background.
23:13:41 <sp3tt> And the text is a brainfuck program that outputs "Your brain is fucked".
23:30:55 <sp3tt> Night all.
23:31:22 -!- sp3tt has quit ("Chatzilla 0.9.68a [Firefox 1.0.4/20050511]").
23:35:28 <lament> that's a very long program.
23:35:31 <lament> i bet it could be shorter.
23:37:28 <lament> cpressey: perhaps program growth vs. problem complexity growth has something to do with it
23:37:39 <lament> not sure what exactly those two would mean
23:37:59 <lament> (it = "turing-complete-likeness")
23:38:21 <lament> so yeah, "compression", asymptotically