00:00:15 <oerjan> there is some strange unicode i cannot read on that proto-indoeuropean in http://en.wiktionary.org/wiki/facio#Latin
00:00:24 <ihope> Now don't tell me the English word "chase" comes from "fugare".
00:01:04 <ihope> Proto-Indo-European notation is ridiculous. :-P
00:01:15 <oklopol> okay, okay, göa just sounded pretty.
00:01:31 <oklopol> you have to understand, i've been drawing eer diagrams for hours.
00:01:37 <ihope> Shall I start referring to Agora as Agöra?
00:01:48 <oklopol> with the buggiest drawing program in the world
00:01:52 <oerjan> actually "chase" is from latin "captare", it says
00:02:27 <oklopol> wonder if there's a linux port for paint... i miss paint...
00:02:41 <ihope> I'd be slightly surprised if the word "capture" didn't come from the same word.
00:03:32 <oerjan> actually they're both probably derived from capere
00:03:58 <ihope> And "capital" and "cabeza" both come from the same Latin word, I'd expect.
00:04:13 <oerjan> capital is from caput, i think
00:06:25 <oerjan> cognate with head, more or less
00:06:42 <oerjan> "Old English h.afod, from Proto-Germanic *khaubuthan, from Proto-Indo-European *kauput- (..head, bowl..). Cognate with German Haupt, Dutch hoofd, Swedish huvud; the Indo-European root is also the source of Latin caput."
00:07:56 <ihope> h.afod from *khaubuthan?
00:08:32 <oerjan> that . is e with a bar btw
00:09:12 <oerjan> indo-european k -> germanic h is pretty basic
00:09:46 <ihope> But then you still have the fod from buthan.
00:10:10 <oerjan> i don't know how the proto-germanic fits in between
00:10:34 <oerjan> and t -> th which must have been weakened afterwards
00:11:10 <ihope> Makes sense, I guess.
00:11:22 <ihope> That "an" on the end was just a passing fad, then. :-P
00:11:31 <oerjan> http://en.wikipedia.org/wiki/Grimm's_law
00:11:40 <oerjan> probably just an inflection yeah
00:13:53 -!- slereah_ has quit (Remote closed the connection).
00:14:14 -!- slereah_ has joined.
00:18:43 <oerjan> there seems to be an entire class of nouns getting vowel+n endings in germanic, in norwegian the ending turns into -e, sometimes called "weak" nouns
00:18:53 <oerjan> german has something of the same, though not in this word (e.g. Name, with occasional -n)
00:18:53 <oerjan> (it's "hode" in norwegian)
00:20:40 <oerjan> (some norwegian dialects inflect weak nouns rather differently from strong ones)
00:21:56 <oerjan> that's the case in swedish too i think, e.g. plural -or vs. -ar
00:22:24 <oklopol> your mother is a weak noun.
00:34:37 -!- ihope_ has joined.
00:37:09 <oerjan> aha! the th -> d is http://en.wikipedia.org/wiki/Verner%27s_law
00:37:46 <slereah_> SimonRC, this is all your fault :o
00:38:20 <ihope_> Of course! #linguistics doesn't exist--wait, actually, it's much bigger than this channel.
00:39:59 <ihope_> It has almost a long novemnonagintilliard people in it.
00:40:35 <ihope_> Which I guess is 10^597.
00:45:42 <ihope_> Not as much as a long centillion, though.
00:46:37 <ihope_> Much less a long nongennovemnonagintilliard.
00:48:15 -!- timotiis has quit ("leaving").
00:50:37 <ihope_> Here's a fun word: milliatillion.
00:51:24 <slereah_> Although really, above 10^100, things start to get useless.
00:51:43 <slereah_> Above that, it's mostly silly probabilities and theoretical mathematics.
00:52:02 -!- ihope has quit (Read error: 110 (Connection timed out)).
00:54:20 <ihope_> Graham's number, the biggest important number.
00:54:44 -!- calamari has joined.
00:54:58 <Sgeo> Have you been keeping up with PSOX?
00:55:30 <pikhq> http://pikhq.nonlogic.org/wget.b
00:55:30 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
00:55:44 -!- slereah_ has joined.
00:55:46 <pikhq> Actually fairly trivial with Sgeo's SVN; it has an HTTP domain.
00:55:54 <pikhq> (binding HTTP to a file descriptor)
00:55:59 <slereah_> Graham's number isn't very important.
00:56:16 <pikhq> It's the largest important number.
00:56:18 <ehird`_> slereah_: the real value is closer to 6, apparently.
00:56:18 <ihope_> Are there any bigger numbers that have any importance at all?
00:56:29 <ihope_> It's at least 11 and probably bigger.
00:56:59 <slereah_> Well, if it's bigger than 11, it shouldn't be too far from Graham's number.
00:57:14 <pikhq> Amusingly, Graham's number is too large to be written in scientific notation.
00:58:34 <Sgeo> pikhq, did you have any trouble writing wget.b? If so, what?
00:58:35 <oerjan> hm there seems to be a typo in the Verner article, th -> d should be th -> dh
00:58:37 <ihope_> I think I'll write a program to list out the name of a number.
00:59:20 <pikhq> Sgeo: The cat bit was slightly difficult, actually.
00:59:35 <pikhq> But even that wasn't too hard, since PSOX has decent debugging facilities.
00:59:51 <pikhq> Yeah; that was really helpful.
01:03:15 <Sgeo> It was basically made while trying to chase down a bug which turned out to be a * where there shouldn't have been a *
01:04:33 <ehird`_> one thing stupid about psox
01:04:38 <ehird`_> the os provides that stuff alread
01:05:36 <Sgeo> calamari, PSOX in general, or wget.b, or what?
01:05:57 <calamari> does it require a special interpreter?
01:06:14 <Sgeo> calamari, yes, svn co http://svn2.assembla.com/svn/psox/trunk
01:06:34 <Sgeo> Well, it's not a BF interpreter itself
01:06:38 <calamari> oh, so all the existing esolang interpreters/compilers will need to be redone to support psox?
01:06:49 <Sgeo> It goes between a standard interpreter and stdio
01:06:52 <Sgeo> calamari, not at all
01:07:06 <Sgeo> Misunderstood your question, is all
01:07:15 <ehird`_> Sgeo: will you remove the safety stuff? honestly, my os is very good at that and its going to be a pain coding the domains i want to with it
01:07:26 <Sgeo> ehird`_, it's going to be a pain to do:
01:07:35 <Sgeo> if "nogui" in G.SAFETYLIST:
01:07:41 <Sgeo> MY_VERSION = 0
01:07:46 <Sgeo> MY_VERSION = 1
01:07:49 <Sgeo> that's a pain?
01:08:02 <ehird`_> Sgeo: the whole idea is a pain
01:08:04 <Sgeo> or do you mean ffi? If ffi, just make the domain require ffi as a safety option
01:08:28 <ehird`_> Sgeo: the whole idea is a pain
01:08:37 <Sgeo> How is it a pain?
01:08:56 <ehird`_> calamari: it is half-assed disabling of certain functions in psox.
01:09:01 <pikhq> G=g64, where g1 = 3^^^^3, and gn = 3^(gn-1)3. . .
01:09:03 <ehird`_> that can already be done from within the os
01:09:07 <pikhq> Holy hell, that's big.
01:09:11 <Sgeo> calamari, on the command line, if for example, I don't want PSOX to go online, I can give the commandline option -s nonet
01:09:17 <ehird`_> Sgeo: or you could tell your os.
01:09:27 <Sgeo> Or if I want to allow it to go outside the sandbox, I can give -s fullfileio
01:09:39 <ehird`_> idea: if i removed the safety right now, how many people do you think will notice?
01:09:45 <Sgeo> ehird`_, I will
01:10:20 <ehird`_> yes... because you like the feature; not because of it being any good
01:10:34 <calamari> I suggest that if you don't want certain functions, you could run it sandboxed or as a less privileged user
01:11:02 <Sgeo> pikhq, what's your opinion on the safety debate?
01:11:22 <calamari> but for windows, that wouldn't work very well :)
01:11:23 <ehird`_> alternatively... if you don't want to do that... just remove the import from the code! seriously.
01:11:28 <ehird`_> calamari: see what i just said
01:11:36 <ehird`_> you don't run external code without reading it
01:11:38 <ehird`_> if you're paranoid like that
01:11:43 <ehird`_> its just like downloading and running a perl script!!
01:12:25 <calamari> ehird`_: did you help write PSOX?
01:12:40 <ehird`_> calamari: no, but i have svn access since a few seconds ago
01:12:48 <ehird`_> and have sat by and complained since forever
01:12:48 <Sgeo> calamari, ehird helped shape some parts, and is now trying to redo how I/O is done
01:13:02 <calamari> ehird`_: just seems like you're kinda hostile towards it ..hehe
01:13:10 <ehird`_> calamari: just that feature. :-)
01:13:26 <Sgeo> calamari, ehird`_ has been less hostile towards it since he pointed out that most of the bitwise stuff could be removed
01:13:48 <Sgeo> I think ehird`_ originally became hostile when some stuff he suggested was removed (TDATA (the "ANY" type))
01:13:57 <Sgeo> right, boolean, not bitwise
01:14:05 <calamari> bitwise is hard for bf tho.. and/or/xor
01:14:16 <Sgeo> calamari, I meant removed boolean
01:14:33 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/spec/psox-utils.txt
01:15:07 <ehird`_> Sgeo: can i just remove the safety stuff and we'll see who exactly is going to write a brainfuck virus and regular people who won't read the code will download it, psox, an interpreter, and blindly run it?
01:15:57 <Sgeo> ehird`_, I don't see why you're so violently opposed to the safety stuff
01:16:28 <ehird`_> Sgeo: it's crap pointless and will make writing stuff harder for no reason
01:16:46 <ihope_> I'm quite fine with the safety stuff as long as there's some switch to disable it.
01:17:02 <Sgeo> ihope_, there's really nothing to disable
01:17:10 <ehird`_> ihope_: nobody will use it
01:17:11 <ihope_> What is the safety stuff, then?
01:17:21 <ehird`_> iit's just pointless and doesn't help devs
01:17:36 <Sgeo> ihope_, putting -s nonet to disable internet acces, or -s fullfileio to not force file I/O to be in a sandbox
01:18:03 <ehird`_> ... which is of course useless as your os can do it anyway
01:18:06 <ehird`_> and you can just edit the psox code
01:18:07 <calamari> Sgeo: are these options defined by the libraries, or are they hardcoded into the executable?
01:18:14 <ihope_> File I/O is in a sandbox by default?
01:18:16 <ehird`_> calamari: libraries have to go around them...
01:18:19 <Sgeo> calamari, defined by the libraries
01:18:22 <ehird`_> and 'normal users' aren't going to use psox anyway
01:18:27 <ehird`_> and people who will use psox
01:18:40 <ehird`_> it is JUST LIKE downloading a Perl program, can't you see that Sgeo?
01:18:51 <Sgeo> Who said I can read Brainfuck code written by others?
01:18:53 <ehird`_> How come they don't have any need for it; but PSOX does?
01:19:01 <ehird`_> And WHO IS GOING TO WRITE A BRAINFUCK&PSOX VIRUS?
01:19:02 <calamari> Sgeo: so if I'm writing my own library calamari::blah .. it could add -s abcd to do something?
01:19:20 <ihope_> Are there other safeties that are enabled by default?
01:19:24 <calamari> Sgeo: that seems fine to me.. *shrug*
01:19:40 <ehird`_> Sgeo: Don't you see, though? I honestly don't see how you don't get what I'm saying
01:19:53 <ihope_> If so, it seems that there is indeed something to disable.
01:20:06 <calamari> ehird`_: if I'm understanding what he is saying.. you don't even need to worry about the safety stuff if you don't care
01:20:20 <ehird`_> calamari: you most certainly do
01:20:44 <calamari> ehird`_: why? if my calamari:: library doesn't want to respect -s nonet, it would just ignore it
01:21:02 <ehird`_> calamari: ahh but it needs to respect -s nocalamarilibrary
01:21:08 <Sgeo> What calamari said
01:21:13 <ehird`_> and also if i want stuff included in the main psox distro
01:21:31 <ehird`_> Sgeo: Name one use case for the safety, and tell me how it is different from just running a Perl script?
01:21:40 <ehird`_> And also, tell me who will write a PSOX virus.
01:21:48 <Sgeo> ehird`_, someone who hated me
01:21:58 <Sgeo> or some other PSOX fanatic who is unable to read BF code
01:21:59 <calamari> ehird`_: if you don't like the standard library, make one without the safety stuff.. problem solved?
01:22:10 <ehird`_> I HATE YOU SGEO!! Wait.. I know... I'll write a PSOX virus!
01:22:14 <ehird`_> MWAHAHAHAHHAHAHAHHAHAHAHAHAHAHA!!!!!
01:22:42 <Sgeo> http://esolangs.org/wiki/PSOX
01:22:52 <ehird`_> Sgeo: anyway, what if I can't read Perl?
01:22:55 <calamari> Tritonio_: it's an esolang wrapper that extends its functionality
01:23:17 <Sgeo> Tritonio_, eventually, yes
01:23:29 <ehird`_> Sgeo: Here are some scenarios:
01:23:35 <Sgeo> Tritonio_, currently, there are only math utilities and HTTP
01:23:35 <ehird`_> 2. I download a Perl script
01:23:43 <ehird`_> 1. I don't know Brainfuck.
01:23:48 <ehird`_> 2. But I have a brainfuck interpreter and PSOX!
01:23:55 <ehird`_> 3. And I like downloading PSOX programs!
01:24:00 <ehird`_> 4. And someone has written a PSOX virus!
01:24:03 <ehird`_> 5. And I download it and run it!
01:24:20 <ehird`_> Sgeo: The Perl script is 5 times more likely to be a virus; PSOX just does not have the need for these features.
01:24:52 <calamari> ehird`_: I like the idea that my code will have the ability to read command line options
01:25:09 <ehird`_> calamari: Sure. That's great and all. I'm just highlighting a problem.
01:25:12 <Tritonio_> Sgeo, why don't you simply map the functions of a high level language? like python...
01:25:26 <ehird`_> And PSOX will offer normal command-line argument handling, presumably.
01:25:28 <Sgeo> calamari, thing is, there is a virtual command line that a PSOX client can read (-c fakecommandline)
01:25:47 <Sgeo> A bit ugly, but I don't know how to do it better
01:25:54 <Sgeo> wget.b uses it
01:26:12 <calamari> Sgeo: that sounds fine.. sh/bash do it that way
01:26:50 <Sgeo> calamari, but that weighs in in ehird`_'s favor in the debate, so -s isn't needed for that sort of functionality
01:27:22 <Sgeo> Well, I think that would leave the virtual command line blank actually
01:27:26 <Sgeo> I'm not sure how it works
01:27:54 <Sgeo> -c would generally be used for the client to read
01:28:03 <calamari> but then the program would have to handle it
01:28:10 <Sgeo> -s is instructions to the libraries usually regarding what to allow and not to allow
01:28:48 <calamari> well how about this? -s HTTP=no
01:29:12 <Sgeo> Hm, I'm not sure how I'd go about coding that
01:29:23 <Sgeo> Although that does make sense
01:29:28 <calamari> isn't HTTP definied in its own file?
01:29:33 <Sgeo> I don't know how optionparser works
01:29:45 <Sgeo> but the safety stuff could be stored in a dictionary I guess
01:29:55 <calamari> neither do I.. haven't really studied perl.. just python
01:30:15 <Sgeo> The reference PSOX interpreter is Python
01:30:19 -!- slereah__ has joined.
01:30:21 <ehird`_> that's just loading&unloading domains
01:30:21 <calamari> then the libraries wouldn't have to deal with safety at all
01:30:27 <ehird`_> but its nothing to do with safety
01:30:33 <Sgeo> calamari, yes they would
01:30:51 <calamari> well I can help you then.. I've done a lot with python parsing
01:31:01 <Sgeo> calamari, currently, PSOX.py uses regex
01:31:20 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/impl/PSOX.py
01:31:59 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
01:32:37 <Sgeo> ehird`_, you just removed safety from the trunk
01:32:47 <ehird`_> I was wondering how long it would take you to notice.
01:34:41 <Sgeo> ehird`_ broke PSOX
01:34:56 <Sgeo> MY_VERSION is required
01:36:22 <Sgeo> ehird`_, no you didn't
01:36:26 <Sgeo> You fixed it in one place
01:36:31 <ehird`_> Sgeo: the rest were already fixed
01:36:45 <Sgeo> dc_exampledomain?
01:37:04 <Sgeo> Also, one of the system domain functions looks at G.SAFETYLIST
01:37:25 <Sgeo> ehird`_, going to fix the specs too?
01:37:27 <ehird`_> that's specifically safety-related
01:37:32 <ehird`_> so, i'll comment it out and reserve it for use
01:38:09 <Sgeo> calamari, pikhq, do either of you find it objectionable that ehird`_ just unilaterally made a change without my permission?
01:38:28 <ehird`_> but i don't think anyone noticed
01:39:21 <ehird`_> Sgeo: anyway, all fixed and spec updated.
01:40:20 <Sgeo> No, python PSOX.py python testcustdomain.py isn't working
01:40:36 <Sgeo> Are you still importing SAFETYLIST?
01:40:54 <Sgeo> no, not in PSOX.py
01:42:19 <Sgeo> Or you could have assigned a blank list to G.SAFETYLIST
01:42:55 <calamari> Sgeo: dunno why.. but I gues I had to see something like wget before I woke up and got interested :)
01:43:14 <calamari> although I'm not completely thrilled by the impl.. seems like it could be simpler
01:43:32 <ehird`_> you could practically golf it
01:43:56 <calamari> so if you don't mind.. I may fool around with a fork and see what comes of it
01:44:00 <Sgeo> calamari, thank pikhq for wget.b
01:44:23 <calamari> then if you like it, could merge it
01:44:29 <ehird`_> calamari: please don't add safety... i can't be bothered to have another debate
01:44:50 <Sgeo> ehird`_, we really haven't finished our debate, you unilaterally removed safety
01:44:52 <calamari> you agreed with what I had to say about it I think
01:45:01 <ehird`_> Sgeo: Would a C psox be a good idea?
01:45:17 <Sgeo> ehird`_, not if it would be difficult to implement domains
01:45:18 <ehird`_> I mean, as the main impl. Justification:
01:45:25 <ehird`_> You can embed Python and stuff.
01:45:25 <calamari> ehird`_: C isn't good at dynamically importing stuff, is it?
01:45:45 <ehird`_> Sgeo: But I mean, the justification
01:45:49 <ehird`_> is that C has the best library support
01:45:52 <ehird`_> so the FFI would be the richest
01:46:08 <calamari> I think that'd tie it down to linux only
01:46:44 <calamari> you can't be suggesting that all os's have the same libraries
01:46:44 <Sgeo> No, Linux only is not an option. I complicated retrieving input so PSOX would work with Windows
01:47:09 <ehird`_> calamari: I assume Sgeo isn't actively planning to support VMS.
01:47:39 <ehird`_> as long as you write a 3-line wrapper for it
01:47:40 <calamari> ehird`_: can you give a dhopen example? I am not familiar with it
01:47:48 <Sgeo> Can't you embed C into Python?
01:47:48 <ehird`_> calamari: eh, google... not off the top of my head
01:47:56 <ehird`_> Sgeo: Uh, that's not quite the point.
01:48:03 <ehird`_> And no, you can't without a lot of horrid pain.
01:48:29 <calamari> ehird`_: the advantage of python is that it is cross platform with a standard set of libraries
01:48:43 <ehird`_> c has more libraries, too.
01:48:50 <ehird`_> also, you overestimate how complex psox is...
01:48:56 <ehird`_> and how many libraries it'd need to use
01:49:00 <calamari> s is.. but besides the std lib, nothing else is standard
01:49:32 <calamari> they'd pretty much have to install cygwin to use it
01:49:50 <Sgeo> One objection to a C interp as ref is that I don't know C
01:51:14 <ehird`_> i can write it as libc with a few wrappers for dlopen
01:51:48 <calamari> please provide a simple example, even if it's pseudocode
01:52:45 <ehird`_> which will call the win32api on windows
01:53:25 <calamari> but there is no guarantee that foo.so and foo.dll are even compatible
01:53:41 <ehird`_> they will be compiled to .so
01:53:47 <ehird`_> and the wrapper will handle it
01:53:51 <ehird`_> what is hard to understand about this?
04:03:31 -!- clog has joined.
04:03:31 -!- clog has joined.
04:04:10 <calamari> now all file I/O can go into a domain
04:04:26 <calamari> rather than be a PSOX core function
04:05:06 <Sgeo> So both you and ehird want the same thing?
04:05:16 <Sgeo> re: Shoving I/O into a domain?
04:05:22 <calamari> so, for example if you imported a domain dedicated to input to 0x01, then you'd say 0x01 "text" 0x00 .. something like that
04:06:11 <calamari> although it'd probably be more of an i/o domain, with file handling, etc
04:06:25 <Sgeo> Why these redesigns now when PSOX is so close to completion of 1.0?
04:06:41 <calamari> oh, I'm not saying you should redesign anything
04:07:10 <calamari> I'll implement it separately.. and then we can get together and see what we think of it
04:07:27 <calamari> that way if it doesn't work out, you haven't lost a thing
04:08:34 <Sgeo> I guess, but it seems like a lot of effort on your part for something that IMO isn't really needed
04:10:40 <Tritonio_> it's 6am here so i am going to sleep. i'll check it thoroughly tomorrow. calamari use this for reading from the table: >[>>>[-<<<<+>>>>]<[->+<]<[->+<]<[->+<]>-]>>>[-]<[->+<]<[[-<+>]<<<[->>>>+<<<<]>>-]<< i think it's ok. but maybe it's not...
04:10:57 <Sgeo> G'night Tritonio_
04:23:43 <calamari> Tritonio_: dunno if you will see this, but I never used the reading code
04:23:57 <calamari> I was examining the values directly from BF memory
04:31:19 <calamari> Sgeo: TDATA is mentioned in psox-types.txt then never defined
04:32:05 <Sgeo> calamari, oh right, that's old
04:33:34 <calamari> http://trac2.assembla.com/psox/browser/trunk/spec/psox-types.txt
04:34:02 <Sgeo> Nov. 8, 2007 old
04:34:18 <Sgeo> Revision 10 old
04:34:26 <calamari> what is STRINGNL needed for? I see the description, but why wouldn't a STRING work?
04:34:49 <Sgeo> A STRING would work, but it's a bit of overhead to have a 0x00 right at the end before the 0x0A
04:35:08 <calamari> oh, does every command have to end with 0x0A?
04:36:14 <calamari> I guess it would, since you read lines only
04:38:07 <Sgeo> The reason is for any esolang interpreters that only write out on a newline
04:38:11 <Sgeo> No floating point
04:40:06 <calamari> cool, just learned something about python.. j gives you imaginary numbers.. so a=1j, a+=1 gives a=(1+1j)
04:43:05 <Sgeo> FNUM(1) is 1 byte, FNUM(2) is two bytes, etc
04:49:23 <Sgeo> http://trac2.assembla.com/psox/browser/trunk/spec/psox_net.txt does this look good so far?
04:55:42 <calamari> Sgeo: did you guys consider another data representation for unknown length, escaped ASCII... where 0x01-0xFF are as normal, 0x00 0x00 = 0x00, 0x00 0xelse=EOF?
04:56:13 <Sgeo> calamari, that might not be easy for BF to process
04:56:13 <calamari> that would possibly incur less overhead than LNUM/LBYTES
04:57:37 <calamari> it wouldn't be too bad.. you'd use the standard if=0 code
05:00:45 <calamari> while not eof { data=read_byte; if=0 { data=read_byte; if<>0 { set_eof } }; if !eof { do_something_with_read_byte } }
05:03:06 <calamari> or is that a way of dismissing what I said without actually coming up with a refutation?
05:03:21 <oerjan> most exquisitly horrible
05:04:19 <Sgeo> I think I like the easier-for-BF-to-process solution
05:04:39 <calamari> doesn't seem like it's much different to me
05:05:01 <calamari> you're still going to need the inner if to decide what to do
05:06:19 <calamari> while not eof { data1=read_byte; data2=read_byte; if data1=0x01 { set_eof }; if !eof { do_something_with_data2 } }
05:07:07 <calamari> note that my if<>0 is easy to code up, so that's nothing
05:08:26 <calamari> see? they are essentially identical.. and now more capable langs don't have to output so much
05:09:45 <Sgeo> I still hold that the current way is simpler
05:10:17 <calamari> yes it is slightly simpler at the expense of approx twice as much I/O
05:11:48 <Sgeo> Wait, what was your way again?
05:12:31 <Sgeo> 0x01-0xFF are as normal, 0x00 0x00 = 0x00, 0x00 0xelse=EOF?
05:12:39 <calamari> 00 = ESC, ESC 00 = 00, ESC 01 = END_OF_DATA
05:13:42 <Sgeo> I thought there was a flaw, but I was thinking of something else
05:14:16 <Sgeo> Writing out to that format requires a bit of processing
05:14:37 <calamari> an if statement is a lot of processing?
05:14:49 <Sgeo> I rememeber trying to do something similar, where 0x01 escapes, and unescaped 0x00 is EOF
05:14:59 <calamari> if data_to_output = 0x00 { output 0x00; output 0x00 }
05:17:32 <calamari> I'm not saying you need to replace the other.. but it would be nice to see this as an alternative format
05:17:57 <calamari> although with the way you are doing the processing it might be a pain to add it
05:18:03 <Sgeo> Well, there's currently no provisions for clients to choose which format they want to do
05:18:23 <Sgeo> And that's basically the only way I can think of adding it
05:18:40 <calamari> ahh it's all up to the function receiving it?
05:18:57 <calamari> right, then it'd have to be one or the other
05:20:04 <calamari> serialization is such a pain :)
05:20:18 -!- ihope_ has quit (Read error: 110 (Connection timed out)).
05:25:16 -!- calamari has quit ("Leaving").
05:35:53 <Sgeo> Ok, I think I mostly completed the docs for the Net domain
05:36:10 <Sgeo> I'll then eventually work on the File I/O domain and base the FTP parts of the Net domain on that
05:39:22 <Sgeo> I should probably go now
05:54:06 -!- rutlov has joined.
05:56:42 -!- oerjan has quit ("leaving").
06:00:06 -!- rutlov has left (?).
06:26:09 <Sgeo> 0x00 0x08 0x01 0x05 0x00 0x00 0x50 0x0A
06:26:46 <Sgeo> ^^ beginnings of an HTTP server
06:27:34 <Sgeo> 0x00 0x08 0x02 0x00 0x0A
06:27:44 <Sgeo> 0x00 0x02 0x11 0x04 0x0A
06:27:58 <Sgeo> 0x00 0x01 0x00 0x0A
06:31:03 <Sgeo> 0x00 0x08 0x01 0x05 0x00 0x00 0x50 0x0A 0x00 0x08 0x02 0x00 0x0A 0x00 0x02 0x11 0x04 0x0A 0x00 0x01 0x00 0x0A
06:42:47 <RodgerTheGreat> hey guys, check it out- I wrote a lisp-derivative bingo card generator in postscript: http://www.nonlogic.org/dump/text/1203316480.html
07:04:41 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:11:23 -!- BMeph has quit ("calls it a night").
10:16:13 -!- olsner has joined.
10:24:10 -!- timotiis has joined.
10:35:07 -!- Corun has joined.
10:54:57 -!- es0n00b has joined.
10:55:16 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
10:55:18 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
10:56:42 <es0n00b> !unlambda ```s``sii`ki``s``s`ks``s``s`ks``s`k`s`kr``s`k`si``s`k`s`k`d````````````.H.e.l.l.o.,. .w.o.r.l.d.!kk`k``s``s`ksk`k.*
10:57:16 <slereah_> Me neither. I don't do well on strict evaluation.
11:01:40 <es0n00b> it was supposed to do an endless loop print of "Hello World!"
11:01:59 <es0n00b> but it's based on unlambdaV3
11:02:12 <es0n00b> (copied from http://www.madore.org/~david/programs/unlambda/#lambda_elim)
11:02:36 <slereah_> Well, EgoBot doesn't like infinite loop much
11:02:36 -!- Corun has quit ("This computer has gone to sleep").
11:03:00 <es0n00b> yeah. just wanted to test egobot's limits
11:05:02 <es0n00b> are all egobots languages obsficated?
11:05:45 <es0n00b> i know esoteric doesnt always mean obsficated (or does it?)
11:05:56 <slereah_> I wonder if it would output something with a random string.
11:06:01 <es0n00b> malbolge is a nightmare from what i've read
11:06:15 <slereah_> Well, the popular languages are mostly turing tarpits.
11:06:39 <slereah_> And they're usually harder to read than write.
11:06:47 <slereah_> !malbolge é(,hjy_én,hju_ç)éj-ué"(èk87"èk876l4k"-k4'7è_4kl7kn7-"-jk4è-l4
11:06:48 <EgoBot> invalid character in source file
11:07:12 <es0n00b> just wondering which is a ?good? one to try and write an interpreter in
11:07:35 <es0n00b> so i could test a prototype language in another language
11:07:54 <es0n00b> (good is hard to define in this sense)
11:09:25 <es0n00b> unlambda has still got me thinking. i just still cant quite get my brain around it
11:09:27 <slereah_> !malbolge (=<`#9]~6ZY32Vw/.R,+Op(L,+k#Gh&}Cdz@aw=;zyKw%ut4Uqp0/mlejihtfrHcbaC2^W\>Z,XW)UTSL53\HGFjW
11:10:11 <es0n00b> unlamba accepts functions, performs functions on them, and returns functions
11:10:26 <slereah_> Well, it also does side effects.
11:11:19 <es0n00b> surely, if unlambda is TC, there exists unlambda functions that will return the derivatives, antiderivatives, and inverses of functions
11:12:01 <es0n00b> i just cant work out how to represent numbers other than natural numbers
11:12:18 <slereah_> Well, you can try to look at the foundation of mathematics.
11:12:47 <es0n00b> i understand thats what unlambda is about- mathematical foundation
11:12:47 <slereah_> For instance, rational numbers can be represented as ordered pairs.
11:12:56 <slereah_> And unlambda has ordered pairs
11:13:37 <es0n00b> i'm just waiting for the flash of inspiration when i understand exactly what S, K and ` do
11:14:14 <olsner> ah, combinatory logic ensnaring yet another wayward soul
11:14:35 <slereah_> It has this simple yet alien beauty
11:14:57 <slereah_> There's nothing much more to get, really.
11:15:15 <slereah_> The thing to understand after that is how to change that into something useful.
11:15:59 <slereah_> An easy one is the conditional.
11:16:14 <slereah_> "True" and "False" can be written as k and `ki
11:16:49 <slereah_> A conditional can be written as ``[condition][A][B]
11:17:05 <es0n00b> ```sabc == ``ac`bc. is this the simplest use of S?
11:17:22 <slereah_> If it's true, it transforms to k, and ``k[A][B] converts to A
11:17:53 <slereah_> False, to `ki, and ```ki[A][B] converts to `iB, to B
11:18:39 <slereah_> So ``[condition][A][B] is "if condition, then A, else B"
11:18:54 <es0n00b> ok, so ```sabc==``ac`bc and ``kab==k define S and K?
11:19:55 <slereah_> Or in lambdas, S = ^abc.(ac)(bc), K = ^ab.a
11:20:06 <es0n00b> wow - i understand what you mean by trying to make something useful out of it
11:21:14 -!- olsner has quit ("Leaving").
11:21:59 <es0n00b> (trying to absorb unlamdba's if-then-else)
11:22:58 <es0n00b> ok -why is k=TRUE, `ki=FALSE?
11:23:54 <slereah_> You could probably work some true-false with something else, but conditionals are easy to do this way.
11:24:05 <slereah_> Logical operator are easy too.
11:24:07 <es0n00b> ok. and what does the I in `kI do?
11:25:03 <slereah_> It's not necessary, since there's also ```skkA = ``kA`kA = A
11:25:21 <es0n00b> (so used to instructions doing things. is it still right to call them instructions, and say that they do thinks? unlambda is beginning to unravel my understanding of the definition of things)
11:26:03 <slereah_> Here's a useful fellow : ``s``si`k`k`ki`kk
11:26:16 <es0n00b> ok. think i got that part. `iA says perform identity function on A, returning identity(A)=A
11:26:41 <slereah_> Returns true for 0, false for something bigger.
11:27:21 <es0n00b> example of "``s``si`k`k`ki`kk" plz?
11:27:52 <slereah_> Well, in Church numerals, 0 is ^fx.x -> ki
11:28:07 <slereah_> So ```s``si`k`k`ki`kkki transforms to k
11:28:36 <slereah_> And 1 = ^fx.fx = (through eta reduction) ^x.x = i
11:28:47 <slereah_> so ```s``si`k`k`ki`kki transforms to ki
11:29:38 <slereah_> 2 would be something like ``s``s`ksk``s``s`ksk`ki according to my abstraction elimination program, so I'll probably stop there
11:30:29 <es0n00b> ok- being able to evaluate x=0 is useful, but evaluating x>0 is more useful
11:31:43 <slereah_> a>b is ``b`b``c`t0k``c``bb``b`b``c`t`k0k``c``bb`c`t``c``bc``b`bc``c``bc``b`bb``cb``b`bttkiii in lazy bird, and it's already quite compressed.
11:31:45 <es0n00b> x=y, x=0, x<0, etc etc can all be derived from x>0 (the basis of OISC type languages)
11:32:46 <slereah_> Well, if I use the a<b (``b`b``c`t0k``c``bb``b`b``c`t`k0k`c`c`t``c``bc``b`bc``c``bc``b`bb``cb``b`bttkii) and apply 0, I get ``b``c`t0k``b``b``c`t`k0k``c`c`t``c``bc``b`bc``c``bc``b`bb``cb``b`bttki0i
11:33:28 <slereah_> Of course, since this is Chuch numerals, it will always be true except for 0.
11:34:40 <es0n00b> its annoying, im only half getting it
11:35:02 <es0n00b> i get the idea of how it can work, but dont understand the mechanics of how it works
11:36:30 <es0n00b> so - it should be possible to compile OISC into unlambda (sort of the definition of both being TC)
11:36:58 <es0n00b> by using the x>0 and if-then-else versions of unlamba
11:37:06 <slereah_> Yes, though probably not pleasant.
11:37:41 <slereah_> You can probably tinker some negative number with some ordered pair <true or false;number>
11:37:54 <es0n00b> the problem would then be trying to find ways of eliminating redundant code
11:37:58 <slereah_> And the operation applied on it will depend on the truth value.
11:39:03 <es0n00b> the idea has been floating around in my head for a few days now, the problem of compiling one Turing tarpit into another tarpit
11:39:18 <slereah_> Well, a simple way is to write first in lambdas, since with lambda calculus, any function f used more than once can be rewritten as (^f.program)function
11:39:35 <slereah_> But lambda calculus doesn't transform to combinators very efficiently
11:43:18 <es0n00b> machine translation if fascinating. like transforming english->japanese->english. good for shits and giggles
11:44:28 <es0n00b> (too many ideas - too little time and skill to implement)
11:45:29 <es0n00b> cant even imagine trig function i unlamba, but i guess they've been explored already??
11:46:44 <es0n00b> thinking of it - even divide seem difficult.
11:47:02 <slereah_> I suppose it's just some iteration of series.
11:47:59 <es0n00b> of course! first, define factorial, then use some recursive version of the Taylor series!
11:48:29 <slereah_> It's usually the standard example for the fixed point combinator.
11:50:14 <es0n00b> ok. know much about the gamma function (related to factorial, but also valid for non-natural numbers)
11:51:11 <slereah_> Well, we don't use it that much in physics.
11:51:29 <es0n00b> http://en.wikipedia.org/wiki/Gamma_function
11:52:22 <es0n00b> how wouyld you define the integral version of gamma in unlamba?
11:53:02 <slereah_> Well, my guess would be that first, you have to define reals.
11:53:47 <slereah_> Although you could probably scratch up something out of rationals and taylor series.
11:54:28 <es0n00b> i worked out a way to define integration by recursion of a function without determining its antiderivative, but it was only valid for bounded integrals
11:54:36 <es0n00b> ie wouldnt apply for gamma
11:55:48 <slereah_> I'd advise to first work on simpler programs.
11:56:09 <slereah_> Unlambda isn't the easiest language in the world.
11:56:33 <slereah_> Also often hard to manipulate, since it's hard to keep tracks of variables
11:56:34 <es0n00b> (just want to dive in and do things - but understand it aint that easy)
11:57:57 <es0n00b> PS: yep. gamma doesnt have an taylor polynomial definition, but there is another non-integral definition that would be an easier approach
11:58:06 <slereah_> I personnaly usually just write my functions in lambda calculus.
11:58:14 <es0n00b> (at least not an EASY taylor definition)
11:58:28 <slereah_> And then converts it to combinators.
11:58:49 <slereah_> I keep a small list of functions, plus numbers from 0 to 100
11:59:27 <slereah_> And then, I try to optimise the functions.
12:00:10 <es0n00b> thats the sort of line of thinking i was having
12:00:26 <slereah_> Usually by letting them run through Lazy Bird (it can prints the expression at each step, so I can pick the shortest), trying to see by hand what it does, or passing it through the JUGGERNAUT
12:00:41 <slereah_> The JUGGERNAUT is a fucking stupid program, but it works.
12:01:03 <slereah_> Well, on a certain class of expressions at least
12:01:04 <es0n00b> read a little about Lazy-Bird. whats that about?
12:01:32 <slereah_> That's my version of unlambda, with lazy evaluation.
12:02:03 <es0n00b> sort of a short-cut version of unlamba?
12:02:39 <es0n00b> (easier to read, not difficult to convert Lbird -> unlambda?)
12:02:59 <slereah_> Well, actually, it's probably not that easy to convert to unlambda
12:03:06 -!- sebbu2 has joined.
12:03:51 <slereah_> The Juggernaut will generate all possible combinators (minus some expressions like `iA, since it's the same as A), try them on a bunch of dummy combinators, and compare the result to the original combinator.
12:04:28 <slereah_> For instance, for some dummy combinator A, ```skkA converts to A, and so does `iA, so it will give that answer.
12:05:15 <slereah_> But stuff like ``uuA converts to `A``uuA, so it won't be able to find equivalents without u's in them.
12:05:48 <slereah_> It's also very fucking slow, but it's useful on small bits of code.
12:06:06 <es0n00b> !unlambda ``s``s`ksk``s``s`kski
12:06:36 <slereah_> Unlambda expressions without output won't give you much results.
12:07:28 <slereah_> !unlambda ``k```.b.u.t.t````.s.t.u.f.f
12:07:58 <es0n00b> guess there are more consise ways of representing large numbers, other than the iterative version like s(s(s(z)))
12:08:22 <slereah_> Large numbers can usually be represented by operations on smaller one.
12:08:42 <slereah_> The most basic is through the successor operator, but there's shorter ways
12:09:03 <slereah_> For instance, http://membres.lycos.fr/bewulf/Russell/Lazy%20Bird/Church%206.txt
12:10:36 <slereah_> The sudden reduction in size of the writing usually corresponds to a power of some numbers
12:10:53 <slereah_> Because the power of a number is the shortest operation.
12:11:33 <slereah_> 256 is very short because it's (2^2)^(2^2)
12:11:36 <es0n00b> (knew powers would have to feature somewhere in the definitions)
12:12:37 <es0n00b> was kind of thinking along the lines of binary is more compact than unary, but other base numbers being more efficient for other nautral numbers
12:12:55 <es0n00b> but your page defines that brilliantly. THX!!
12:13:27 <slereah_> I actually mostly used the Lazy K reference doc on numbers.
12:13:35 <slereah_> Except translated from lambdas to lazy K
12:14:14 <es0n00b> ok. how do i get !unlambda to evaluate and output 256=`m`m``sbi. it's going to return it in unary form, right??
12:14:40 <slereah_> Well, church-to-ASCII is bothersome to write.
12:14:44 <es0n00b> (seems like it's going to be too easy to flood the page)
12:15:29 <es0n00b> sorry. my question wasn't well defined. lets say i wanted to print 256 asterisks??
12:15:31 <slereah_> !unlambda ````b``sb`m``sbi``sbi`d.xi
12:15:32 <EgoBot> ./unlambda/unlambda: file ./tmp/egobot.0kJFuG: parse error
12:15:51 <slereah_> I'll never understand unlambda.
12:16:35 <slereah_> (Birdiest being Lazy bird -> SKI translator)
12:17:23 <es0n00b> (said with my lasiest owl impersonation)
12:18:27 <slereah_> It just replaces b-c-w-... with their sk equivalents.
12:18:41 <slereah_> !unlambda ``````s`ksk``s``s`ksk```s``skk``skk``s``s`ksk``skk``s``s`ksk``skk`d.xi
12:19:00 <slereah_> !unlambda ``````s`ksk``s``s`ksk```s``skk``skk``s``s`ksk``skk``s``s`ksk``skk.xi
12:19:56 -!- sebbu has quit (Connection timed out).
12:20:31 <slereah_> So yes, there's the unary printing.
12:21:15 <es0n00b> !unlamda ```s``s``sii`ki`k.*``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk`k``s`ksk
12:21:20 <es0n00b> !unlambda ```s``s``sii`ki`k.*``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk`k``s`ksk
12:21:40 <es0n00b> (ok - either fibbonacci or crash)
12:22:27 <es0n00b> just copying straight from http://www.madore.org/~david/programs/unlambda/
12:22:47 <es0n00b> but the codes might be for unlambdaV3.0
12:23:15 <es0n00b> so far, none of the codes from that page have worked. at least, not the ones with looping
12:23:26 <es0n00b> your right. egobot might not like infinite loops
12:23:39 <es0n00b> anyway to kill a bad looping process??
12:23:50 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
12:23:52 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
12:24:26 <slereah_> Well, you could either use iterations instead of loop, or you could use v with some conditional.
12:24:46 <es0n00b> ok. time to go to bed. and count sheep. in LAMB-da, of course ;)
12:25:12 <es0n00b> ciao for now. have a good day
12:25:30 -!- es0n00b has quit ("JWIRC applet").
13:44:56 -!- timotiis_ has joined.
13:58:00 -!- timotiis has quit (Read error: 110 (Connection timed out)).
15:07:51 -!- helios24 has joined.
15:09:13 -!- jix has joined.
15:26:21 <Tritonio_> i think they work now... http://inshame.blogspot.com/2008/02/efficient-brainfuck-tables.html
15:47:35 -!- ehird` has joined.
15:48:15 <ehird`> hello, vaguely crazy world
15:48:45 <ehird`> the topic would be clearer with | as the seperator
15:49:21 -!- ehird` has set topic: the international hub for esoteric programming language design and deployment | map: http://www.frappr.com/esolang | forum: http://esolangs.org/forum/ | EgoBot: !help | wiki: http://esolangs.org/wiki/ | logs: http://tunes.org/~nef/logs/esoteric/ or http://ircbrowse.com/channel/esoteric | Pastebin: http://pastebin.ca/.
15:52:25 -!- faxathisia has joined.
15:56:26 <ehird`> does !unlambda not support v3?
15:58:44 <slereah_> Well, since the example used involved infinite loops, I'm not sure that was the problem
16:18:03 <ehird`> pikhq: what's this about tcl virtual what what
16:50:53 -!- RedDak has joined.
17:04:06 -!- RedDak has quit (Remote closed the connection).
17:16:31 <pikhq> ehird`: Tcl has a virtual filesystem layer, allowing one (with the right module) to just attach a file descriptor to http://pikhq.nonlogic.org/wget.b.
17:16:40 <pikhq> Or to a file in a Tclkit. . .
17:17:36 * ehird` is considering writing a cleaner psox
17:17:43 <ehird`> Socks Pee, or something. :-P
17:18:42 <pikhq> (are you at all familiar with Tclkits, Starkits, and Starpacks?)
17:19:13 -!- RedDak has joined.
17:30:58 <pikhq> A Tclkit is a full, complete Tcl setup in one file.
17:31:19 <pikhq> A Starkit is an archiving format for Tcl files. A Tclkit can run one directly.
17:31:26 <pikhq> A Starpack is a Tclkit with a Starkit in it.
17:37:51 -!- RedDak has quit (Remote closed the connection).
17:46:37 -!- RedDak has joined.
17:46:51 <ehird`> "(I should be able to manipulate code as a list)." -- Someone, on Scheme.
17:48:17 <pikhq> [info proc proc_name] returns the code body of a function.
17:50:02 <ehird`> faxathisia: Well, that's what Lisps are known for..
17:50:07 <ehird`> You can manipulate code as a list.
17:57:35 -!- Tritonio_ has quit (Remote closed the connection).
17:57:52 -!- Tritonio_ has joined.
17:58:38 -!- BMeph has joined.
18:00:49 -!- olsner has joined.
18:16:16 -!- Corun has joined.
18:26:38 -!- RedDak has quit (Remote closed the connection).
18:32:07 -!- helios24 has quit ("Leaving").
18:45:08 -!- ais523 has joined.
18:51:17 -!- Endeavour has joined.
18:51:17 -!- Endeavour has left (?).
18:51:18 -!- Endeavour has joined.
18:51:20 -!- Endeavour has quit (Client Quit).
18:52:13 <ehird`> i'll take that to #endeavour
18:55:44 * ais523 has been trying to write code on some buggy hardware
18:56:01 <ais523> although the code was originally in C, I ended up having to edit the assembly by hand to get round the machine code instructions that didn't work
18:56:08 <ais523> and even then it only ran under a debugger...
18:56:33 * slereah_ thinks of : http://www.mini-moto.fr/photo%20jpeg%20bon%20format/buggy%201.jpg
18:56:37 <ais523> hopefully it was just a faulty chip
18:56:49 <ais523> so I've ordered a couple of replacements to see if they work
18:57:50 <ehird`> (Endeavour, btw, is my EgoBot-alike)
18:58:04 <ais523> does it run any esolangs yet?
19:01:01 <ehird`> in tcl due to pikhq's ... uh, total failure to evangelize it
19:01:06 <ehird`> but at least that means it'll be utf-8!
19:05:51 -!- timotiis_ has changed nick to timotiis.
19:10:48 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
19:11:48 -!- slereah_ has joined.
19:29:20 -!- Sgeo has joined.
19:32:52 * ais523 has a new idea for an uncomputable language
19:33:05 <ais523> it's sort of like Prolog, but uses multithreading rather than backtracking
19:33:09 <ais523> with an infinite number of threads
19:33:19 <ais523> it starts with a thread for every possible value of every possible variable
19:33:28 <ais523> and the threads die whenever they reach a contradiction
19:33:37 <ehird`> ais523: you can do that, lazily
19:33:51 <ais523> it's trivial to write the halting problem in it
19:33:54 <ais523> and infinite loops are impossible
19:34:17 <ais523> because it oraclises to tell that the infinite loop would happen
19:34:51 <Sgeo> Oh ehird`, maybe FDs aren't the way to go with a GUI domain, come up with something else?
19:34:57 <oklopol> if it solves *the halting problem*, it's an oracle, if it computes its own halting problem it's an impossible language.
19:35:13 <ais523> it computes its own halting problem
19:35:15 <ehird`> Sgeo: I'm writing soxp, so maybe not best to ask me
19:35:26 <ais523> but the famous impossibility proof for halting fails on it
19:35:31 <ais523> because you can't drive it into an infinite loop
19:35:31 <ehird`> Sgeo: Like psox, but soxp.
19:35:40 <Sgeo> Are you serious?
19:35:49 <ehird`> ais523: I'm pretty sure you can kind of compute that, lazily and non-deterministically
19:36:30 <Sgeo> ehird`, why are you wasting effort on your own version of something that already exists?
19:36:43 <ehird`> Sgeo: because soxp is sane -- so it doesn't exist
19:36:45 <ais523> Russel:-suchthat(X,not(member(X,X))),member(X,X).
19:36:59 <ais523> I thought a while about that one before realising it failed
19:37:01 <ehird`> all esolangs are wasting time pretty much anyway.
19:37:04 <Sgeo> How is PSOX not sane?
19:37:12 <ehird`> Sgeo: Various ways, none of which you acknowledge
19:37:13 <ais523> replacing member(X,X) with not(member(X,X)) also causes it to fail
19:37:22 <ais523> but adding neither, the command succeeds
19:37:23 <Sgeo> ehird`, such as?
19:40:51 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
19:40:59 <ais523> the reasoning: the notion of a set that contains all sets that do not contain themselves is not a contradiction by itself
19:41:11 <ais523> but it is a contradiction to assert either that it contains itself or that it doesn't
19:41:14 <ehird`> russel lists = [not (elem x x) | x <- lists]
19:41:20 <Sgeo> ehird`, so no GUI domain?
19:41:29 <ehird`> Sgeo: soxp will have one.
19:41:51 <Sgeo> PSOX already exists, you know
19:42:08 -!- slereah_ has joined.
19:42:29 <ehird`> russel = filter (\x -> not (elem x x))
19:42:34 <ehird`> doesn't type, of course.
19:42:59 <ais523> in my new idea of a language infinite datatypes are entirely possible and even possibly common
19:43:23 <ehird`> infinite datatype in AwesomeHaskell:
19:43:26 <oklopol> ais523: kinda like in haskell?
19:43:35 <ehird`> oklopol: infinite datatypes are no tpossible in haskell.
19:43:37 <Sgeo> ais523, do you think ehird` should attempt to redo PSOX in what he believes to be a cleaner way?
19:43:38 <ehird`> that's why my thing doesn't type.
19:43:42 <ehird`> that's why the y combinator doesn't type
19:43:50 <ehird`> and sgeo can't come up with opinions for himself without consulting other people.
19:43:52 <ais523> ehird`: Haskell syntax inspired much of the syntax of my new language
19:44:01 <ais523> but it looks more like Prolog because the Prolog syntax is used more often
19:44:09 <ehird`> type InfiniteListType = [InfiniteListType]
19:44:14 <ais523> infinite datatypes ought to be possible anywhere
19:44:14 <Sgeo> ehird`, My opinion is that you shouldn't do it
19:44:23 <ais523> at least anywhere that doesn't care about efficiency
19:44:27 <ehird`> Sgeo: Yes, because god forbid you get competition
19:44:41 <ais523> I still want my t -> t -> t -> t -> ... datatype
19:44:42 <Sgeo> ehird`, it's needless work on your part
19:44:48 <ehird`> thank you, sgeo, for making me see the light. From now on, since you say I shouldn't do it, I won't.
19:44:53 <ais523> so I can write sii in Haskell
19:45:04 <ehird`> type Inf a = a -> Inf a
19:45:37 <ais523> that's easy enough to define in Haskell, only the compilers don't allow it
19:45:47 <ais523> at least not without the constructor
19:45:52 <ais523> and the constructor sort of defeats the point
19:46:15 <ehird`> type Fooer a = (Fooer a -> a)
19:46:15 <ehird`> type YType a = (Fooer a) -> a
19:46:15 <ehird`> y f = (\x -> x x) (\x -> f (x x))
19:46:23 <ehird`> ais523: This is awesomehaskell!
19:46:29 <ais523> infinite types aren't even needed for sii, just the typechecker isn't good enough
19:46:52 <ehird`> type Fooer a = Fooer a -> a
19:46:57 <ehird`> is that even the first argument of y?
19:47:00 <ehird`> It seems like it should be
19:47:01 <ais523> churchnumeral2 x y = x (x y)
19:47:18 * Sgeo wonders how likely/unlikely it is for ehird` to ever complete his soxp
19:47:21 <ais523> then (sii churchnumeral2) has a perfectly well-defined type
19:47:30 <ehird`> Sgeo: Certainly quickly
19:47:33 <ehird`> In fact, I will start a spec now.
19:47:56 <Sgeo> I think I'll work on implementing the Net domain now
19:48:12 <Sgeo> pikhq, does the Net domain really need FTP stuff other than getting from an FTP URL?
19:48:29 <pikhq> Sgeo: That ought to suffice.
19:48:35 <ais523> I wouldn't have thought so
19:48:48 <Sgeo> pikhq, getting from a URL? ok
19:48:50 <pikhq> A more complex FTP client would want to use the TCP stuff, anyways.
19:49:16 <Sgeo> or use a custom FTP domain
19:50:03 <pikhq> Hell, even if ehird creats the world's most awesome API for esolangs, at least Sgeo can claim credit in making the first one that's been fully implemented.
19:50:11 <pikhq> And driving ehird's into existence. ;)
19:52:39 <ehird`> http://pastebin.ca/908860
19:55:27 * ais523 prefers the Sgeo I/O design to the ehird` I/O design
19:55:38 <ais523> but it's a pity that you can't portably have waiting-for-input detection
19:55:50 <ehird`> yes, my io will have a sugar on top of it
19:55:51 <ais523> or maybe you can... I heard somewhere that Windows is POSIX-compatible
19:56:02 <ais523> which would mean that select may be available there after all
19:56:08 <ehird`> my model is cleaner conceptually though
19:56:11 <ehird`> and the sugar will make it even nicer
19:56:17 <ais523> probably with a different name and syntax, knowing Microsoft
19:56:52 <Sgeo> ais523, all I know is that the Python docs for select.select() say that Windows can't do it with files
19:57:09 <ais523> you don't have to do it with files, though
19:57:21 <Sgeo> well, pipes I think I meant
19:57:43 <ais523> select isn't very useful with other types of file-like object
19:57:52 <Sgeo> " Note: File objects on Windows are not acceptable, but sockets are. On Windows, the underlying select() function is provided by the WinSock library, and does not handle file descriptors that don't originate from WinSock.
19:58:00 <Sgeo> http://docs.python.org/lib/module-select.html
19:58:06 <ais523> I've only ever used it with pipes and keyboard/screen stdin/stdout
19:58:21 <ais523> and I wonder whether pipes are implemented with sockets on Windows
19:58:52 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
19:59:06 -!- slereah_ has joined.
19:59:32 <pikhq> ehird`: Would I be correct in assuming you'll simplify the type system?
20:00:01 <ehird`> pikhq: Most definately.
20:00:11 <Sgeo> ehird`, how would it be simplified?
20:00:24 * pikhq should play with that fancy array code
20:00:32 <ehird`> Sgeo: not being ridiculous
20:08:24 <ehird`> lazy lists in 23 lines of simple, readable ruby. cool.
20:09:11 -!- slereah__ has joined.
20:09:30 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
20:10:48 <ehird`> faxathisia: hmm, i was trying to make 'fold' (inject) lazy
20:11:28 <ehird`> ones = LazyList.new(1) {ones}
20:11:50 <ais523> fold can be lazy in one direction
20:11:59 <ehird`> ones.map {|x| puts x} # this actually prints one 1, until you give it tail. heh.
20:12:07 <ais523> although admittedly if you try that it will go into an infinite loop if the list is, in fact, infinite
20:13:17 -!- pikhq_ has joined.
20:13:53 <Sgeo> pikhq_, should I have sockets flush themselves whenever they're written to?
20:14:04 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
20:14:04 <ehird`> def inject(base, &blk)
20:14:04 <ehird`> blk[head, tail.inject(base, &blk)]
20:14:08 <ehird`> think it's worth making that use a thunk?
20:14:31 <ais523> Sgeo: I know you weren't asking me, but I know from experience that some obscure bugs in code I wrote were traceable to not doing that
20:14:49 <Sgeo> ais523, so don't force the client to do it themselves?
20:14:52 <ais523> combine that with the slow speed of most esolangs, and there's no reason not to
20:19:32 <ehird`> ais523: http://pastebin.ca/908906 weird bug with thunks
20:19:45 <ehird`> def method_missing(*args, &blk)
20:19:45 <ehird`> Thunk.new {@block.call.__send__(*args, &blk)}
20:19:49 <ehird`> thus making it return a Thunk
20:19:55 <Sgeo> According to #python sockets aren't buffered, so don't flush
20:19:58 <ehird`> if it type-checks that,
20:20:03 <Sgeo> I am using sendall() though
20:20:07 <ehird`> then it should go through method_missing, and getting it properly
20:20:13 <ehird`> it uses the internal ruby c api to do it
20:20:28 <ais523> Sgeo: so in otherwords even the Python devs thought autoflush was a good idea
20:23:59 <ehird`> one thing i wish ruby had was to_b
20:24:04 <ehird`> definable boolean coercion
20:24:41 <ais523> in C++ it would be your_class_name_here::operator(bool)
20:24:52 <ais523> you overload the cast operator
20:25:33 <ehird`> but, can you do this in C++:
20:25:39 <ehird`> class TrueClass; def to_b; false; end end
20:25:46 <ehird`> class FalseClass; def to_b; true end end
20:26:07 <ehird`> ais523: true.is_a? TrueClass
20:26:23 <ehird`> (ok, admittedly since TrueClass/FalseClass instances (aka true & false) would be handled primitively, that would do nothing, but :))
20:26:33 <ais523> class TrueClass{public: bool operator(bool){return false;}};
20:27:08 <ehird`> ais523: but true isn't a trueclass in c++...
20:27:22 <ehird`> that ruby changes the meaning of true and false
20:27:22 <ehird`> though, as my note says, tahat wouldn't actually work
20:27:32 <ais523> in C++ you have to know which type each object is at all times
20:27:40 <ais523> but you could create a constructor that constructed it from true
20:27:53 <ais523> thus allowing true to be casted into a TrueClass
20:28:03 <ehird`> yes... but true IS a trueclass, in ruby
20:28:05 <ais523> you could even have it throw an exception if you wrote (TrueClass)false...
20:28:08 <ehird`> true is a regular object
20:28:10 <ehird`> an instance of TrueClass
20:28:18 <ais523> ehird`: what if you have two TrueClasses
20:28:24 <ais523> with different member functions
20:28:29 <ehird`> there's only one TrueClass
20:28:49 <ehird`> this is how e.g. you can extend Array and stuff in ruby
20:28:56 <ehird`> can be used for evil, but it can also be used for very cool things
20:29:16 <ais523> who was it who went and created C++ that looked like Lisp by overloading most of the operators?
20:29:26 <ais523> I think it was someone in #esoteric, but I can't remember who
20:29:34 <ehird`> but, basically, mine reverses the truth values, but of course if ruby actually checked to_b for true/falseclass, it would be an infinite regress, so it wouldn't
20:29:57 <oklopol> he's done a lot of weird shit in c++
20:29:59 <ais523> oklopol: that rings a bell
20:33:00 <ehird`> the only thing hideously broken about ruby
20:33:09 <Sgeo> 0x00 0x08 0x00 implemented!
20:33:16 <ehird`> x = 2; something_taking_a_block {|x| ...}; x => the value in the block
20:33:19 <ehird`> this is being fixed for 1.9
20:33:24 <ehird`> as well as huge speed improvements with the new vm
20:43:46 -!- pikhq_ has changed nick to pikhq.
20:46:53 <ehird`> I can't make 'inject' lazy..
20:46:58 <ehird`> because the only way is basically this:
20:47:04 * Sgeo wonders if FBF will support PSOX
20:47:16 <ehird`> def inject(base, &blk)
20:47:16 <ehird`> blk[head, (magic thunkify: tail.inject(base, &blk))]; end
20:47:23 <ehird`> but the magic thunkify is basically impossible
20:47:32 <ehird`> because you can't make it be a truly transparent proxy
20:48:29 <ais523> Sgeo: how can I checkout the PSOX repo?
20:48:30 <Sgeo> ais523, svn co http://svn2.assembla.com/svn/psox/trunk
20:48:41 <Sgeo> or svn co http://svn2.assembla.com/svn/psox
20:48:49 <Sgeo> If you want the branches and tags and stuff
20:48:59 <Sgeo> Probably unneeded
20:50:07 <olsner> heh, esolangs embedded in C++ through operator overloading sounds interesting
20:50:49 * ais523 is thinking about writing an INTERCAL library to make use of PSOX
20:51:38 <ais523> there are already libraries for other things
20:51:45 <ais523> including infamously floating-point arithmetic
20:52:18 <Sgeo> There's no floating-point in PSOX :/
20:52:32 * Sgeo wonders if floating-point will be in ehird`'s SOXP
20:52:49 <Sgeo> But yeah, support PSOX before even considering SOXP please
20:53:03 <Sgeo> Well, nothing can support SOXP yet so there =P
20:54:20 <Sgeo> pikhq, once I implement domain 0x08, are you going to write some stuff to test it?
20:54:54 <ais523> "Conformance with widely-accepted standards was not considered to be a priority for an INTERCAL library. (The fact that the general format conforms to IEEE at all is due to sheer pragmatism.)"
20:55:27 <ais523> there's also a note stating that pi is represented as #571$#35133
20:55:45 * ais523 is amused at the way that their client assumes that INTERCAL constants are IRC channels
20:56:15 * Sgeo goes to the official INTERCAL PI channel
20:57:15 <ehird`> '<Sgeo> But yeah, support PSOX before even considering SOXP please' you realise how stupid this sounds
20:57:29 <ehird`> 'Hello! Everyone ignore Elliott's project, it upsets me. Use PSOX, it's so much better!!!'
20:57:42 <Sgeo> For one, PSOX currently exists >.>
20:58:00 <ehird`> it didn't for an awful long time, I add.
20:58:05 <GregorR> For two, double-u tee ef is SOXP?
20:58:21 * GregorR already regrets asking that.
20:58:35 <Sgeo> SOXP is ehird`'s hypothetical redoing of PSOX, in a supposedly cleaner way
20:58:43 <ehird`> GregorR: Hmm - you're right, it needs an acronym expansion. SOXP Only eXceeds PSOX
20:59:11 <Sgeo> Hey, PSOX doesn't get an ancronym expansion, its name is historical
20:59:50 <ehird`> Yes, SOXP is better than PSOX in that way too.
21:06:31 -!- oerjan has joined.
21:08:09 <Sgeo> please leave logs to learn about ehird`'s latest copycat insanity </bitterness>
21:08:33 <Sgeo> not leave, read
21:08:50 <Sgeo> lol faxathisia
21:08:54 <ais523> maybe I should write something called SPOX
21:09:03 <ais523> which has nothing to do with PSOX, OXPS, SOXP, etc., apart from the name
21:09:03 <ehird`> 'I AM SO EMOTIONALLY HURT ABOUT SOMEONE DECIDING TO DO SOMETHING SIMILAR TO MY PROJECT THAT I WILL MAKE STUPID COMMENTS ABOUT IT TO EVERYONE TO REAFFIRM PSOX'S AWESOMENESS'
21:09:21 <ais523> who's is/was PESOIX, by the way?
21:09:31 <Sgeo> ais523, calamari
21:09:46 <Sgeo> Calamari was involved somehow
21:11:02 <oerjan> clearly the time is overdue for PSUX
21:11:54 <Sgeo> Does anyone other than ehird` honestly see a point for SOXP?
21:12:31 <ehird`> 'Does anyone other than Sgeo honestly see a point for PSOX? I mean, we have PESOIX and EsoAPI' <-- past people
21:12:43 <faxathisia> the better you make PSOX the worse SOXP is gonna look..
21:12:58 <ais523> I'd sort of remembered EsoAPI, but only vaguely, so couldn't remember the name
21:13:06 <oerjan> Sgeo: that'll teach you try and make others interested in your projects! :D
21:13:12 <ehird`> right now it just looks like he's insecure about someone thinking PSOX is something other than perfect. So he's stifiling any innovation, because it's not his.
21:13:42 <oerjan> ah yes competition is good, say the free-wheelers, er market people
21:13:58 <oklopol> Sgeo: just accept it, ehird`'s only way to get interested is to take your idea and make it good
21:14:34 <oklopol> i'm still waiting for ehirdphica :<
21:15:01 * faxathisia wonders how to get ehird` interested in my broken thingymajig
21:15:05 <ehird`> faxathisia: what thingy
21:15:30 <Sgeo> oklopol, what's ehirdphica?
21:15:36 <faxathisia> ehird`: Hard to say what's broken.. It's either the self interpreter from the paper, my compiler or my interpreter
21:16:06 <oklopol> graphica never rose that much interest, except for faxathisia, the official non-tc lang enthusiasist
21:16:06 <faxathisia> ehird`: but anyway, something doesn't work.. so I can't run the Janus self interpreter
21:16:40 <ais523> faxathisia: if that's an esolang, could you put a stub with a link on the wiki so I can take a look?
21:17:04 <faxathisia> I'm not 100% sure but I think it's an esolang
21:17:19 <faxathisia> It's kind of minimal and every program is reversible
21:17:24 * Sgeo wonders if perhaps a layer could be made between a SOXP client and a PSOX server to make them work together.. or the other way around..
21:17:58 <oklopol> Sgeo: ehirdphica was what ehird would turn graphica into, naturally.
21:18:01 <ehird`> >> ones.dump_to($stdout)
21:18:01 <ehird`> lazy(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
21:18:26 -!- sebbu2 has changed nick to sebbu.
21:25:29 <ehird`> ais523: anyone: ones = lazy(1) { ones } # comments on this syntax?
21:25:51 * ais523 doesn't really know Ruby
21:26:22 <ehird`> foo = lazy(1,2,3) { foo }
21:26:27 <ehird`> for [1,2,3,1,2,3,1,2,3,1,2,3,...]
21:26:40 * ais523 likes the way lists are implemented in Unlambda
21:26:42 <ehird`> faxathisia: ah. i can make both head and tail lazy if you want, but then it's LazyMegaThing, not LazyList
21:26:49 <ais523> and my most usual Underload implementation works a similar way
21:27:00 <ehird`> this is meant to fit into ruby well...
21:27:10 <oerjan> ais523: there are many options for implementing lists in Unlambda
21:27:24 <ehird`> faxathisia: you can even print it infinitely like in haskell
21:27:30 <ehird`> though not via 'inspect' since that returns a string
21:27:34 <oklopol> oerjan: infinitely many, perhaps?
21:27:40 <ais523> oerjan: the one I know is where the list returns its head when applied to one function and its tail when applied to another
21:27:52 <ehird`> foo = lazy(1,2,3) { foo }; foo.map {|x| x+2}.dump_to(STDOUT)
21:27:59 <oklopol> yeah, that was quite an underestimate
21:28:00 <ehird`> lazy(1,2,3,1,2,3,1,2,3,...
21:30:32 <Sgeo> With the Net::urlget function, should I attempt to return the HTTP status code, or don't bother?
21:30:50 <Sgeo> Since it might not even be an HTTP url..
21:34:53 <Sgeo> pikhq, changes committed. Want to test sockets?
21:35:30 <ehird`> is pikhq your testing dummy or something
21:36:54 <pikhq> Gotta finish off homework. ;)
21:41:45 -!- ais523 has quit ("bye everyone").
21:43:02 -!- slereah_ has joined.
21:44:24 -!- slereah__ has quit (Read error: 110 (Connection timed out)).
21:45:11 <Sgeo> It is now fully possible to write a multi-threaded HTTP Server in Brainfork
21:45:26 <Sgeo> Well, except for the lack of File access, sorry
21:45:30 <pikhq> A. . . Multithreaded server?
21:45:42 <ehird`> Besides, fork() isn't threads.
21:45:58 <ehird`> faxathisia: Brain*fork*.
21:46:21 <ehird`> Anyway, Sgeo, that's like saying
21:46:27 <ehird`> "Brainfork multithreaded http server: ''"
21:46:34 <ehird`> "With my MagicalServerEnabler filter."
21:46:45 <ehird`> Anyway, multi-threaded servers suck. You want async io.
21:47:41 <Sgeo> Actually, with the way PSOX works, it would probably make more sense not to use forking, really
21:55:10 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
21:55:19 <Sgeo> Hm, ehird`, idea for SOXP: Support threads, e.g. have each thread, when issuing a SOXP command, print out a byte indicating the thread first
21:55:45 <ehird`> i would comment on how that accomplishes nothing at all
21:55:49 <ehird`> but instead i'll just laugh a bit
21:56:16 -!- slereah_ has joined.
21:56:36 <faxathisia> It's just that only VM processes are parallel, you don't get extra parallelism in the language
21:56:55 <Sgeo> faxathisia, you could use brainfork
21:57:09 <Sgeo> Except you'd need to make sure that only one thread issues a command at a time, I guess
21:57:14 <Sgeo> So that's very meh
21:58:05 <Sgeo> Well, going to watch Seinfeld/take care of books for an hour
22:07:52 -!- jix has quit ("CommandQ").
22:11:48 -!- slereah__ has joined.
22:21:09 -!- slereah__ has quit (Read error: 104 (Connection reset by peer)).
22:27:40 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
22:29:51 -!- Corun has changed nick to Corun|pants.
22:37:08 -!- slereah__ has joined.
22:44:23 -!- slereah__ has quit (Read error: 104 (Connection reset by peer)).
22:46:40 -!- slereah__ has joined.
22:51:48 -!- slereah_ has joined.
22:54:10 -!- slereah__ has quit (Read error: 104 (Connection reset by peer)).
23:00:34 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
23:02:37 <Sgeo> Did I miss anything.. wow absolutely notjing
23:02:55 <Sgeo> Can we start talking about PSOX and SOXP again/
23:04:13 -!- slereah_ has joined.
23:07:15 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
23:07:23 -!- olsner has quit ("Leaving").
23:16:16 -!- faxathisia has quit (Remote closed the connection).
23:23:42 -!- slereah_ has joined.
23:24:38 -!- slereah_ has quit (Remote closed the connection).
23:38:02 -!- slereah_ has joined.
23:51:21 -!- BrainF has joined.
23:51:21 -!- BrainF has quit (Client Quit).
23:51:43 -!- BrainF has joined.
23:51:43 -!- BrainF has quit (Client Quit).
23:51:58 <Sgeo> WHY is it just saying Hi?
23:53:37 -!- BrainF has joined.
23:53:37 <BrainF> Hi all. I wrote this BF program with the help of a horrible horrible generator I wrote.
23:53:37 -!- BrainF has quit (Client Quit).
23:53:51 <slereah_> Looks like that generator is really horrible!
23:54:05 <Sgeo> Want to see the code for the generator?
23:54:19 <Sgeo> Better yet: The generated code
23:55:35 <Sgeo> http://pastebin.ca/909224
23:56:52 <Sgeo> It was generated
23:57:04 <Sgeo> http://pastebin.ca/909227
23:57:44 <Sgeo> That was the script
23:58:05 <Sgeo> http://pastebin.ca/909228 is the generator
23:58:11 <slereah_> Do you think we're lacking newcomers?
23:58:18 <slereah_> So you're building them yourself?
23:59:05 <Sgeo> Just wanted to test/demonstrate sockets from PSOX