00:01:46 <ehird`> bsmnhttp://en.wikipedia.org/wiki/Symmetric_monoidal_category
00:01:53 <ehird`> bsmntbombdood: http://en.wikipedia.org/wiki/Symmetric_monoidal_category
00:01:59 -!- ehird` has quit (Remote closed the connection).
00:02:12 -!- ehird` has joined.
00:03:03 <oerjan> ehird`: i strongly doubt those pi-calculus people meant anything that advanced :D
00:03:31 <ihope> I should study it eventually.
00:03:50 <ihope> And gauge theory, which is oh-so-important for particle physics. At least, it seems important.
00:08:24 -!- jix has quit ("CommandQ").
00:33:55 -!- Sgeo has joined.
00:36:42 * Sgeo pokes ihope, oerjan oklopol
00:36:55 <ihope> Who's oerjan oklopol?
00:36:59 <ihope> Or is oerjan the new and?
00:37:24 <oerjan> well, if bsmntbombdood is xor...
00:37:39 <Sgeo> I'm completely redoing PSOX
00:41:27 <Sgeo> Anyone going to ask me why?
00:42:13 <pikhq> Sgeo: Self-whoring.
00:43:23 <Sgeo> As far as I can tell, it would be near-impossible for the server to determine when the client is requesting input..
00:45:17 -!- ehird` has quit.
00:45:22 <Sgeo> The system domain is moving to 0x02
00:45:29 <Sgeo> 0x00 and 0x01 will be special cased
00:45:44 <Sgeo> 0x00 0x00 is 'print next character safely'
00:45:55 <Sgeo> and does not require a 0x0A after it
00:46:39 <Sgeo> 0x00 0x01 will be for input
00:46:46 * Sgeo gets to writing the revised specs
00:52:10 -!- oerjan has quit ("Good night").
01:00:54 -!- RedDak has quit (Read error: 113 (No route to host)).
01:40:00 -!- sebbu has quit ("@+").
02:00:45 <Sgeo> BRB then I'll start writing the new specs for real
02:00:59 <pikhq> (x){x(x)}((x){x(x)})
02:01:29 <pikhq> No, the equivalent is \x.xx \x.xx
02:24:27 <ihope> And suddenly, I wonder why I've been writing (\x.xx)(\x.xx) instead of (\x.xx)\x.xx... or have I? :-P
02:29:58 <bsmntbombdood> lambda calculus is so easy to understand, why not pi?
02:33:49 <ihope> Because it's different?
02:33:54 <ihope> Go learn gauge theory instead!
02:34:32 <ihope> Or get a parallel text description of pi calculus.
02:34:50 <ihope> Formal on one side, intuitive on the other.
02:35:09 <Sgeo> bleh at input function
02:35:47 <Sgeo> `,` won't be enough to get input in PSOX anymore
02:35:58 <Sgeo> ^^main point of the revisions
02:38:01 * Sgeo was thinking something like `[-].+..+++++++++.,` would be a (naive) replacement, but it won't
02:38:23 <Sgeo> There will be a newline that will need to be discarded after the ,'
02:39:32 <Sgeo> well, it would be `[-].+..+++++++++.,,,` then an extraneous newline
02:39:48 * Sgeo pokes ihope and pikhq and people
02:41:27 <pikhq> That's *remarkably* bad.
02:41:55 <Sgeo> The PSOX server needs to be told somehow to get input
02:42:01 <Sgeo> to give to the client
02:42:48 <Sgeo> Would taking away a `,` or two help at all?
02:43:30 <Sgeo> Incidentally, that wouldn't be needed for every `,`, only for people who like Search&Replace and are basically idiots
02:44:44 <Sgeo> might it help if I said that it's sending (0x00 0x01 (input function) 0x01 (number of bytes) 0x0A (newline)) and returning (EOF status) (number of successful bytes) (the byte) (newline)?
03:09:55 <Sgeo> pikhq, http://sgeo.diagonalfish.net/esoteric/psox.txt
03:10:00 <Sgeo> see under Pseudodomains
03:11:05 <Sgeo> and oklopol and GregorR and ihope and and and
03:21:06 <Sgeo> ihope, pikhq EgoBot GregorR ?
03:30:42 * Sgeo watches tumbleweeds float bye
03:31:46 * pikhq joins the tumbleweeds
03:32:48 -!- Tritonio has quit (Remote closed the connection).
03:34:03 <Sgeo> pikhq, any comments?
04:23:50 * Sgeo enters that channel
04:24:00 * Sgeo pokes pikhq and ihope and and and
04:38:20 -!- rutlov has joined.
04:46:20 -!- rutlov has left (?).
05:37:14 -!- catron has joined.
05:37:54 <Sgeo> http://sgeo.diagonalfish.net/esoteric/psox.txt
05:40:17 -!- calamari has joined.
05:41:47 <Sgeo> calamari, you're the PESOIX person?
05:42:08 <calamari> I was working on an implementation of it
05:42:23 <pikhq> He designed the precursor to PESOIX, IIRC.
05:42:25 <Sgeo> Integrated with a BF interpreter?
05:42:56 <Sgeo> Because if it was separate, I'd really like to know how it was done
05:43:18 <calamari> I couldn't get the piping to work correctly, so the project got stuck
05:43:45 <Sgeo> couldn't determine when the BF interpreter or whatever wanted input?
05:43:49 <calamari> ESO api was implemented as a 512-byte x86 boot sector
05:44:07 <calamari> Sgeo: yeah it buffers stuff and messes it all up
05:44:14 <Sgeo> buffers stuff?
05:44:30 <Sgeo> Is it possible to find out when a program is requesting input?
05:44:34 <Sgeo> Or is that meaningless?
05:44:45 <Sgeo> calamari, how?
05:45:04 <pikhq> The oft-broached idea of the Brainfuck OS. . .
05:45:29 <Sgeo> calamari, how do I determine when the program requests input?
05:45:34 <pikhq> calamari: Excuse me, I may be using odd vocabulary ATM.
05:45:47 <pikhq> My brain is getting shot by it being 11. . .
05:45:57 <pikhq> And me having woken up at 5:20 today.
05:45:59 <Sgeo> It's 12:45AM here..
05:46:08 <Sgeo> calamari, how?
05:46:19 <calamari> pikhq: nah my vocabulary is just smaller it seems
05:46:41 <calamari> Sgeo: I don't remember all the details anymore.. that was a long time ago
05:46:50 <Sgeo> For the buffering issue, I just sticked newlines everywhere
05:47:08 <calamari> Sgeo: I was trying to do it so that interpreters wouldn't need to be modified
05:47:10 <Sgeo> But that doesn't help me know when the program is requesting stuff on stdin
05:47:11 <pikhq> (transitive) (figuratively) To begin discussion about (something).
05:47:14 <Sgeo> calamari, same here
05:47:37 <Sgeo> although I'm thinking about my own spec, PSOX
05:47:42 <pikhq> Guess I was using valid verbiage, even at this time of night.
05:47:58 <pikhq> calamari: Let me just say that PSOX seems to be a sanely-done PESOIX for the most part.
05:48:08 <Sgeo> pikhq, did you see the changes?
05:48:10 <calamari> pikhq: yeah .. I looked it up in my paperback dict
05:48:24 <pikhq> (although I need to look at the spec when I feel more ready & awake for programmatical thought)
05:48:43 * Sgeo made it so that the BF program needs to send a command in order to receive input
05:48:49 <calamari> anyhow, after all the bf os talk, I seem to be so far the only one who has actually done anything about it.. that I am aware of anyhow
05:49:12 <Sgeo> because I can't seem to work out how to detect when something requests stuff on stdin
05:49:20 * pikhq notes that calamari missed out on PEBBLEversary. :p
05:49:24 <Sgeo> http://sgeo.diagonalfish.net/esoteric/psox.txt
05:49:42 <Sgeo> (new version, with a bit of strangeness due to copy&paste goodness
05:50:04 <Sgeo> http://sgeo.diagonalfish.net/esoteric/psox-old.txt is without the send-a-command-to-get-input thing
05:50:43 * Sgeo pokes calamari to those URLs
05:51:13 <Sgeo> hm, the "To map a longname (e.g. "http://example.com/longname") to
05:51:13 <Sgeo> an odd shortname (e.g. 0x03):" thing is a bit dated
05:51:16 <pikhq> I don't like the idea of needing a PSOX command to get something from stdin. . .
05:51:44 <Sgeo> If there's a better way to do it, like knowing when the client requests data from stdin, I'm all for it
05:51:56 <Sgeo> But if there isn't..
05:52:02 <pikhq> It makes it exceptionally hard to get PEBBLE to work with PSOX.
05:52:21 <pikhq> calamari: One year of PEBBLE development.
05:52:40 <pikhq> Sgeo: I was thinking about having PSOX just be supported via some additional macros. . .
05:52:58 <Sgeo> couldn't an input macro output some stuff too?
05:53:12 <pikhq> "input" is a builtin.
05:53:25 <Sgeo> make a p_input macro
05:53:45 <pikhq> calamari: BFM got renamed to PEBBLE.
05:53:54 <pikhq> A few months ago. ;)
05:54:06 <pikhq> Sgeo: Removing source-compatibility.
05:54:36 <Sgeo> pikhq, eh? Programs not written for PSOX don't need to be compatible with PSOX
05:54:59 <pikhq> A program written for PEBBLE should work regardless of the target language.
05:55:01 <Sgeo> If PSOX-Init isn't the first thing output, PSOX ignores it
05:55:16 <pikhq> (unless it uses a language-specific feature)
05:55:38 <Sgeo> PEBBLE programs that don't output PSOX-Init will still work
05:55:45 <Sgeo> Same thing that PESOIX does
05:55:51 <pikhq> You don't seem to get the point. . .
05:56:11 <pikhq> I want the same PEBBLE input to work regardless of whether it targets Brainfuck or PSOX+Brainfuck.
05:56:44 <pikhq> I want to be able to just plug in PFUCK and PSOX-specific versions of the PEBBLE macros and get a program taking advantage of PSOX.
05:57:09 <Sgeo> ..That's meaningless. If it uses no PSOX features, then it just targets BF
05:57:26 * pikhq beats Sgeo for being clueless
05:57:41 <pikhq> The PSOX-specific versions of PEBBLE macros could well be using PSOX features.
05:58:18 <pikhq> I don't want to rewrite *every single PEBBLE program* to be able to take advantage of features added by PSOX, when I could just rewrite the PEBBLE stdlib instead.
05:58:24 <Sgeo> So if it wants to take advantage of PSOX then it needs to emit PSOX-Init at the beginning anyway, and be written for PSOX
05:58:38 * pikhq beats Sgeo some more.
05:59:26 <Sgeo> So instead of having to replace stuff, you just want to be able to add PSOX stuff in, and not worry about s/input/p_input/?
06:00:20 <Sgeo> Memo me if you can solve the pipes problem
06:00:26 <pikhq> Now, an easy way to tell whether a program wants to read a return code. . . If there is a return value that has not been read, put that into stdin.
06:01:25 <pikhq> read_from_stdin(){if(return_code_not_read()) putchar (return code); else putchar (getchar());}
06:01:52 <Sgeo> What's return_code_not_read()?
06:02:29 <pikhq> A chunk of psuedocode?
06:02:32 <Sgeo> Imean, how does it work?
06:02:56 <Sgeo> I guess, if the stdin pipe or whatever holds a readable queue..
06:03:04 <pikhq> If there's something returned from a PSOX function that hasn't been received yet, it returns true. Otherwise, it returns false. . .
06:03:19 <Sgeo> Can I tell if it's been received yet?
06:03:31 <pikhq> Imagine that you've got a queue into which PSOX function return values are put into.
06:04:08 <pikhq> You pop from that when reading a return code. . . If the queue is empty, everything has been received by the program.
06:04:31 <Sgeo> How do I know that the client wants to read anything?
06:04:37 <Sgeo> and thus to pop something?
06:05:53 <pikhq> Easier solution: just always put return values to the program's stdin, and take advantage of file-stream buffering.
06:06:18 <Sgeo> file-stream buffering?
06:06:55 <Sgeo> How could I take advantage of that like that?
06:06:58 <pikhq> Ignore my "easier solution"'s explanation.
06:07:39 <pikhq> In that pipe (as with any other pipe), cat won't output everything at once. When it outputs something, the output function makes it halt until bar reads from its stdin.
06:08:00 <Sgeo> How does it do that? That's what I need
06:08:17 <pikhq> It does that via the magic of Unix.
06:08:23 <Sgeo> ..I mean, unless it's really putting things into a stdin queue for bar..
06:08:30 <Sgeo> pikhq, can I hook into it easily?
06:08:45 <pikhq> Just set up a pipe; it's a fairly mundane part of the POSIX API.
06:09:07 <Sgeo> But I need to know WHEN bar requests input
06:09:17 <Sgeo> Before or after bar outputted some command..
06:10:08 * pikhq beats his head into the desk
06:11:39 <pikhq> If there is anything on PSOX-interp's stdin, put that into PSOX-program's stdin. Then, if a command is executed, put that command's result to PSOX-program's stdin.
06:11:45 <pikhq> There, your algorithm.
06:12:45 <Sgeo> Memo me with any more thoughts
06:12:53 -!- Sgeo has quit ("Ex-Chat").
06:26:20 -!- catron has left (?).
06:56:41 -!- g4lt-mordant has changed nick to g4lt-xperienced.
06:56:48 -!- g4lt-xperienced has changed nick to g4lt-eexperience.
06:57:16 -!- g4lt-eexperience has changed nick to g4lt-experienced.
07:27:58 -!- calamari has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:06:23 -!- sebbu has joined.
09:47:19 -!- RedDak has joined.
11:04:11 -!- oerjan has joined.
11:38:24 -!- jix has joined.
13:07:09 -!- ehird`_ has joined.
13:38:07 <oerjan> that IS the NATURELLE CONCLUSION
13:38:38 <ehird`_> i like the NATURALLE CONCLUSION
13:40:00 <ehird`_> how about or = GregorR, not = ihope
13:43:25 <ehird`_> since they have no "real" value
13:43:58 <ehird`_> Sukoshi oerjan bsmnt_bot Sukoshi pikhq RodgerTheGreat cmeme
13:45:00 <ehird`_> if i have got the notation right, that is Q and ( Q implies P )
13:47:15 <ehird`_> ihope bsmnt_bot RodgerTheGreat oerjan ihope RodgerTheGreat cmeme
14:20:17 -!- RedDak has quit (Remote closed the connection).
14:33:54 -!- oerjan has quit ("Dinner").
14:50:47 -!- jix has quit (Nick collision from services.).
14:50:59 -!- jix has joined.
15:18:46 <ehird`_> i wouldn't trust you to operate on anyone, RodgerTheGreat
15:22:08 <ehird`_> speaking of esoteric thinsg,
15:22:37 <ehird`_> does a Python-based music programming software count?
15:22:50 <ehird`_> here's the "official" lowdown on what that actually means:
15:22:51 <ehird`_> "The idea is that you have various instruments - which are (suprise suprise) Python classes, and you write some code using a library which takes some input parameters, does something (Runs a cellular automata? Generates a sine wave? Distorts a sample in some way?) and returns some audio. Now, for each track in the application you write code to call the various instruments, and the track's volume etc. plus you can write a sort of middle
15:22:58 <ehird`_> (did that all get through?)
15:23:58 <ehird`_> ware for a whole track which will apply to all audio played on it. Then it just mixes it together and produces the track."
15:26:02 <RodgerTheGreat> would the "track" ultimately sound musical or consist of usable binary data of some kind (or both, via some odd interlacing method or somesuch?)
15:26:31 <ehird`_> you write the instruments and arrange them, after all
15:26:43 <ehird`_> but that's just a frontend (exporting or playing back etc)
15:27:18 <ehird`_> probably i'd just code it so it can play the track back or export to .wav/PCM
15:27:24 <ehird`_> two most common operations i'd say
15:31:27 <RodgerTheGreat> this one actually seems pretty useful, but I'm still tweaking the syntax a bit
15:31:52 <RodgerTheGreat> it has recursion, something akin to function pointers and some other nifty stuff
15:33:46 <ehird`_> i think i'll implement a first prototype of that music software
15:33:50 <ehird`_> as soon as i find an audio lib for python
15:34:04 <ehird`_> something that can generate tones (sine waves, etc) but can also modify samples
15:34:17 <ehird`_> (preferably everything from adding and removing single samples to changing the volume, etc)
15:34:29 <ehird`_> but pygame isn't that fun :p
15:34:31 <RodgerTheGreat> I got the impression audio synth and the like are pretty easy in SDL
15:35:21 <ehird`_> its not really an audio synth though is it?
15:35:33 <ehird`_> it's just something that can morph and generate sounds
15:36:26 <RodgerTheGreat> well, that involves exactly the same kind of stuff, at the end of the day
15:57:19 <ehird`_> hm, i wonder how i should implement the middleware
15:57:41 -!- Sgeo has joined.
15:58:46 <ehird`_> RodgerTheGreat: have any ideas how i could implement the middleware functionality?
15:59:40 <RodgerTheGreat> would it just be a data structure for music that calls "instruments" in sequence, or what?
15:59:49 <ehird`_> the idea, of course, is that you could hook up the "reverb" middleware to an instance of the "echo" middleware which is given the current track
16:00:11 <ehird`_> Reverb.apply(Echo.apply(self))
16:00:23 <ehird`_> tracks would probably just be a special case of middleware
16:00:37 <ehird`_> maybe Reverb(settings).apply(Echo(settings).apply(self))
16:02:01 <ehird`_> hm, no, that wouldn't be good
16:02:24 <ehird`_> echo.apply(Reverb(settings))
16:02:48 <ehird`_> so middleware.apply(other_middleware) morphs middleware to have other_middleware in it
16:03:51 <ehird`_> does that sound like a good way, RodgerTheGreat?
16:04:26 <ehird`_> i'll write a full sort of example
16:07:52 <Sgeo> and GregorR and ihope for good measure
16:10:36 <Sgeo> Why is it that it seems no one cares?
16:12:22 <ehird`_> Sgeo: because people do other things than talk about psox
16:13:57 <Sgeo> pikhq, re: your idea, couldn't it cause a race condition or something? Or at least cause problems with users entering stuff before the program asks for it?
16:15:00 <Sgeo> The user would need to correctly be able to determine that the program wants input, and not provide too much, I think
16:15:13 <Sgeo> Unless the program had to scroll pass newlines maybe?
16:15:19 * Sgeo is not fully coherent right now
16:16:05 <ehird`_> nonlogic dump is the official pastebin of here isn't it?
16:16:28 <ehird`_> RodgerTheGreat: http://nonlogic.org/dump/text/1189264162.html here's a kind of example
16:16:39 <ehird`_> the newlines doubled up randomly in that paste o_O
16:22:39 <pikhq> Sgeo: Hmm. That actually is a bit tricky.
16:23:39 <Sgeo> Incidentally, is output a builtin in PEBBLE?
16:24:04 <ehird`_> it DOES compile to brainfuck...
16:24:30 <Sgeo> So then in any spec, output would need to be changed, or a p_output made..
16:25:26 <Sgeo> How is making a p_output different from requiring a p_input? Not that I wouldn't like a nice solution to the pipes problem that lets input be `,` mind you
16:33:37 * Sgeo pokes pikhq, then goes AFK
18:01:38 <pikhq> I might be able to get stuff to work in PEBBLE. . .
18:01:56 <pikhq> New PEBBLE-specific pass.
18:03:01 <pikhq> Provide the p_input, p_output, and p_string commands, which will output via just "," and ".", rather than the in and out macros, which will call the PESOIX functions.
18:06:19 -!- sebbu2 has joined.
18:08:19 -!- g4lt-experienced has changed nick to g4lt-mordant.
18:13:34 -!- sebbu has quit (Nick collision from services.).
18:13:37 -!- sebbu2 has changed nick to sebbu.
18:39:16 -!- KajirBot has joined.
18:40:25 -!- KajirBot has quit (Remote closed the connection).
18:41:12 -!- jix has quit ("This computer has gone to sleep").
18:42:51 -!- ehird`_ has changed nick to ehird`.
19:08:27 <Sgeo> pikhq, you mean PSOX?
19:11:35 * Sgeo is here only for a few min right now
19:11:42 <Sgeo> I'll be back laterish maybe
19:12:31 <Sgeo> um, actually, I can't risk the computer beeping
19:12:36 -!- Sgeo has quit ("Ex-Chat").
19:59:53 -!- oerjan has joined.
20:20:18 -!- ehird` has quit (Remote closed the connection).
20:20:39 -!- ehird` has joined.
21:00:55 -!- importantshock has joined.
21:29:15 -!- ihope has quit ("Reconnecting...").
22:37:45 -!- Sgeo has joined.
22:49:31 -!- calamari has joined.
22:49:58 <Sgeo> Do you have any code from your implementation of PESOIX that could help me understand pipes?
22:53:36 -!- calamari has quit (Read error: 104 (Connection reset by peer)).
23:07:06 -!- ihope has joined.
23:10:02 <ihope> Uh oh. I seem to have two Firefox windows open.
23:10:24 * ihope closes... that one
23:13:18 * Sgeo safely pokes pikhq
23:15:38 <Sgeo> Testing http://sgeo.diagonalfish.net/esoteric/psox.txt
23:16:28 <Sgeo> Testing PSOXURL/psox-safety.txt
23:16:33 <Sgeo> http://sgeo.diagonalfish.net/esoteric/
23:16:53 <Sgeo> http://sgeo.diagonalfish.net/esoteric/psox.txt
23:21:26 -!- calamari has joined.
23:21:40 -!- jix has joined.
23:24:00 <Sgeo> re calamari, hi jix
23:24:27 <calamari> I was in the process of making the pesoix files available to you
23:25:00 <Sgeo> ty (in advance?)
23:25:06 <Sgeo> What language is the code in?
23:25:08 * oerjan vaguely recalls someone needing a german. not why, though.
23:25:19 <calamari> ehh, apache isn't cooperating.. email? (pm is fine)
23:29:18 <ihope> I could do with some German chocolate cake. :-P
23:29:50 <ihope> Or maybe I should call it German's chocolate cake, to sort of make a ding in that rumor.
23:35:58 <oerjan> http://whatscookingamerica.net/History/Cakes/GermanChocolateCake.htm
23:36:15 <oerjan> indeed, i don't think Germans are big on pecans
23:36:44 <oerjan> i could be wrong, of course :)
23:37:21 <Sgeo> erm, I don't know C
23:37:27 <Sgeo> What's write(), and how does it work?
23:37:48 <ihope> Yeah, German chocolate cake was named after a guy named German, wasn't it?
23:38:22 <Sgeo> I guess PESOIX3.c is the file I should look at for the main loop?
23:39:03 <Sgeo> Is it that PESOIX1-3.c represent attempts?
23:39:06 <calamari> sorry, I don't remember anymore
23:39:38 <calamari> and some of those other files are scripts, etc to test it
23:39:52 * Sgeo wishes he understood nonblocking I/O
23:40:10 <Sgeo> /* handle esolang input requests */
23:40:10 <Sgeo> pthread_create(&input_thread, NULL, handle_input, NULL);
23:40:12 <calamari> like I say.. it never worked properly
23:40:14 <ihope> Non-blocking I/O? Hmm, that sounds evil.
23:40:35 <ihope> What is it, anyway?
23:40:35 <Sgeo> Was it not working because of line-buffering?
23:40:46 <Sgeo> Or for different reasons?
23:41:03 <ihope> Something where I/O functions return stuff like "no input yet"?
23:41:09 <calamari> I don't remember now.. maybe Gregor has a better memory than I.. I bugged him about it repeatedly
23:41:37 <Sgeo> GregorR mentioned to me that some interpreters might require newlines
23:41:42 <ihope> Fine as long as there's a "wait for input" function.
23:41:42 <Sgeo> That is now part of the spec
23:42:08 <ihope> An interface that provides a "has anything happened yet?" function but no "wait for something to happen" function is sort of broken.
23:42:10 <Sgeo> Gah! What's pthread_create?
23:42:48 <ihope> Unless, of course, providing only "has anything happened yet?" is more efficient for some reason.
23:42:49 <Sgeo> handle_input()
23:43:12 <ihope> This is called IRC. You type stuff here and push this button and people see what you typed.
23:43:25 <Sgeo> GregorR, you worked on a PESOIX implementation?
23:44:00 <GregorR> I just laughed as other people tried to hook one up to interpreters that waited on \n.
23:44:16 <Sgeo> Um.. different Gregor Richards I guess...
23:44:44 <Sgeo> "Copyright (c) 2006 Gregor Richards "
23:45:37 <Sgeo> GregorR, is it possible to tell if a process is requesting input or not?
23:45:42 <calamari> you can safely delete those, I was just using them for examples
23:45:58 <Sgeo> PESOIX3.c has that copyright notice
23:46:22 <Sgeo> /* handle esolang input requests */
23:46:22 <Sgeo> pthread_create(&input_thread, NULL, handle_input, NULL);
23:46:44 <calamari> Sgeo: oh, probably because I used some of his code in there
23:47:05 <Sgeo> I just need to learn what pthread_create is
23:47:47 <Sgeo> sgeo@ubuntu:~$ man pthread_create
23:47:47 <Sgeo> No manual entry for pthread_create
23:48:07 <calamari> do you have all the man pages installed?
23:49:43 <calamari> sudo apt-get manpages-dev manpages-posix manpages-posix-dev
23:49:46 <Sgeo> the input_thread thing seems to be declared, but not assigned..
23:49:55 <calamari> sudo apt-get install manpages-dev manpages-posix manpages-posix-dev
23:50:38 <calamari> then you should have all sorts of good stuff
23:51:47 * Sgeo wants this thing to work on Windows too, incidentally..
23:52:10 <calamari> ahh well then you're out of luck with that code then
23:52:19 <calamari> but, but cares about Windows anymore?
23:56:28 <ihope> Especially Microsoft :-P
23:56:51 <ihope> And people whose Linux machines don't mix with their wireless adapters.
23:59:07 <calamari> my IBM Thinkpad at work runs Linux happily, including wireless
23:59:31 <Sgeo> Does the PESOIX code know when the esolang interp. requests input?
23:59:39 <Sgeo> "/* handle esolang input requests */ "
23:59:50 <Sgeo> How does that work? How would I do that in Python?