00:00:12 <elliott> oklopol: but how many predefined block types will there be :P
00:00:12 <oklopol> elliott: combinations of as many features as i can come up with, and can make work together
00:00:21 <oklopol> you can just read the code of the blocks to see what they do
00:00:24 <elliott> oklopol: as in, an actual number
00:00:45 <oklopol> well astronomically many, because it's features that are optimized, not individual blocks
00:00:57 <elliott> oklopol: so a block is a set of features?
00:01:29 <oklopol> basically it's a list of components that perform a physical action, and a program that executes them.
00:01:51 <elliott> oklopol: so the former are like...limbs?
00:02:23 <oklopol> you can think of them that way, but components can teleport, change the block's shape, move it, copy it, change programs of other blocks, glue to other blocks, etc
00:02:48 <elliott> oklopol: so what _is_ a component
00:03:01 <elliott> oklopol: also, so, there are no hardcoded programs?
00:03:03 <oklopol> there's also a kind of discrete version of euclidean physics in play, for when you build make huge structures, but dunno if i'll actually implement that
00:03:05 <elliott> if blocks aren't hardcoded, just features
00:03:48 <oklopol> the programs shouldn't be very complicated
00:03:58 <elliott> oklopol: so updating the world is running millions of programs, still.
00:04:04 <elliott> that's not going to be fast.
00:04:17 <oklopol> not really, many of them will be event-based, and can just be unloaded
00:04:46 <elliott> oklopol: :D so it's actually a table of programs?
00:05:07 <oklopol> and the programs are executed very slowly. and why do you say that? just a programming language that allows events.
00:05:49 -!- ais523 has quit (Remote host closed the connection).
00:05:58 <elliott> oklopol: so updating the world does not actually run the block programs?
00:06:02 <oklopol> so anyway basically if you find a block that can execute a lot of code, you might still need a block that computes a specific type of function or your bot will take ages doing that in software
00:06:07 <oklopol> for instance pathfinding is like this
00:06:29 <oklopol> elliott: it does on paper, but the world is designed so that it can usually be optimized awayt.
00:06:30 -!- MigoMipo has quit (Read error: Connection reset by peer).
00:07:04 <elliott> oklopol: :D your game is not very conceptually pure, i have no idea what the block structure definition would look like at all
00:08:10 <oklopol> it is. a block has a piece of code that it executes at that blocks execution speed, and can call functions specific to that block.
00:08:22 <oklopol> math, corrently, rather cs type
00:08:46 <oklopol> doing my master's thesis in picture languages, currently doing automata on pics
00:09:20 <oklopol> currently as in forever from now on, but i was doing cs a year ago, and officially changed only after i finished my bachelor's which was a few months ago
00:09:29 <oklopol> again, oklo month which is anywhere between a day and a year
00:09:40 <oklopol> yeah matrices over finite alphabet
00:09:56 <elliott> oklopol: are you still in your second year :)
00:10:06 <oklopol> without any operations, automata theory in 2d, basically
00:10:12 <oklopol> elliott: no, second year of math tho
00:10:28 <oklopol> yeah third year of uni going
00:10:48 <elliott> i wonder how you and Sgeo can be in the same room without, like, exploding
00:10:51 <elliott> matter, antimatter, that sorta shit
00:11:01 <oklopol> if you count the cs time, i'm only half a year ahead of the usual scheduly, degreewise
00:11:30 <zzo38> elliott: It is not a bomb. It is a device that is (not) exploding.
00:11:35 -!- zzo38 has quit (Quit: zzo38).
00:11:53 <elliott> oklopol: yes but you have a stupidly large awesome surplus
00:12:01 <oklopol> lol i'm not that good, my master's thesis is going to be complete bullshit for instance
00:12:26 <oklopol> i have an open problem that i decided to solve
00:12:30 <oklopol> and i haven't been able to
00:12:41 <oklopol> even though anyone could do it
00:13:44 <elliott> oklopol: does your game have gravity
00:14:31 <elliott> who likes restricted movement
00:14:35 <oklopol> gravity exists, but you can hover quite far
00:14:37 <elliott> oklopol: unless you mean like
00:14:43 <elliott> oklopol: air blocks have their program built to push you down
00:14:47 -!- cheater00 has joined.
00:14:47 <oklopol> i don't want lack of gravity, because i like the idea of falling
00:14:49 <elliott> oklopol: and you can just hack their program out if you want :D
00:14:53 <elliott> because that would be... amazing
00:16:47 <oklopol> well see currently there is quite a complicated physics, but i'll probably leave those optional, because i can't imagine others enjoying them.
00:17:15 <elliott> oklopol: dude, my idea was amazing? leave the physics up to the blocks?
00:17:18 <oklopol> because i seem to be the only man on earth who enjoys learning weird physicses
00:17:27 <oklopol> or at least people don't play my cool games :(
00:17:34 <elliott> oklopol: i want to but you only provide exes on vjn ;o
00:17:53 -!- cheater99 has quit (Ping timeout: 240 seconds).
00:18:11 <oklopol> elliott: erm yeah, physics are up to the blocks of course
00:18:22 <oklopol> but you don't need air to even be an actual block for that
00:18:37 <elliott> oklopol: the great thing is
00:18:44 <elliott> oklopol: have an air meter which goes down very quickly
00:18:52 <elliott> oklopol: then, air blocks just have code to give you air :D
00:19:00 <elliott> and you can make a vacuum, which will suffocate you
00:19:14 <elliott> and if you want to breathe but float, you could hack some air blocks' source
00:19:40 <oklopol> yeah at some point i was thinking about air physics, air pressure etc
00:19:59 <oklopol> not suffocation tho, you have to keep eating to survive anyway
00:20:08 <elliott> oklopol: but then you could just chill in a vacuum
00:20:10 <elliott> which makes little sense :D
00:20:11 <oklopol> (but you just have a program for that ofc)
00:20:21 <elliott> oklopol: also bonus: if stuff like falls on top of you, you suffocate
00:20:27 <elliott> or if you jam your head into stone somehow
00:22:27 <elliott> oklopol: but you could turn yourself into a robot if you wanted right?
00:22:30 <elliott> artificial head etc. just have you as a brain
00:22:47 <oklopol> you can glue blocks to yourself if you get the glueing component
00:22:56 <oklopol> you inherit components from the blocks you own
00:23:21 <oklopol> you can make yourself into a robot, yes, that's basically what the game is about
00:23:27 <elliott> oklopol: can i make a perpetual motion machine
00:24:03 <oklopol> well you have your in-game coding window, which is maybe not your primary, but a very important part of your movement.
00:24:44 <oklopol> and there's a high-level clue-based stack language.........................
00:24:52 <oklopol> maybe i shouldn't have mentioned that
00:25:03 <elliott> oklopol: when can i buy it
00:25:35 <oklopol> i'll try to finish my thesis in february, then start allocating coding time
00:25:49 <oklopol> i have a tiny little coding spark atm, actually
00:25:53 -!- Phantom__Hoover has quit (Ping timeout: 240 seconds).
00:26:02 <elliott> oklopol: i kinda wanna code it somehow except i'd be terrible :D
00:26:56 <oklopol> go ahead, a proof of concept shouldn't be hard to make
00:27:28 <elliott> oklopol: no it sounds _really_ hard
00:27:52 <elliott> oklopol: even doing it in haskell sounds like drudgery :D
00:27:57 <elliott> oklopol: you should write the whole thing in Clue++
00:29:13 <oklopol> basically you have a stack language, but there are events, and a command for "use the components X to achieve Y", which should work for simple things like pathfinding very well, and hopefully could manage some slow stupid way for more complicated things
00:29:35 <oklopol> and the language is very high-level, like you can just directly refer to things you see on map
00:29:51 <oklopol> that's not all that high-level, that clue command is much more high-level :D
00:30:13 <elliott> oklopol: also you should make the code have no text form, clicking blocks to actually put a little line from them to a little point in the code sounds hilariously funsilly
00:30:15 <oklopol> yeah dunno about stack, for some reason it feels natural for that kind of things
00:30:32 <elliott> well, maybe make a block highlight be, like, a picture of a block and its moore neighbours dimmed
00:30:35 <oklopol> yeah, it should be very untexty
00:30:49 <elliott> and you can like hover over it with your mouse and it shows you that part of the map with a red border around the block
00:31:36 <oklopol> yeah that's pretty much what i'm going for
00:32:31 <oklopol> but anyway i'll probably publish the physics before starting to code it
00:32:36 <elliott> oklopol: well then allow me to state the obvious
00:32:43 <oklopol> or at least completely specify them
00:32:43 <elliott> oklopol: have there be another map, filled with functions
00:32:52 <elliott> oklopol: you don't ever use words, you just include parts of the code-map
00:33:06 <elliott> and you can draw a little like 16x16 icon for each block in the code-map
00:33:09 <elliott> so you could fit a few letters on
00:33:14 <elliott> or a representative picture demonstrating its operation
00:33:20 <elliott> and then code is just a sequence of pictures
00:33:24 <oklopol> heh, i wish i didn't find that such a great idea.
00:33:39 <elliott> oklopol: it's great because it'd show you the dimmed neighbours of that function in the actual code... like you know ...
00:33:43 <oklopol> but yeah i was kinda thinking that, something like an inventory of code blocks
00:33:45 <elliott> oklopol: if you liked this function, why not try these similar functions...
00:35:22 <elliott> oklopol: okay but seriously, it would be cool
00:35:33 <oklopol> yeah but anyway, mainly i'm interested in enemies.
00:35:35 <elliott> oklopol: those function-squares?
00:35:39 <elliott> oklopol: should be doors leading into function rooms
00:35:50 <elliott> oklopol: that's right: individual pieces of code are themselves a map
00:35:54 <elliott> after all, they're just a bunch of blocks
00:36:01 <elliott> stop laughing, i am a revolutionary
00:36:41 <elliott> oklopol: so that's how you're doing it, yes?
00:37:17 <oklopol> anyway the thing is i want the game to be fucking scary, you never know if the next block you mine out is a tree that grows 5 blocks at a time for 10 seconds, then explodes
00:37:45 <oklopol> you have to use bots to mine, and try to find ways to do that safely
00:37:53 <elliott> oklopol: question, is it realtime or turnbased
00:38:47 <oklopol> realtime, a couple moves a second, where a move could be moving to your neighbor cell. (it will actually look rather smooth tho, because you have to look at it all the time.)
00:39:17 <oklopol> like when you start, it's that, of course later on your player block can basically just teleport whereever it wants
00:40:50 <elliott> oklopol: but time is like... boring?
00:41:42 <oklopol> it's on the commutative free group with two generators, the second most done to death thing in the mathematical world
00:42:12 <oklopol> time i do not mind, however.
00:42:16 <elliott> oklopol: but time is lame.
00:42:33 <elliott> oklopol: at least make each second take an amount of time determined by a complex formula
00:43:37 <oklopol> time slows down further away from sentient blocks
00:44:21 <oklopol> and comes to a stop, eventually (i would make it never come to a stop due to purity, but that's not very practical)
00:45:41 -!- GreaseMonkey has quit (Quit: ilua).
00:45:51 <elliott> oklopol: just make it so that some kind of circuit fails if time is going too slowly
00:45:56 <elliott> and it turns out, everything is made out of this circuit!
00:46:40 <elliott> oklopol: then your problem is solved PURELY
00:47:12 <oklopol> "<elliott> oklopol: just make it so that some kind of circuit fails if time is going too slowly"
00:47:17 <oklopol> somehow i managed to read something like
00:47:33 <oklopol> "doesn't it make certain kinds of circuits fail if time slows down at a certain boundary"
00:48:17 <oklopol> because this is a very bad thing if you want to have say a computer: it doesn't just stop when you move away, it might completely break due to time slowing in an unfortunate way in one part of the machine
00:48:46 <elliott> oklopol: just make the story be that everything is made out of this material or whatever
00:48:59 <elliott> oklopol: and that its interactions break down when time gets too slow, such that it just sort of warbles on the spot
00:49:05 <elliott> oklopol: and then starts running again if time is faster
00:49:12 <oklopol> but, 1) these distances are very big, 2) this is a completely documented (or at least consistent) physics thing, so you just have to deal with it.
00:49:23 <elliott> then, you can simulate infinite time-slowdown, with a discrete universe
00:49:34 <elliott> just by ignoring all blocks beyond a certain point
00:49:39 <elliott> and this is deemed OK by the pure physics
00:50:38 <oklopol> well, anything can be called pure, and somehow implemented in-game, conceptually. although i'm sure this is a rather kill-joy thing to say
00:51:15 <elliott> oklopol: specify the pure semantics based on the semantics of finite-state machines, x86, Unix, and C
00:51:18 <elliott> oklopol: SO PURE YET SO PRACTICAL
00:51:29 <Vorpal> elliott, cool craftbook has "ICs" that shoot arrows. I'm building a battery of them now
00:52:12 <oklopol> also pvp should be more fun when you can program thousands of blocks to fight each other
00:52:29 <Vorpal> oklopol, too many arrow cause lag
00:52:39 <Vorpal> even when they are on ground
00:52:46 <oklopol> we're talking about my nonexistant game, no lag in that one.
00:53:04 <Vorpal> oklopol, I was talking about craftbook
00:53:28 <oerjan> elliott: your radiation stuff should mutate animals into monsters. just saying.
00:53:51 <elliott> oerjan: way ahead of you :D
00:54:01 <oerjan> elliott: i didn't see you mentioning that...
00:54:08 <elliott> my head calculates quickly
00:54:18 <elliott> oerjan: i was thinking they'd turn into rotting, crazy animals that die easily but are vicious
00:54:29 <elliott> oerjan: or maybe sometimes they are really hard to kill thanks to radiative superpowers
00:54:37 <elliott> oerjan: i just couldn't perfect it enough to be worth saying yet :D
00:55:10 <oklopol> all of that feels so small-scale now that i have my game in my head again.
00:57:00 <oklopol> another thing i'd like to make is this game where you have an arbitrary monoid, and you can walk on it, dunno what the game is really, or if there is one, i have this marvelous way to project it in 3d
00:57:22 <oklopol> but it can't fit in an irc message
00:58:17 <elliott> oerjan: so do you play MC :D
00:58:47 <oklopol> no he's too busy doing things
00:59:11 <elliott> oerjan: if i giftcoded you it would you play it, it sounds like a hilarious event
01:01:47 <elliott> oerjan: you would ... reject my purchase??!?!?!?! ;(
01:01:50 <elliott> oerjan: take that insult back
01:01:56 <oklopol> oerjan: you can't do that, that's stealing
01:02:37 <elliott> i'm trying to convince oerjan that he should play minecraft
01:03:08 <cheater00> i think he's sort of had this thing where he was "siding with me" in not playing minecraft
01:03:24 <elliott> oerjan: are you aware of any alliance with cheater00
01:03:39 <oklopol> oerjan: what's your relationship with cheater00?
01:03:47 <oerjan> it would be useless as i would undoubtedly trigger my rsi
01:03:54 <elliott> cheater00: well i kinda know you for making up bullshit theories to explain random things you see. usually related to yourself
01:03:58 <elliott> oerjan: rsi enhances the experience
01:04:20 <cheater00> elliott: that's because i am god and everything i say immediately becomes reality... right?
01:04:36 <cheater00> oerjan: play with the other hand!!!!!!!!!!
01:04:55 <oklopol> haha yeah the one YOU DON'T USE FOR MASTURBATION :dDDDDDDDDD
01:05:04 <oerjan> cheater00: none of my hands are entirely free of it
01:05:09 <cheater00> also elliott, the functions of the mouse buttons, can you remap them to the keyboard somehow?
01:05:17 <cheater00> because you mostly only get rsi when you click the mouse
01:05:23 <cheater00> if you just move it around it's much better
01:05:30 <elliott> surely. but not with minecraft itself
01:05:33 <cheater00> oklopol: :DDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
01:05:52 <elliott> also it's nice to have them on the mouse
01:06:02 <elliott> oerjan: i'll pay you, regularly, to play minecraft
01:06:02 <oerjan> cheater00: also it's not _really_ rsi because my feet hurt as well
01:06:16 <cheater00> :DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
01:06:21 <oerjan> but it definitely gets worse when i play games
01:06:21 <oklopol> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxD
01:06:33 <cheater00> <oklopol> haha yeah the one YOU DON'T USE FOR MASTURBATION :dDDDDDDDDD
01:06:43 <oklopol> is that why you couldn't play mastur minecra minesweeper
01:06:59 -!- zeotrope has joined.
01:07:08 <cheater00> never mind masturbating with the feet..
01:07:20 <oklopol> i remember i told my record
01:07:29 <oklopol> and oerjan is like LOL goddammit oklo ur so nub
01:07:37 <elliott> oklopol: your masturbation record?
01:07:39 <oklopol> i can do it in like MINUTE
01:07:49 <elliott> oerjan gets it down to, like, 20 seconds
01:07:49 <oklopol> and i go well do it and show vid
01:07:52 <elliott> unfortunately it's given him rsi
01:07:58 <oklopol> then says nah hands can't do it.
01:08:14 <elliott> oklopol: i see no reason _whatsoever_ to read your words with the correct interpretation
01:08:18 <oklopol> true story, do you remember oerjan?
01:08:20 <elliott> although i suspect you might have been encouraging that. sightly.
01:08:29 <oklopol> the part i said, the others may have added stuff
01:08:59 <oklopol> i'm angry at you people for doing that
01:09:09 <elliott> i have damaged oerjan's stellar reputation
01:09:10 <oklopol> and just for that i'm never letting you play my game
01:09:37 <cheater00> <x> but that would be more expensive and generate more heat
01:09:48 <oklopol> <z> haha ur mum generate heat
01:09:49 <cheater00> <x> i just want something i can order and plug in ;(
01:09:58 <oklopol> <z> haha like a sexual dol
01:10:00 <elliott> cheater00: censoring usernames = lame
01:10:13 <elliott> cheater00: also that quote wasn't...funny
01:10:27 <cheater00> i don't want you quazimodos bothering srs ppl
01:10:39 <elliott> cheater00: usernames != channel name
01:11:03 <HackEgo> 139) <Bubo> ooh a test to see your procrastination hotspots <Bubo> ill do it later
01:11:04 <HackEgo> 126) <Gregor> Well yeah, but furthermore unlike, oh, say, an Apple product, you don't have to sign their "we own your sperm" license agreement to GET that SDK and the requisite libraries. ... <Gregor> pikhq: Sure, but it's the only way Apple could get a first-born-son clause into a modern licensing agreement without infringing
01:11:04 <HackEgo> 109) <ais523> so a.b.c.d.e.f.g.h.i.j.k.com might be self-relative, but a.b.c.d.e.f.g.h.i.j.k.l.com always means a.b.c.d.e.f.g.h.i.j.k.l.com.?
01:11:04 <HackEgo> 6) <Quas_NaArt> His body should be given to science. <GKennethR> He's alive :P <GreenReaper> Even so.
01:11:04 <HackEgo> 249) <ais523> I love the way zzo38's comment was cut off after the f of brainfuck <ais523> that's just the most hilarious place to cut it off in a discussion about censorshi
01:11:12 <elliott> cheater00: who would bother doing that
01:11:56 <elliott> oklopol talking is a gift to anyone so stfu
01:12:14 <oklopol> yeah just the other day i was talking about bukkake on this channel on programming
01:12:24 <cheater00> what was your gift for christmas???????????????????????
01:12:25 <oklopol> everyone was like OH GOD WHERES THE OPS ::DOS
01:12:36 <elliott> oklopol: i don't recall oh god wheres the ops :P
01:12:38 <elliott> oklopol: "about programming"
01:12:46 <cheater00> oklopol: you seriously need to die xD
01:13:11 <oklopol> i'm surprisingly hard to kill
01:13:28 <oklopol> i got this 2tb drive actually
01:13:34 <oklopol> i guess that was sorta a present from my mumma
01:13:49 <elliott> afaik 2.5 is the largest drive you can actually buy :p
01:13:51 <oklopol> yes, they didn't have smaller ones
01:14:00 <oklopol> so i'll have to do with that
01:14:26 <oklopol> i'm not gonna put an os on it
01:14:45 <cheater00> oklopol has a computer with no operating system in it
01:15:06 <cheater00> he turns it on, lets it fail booting, and then tries different keyboard inputs to see if anything happens like on a c64.
01:16:05 <oklopol> this computer has maybe dunno 200gb
01:16:44 <oklopol> nowadays i usually stream everything
01:17:19 <oklopol> i do not have donkey porn on my hd
01:17:33 <oerjan> you can lead a donkey to the stream, but you can't make it drink
01:17:35 <cheater00> oklopol is the registrar ceo for www.donkeyporn
01:18:01 <oerjan> one of the lesser known toplevel domains
01:18:27 <oklopol> it seems i foresaw the funny
01:18:51 <oerjan> they had to allow it but chose to keep it under lids
01:19:49 <oerjan> it's banned in most muslim countries though. not because they're donkeys, but because some of them are male.
01:20:33 <oklopol> lol it links femanic there
01:21:49 <oklopol> rule 34 is pretty silly, clearly none of the people advertising it have actually researched the subject
01:22:20 <elliott> oklopol: no no it's far more subtle than you believe
01:22:32 <elliott> oklopol: it's essentially a platonist statement
01:22:49 <elliott> oklopol: basically you can't consider 34 along, 35 is just as important
01:22:55 <elliott> oklopol: porn *exists*, but if porn *doesn't* exist, it will be made
01:23:37 <elliott> oklopol: the point is: 34 is "For every thing, there _exists_ porn of it." but 35 is "For every thing, if the _extant_ porn of it is has not been _realised_ and distributed yet, then it is _guaranteed_ to be at some point in the future (given that civilisation continues)."
01:23:57 <elliott> oklopol: i.e., when porn of something is created for which no porn previously existed, it is actually just being _realised_; it already existed in the platonic realm of ideas.
01:24:16 <elliott> therefore, rules 34 and 35 can and do coexist without contradiction; they are both completely true.
01:24:22 <elliott> a deep philosophical statement.
01:24:30 -!- hagb4rd has joined.
01:25:09 <oklopol> we're talking about esolangs
01:25:29 <oklopol> i wanted to start explaining clue but ugh
01:25:44 <Sgeo> Someone should rule34 Brainfuck
01:26:29 <oerjan> as long as you didn't come to conquer
01:26:56 <oklopol> clue is pretty awesome tho
01:27:57 <oerjan> division is quite accepted here
01:28:31 <oklopol> heeey found it www.vjn.fi/oklopol/clue.rar
01:28:37 <hagb4rd> at least to anything but zero
01:28:41 <oklopol> probably doesn't work with current pythons :(
01:30:20 -!- FireFly has quit (Quit: swatted to death).
01:31:08 <oklopol> every time an error in the official clue imp is corrected, a new u is added
01:31:16 <oklopol> the name is still clue because i'm very smart
01:31:41 <oerjan> unlike others who have no clue
01:31:49 <oklopol> actually me and a uni friend designed a much nicer conditional system but i've been too lazy to implement it
01:31:57 <oklopol> that was like when clue was first implemented
01:32:01 <oklopol> so what was that like last week
01:32:08 <elliott> "SKI compiles in about 20 seconds on my machine."
01:32:12 <elliott> "All this code is mine, don't touch it unless you really want to."
01:32:39 <elliott> oklopol: so is oklotalk superseded by clue
01:32:44 <oklopol> ilkka made an interp for random or what's it called
01:33:42 <elliott> http://esolangs.org/wiki/Random? :P
01:33:42 <oklopol> a language on esolang, pretty retarded
01:33:52 <elliott> oklopol: so is oklotalk 2 clue++
01:34:19 <elliott> clue where everything is an oklotalk object? :P
01:34:24 <elliott> def funthatreturnsntharg(i):
01:34:25 <elliott> return lambda*args:args[i]
01:34:28 <elliott> i like your naming convention
01:34:42 <oklopol> basically i'd like clue with something like object
01:34:55 <elliott> oklopol: right, and then you'll code oklOS in it
01:35:18 <elliott> oklopol: where you write programs by drawing a gui, drawing the result of using this gui, repeat a few times, and give it a few clues as to what operation the program performs
01:35:23 <elliott> and it spits out a half-broken gui app object
01:35:27 <oklopol> but most importantly, the concept of strategies.
01:36:13 <elliott> oklopol: so erm is there a way to get clue to print out the function it infers
01:36:44 <oklopol> maybe the compiler has a way, but the code is not very structured
01:36:56 <oklopol> (and of course even if it were, you wouldn't know by reading it)
01:37:07 <elliott> # functions are applied (using applier and aritiers) randomly to objects, to get new objects
01:37:33 <oklopol> not in that implementation, i think
01:37:40 <elliott> afaict it has no actual interface :)
01:37:59 <elliott> oklopol: hmm i think if you print out the function right before compiling it to a func it would work
01:38:09 <oklopol> but it's not specified, so that could be sensible, probably it's just poetic.
01:38:11 <hagb4rd> nice article on that topic http://en.wikipedia.org/wiki/Buridan%27s_ass
01:38:45 <oklopol> of course it doesn't have an interface, interfaces are for people who don't have faces exter.
01:39:03 <oklopol> i hope that is convincing enough
01:39:15 -!- Wamanuz has joined.
01:39:21 <elliott> oklopol: this isn't... imprecise SKI is it?
01:39:28 <elliott> oh no that's timing info :D
01:39:45 <oklopol> there should be a rather clear separation of compilation and running
01:39:48 <hagb4rd> "A discrete decision based upon an input having a continuous range of values cannot be made within a bounded length of time."
01:40:24 <elliott> oklopol: i think i'm gonna try and hack cluetofun to print stuff
01:40:43 <oklopol> erm hrm, i have this vague memory that i considered making a nice output form for funcs
01:40:44 <elliott> C[B[IOP([1]:0)], B[IOP([2]:0)], B[IOP([3]:0)], B[IOP([[2, 1]]:0), IOP([[2, 3]]:0)], B[IOP([[[3, 2], 1]]:0), IOP([[[3, 4], 5]]:0)], B[IOP([[3, 2]]:0), IOP([[3, 4]]:0)], B[IOP([[1, 0]]:1), IOP([[[2, 1], 0]]:2), IOP([[[[3, 2], 1], 0]]:3), IOP([[[[[1, 2]]]]]:4), IOP([[[[[[1, 2], 3], 4], 5], 6]]:4)]]
01:40:48 <oklopol> maybe i never got to that...
01:40:49 <elliott> oklopol: does that look like post-inferred code?
01:40:54 <elliott> or is that the pre-inferring
01:41:02 <elliott> inferring = working out actual function from the source
01:41:16 <elliott> compile_base(clue.bag,clue.helper_objs,i)
01:41:20 <elliott> compile_rec(clue.bag,clue.helper_objs,i)
01:41:26 <oklopol> 1, 2, 3 are the ski functions
01:41:29 -!- Wamanuz5 has quit (Ping timeout: 240 seconds).
01:41:34 <elliott> so what should i print, clue.bag?
01:42:00 <oklopol> can i see the... wait what the fuck maybe i can just dl it
01:42:08 <Sgeo> elliott's writing Python?
01:42:38 <elliott> oklopol: why do you use classes, you should write all your python code with functions
01:42:41 <oklopol> hagb4rd: my code, elliott is just reading
01:42:52 <oklopol> elliott: www.vjn.fi/oklopol/python.txt
01:43:09 <elliott> oklopol: yeah that is quite acceptable, but you still use objects
01:43:58 <oklopol> opening the jar of beauty that is clue.py
01:44:20 <elliott> return{'car':nil,'cdr':nil,'length':0}[g]
01:44:22 <elliott> def _(g):return{'car':x,'cdr':y,'length'1+y('length')}[g]
01:44:27 <elliott> oklopol: is this not a more perfect way to implement lists than any other?
01:44:43 <elliott> ofc ideally you'd do your own naturals too for the length
01:44:50 <oklopol> you should probably print code
01:45:33 <elliott> oklopol: that just prints a lot of None :D so i guess compile_clue is the important func
01:45:51 <oklopol> well you have to umm argh i'll read better
01:45:55 <elliott> return call_clue(clue,args,10)
01:45:57 <elliott> funn=stuff.unvararg(fun,clue.arity)
01:46:27 <oklopol> yeah that funn should be the program i think
01:46:58 <elliott> oklopol: yess, but you see it's a python function
01:47:16 <elliott> def call_clue(clue,args,depth_lim):
01:47:18 <elliott> value=clue.condcode(*args)
01:47:22 <elliott> so condcode has something to do with it
01:47:24 <oklopol> compiles all functions in a piece of clue code, and returns a hashtable with these program
01:47:28 <elliott> it's definitely clue.branches
01:47:36 <elliott> return call_branch(clue,i,args,depth_lim)
01:47:41 <oklopol> it's a python function yeah
01:47:42 <elliott> oklopol: clue.branches is the real code, then?
01:47:52 <elliott> oklopol: but then branch.code is a python function :D
01:47:55 <oklopol> indeed i compile to python code
01:47:58 <elliott> oklopol: so what's the precompiled version
01:48:03 <elliott> is there an internal representation
01:48:20 <elliott> [B[IOP([1]:0)], B[IOP([2]:0)], B[IOP([3]:0)], B[IOP([[2, 1]]:0), IOP([[2, 3]]:0)], B[IOP([[[3, 2], 1]]:0), IOP([[[3, 4], 5]]:0)], B[IOP([[3, 2]]:0), IOP([[3, 4]]:0)], B[IOP([[1, 0]]:1), IOP([[[2, 1], 0]]:2), IOP([[[[3, 2], 1], 0]]:3), IOP([[[[[1, 2]]]]]:4), IOP([[[[[[1, 2], 3], 4], 5], 6]]:4)]]
01:48:26 <elliott> which is pretty much what print clue gave :D
01:48:56 <oklopol> i think that does roughly what you want
01:49:58 <oklopol> like just get_ast(funcs["ski apply"]) say
01:50:07 <oklopol> my python is too new, would have to correct a lotta stuff
01:50:09 <elliott> funcs,asts=clue.compile_all(open(cluefile).read(),stuff.funcs)
01:50:19 <elliott> oklopol: asts suggests that compile_all might actually already return the asts?
01:50:22 <elliott> ('ski apply', "Condition: ski type?('#0')\nBase branch (0)\n'#0'\nRec branch (1)\nSubast(0,0):['car', ['cdr', '#0']]\nMain ast: '#1'\nRec branch (2)\nSubast(0,0):['cadar', '#0']\nMain ast: '#1'\nRec branch (3)\nSubast(0,0):['pair', ['cadaar', '#0'], ['car', ['cdr', '#0']]]\nSubast(1,0):['pair', ['cadar', '#0'], ['car', ['cdr', '#0']]]\nSubast(2,0):['pair', '#1', '#2']\nMain ast: '#3'\nRec branch (4)\nSubast(0,0):['car', '#0']\nSubast(
01:50:22 <elliott> 1,0):['pair', '#1', ['car', ['cdr', '#0']]]\nMain ast: '#2'\n")
01:50:23 <oklopol> that just compiles the clues in the code
01:50:30 <elliott> oklopol: asts contains the asts
01:50:34 <elliott> oklopol: so you already had all this code :D
01:50:43 <elliott> oklopol, always one step ahead of oklopol
01:50:53 <oklopol> i just skipped it, "don't need the ast... now how to convert funcs to ast"
01:51:17 <oklopol> anyway dunno if i print that nicely anywhere
01:51:25 <oklopol> i might just have been satisfied with that
01:51:35 <elliott> for k,v in asts.iteritems():
01:51:48 <elliott> still not really readable though
01:53:15 <elliott> oklopol: http://sprunge.us/cERU
01:53:22 <elliott> oklopol: whether you consider this readable or not is down to personal taste.
01:53:35 <elliott> oklopol: i would, personally, prefer it outputted in a format "like" clue source, except without all the actual clue-y parts, but :)
01:53:50 <oklopol> well, obviously you need to know how clue works internally
01:53:53 <elliott> hm is id(x) always true or something
01:54:08 <oklopol> no, it's just the identity function... conditions work kind of weirdly
01:54:10 <elliott> that would seem to me like <more than 3>(x) is only valid if x is true
01:54:25 <oklopol> it's not actually a condition, it's a branch
01:54:48 <elliott> oklopol: but of course. that's why you've called it a condition
01:55:12 <oklopol> you have an expression, and a function on it, then, certain values of that function correspond to certain codes being executed
01:55:18 <oklopol> and there's always a default branch
01:56:51 <elliott> oklopol: clue is kind of pretty really, you started off with the most obviously readable and beautiful way to write a program possible (just show what it should do and let the computer figure it out), and have managed to make it completely incomprehensible and difficult
01:56:51 <oklopol> after Base branch, it shows (x) in parens, that's the value of the condition leading to that branch
01:57:20 <elliott> oklopol: so basically, it does a switch statement (ala C) on the result of the condition?
01:57:27 <elliott> i assume you know what switch is >_>
01:57:43 <oklopol> elliott: yes, that's the whole point, make a beautiful concept really technical and complicated, while technically keeping the basic idea
01:58:26 <oklopol> but anyway that is a stupid system, and there's a better one coming, it's just so you have *some* way of doing stuff
01:58:39 <oklopol> it's really annoying when you have say multiple recursive branches
01:59:07 <elliott> oklopol: i really really have to meet you sometime, i get this feeling you're some kinda being of pure energy
01:59:21 <elliott> who has three modes, programming, mathing, and normal
01:59:30 <elliott> the latter seems a bit boring though
01:59:49 <elliott> oklopol: while programming?
01:59:50 <oklopol> you wouldn't notice me on the street
01:59:57 <elliott> oklopol: that's why i said, three modes
02:00:04 <elliott> one normal, the other two oklopol
02:00:56 <oklopol> i should ask ilkka how all this works
02:01:03 <oklopol> he's probably the only one who gets it
02:01:11 <elliott> no no no shut up i want to get this
02:01:25 <elliott> why do you say <id>, isn't <> for quoting multi word names
02:04:06 <oklopol> make singleton conses two arguments together? maybe i don't know what #0 and #1 are...
02:04:45 -!- cal153 has quit (Ping timeout: 240 seconds).
02:04:49 <elliott> oklopol: make singleturn turns x into [x]
02:05:02 <elliott> make singleton ~ {. 1 -> [1]
02:05:02 <elliott> . [1, 2, 3] -> [[1, 2, 3]]}
02:05:02 <elliott> make singleton ~ <id>; cons; #[]
02:05:36 <elliott> oh is that an implicit param
02:05:39 <oklopol> the idea is it gives the empty list as an arg
02:05:54 <oklopol> that's how you do constants
02:06:10 <elliott> it should figure the constants out ITSELF
02:06:21 <elliott> can i just omit the hints entirely
02:06:34 <elliott> will it just try everything
02:06:38 <oklopol> no! that's not what clue is about
02:06:51 <elliott> you are such a fucking cheat
02:06:54 <oklopol> clue is about doing the drudge work BUT MAKING IT LOOK LIKE YOU'RE JUST GIVING THE RESULT
02:07:09 <oklopol> that's why it's so fucking awesome
02:07:24 <elliott> oklopol: you stole "drudge work from me"...bitch
02:07:30 <elliott> *drudge work" from me...bitch
02:07:31 <oklopol> but i mean it's actually pretty nice to read, for simple functions
02:08:05 <oklopol> i did, i take things people say and use them. that's what i do.
02:08:06 <elliott> found at the bottom of cluetest.py
02:09:02 <oklopol> yeeeah i'm not really into solving trivial problems in sensible ways :D
02:09:07 <elliott> TypeError: 'NoneType' object is not iterable
02:09:12 <elliott> that means my code is insufficiently helpful, right?
02:09:23 <oklopol> erm hrm, i... dunno, what did your code say? :D
02:09:49 <elliott> File "/Users/ehird/clue/clue.py", line 574, in separate_cond
02:09:49 <elliott> if l[i][0]=="<" and l[i][-1]==">":
02:09:51 <elliott> TypeError: 'int' object is unsubscriptable
02:10:56 <elliott> File "/Users/ehird/clue/clue.py", line 640, in compile_all
02:10:56 <elliott> raise DepthLimitException("depth limit exceeded ("+i+")")
02:10:56 <elliott> clue.DepthLimitException: depth limit exceeded (succ)
02:11:08 <elliott> File "/Users/ehird/clue/clue.py", line 648, in compile_all
02:11:08 <elliott> [i+"("+unfounds[i]+")" for i in compilees if not compilees[i].iscompiled])
02:11:08 <elliott> TypeError: exceptions must be classes or instances, not str
02:11:19 <elliott> oklopol: you fail at triggering errors
02:11:34 <oklopol> yeeeeeah i use strings as errors, it used to be possible
02:11:52 <elliott> oklopol: frowned upon -- you stole that from me from notch
02:12:12 <oklopol> oh you came up with that, i see
02:12:23 <oklopol> anyway, gah, can't you get anything to compile?
02:12:43 <oklopol> it shouldn't be *that* hard :( and i'm not saying ur stup i'm saying clue is
02:12:47 <elliott> oklopol: almost almost almost i can do this
02:13:05 <elliott> Exception: Can't compile succ(<id>)
02:14:18 <elliott> added one testcase, didn't help
02:14:34 <elliott> oklopol: wait, what is this :. stuff
02:14:41 -!- hagb4rd has quit (Ping timeout: 240 seconds).
02:14:42 <elliott> is that only for recursive shit
02:15:03 <elliott> more than 3 ~ <id>; #0; #1
02:15:05 <oklopol> should have the same value of condition func
02:15:11 <elliott> around my other testcases?
02:15:13 <elliott> as in have each be separate
02:15:27 <oklopol> <id> and <succ> can't make all those 3 numbers into the same thing!
02:15:55 <elliott> Exception: Can't compile succ(<inc>)
02:16:11 <oklopol> hmm maybe i have old python as well
02:17:45 * oklopol is waiting for ski to compile
02:17:54 <elliott> ski compiles fine here at least
02:18:19 <elliott> oklopol: im gonna try a less ambitious function
02:18:42 <oklopol> took only a minute to compile that
02:19:13 <elliott> note: function is actually is zero
02:19:16 <oklopol> that's wrong tho, isn't it :D
02:19:25 <elliott> I think None matches anything
02:19:40 <elliott> oklopol: can i make the condition a constant?
02:19:42 <oklopol> yeah but <inc> isn't applied is it
02:19:54 <elliott> oklopol: can i make the condition a constant
02:20:44 -!- Behold has quit (Remote host closed the connection).
02:20:49 <oklopol> and then # gives you constants
02:21:03 <elliott> will it actually use them for condition though
02:21:08 <elliott> or will it try and condition on inc or something stupid like that
02:21:50 -!- hagb4rd has joined.
02:22:02 <elliott> File "/Users/ehird/clue/clue.py", line 419, in parse_number
02:22:02 <elliott> return int(code[:i]),code[i:]
02:22:02 <elliott> ValueError: invalid literal for int() with base 10: '11-'
02:22:23 <elliott> note distinct lack of "11-"
02:22:46 <oklopol> i... wish i knew what to say
02:23:12 <elliott> while i<len(code) and (code[i]=='-' or code[i].isdigit()):
02:23:15 <elliott> return int(code[:i]),code[i:]
02:23:30 <elliott> Elliott-Hirds-MacBook-Air:clue ehird$ python cluetest.py
02:23:40 <elliott> that's code at each iteration
02:23:46 <elliott> how is code growing, it's not even touching code
02:23:52 <elliott> the loop body is literally += 1
02:23:57 <elliott> oh because a different call
02:24:01 <oklopol> i'm laughing my ass off here
02:24:07 <elliott> I forgot the . before the next condition
02:24:14 <elliott> no you didn't, because your syntax sucks
02:24:20 <elliott> or did you notice that and are mocking me
02:24:32 <elliott> Exception: Can't compile succ(<inc>)
02:24:54 <elliott> do the order of hints matter?
02:25:07 <elliott> i think constants have to go last
02:25:12 <elliott> oklopol: default condition?
02:25:25 <elliott> Exception: Can't compile succ(<_>)
02:25:57 <elliott> oklopol: this is the worst language i have ever used ... was gonna say "game i have ever played", my mind can't really view this as a rational activity
02:26:20 <elliott> if str(e)[-12:]=="not callable":
02:26:28 <elliott> oklopol: what on earth made you write that
02:26:43 <elliott> oklopol: did you not consider any of the other 439857349857345 simpler and faster solutions :D
02:27:10 <oklopol> i think i didn't want to open a browser
02:27:46 <oklopol> my first program compiled just fine, but lemme try succ
02:28:59 <elliott> oklopol: things your shitty language cannot handle: this function
02:29:29 <oklopol> see <> means "this is the condition"
02:29:40 <oklopol> so nothing worked when it was used multiple times
02:29:56 <elliott> your language is the worst
02:30:04 <elliott> i thought it was pretty stupid mind :D
02:30:27 <elliott> oklopol: i meant it being used as stdlib
02:30:51 <oklopol> i just threw it in the air more like, then started considering it word of god
02:31:16 <elliott> hmhmm do you have negation in this language perchance
02:31:21 <elliott> or should i just pretend negative numbers don't exist
02:31:37 <oklopol> succ ~ {. 0 -> 1 . 1 -> 2 } succ ~ <id>; inc
02:31:51 <oklopol> well you can just sub from zero i suppose
02:31:56 <elliott> oklopol: ^ less stupid ver :P
02:32:33 <elliott> oklopol: now i just have to figure out how to do "is negative?"
02:33:10 <elliott> does this thing have comments
02:33:18 <oklopol> for a proof of nonexistance of comparison operator
02:33:24 <elliott> oklopol: which less than three function
02:33:51 <Sgeo> What language is tis?
02:34:10 <Sgeo> Eso or noneso, it looks noneso
02:34:38 <oklopol> write a comment and give it a bag...
02:34:43 <Sgeo> Also, linky to info? Is this a new language youre making now?
02:34:47 <oklopol> THIS IS AN COMMENT HERE RIGHT HERE ~ <ID>
02:34:52 <elliott> oklopol: comments to erase my undone code :D
02:34:59 <elliott> Sgeo: it's pretty old actually
02:35:01 <oklopol> yeah sorry, nothing for that.
02:35:07 <oklopol> was wondering why you'd need them
02:35:08 <elliott> oklopol: maybe i'll hack in a _stop peeking here_
02:35:28 <oklopol> just strip lines that start with #
02:35:42 <elliott> Sgeo: basically you show a few examples of inputs and outputs in the function, give a basic list of operations to hint the impl what it needs to do, and it figures out the rest
02:35:48 <elliott> works surprisingly well with sufficiently disciplined use
02:35:49 <Sgeo> Ah, old as in, "we're not making it right now"
02:36:09 <oklopol> i told we were playing with my clues
02:36:13 <Sgeo> elliott, that sounds awesome
02:36:20 <oklopol> i don't know uni guys that irc
02:36:33 <Sgeo> "A Clue program is a string consisting only of 0s and 1s. "
02:36:39 <Sgeo> Then what are you talking about?
02:36:44 <elliott> oklopol doesn't use the wiki.
02:37:02 <oklopol> made for the purpose of having a language there
02:37:15 <elliott> make singleton ~ {. 1 -> [1]
02:37:15 <elliott> . [1, 2, 3] -> [[1, 2, 3]]}
02:37:15 <elliott> make singleton ~ <id>; cons; #[]
02:37:19 <elliott> . [3], [4, 5] -> [[3], [4, 5]]}
02:37:21 <elliott> pair ~ <id>; make singleton; cons
02:37:23 <elliott> Sgeo: pretty obvious to see how that works
02:37:35 <elliott> the {. ...} are example inputs -> outputs
02:37:41 <oklopol> but, once you start using recursion, things get slightly more hairy.
02:37:54 <elliott> i think it is pretty obviously the best language?
02:38:25 <elliott> Sgeo: example of recursion, very obvious code here:
02:38:25 <Sgeo> Is it implemented?
02:38:26 -!- Wamanuz has quit (Ping timeout: 272 seconds).
02:38:27 <elliott> ski apply ~ {:. [1, [1, 2]] -> 2
02:38:31 <elliott> ski apply ~ {:. [[2, [1, 3]], 2] -> 3
02:38:35 <elliott> ski apply ~ {:. [[[3, [2, 2]], [2, 1]], 5] -> [2, 1]
02:38:51 <elliott> ski apply ~ {:. [[[[1, 2], 1], 2], 1] -> 1
02:38:57 <elliott> :. [[[[[3, 2], 3], 2], 3], 1] -> 3
02:38:58 <Sgeo> I'm too tired and stressed to think about all that
02:38:59 <elliott> : [[[[3, 2], 3], 2], 3] -> [2, 3]
02:39:05 <elliott> ski apply ~ pair; car; cdr; cadaar; cadar
02:39:07 <elliott> Sgeo: yes, it is implemented
02:39:11 <elliott> obviously figuring out that ski apply just takes like a second
02:39:13 <elliott> the examples illuminate it all
02:39:15 <elliott> and the hints only make it obvious
02:39:36 <oklopol> btw, if you could write all that as actual ski code, it might make *even more* sense, if possible
02:39:44 * Sgeo is too tired to try to understand anything
02:39:57 <elliott> Traceback (most recent call last):
02:40:00 <elliott> TypeError: 'NoneType' object is not iterable
02:40:04 <Sgeo> es I did just say that
02:40:04 <elliott> oklopol: i don't think it likes negatives
02:40:18 <Sgeo> I think I'm going to explode in a Trogdor
02:40:35 <Sgeo> I wa recently linked to H*R somehwere, btpobably TVTropes
02:40:48 <oklopol> you can add new commands if you like
02:40:58 <oklopol> i just added what i absolutely needed for ski, and a few other completely random ones
02:41:01 <Sgeo> What are the Clue primitives?
02:41:06 <oklopol> comparison would be very nice
02:41:13 <oklopol> Sgeo: there are very few, but you can do stuff with lists and numbers
02:41:37 <elliott> nonexistence of a compare function
02:41:53 <elliott> oklopol, adding features before he even realised
02:42:10 <oklopol> what, compare is there? :D
02:42:19 * Sgeo compares oklopol
02:42:25 <hagb4rd> have you written a doc or sth oklopol?
02:42:43 <oklopol> hagb4rd: you're not a regular are ya? :P
02:43:00 <elliott> while i<len(code) and (code[i]=='-' or code[i].isdigit()):
02:43:08 <elliott> oklopol: i like how you've made sure it can parse such numbers as 3--2-1309324-2-34
02:43:10 <oklopol> there's a reference imp, and there's the ski program
02:43:15 <elliott> oklopol: yet neglected to actually allow initial -
02:43:51 <elliott> oklopol: also syntax errors don't actually stop the program...
02:43:57 <elliott> TypeError: compare() takes exactly 2 arguments (1 given)
02:44:04 <elliott> can this thing actually "do" multi arg conditions
02:44:31 <oklopol> things can take multiple args
02:44:38 <oklopol> ski apply is an example of that
02:44:47 <elliott> oklopol: can you do <foo> where foo takes 2 args
02:44:54 <elliott> and if so, how do you get clue not to die by trying it with one
02:45:05 <oklopol> that i don't know, because compare has probably never been tried :D
02:45:19 <oklopol> conditions are kinda special...
02:45:24 <oklopol> they can not take two args xD
02:45:32 <elliott> oklopol: if i made a wrapper for compare
02:45:35 <elliott> that takes it as a two-arg list
02:45:40 <elliott> oklopol: then would that work?
02:45:42 <oklopol> just have <id> as condition
02:45:46 <elliott> it'd have to call pair in the condition of course
02:45:51 <Sgeo> Take it, take it, take it, I've gont tloco
02:46:10 <Sgeo> Sorry, just in a weird mood
02:46:36 <oklopol> somehow i thought giving the condition func would make things faster or whatever, but it's just fucking stupid
02:46:53 <elliott> oklopol: i dont think that'll actually work
02:46:57 <elliott> it doesn't really call compare at ... all
02:47:07 <elliott> oh lol my test was wrong too
02:47:24 <elliott> oklopol: oh my god, it just figured out what zero is
02:47:35 <elliott> Condition: id(['compare', '#0', ['compare', '#0', '#0']])
02:47:55 <elliott> oklopol: it wanted 0, but despite the fact that it was _given_ 0,
02:48:00 <elliott> oklopol: it compares it to itself to get it
02:48:18 <pikhq> Wild shiny mon found.
02:48:19 <oklopol> i'm laughing so goddamn loudly right now
02:48:37 <cheater00> elliott: have you heard about that embarassing DOS bug in php that they have found monday?
02:48:41 <elliott> oklopol: i think, if you have 0, 1, and compare, and you want 0, choosing compare(x,x) to get it is an inspired solution
02:48:54 <elliott> cheater00: yes, but i'd rather forget php exists. also the bug is rather subtle and not _all_ that stupid
02:49:57 <cheater00> they copypasted code from someone who didn't know wtf they were doing.
02:50:02 <elliott> cheater00: no, they didn't
02:50:15 <elliott> cheater00: it was to do with an edge-case on x87 vs sse
02:50:15 <oklopol> elliott: can i get your negative number parsing code?
02:50:32 <elliott> if code[0].isdigit() or code[0]=='-':
02:50:37 <elliott> that's it, the rest you already wrote :D
02:50:40 <cheater00> they didn't even write an exhaustive unit test for it which would have taken, only once executed, a minuscule amount of time.
02:50:52 <elliott> cheater00: unit tests are stupid.
02:50:57 <elliott> executing them only once is doubly so.
02:51:12 <cheater00> you only need to test code once every time it changes
02:51:14 <elliott> cheater00: enjoy enumerating every floating point value lol
02:51:44 <cheater00> exhaustive doesn't mean every value
02:51:49 <cheater00> exhaustive means every important value
02:52:02 <elliott> ah, so basically what you are saying is: they should have predicted the bug perfectly
02:52:08 <cheater00> since when are you such a php fanboi?
02:52:12 <elliott> i hate php, php devs are idiots, but this bug is subtle and not something i would expect anyone to catch.
02:52:18 <elliott> every decision they make is idiotic.
02:52:32 <elliott> but it's like saying, oh, "john mccain raped me and my sister for five days on end and that's why he's terrible"
02:52:37 <elliott> no, that's stupid, he's terrible for entirely other reasons?
02:52:54 <elliott> oklopol: okay so i am going to see if it can NEGATE
02:53:00 <cheater00> a little enjoyment hasn't hurt anyone so far
02:54:07 <elliott> oklopol: so to subtract i use the add function despite the fact thaty ou have decrement :D
02:54:14 <elliott> because there's no subtract functin
02:54:34 <hagb4rd> what bout addin neg numbers
02:54:45 <elliott> oklopol: lol... you can't actually do negate i don't think
02:54:55 <elliott> so to do negate with add, you need negate
02:55:07 <elliott> oklopol: care to try and do negate or subtract as a recursive fn? :D
02:55:32 <oklopol> well you could start incing and deccing in both sides of a pair
02:55:52 <oklopol> well something like that, i mean there's a workaround
02:56:09 <elliott> this platonic core will be perfect forever
02:56:18 <elliott> oklopol: you write the subtract or negate function (negate is more useful for me fwiw)
02:56:20 <Vorpal> elliott, want to get stats on block count so far in building that castle with hmod + worldedit + craftbook?
02:56:25 <elliott> oklopol: wait, why don't we just use lists of []
02:56:28 <elliott> oklopol: to denote naturals
02:56:31 <Vorpal> elliott, even though it is just a shell it is rather massive
02:57:39 <Vorpal> elliott, 596516 stone (note, area uneven, might include 5-10 deep into ground). 62806 obsidian. 968 lightstone. 829 torch.
02:57:47 <Vorpal> plus a number of other ones
02:57:58 <Vorpal> elliott, no, more like half a day of work
02:58:08 <Vorpal> elliott, also some cool redstone stuff :P
02:58:13 <Vorpal> elliott, that took time
02:58:23 <Vorpal> elliott, like the automated arrow shooting battery
02:58:31 <elliott> oklopol: so is negate done yet
02:58:37 <hagb4rd> anyway whats the clue of clue, but making comments useless :p
02:58:44 <oklopol> http://www.vjn.fi/pb/p6778978682.txt
02:59:01 <Vorpal> elliott, flip a lever, watch it shoot. Then watch notch poor code for arrows over network lag the thing to hell
02:59:17 <elliott> oklopol: excuse me, i meant in clue
03:00:04 <elliott> oklopol: i just don't see how you can write negate in clue at all :D
03:00:30 <oklopol> so whether it's negative or positive, you'll find it if you go both directions
03:00:44 <oklopol> that's just comparison with 0
03:00:57 <oklopol> if you know it's negative, then just inc until 0, and inc twice on other track
03:01:11 <oklopol> you'll end up with (0, abs(n))
03:01:21 <elliott> oklopol: no don't do abs, i'm trying to do abs USING negate :D
03:02:01 <oklopol> but anyway the algo i gave is just for negate
03:02:13 <oklopol> and it requires a bit of list fiddling, but shouldn't be too hard
03:02:28 <elliott> oklopol: ok then ... teach me how to recurse :D
03:03:20 <oklopol> if you have like (three points) a -> b (two points) c -> d
03:03:39 <oklopol> then, a is transformed into c, and a and d are transformed into b
03:03:46 <elliott> i need to brb for ooone sec
03:05:05 <oklopol> okay, well that's recursion
03:05:27 <elliott> a and d transformed into b ... what
03:06:02 <elliott> oklopol: so basically, "given f(c) = d, f(a) = b, where c comes from a and b uses a and d"?
03:06:40 <elliott> oklopol: is that ":D how does anyone else but me understand this" :P
03:07:17 <oklopol> well. kind of, i wasn't actually surprised, more like yay ehird so smart i don't have to explain eeeeverything.
03:07:39 <elliott> oklopol: i feel vaguely insulted :D
03:07:50 <oklopol> that's really all there is to recursion, and it is one of the things i like best about clue
03:07:54 <elliott> oklopol: ok so base cases are done with onedots
03:07:58 <elliott> oklopol: and then i have separate blocks with recursion
03:08:09 <elliott> so (0,x) -> x and (x,0) -> x
03:08:10 <oklopol> btw remember it's just the amt of blocks, you can say ... as well
03:08:18 <elliott> yeah? for this abs subfunction thing
03:08:45 <elliott> oklopol: i bet you were real proud of that
03:09:31 <elliott> oklopol: are five dots like
03:09:44 <elliott> what about six dots, are six dots the one-sentence summary of how the code works
03:10:11 <oklopol> maybe five could actually be comments
03:10:32 <elliott> oklopol: do the order of ~{} blocks matter?
03:10:55 <oklopol> now that i've given this thing some thought
03:11:00 <oklopol> i'm pretty sure they don't really
03:11:06 <oklopol> but, i'd but the default case last
03:11:34 <hagb4rd> what if there is no default case?
03:12:12 <elliott> don't specify it, one would assume
03:12:18 <oklopol> i think there will always be one
03:12:27 <elliott> oklopol: okay so wait what tuple do abs(-5) and abs(5) start out with?
03:12:43 <oklopol> which is actually bad for further inference, you should definitely be able to make things fail
03:13:00 <oklopol> well i'd do negate separately
03:13:16 <elliott> oklopol: okay what tuple do negate(-5) and negate(5) start with :D
03:13:36 <oklopol> i'd write those separately too
03:13:53 <oklopol> negate negative starts with (-5, -5)
03:13:54 <Sgeo> Console Hacking 2010 Part 2 - Chaos Communication Congress
03:13:59 <elliott> oklopol: what about negate positive
03:14:00 <oklopol> and the rules is to (inc, inc inc)
03:14:02 <Sgeo> Is this stuff that will be educational to me?
03:14:06 <Sgeo> I seem to be learning
03:14:28 <oklopol> Sgeo: clue is VERY educational, yes
03:14:31 <elliott> oklopol: okay wait negative negative,
03:14:43 <Sgeo> oklopol, I'm talking about a talk
03:14:46 <Sgeo> About PS3 security
03:14:51 <elliott> oklopol: do we keep going?
03:15:23 <oklopol> i'm sure you'll be able to translate that to clue
03:15:34 <elliott> oklopol: hey i don't even need recursion do i
03:15:48 <oklopol> you just need it for the loop
03:16:22 <oklopol> except you could also just write a program that adds the number to itself, twice
03:16:34 <elliott> oklopol: can clue do that?
03:16:46 <oklopol> what it can't do is negate
03:16:54 <elliott> oklopol: right, negate negative is easy
03:16:56 <elliott> oklopol: negate positive won't be
03:17:20 <oklopol> no negate negative won't be easy!
03:17:36 <oklopol> the idea doesn't work, because you'd need to negate so you could negate
03:17:47 <oklopol> you need to add the negation twice!
03:18:11 <elliott> okay so let's see, i'll write this in a language this is actually easy and obvious in and then translate
03:18:46 <elliott> f (x,y) = x where x = f (a, b); a = x+1; b = y+2
03:18:59 <Sgeo> When it says geohot glitched .. something with the RAM, not entirely sure, do they mean physically?
03:19:09 <elliott> negate negative ~ {:. a, b -> c
03:19:16 <elliott> oklopol: i just need to fill in this template a few times, right?
03:19:38 <Sgeo> "It required really annoying hardware to pull off"
03:20:02 <oklopol> and don't forget base case ofc
03:20:28 <elliott> negate negative ~ {:. -5, -5 -> 5
03:20:37 <elliott> oklopol: is that... correct?
03:20:46 <oklopol> sure, although you don't need that much
03:21:04 <oklopol> everything after -4 -3 is excess
03:21:11 <oklopol> the -5 -5 case is not using all that
03:21:31 <elliott> do i need more than one example?
03:21:40 <oklopol> point is to allow it to just brute force one layer instead of always going to base case
03:21:51 <elliott> oklopol: btw i disagree with how you indent these things, IMO the : for subcase should be aligned with the . for supercase
03:21:56 <elliott> then the two x -> ys get aligned
03:22:01 <oklopol> one may do, one may not, i don't really have an intuition for that atm
03:22:44 <elliott> TypeError: 'NoneType' object is not iterable
03:23:25 <elliott> turns out negative negative != negate negative
03:23:52 <elliott> Subast(0,1):['inc', ['inc', '#0']]
03:24:00 <elliott> oklopol: holy shit, it actually works.
03:24:26 <elliott> oklopol: and negate positive is just the same except it's x, 0 and we do dec/dec dec, right?
03:24:35 <oklopol> i believe this to be the case.
03:24:37 <hagb4rd> always wondered y -1*1 makes -1.. thats kind of evil
03:24:44 <oerjan> yo dawg, i heard you like negation
03:25:56 <oerjan> hagb4rd: both (-1)*1 and -(1*1) are -1, of course, even if for slightly different reasons
03:26:17 <oerjan> or rather both follow from x*1 = x actually
03:26:54 <elliott> hagb4rd: do you accept that this is true no matter what x is?
03:26:56 <oerjan> hagb4rd: yes, x*1 = x is one of the field axioms
03:27:22 <elliott> hagb4rd: let us suppose that x = -1. so we have x*1 = x. expanding x's value, we have (-1)*1 = (-1).
03:27:34 -!- zzo38 has joined.
03:27:36 <oklopol> elliott: you needed just one recursion case?
03:27:44 <elliott> oklopol: yup, guess clue is magical
03:27:47 <elliott> oklopol: also negate positive works
03:27:53 <oerjan> it is also true that (-a)*b = -(a*b) for all a and b
03:27:56 <elliott> negate negative ~ {:. -5, -5 -> 5
03:27:56 <elliott> negate negative ~ {. 0, 1 -> 1
03:28:02 <elliott> negate negative ~ <is zero?>; inc
03:28:04 <elliott> oklopol: guess i am a better clue programmer than you?
03:28:49 <hagb4rd> you could have -a*b = b .. isnt it a question of notation?
03:28:50 <elliott> clue.DepthLimitException: depth limit exceeded (negate)
03:28:51 <oklopol> http://www.vjn.fi/pb/p1551824545.txt
03:29:04 <elliott> hagb4rd: so negative one times two apples is two apples?
03:29:14 <elliott> hagb4rd: also, you can have 2*2 = 72.
03:29:17 <oerjan> hagb4rd: um -a*b usually parses as -(a*b)
03:29:20 <elliott> the fact is that * is an operation defined by certain facts about it.
03:29:21 <oklopol> so maybe that's the reason you only needed one
03:29:34 <oerjan> i think some programming languages violate that, though
03:30:06 <elliott> oklopol: oh i think i might actually need a non-inner loop version...
03:30:18 <elliott> or maybe i just need to give it id
03:30:21 <oklopol> you just check if it's pos or neg and negate
03:30:27 <hagb4rd> thats the direction i wanted to get it goin
03:30:42 <elliott> negate ~ <is negative?>; negate negative; negate positive; id
03:30:44 <elliott> oklopol: goes all depth limit,
03:30:46 <elliott> oklopol: because negate X takes two arguments
03:30:48 <elliott> I want it to give them both as the same
03:30:50 <elliott> but i don't know if it's smart enough to
03:30:51 <oerjan> hagb4rd: but it is still true that both the obvious parsing candidates give the same final value
03:31:21 <oklopol> it should certainly be smart enough for that :\
03:31:38 <oerjan> also -a*b = b holds for a = -1 or b = 0
03:31:51 <oklopol> i mean it can deduce things like cadar
03:32:37 <elliott> is negative? ~ {. 0 -> 0 }
03:32:43 <elliott> is negative? ~ <id>; compare; #0; #1
03:32:45 <elliott> i think it might infer wrong ...
03:32:50 <elliott> Condition: id(['compare', '#0', ['compare', '#0', '#0']])
03:33:03 <elliott> that seems very suspicious to me
03:33:58 <oklopol> is #0 the zeroth arg or is it a zero
03:34:26 <elliott> i think it' the zeroth arg
03:34:27 <elliott> but that makes like ... no sense
03:35:19 <elliott> oklopol: just tested in console
03:35:36 <elliott> >>> _['negate negative'](-5,-5)
03:36:06 <elliott> >>> _['negate positive'](5,5)
03:36:14 <elliott> oklopol: you're lying to me about how these constructs work ... or something
03:38:03 <elliott> i mean the _actual test case_ is failing
03:38:14 <elliott> maybe <is zero?> is fucking it up somehow...naw
03:39:07 <hagb4rd> <elliott>the fact is that * is an operation defined by certain facts about it. <-- so multiplication of a negative and a positive value results in a negative value,yes..it may be a metaphysical question, but i wonder if it's based on a natural law or just another entropy
03:39:20 <elliott> oerjan: do you have the swatter?
03:39:27 <elliott> oerjan: it is _really_ desperately needed.
03:40:00 <elliott> oklopol: ok mine can't even figure out a one-arg negate negative :D
03:40:22 <elliott> oklopol: i think our implementations are subtly different now :/
03:40:49 <oklopol> i'll finish mine, and try to come up with why you can't
03:41:52 <elliott> oklopol: gimme your current src tree and i'll diff it against mine
03:45:39 <oklopol> http://www.vjn.fi/pb/p2332981772.txt http://www.vjn.fi/pb/p1364929955.txt http://www.vjn.fi/pb/p9712658752.txt
03:46:33 <elliott> oklopol: okay, you have negate built in obvs
03:47:14 <elliott> oklopol: the only cluedifferences we have are that i fixed the exception messages differently
03:47:29 <elliott> cluetest mine is just a bit more featured
03:47:34 <elliott> print funcs["is negative?"](-7) # --> 3
03:48:24 <oklopol> hey i can't get this little pecker to compile
03:49:18 <elliott> clue is still the stupid one
03:49:52 <oklopol> something wrong with parsing maybe, because negate negative works, but negate positive doesn't, even though i just changed signs
03:50:51 <hagb4rd> oerjan.. hmm.. okay.. so if -ab is kind of a short to notation to -1*a*b*.. there is no need to think in cases of negative or positive, right?.. makes sence
03:50:56 <elliott> oklopol: since the recursion is different
03:51:55 <oklopol> and it's parsing that fails
03:52:00 <elliott> i'm just fixin' my negate negative
03:52:10 <oklopol> as can easily be seen from the error message...........
03:52:17 <oklopol> Traceback (most recent call last):
03:52:17 <oklopol> File "C:\stuff}clue\cluetest.py", line 10, in <module>
03:52:17 <oklopol> funcs,asts=clue.compile_all(open(cluefile).read(),stuff.funcs)
03:52:17 <oklopol> File "C:\stuff}clue\clue.py", line 618, in compile_all
03:52:17 <oklopol> File "C:\stuff}clue\clue.py", line 596, in parse
03:52:17 <oklopol> clues[i]=stuff_to_clue(tokenized[i])
03:52:18 <oklopol> File "C:\stuff}clue\clue.py", line 589, in stuff_to_clue
03:52:19 <oklopol> cond,others=separate_cond(helpers)
03:52:19 <oklopol> TypeError: 'NoneType' object is not iterable
03:52:24 <oklopol> what kind of piece of shit wrote this thing
03:52:31 <oklopol> I WANT FUCKING ERROR MESSAGES
03:52:48 <elliott> oklopol: ahh ,yes, i remember that error
03:52:51 <elliott> oklopol: show me your code?
03:52:58 <elliott> oklopol: i think you forgot to specify clues
03:53:00 <elliott> you got a name wrong somewhere
03:53:47 <elliott> clue.DepthLimitException: depth limit exceeded (really negate positive)
03:54:29 <elliott> >>> _['negate positive'](5,5)
03:54:32 <elliott> >>> _['negate positive'](5,5)
03:54:48 <oklopol> i noticed when i checked my names
03:56:21 <elliott> and your impl was all like
03:57:52 <elliott> Condition: is negative?('#0')
03:57:53 <elliott> ['negate negative', '#0', '#0']
03:57:57 <elliott> ['negate positive', '#0', '#0']
03:58:01 <oklopol> it's not the most user friendly thing
03:58:43 <elliott> Condition: is negative?('#0')
03:59:44 <oklopol> in my defense, i was just gonna do negate negative, not all of negate
03:59:54 <oklopol> elliott: well i finished before you, so prolly not
04:00:02 <elliott> oklopol: did you get abs before me
04:00:17 <elliott> oklopol: i will just have to figure out subtraction
04:00:31 <hagb4rd> the second mouse gets the cheese
04:00:42 <oklopol> yeah i couldn't have seen how that's done
04:00:56 <oklopol> it's like you... meh i'm not even gonna try
04:01:38 <oklopol> well, that's pretty simple..... except you need to do positives and negatives separately again :D
04:01:39 <elliott> subtract ~ <_>; add; negate
04:01:47 <elliott> ['add', '#0', ['negate', '#1']]
04:01:49 <oklopol> i'm a serious fucking retard
04:02:11 <elliott> oklopol: http://sprunge.us/DFfN
04:02:16 <elliott> oklopol: to be honest add shouldn't exist.
04:02:34 <elliott> oklopol: in fact, nothing should exist except pairs and one non-pair object
04:02:44 <elliott> oklopol: no multiple arguments, that's done with pairs
04:03:03 <oklopol> you do realize *ski* takes 20 seconds to compile, and functions are executed about a million times when you compile somethin
04:03:06 <elliott> oklopol: indeed, in a sufficiently advanced implementation, functions would be represented as lists in this kind
04:03:19 <elliott> oklopol: yeah so since it's useless, let's make it good and useless
04:03:54 <oklopol> btw i was close to adding higher order functions to the impl, not really any more work, but would be fucking awesome
04:04:05 <oklopol> i mean just think about the clue definition of map
04:04:25 <elliott> oklopol: see, like i said, do functions as lists
04:04:32 <elliott> oklopol: then you already have it all :D
04:04:36 <elliott> just have an apply function
04:04:40 <elliott> taking an object and an objects
04:04:45 <elliott> object = pair object object | nil
04:04:58 <elliott> and "foo" in examples is just a reference to that object ofc
04:05:21 <oklopol> because it's pretty much perfect now
04:05:30 <oklopol> it just needs MORE stuff, and a better conditional
04:05:42 <elliott> oklopol: this would be more stuff
04:05:45 <oerjan> hagb4rd: the rule -(a*b) = (-a)*b holds for more than just ordinary numbers, it holds for any ring including those where you cannot distinguish positive and negative elements.
04:07:27 <oerjan> > all [ -(a*b) == (-a)*b | a <- [0 .. 255::Word8], b <- [0 .. 255::Word8]]
04:07:28 <lambdabot> Couldn't match expected type `a -> GHC.Bool.Bool'
04:07:43 <oerjan> > and [ -(a*b) == (-a)*b | a <- [0 .. 255::Word8], b <- [0 .. 255::Word8]]
04:07:54 <elliott> oklopol: but you have no expression syntax :D
04:07:58 <elliott> so how ya gonna test things
04:08:05 <oerjan> hagb4rd: Word8 being one such ring, arithmetic mod 256
04:08:25 <oklopol> elliott: i'm not proud of this but... clue was supposed to have main
04:08:35 <zzo38> Do you think there should be any BytePusher related stuff in the esoteric programming files archive?
04:09:31 <elliott> oklopol: all you have to do is write another parser then
04:09:33 <oklopol> that's a bit... impure, really i'd prefer that you can't actually run the programs!
04:09:35 <elliott> oklopol: or reuse the existing one
04:10:00 <oklopol> you just give the bot definitions
04:10:07 <oklopol> and then you can give it mains which are expressions
04:10:08 <elliott> will the parser parse that?
04:10:17 <oklopol> right you would need to parse...
04:10:31 <elliott> oklopol: basically, what can the parser parse that's nested reasonably :D
04:10:56 <oklopol> clue doesn't have logical nesting
04:11:16 <elliott> oklopol: ok if you just extend the parser a tiny bit
04:11:24 <elliott> every expression is parsed as
04:11:27 -!- azaq231 has joined.
04:11:30 <oklopol> and by logical i meant control
04:11:58 <elliott> :. func, 1, x, 2 -> result; func2, 34 -> x
04:12:10 <elliott> :. func, 1, x, 2 -> result : func2, 34 -> x
04:12:39 <oklopol> yeah you could have something like that in a bot
04:12:50 <elliott> oklopol: i mean all you have to do is keep strings you can't parse
04:12:58 <elliott> oklopol: i mean you don't need to write a parser
04:13:04 <elliott> this gives you expressions for FREE
04:13:26 -!- azaq23 has quit (Ping timeout: 272 seconds).
04:13:53 <oklopol> or you could just have somekinda ugly sexp syntax
04:14:07 <oklopol> is that not what you're talking about
04:14:21 <elliott> oklopol: but this way you get to reuse almost the existing parser
04:14:26 <elliott> so it's SO MUCH MORE CONVENIENT?
04:15:17 <oklopol> heeeey i could implement quicksort!
04:15:25 <oklopol> i wonder when i implemented that last
04:15:46 <elliott> oklopol: is that even possible in clue
04:16:02 <oklopol> it's a pretty high-level language
04:18:20 <oklopol> hmm, why can functions only return one value
04:18:29 <elliott> oklopol: workin on the bot
04:18:47 <oklopol> yeah i sort of came up with that
04:20:12 -!- azaq231 has quit (Changing host).
04:20:12 -!- azaq231 has joined.
04:20:24 <elliott> oklopol: take a look at my amazing ast representation
04:20:28 <elliott> [is zero?('#0')] <>(0) =>{0,0}:['inc', '#0'] ; {0,1}:['inc', ['inc', '#1']] ; ;; <= '#2' ;; !.(1) => '#1' ;;
04:20:48 <elliott> hahahaha wow that is the worst ever :D
04:23:28 <elliott> [is negative?('#0')] .(1) => ['negate negative', '#0', '#0'] | .(0) => ['negate positive', '#0', '#0']
04:23:31 <elliott> oklopol: it's getting better!
04:24:53 <elliott> oklopol: what _is_ the "main ast" anyway, for a recursion
04:25:28 <oklopol> i think it's default branch, but... umm....
04:25:50 <oklopol> i guess it's the part that calculates actual result
04:26:07 <oklopol> then there's special asts that calculate subinputs from input
04:26:38 <oklopol> also, i can't get pivot to compile, and i'm not sure it's a coding error...... :D
04:28:11 <elliott> |^(0) => '#2' <= {(0,0): ['dec', '#0']; (0,1): ['dec', ['dec', '#1']]; }
04:28:16 <elliott> oklopol: this is actually a nicer syntax in general xD
04:29:15 <oklopol> actually it was a coding error, and it compiles in a microsecond
04:30:27 <oklopol> that was just a quick thingie so i could see what was going on, i think
04:30:48 <oklopol> or maybe i did give it some thought, don't really remember, if i did, it was bad touhght.
04:31:14 <elliott> this is actually starting to make sense :D
04:31:26 <elliott> oklopol: do Clues know what their constants are?
04:35:06 <elliott> |.(_) => add(#0, negate(#1))
04:35:12 <elliott> |.(1) => {negate negative}(#0, #0)
04:35:14 <elliott> |.(0) => {negate positive}(#0, #0)
04:35:27 -!- Mathnerd314 has quit (Quit: ChatZilla 0.9.86-rdmsoft [XULRunner 1.9.2.12/20101026210630]).
04:35:58 <elliott> |^(0) => #2 <= {(0,0): dec(#0); (0,1): dec(dec(#1))}
04:36:03 <elliott> i can even understand that if i try hard enough :D
04:36:22 <elliott> oklopol: so um constants are _not_in the bag
04:37:28 <oklopol> somehow i think i should optimize this thing, i've been compiling pivot for a couple minutes now
04:38:03 <oklopol> it's incredibly hard to rip a list open, since from the program's standpoint that's not in anyway more sensible than adding stuff to it.
04:38:27 <oklopol> i'm going to make it more sensible, but because i need to do it in a pure an extensible way, that's easier said than done
04:38:58 <elliott> oklopol: could i actually rewrite these constanty things to their val... nah
04:40:32 <elliott> [is zero?(#0)] |^(0) => #2 <= {(0,0): dec(#0); (0,1): dec(dec(#1))} |.(1) => #1
04:40:36 <elliott> [id(#0)] <= [0, 1] |.(0) => #1 |.(_) => #0
04:40:39 <elliott> think that's about as nice as these are gonna get
04:42:54 <elliott> oklopol: wanna write a parser for this
04:43:49 <elliott> oklopol: expr := '#' nat | int | (string_without_spaces | '{' string '}') '(' args ')'
04:43:55 <elliott> where args is comma-separated expr
04:43:58 <Sgeo> Where is the lid?
04:43:59 <elliott> oklopol: c'mon, it'll be fuuun :D
04:44:01 <Sgeo> Oh where is the lid?
04:44:09 <Sgeo> Where is the, where is the, where is the liiiid?
04:44:49 <elliott> oklopol: ok i'll write the parser, but you have to tell me how lovely i am for four days after that
04:46:05 <oklopol> Sgeo: liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
04:48:28 <oklopol> no but seriously i need to optimize this thing, it's kinda ridiculously slow atm :D
04:48:50 <elliott> oklopol: i just realised that your language is so awesome that you don't even need {}
04:49:25 <elliott> [is negative?(#0)] |.(1) => negate negative(#0, #0) |.(0) => negate positive(#0, #0)
04:53:46 <elliott> >>> park('is zero?(#0) this is a comment')[0]
04:53:46 <elliott> ('a', 'is zero?', [('v', 0)])
04:53:54 <elliott> oklopol: note my cunning disregard for trailing text providing useful comment functionality
04:54:09 <elliott> hm wait don't actually need #n here
04:54:31 <oklopol> i managed to compile a tiny helper function for pivot
04:54:45 <elliott> oklopol: should i require commas between arguments
04:55:11 <oklopol> i should probably remove some commas from clue
04:57:20 <elliott> [id(compare(#0 compare(#0 #0)))] <= [0 1] |.(-1) => #1 |.(0) => #0 |.(1) => #0
04:58:16 <oklopol> why does it consistently add that extra computation, i will never understand
04:58:37 <Sgeo> elliott, you didn't punch me. Why didn't you punch me?
04:59:22 <oklopol> i need to reimplement this fucker in a faster language, with a less brute force algo
04:59:54 <elliott> oklopol: ok quick does clue support adding things to a funcs dict
05:00:27 <oklopol> can you get cons to caaar 0, [[1], [2], [3]] -> [[1], [2], [0, 3]] to compile?
05:00:55 <oklopol> the funcs dict is a python dictionary....
05:01:09 <elliott> can i add its compilation to func
05:01:10 <oklopol> cons to caaar ~ {. 0, [[1], [2], [3]] -> [[1], [2], [0, 3]] }
05:01:15 <elliott> assuming it uses the stuff always in funcs
05:01:22 <oklopol> if you can compile that, you're my hero
05:01:28 <elliott> oklopol: well my impl is the same as yours, or do you want me to fiddle with hints
05:01:35 <elliott> if so, i will, just as soon as i get cluebot working, which will be soon
05:01:45 <oklopol> you have an impl for that?
05:02:09 <oklopol> but yeah i do want you to fiddle with hints
05:02:32 <oklopol> i always meant for it to be really hard to get things to compile, but i just plain can't come up with a way to do that :D
05:02:42 <oklopol> well, maybe some reeeeeeeally roundabout way
05:03:13 <oklopol> i mean you can write sequential code if you like ofc
05:03:20 <elliott> oklopol: oh fucking god, compile_all is a bitch
05:03:33 <elliott> oklopol: isn't there something to like...fuck
05:03:52 <elliott> oklopol: compile_all... can you use it on a predone funcs?
05:04:25 <oklopol> i think you can separate parsing if you like
05:04:32 <oklopol> but i don't know what you're supposed to call then
05:05:45 <elliott> asts.update(clue.compile_all(coeducational, funcs)[1])
05:05:48 <elliott> thought koed was too cliche
05:06:41 <oklopol> okay, now it compiles in 4 seconds
05:07:33 <oklopol> i used to use koed because it's nice to write
05:07:40 <oklopol> koedkoedkoedkoedkoedkoedkoedkoedkoed
05:08:15 <elliott> >>> cabinetoflaughter('is negative?(-1)')
05:08:18 <elliott> evaluation function: not so good
05:08:58 <zzo38> Do you know the Unolympics?
05:10:34 * Sgeo wonders what Inventables stuff are good to just have fun with
05:11:44 <elliott> oklopol: cluebot nick is taken :D
05:12:06 <elliott> oklopol: cluebot -> cluebat -> luser attitude readjustment clue
05:12:54 <zzo38> oklopol: That's OK, I don't know either.
05:13:21 <oklopol> zzo38: what do you know then?
05:13:46 <elliott> oklopol: larc is registered :D
05:14:02 <elliott> LUser ATtitude REadjustment clue
05:16:02 <elliott> oklopol: so I'm thinking, for luatre commands,
05:16:04 <zzo38> oklopol: It is just idea... make Unolympics with difference from Olympics, with events such as: * Circular reasoning * Judge bribing * Flagpole sitting * Beer drinking contest * Watch TV all channels at once by changing the channels really fast * You are allowed to use any drugs you want in order to win
05:16:12 <elliott> oklopol: three dots evaluates, four dots defines
05:16:14 <elliott> oklopol: five dots looks up
05:17:32 <zzo38> six dots is just for testing
05:17:40 <zzo38> seven dots means you win immediately
05:17:52 <oerjan> elliott: um it's lart not larc
05:17:58 <elliott> oerjan: luser attitude readjustment clue
05:18:06 <elliott> cluebot -> cluebat -> luser attitude readjustment clue
05:18:11 <oklopol> ARRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRGH FUCKING CLUE IMPLEMENTATION
05:18:16 <oerjan> but lart is already the same as a cluebat
05:18:18 <oklopol> who the fuck as written this piece of shit
05:18:31 <oklopol> i'm gonna kill that little homo
05:19:12 -!- luatre has joined.
05:19:25 -!- luatre has quit (Remote host closed the connection).
05:19:30 -!- luatre has joined.
05:19:46 -!- luatre has quit (Remote host closed the connection).
05:19:50 -!- luatre has joined.
05:20:16 -!- luatre has quit (Remote host closed the connection).
05:20:20 -!- luatre has joined.
05:20:56 -!- luatre has quit (Remote host closed the connection).
05:21:00 -!- luatre has joined.
05:21:10 -!- luatre has quit (Remote host closed the connection).
05:21:14 -!- luatre has joined.
05:21:37 <elliott> zzo38: luatre will not respond
05:22:06 <zzo38> O, I didn't know that.
05:22:10 -!- luatre has quit (Remote host closed the connection).
05:22:16 -!- luatre has joined.
05:22:41 -!- luatre has quit (Remote host closed the connection).
05:22:44 -!- luatre has joined.
05:22:49 <oklopol> yeah umm okay the pivot function may not be implementable :D
05:22:56 <oklopol> i mean, in any sensible way at least
05:23:28 -!- luatre has quit (Remote host closed the connection).
05:23:32 -!- luatre has joined.
05:23:42 -!- luatre has quit (Remote host closed the connection).
05:23:49 <oklopol> it doesn't really have to do all that much...
05:25:18 -!- luatre has joined.
05:25:31 -!- zzo38 has quit (Quit: <CTCP>).
05:25:34 -!- luatre has quit (Remote host closed the connection).
05:25:47 -!- luatre has joined.
05:25:50 <luatre> maximum recursion depth exceeded in cmp :(
05:26:01 -!- luatre has quit (Remote host closed the connection).
05:26:05 -!- luatre has joined.
05:26:07 -!- luatre has quit (Remote host closed the connection).
05:26:19 -!- luatre has joined.
05:26:50 -!- luatre has quit (Remote host closed the connection).
05:26:57 -!- luatre has joined.
05:26:59 <luatre> <type 'exceptions.TypeError'>: cannot concatenate 'str' and 'int' objects :(
05:27:57 -!- luatre has quit (Remote host closed the connection).
05:28:35 <oerjan> wtf http://i.imgur.com/vymTu.jpg
05:31:04 -!- luatre has joined.
05:31:10 <luatre> exceptions.RuntimeError: maximum recursion depth exceeded in cmp :(
05:32:22 -!- luatre has quit (Remote host closed the connection).
05:32:27 -!- luatre has joined.
05:32:28 <oklopol> as far as pieces of shit go, this program is one; i don't mind the lack of error messages really, but fucking hell i can't anything compiled :D
05:32:33 <luatre> exceptions.RuntimeError: maximum recursion depth exceeded in __instancecheck__ :(
05:32:51 <oklopol> i think i compiled stuff more complicated than pivot at some point
05:32:56 <luatre> exceptions.RuntimeError: maximum recursion depth exceeded in __instancecheck__ :(
05:33:58 -!- luatre has quit (Remote host closed the connection).
05:34:02 -!- luatre has joined.
05:34:31 <elliott> :: is zero? ~ {.0->1} is zero? ~{.1->0 .2->0} is zero? ~ <id>; #0; #1
05:34:32 <luatre> is zero?: [id(#0)] <= [0 1] |.(0) => #1 |.(_) => #0
05:34:41 <oklopol> i'm going to compile pivot overnight and see if something happens
05:34:51 <luatre> is zero?: [id(#0)] <= [0 1] |.(0) => #1 |.(_) => #0
05:34:54 <luatre> exceptions.KeyError: 'cons' :(
05:34:58 <luatre> is zero?: [id(#0)] <= [0 1] |.(0) => #1 |.(_) => #0
05:35:39 -!- luatre has quit (Remote host closed the connection).
05:35:44 -!- luatre has joined.
05:35:47 <elliott> oklopol: did i mention that my expression syntax is awesome
05:35:55 <elliott> oklopol: it's literally just
05:35:58 <oklopol> [id(#0)] <= [0 1] <<< this is like what args it gets or?
05:36:09 <elliott> oklopol: feed it something recursive
05:36:28 <elliott> expr := int | '[' expr* ']' | name '(' expr* ')' <----- the entire expression syntax
05:36:30 <oklopol> that's rather verbose, but k
05:36:33 <elliott> with whitespace being irrelevant except to separate
05:36:44 <elliott> oklopol: what is, recursive stuff?
05:36:48 <elliott> or the way to show constants
05:37:40 <oklopol> erm so i don't really see how that syntax works if i'm supposed to use that for def as well
05:37:51 <elliott> oklopol: just remove all newlines
05:37:51 <oklopol> or do i just write normal code
05:38:05 <elliott> oklopol: threedots = expression
05:38:14 <elliott> oklopol: fivedots = look up the ast of this function i give
05:38:22 <elliott> oklopol: guess how many lines cluebot.py is, note that my replacement for get_ast is in there (not in clue.py), also the parser and evaluator for my expression language, and all the irc code :|
05:41:20 <oklopol> .:. parity helper ~ { . 0, 0 -> 0 . 0, 1 -> 1 } parity helper ~ { :. 5, 1 -> 0 : 4, 0 -> 0 :. 3, 0 -> 1 : 2, 1 -> 1 } parity helper ~ <id>; compare; #0; #1; sub
05:41:20 <luatre> Exception: Can't compile parity helper(sub) :(
05:42:07 <elliott> oklopol: i can add it if you want me to cheat
05:42:38 <elliott> :: sub ~ {.1,3->-2 .2,1->1 .-3,-2 -> -1} sub ~ <_>; add; negate
05:42:39 <luatre> Exception: Can't compile sub(negate) :(
05:43:25 <elliott> :: is negative?~{.-1->1 .-2->1} is negative?~{.0->0} is negative?~{.1 -> 0 .2 ->0} is negative? ~ <id>; compare; #0; #1
05:43:26 <luatre> is negative?: [id(compare(#0 compare(#0 #0)))] <= [0 1] |.(-1) => #1 |.(0) => #0 |.(1) => #0
05:43:47 <oklopol> can't you just add it as a primitive :D
05:43:56 <elliott> : negate negative ~ {:. -5, -5 -> 5 : -4, -3 -> 5 :. -4, -3 -> 5 : -3, -1 -> 5 :. -3, -1 -> 5 : -2, 1 -> 5 } negate negative ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate negative ~ <is zero?>; inc
05:44:01 <elliott> :: negate negative ~ {:. -5, -5 -> 5 : -4, -3 -> 5 :. -4, -3 -> 5 : -3, -1 -> 5 :. -3, -1 -> 5 : -2, 1 -> 5 } negate negative ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate negative ~ <is zero?>; inc
05:44:01 <luatre> Exception: Can't compile negate negative(is zero?) :(
05:44:20 <elliott> :: is zero? ~ {.0->1} is zero?~{.1 ->0 .2->0} is zero?~<id>; #0; #1
05:44:21 <luatre> is zero?: [id(#0)] <= [0 1] |.(0) => #1 |.(_) => #0
05:44:23 <elliott> :: negate negative ~ {:. -5, -5 -> 5 : -4, -3 -> 5 :. -4, -3 -> 5 : -3, -1 -> 5 :. -3, -1 -> 5 : -2, 1 -> 5 } negate negative ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate negative ~ <is zero?>; inc
05:44:24 <luatre> negate negative: [is zero?(#0)] |^(0) => #2 <= {(0,0): inc(#0); (0,1): inc(inc(#1))} |.(1) => #1
05:44:52 <elliott> :: negate positive ~ {:. 5, 5 -> -5 : 4, 3 -> -5 :. 4, 3 -> -5 : 3, 1 -> -5 :. 3, 1 -> -5 : 2, -1 -> -5 } negate positive ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate positive ~ <is zero?>; dec
05:44:52 <luatre> negate positive: [is zero?(#0)] |^(0) => #2 <= {(0,0): dec(#0); (0,1): dec(dec(#1))} |.(1) => #1
05:45:04 <elliott> i like how the ast dumps are nicer than the actual code
05:45:19 <elliott> :: negate ~ {. -1 -> 1 . -2 -> 2 . -3 -> 3 }negate ~ {. 0 -> 0 . 1 -> -1 . 2 -> -2 }negate ~ <is negative?>; negate positive; negate negative
05:45:20 <luatre> negate: [is negative?(#0)] |.(1) => negate negative(#0 #0) |.(0) => negate positive(#0 #0)
05:45:26 <elliott> :: sub ~ {.1,3->-2 .2,1->1 .-3,-2 -> -1} sub ~ <_>; add; negate
05:45:27 <luatre> sub: [_(#0)] |.(_) => add(#0 negate(#1))
05:45:31 <oklopol> they are not nearly as nice
05:45:43 <oklopol> .:. parity helper ~ { . 0, 0 -> 0 . 0, 1 -> 1 } parity helper ~ { :. 5, 1 -> 0 : 4, 0 -> 0 :. 3, 0 -> 1 : 2, 1 -> 1 } parity helper ~ <id>; compare; #0; #1; sub
05:45:44 <luatre> parity helper: [id(#0)] <= [0 1] |.(0) => #3 |^(_) => #4 <= {(0,0): sub(#2 #1); (0,1): compare(#1 #3)}
05:46:53 <luatre> ValueError: substring not found :(
05:47:08 <luatre> ValueError: substring not found :(
05:47:29 <luatre> RuntimeError: maximum recursion depth exceeded in __instancecheck__ :(
05:47:43 <elliott> what's parity helper(-2 1) meant to be
05:48:49 <oklopol> :: parity ~ {. 3 -> 1 . 2 -> 0 . 1 -> 1 } parity ~ <_>; #0; parity helper
05:48:50 <luatre> parity: [_(#0)] <= [0] |.(_) => parity helper(#1 #0)
05:48:58 <luatre> ValueError: substring not found :(
05:49:20 <oklopol> dunno about that, but i love clue again
05:49:30 <oklopol> maybe i could just hack up some crappy special casing for lists
05:49:43 <oklopol> because those are impossible to brute force together
05:50:09 <oklopol> whereas in numerical algos, i always completely underestimate the speed
05:50:34 <oklopol> like, when that parity helper compiled, i assumed it was an error message because it was so fast, never seen anything happen that fast with lists
05:53:12 <elliott> oklopol: i should sleep now
05:53:18 <elliott> you can have cluebot.py tomorrow or something
05:53:36 -!- elliott has quit (Remote host closed the connection).
05:53:45 -!- luatre has quit (Remote host closed the connection).
05:54:07 <oklopol> clue cluecleucluceluceluceluceluceluclueclueclue
05:54:21 <oklopol> tomorrow's retro language: toi
05:55:27 <hagb4rd> have you been here before oklopol?
05:55:50 * Sgeo blinks at hagb4rd
05:56:48 -!- TLUL has joined.
05:57:25 <oklopol> been ircing kinda lazily lately
05:57:38 <oklopol> since i have irl stuff i should be doing
05:57:42 -!- poiuy_qwert has joined.
05:59:07 <oklopol> i just realized graphica has kind of a similar syntax as clue
05:59:38 <oklopol> or maybe ef, although i have no idea how that thing works.......
06:01:58 <oklopol> well it's a verrry old language
06:07:44 -!- TLUL has quit (Ping timeout: 255 seconds).
06:13:19 <hagb4rd> i really like this chan..must admit i haven't found anything comparable on the whole wide irc net
06:14:40 <Sgeo> Oh, didn't mean to accidentally offend you
06:14:47 <Sgeo> It's just that oklopol has been here for a long time
06:14:57 * Sgeo continues to fail to eat
06:15:27 <Sgeo> Glad to.. see that
06:17:13 * oerjan hits Sgeo with the saucepan ===\__/
06:19:04 <oklopol> hagb4rd: when did you come?
06:19:23 <oklopol> that was a very rare moment of sanity you saw there, i arranged it just for you
06:19:36 <oklopol> we were talking about porn when you entered
06:20:02 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
06:20:19 <hagb4rd> and i still dont understand anything
06:20:38 <hagb4rd> but, thats kind of good news
06:21:06 <oklopol> have you seen any of my definition listings
06:21:07 <hagb4rd> looking for teachers and friends ya know
06:21:21 <oklopol> i sometimes just define random math concepts
06:22:13 <Sgeo> Phantom_Hoover: If you logread, I think I accidentally left Station V3 [and sister comics on occasion] off the list
06:25:19 <oklopol> mainly to know whether i've been doing that lately
06:29:40 <hagb4rd> thats far behind my person insight so far..but it wouldnt surprise me at all
06:31:54 <hagb4rd> damn, my corroded-schoolenglish must be insulting, so please excuse.. im tryin to fix this
06:38:12 <hagb4rd> and oerjan is send by the goodlord himself.. the good soul ..a real philanthrope :D
06:39:07 <hagb4rd> please just shut up and don't refuse ;)
06:44:17 -!- copumpkin has joined.
06:50:31 -!- poiuy_qwert has quit (Ping timeout: 260 seconds).
06:53:08 <Sgeo> I'm about to start falling asleep on people
06:54:28 <oerjan> that may not be advisable
06:56:59 <hagb4rd> have you considered taking a vacation sgeo?
07:01:45 -!- Zuu has quit (Read error: Connection reset by peer).
07:03:05 <hagb4rd> or feed some animals in the zoo
07:10:37 -!- Zuu has joined.
07:41:27 -!- cal153 has joined.
07:50:21 -!- zeotrope has quit (Quit: Lost terminal).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:35:18 -!- zzo38 has joined.
08:37:54 -!- zzo38 has quit (Remote host closed the connection).
08:39:29 -!- Sgeo has quit (Read error: Connection reset by peer).
08:46:04 -!- j-invariant has joined.
09:16:01 -!- copumpkin has quit (Ping timeout: 250 seconds).
09:16:26 -!- copumpkin has joined.
09:20:15 -!- azaq231 has quit (Quit: Leaving.).
09:32:45 -!- Phantom_Hoover has joined.
09:32:45 -!- Phantom_Hoover has quit (Changing host).
09:32:45 -!- Phantom_Hoover has joined.
09:39:33 -!- impomatic has joined.
09:39:56 <impomatic> Does anyone know when BF Joust and FYB were added to EgoBot?
09:49:50 <oerjan> For BF Joust, i think it was approximately the same time as it was added to the wiki
09:50:17 <oerjan> http://esolangs.org/w/index.php?title=BF_Joust&diff=14558&oldid=14535
09:52:20 <oerjan> for fukyorbrane, i have a vague idea that it was in the previous version of EgoBot as well. the wiki article is from before i joined here.
09:55:32 <oerjan> of course Gregor is the appropriate person to ask
09:57:43 <Gregor> FYB was in EgoBot as long as both existed, more or less, but that was in the pregobot.
09:58:05 <Gregor> It's been in this EgoBot for considerably less time, the hg log is sure to elucidate: https://codu.org/projects/egobot/hg/
09:58:58 -!- MigoMipo has joined.
09:59:35 <Gregor> 20 months for FYB, 19 months for BFJoust.
10:11:35 -!- oerjan has quit (Quit: Good night).
10:23:53 -!- cheater00 has quit (Ping timeout: 240 seconds).
10:25:02 -!- cheater00 has joined.
10:33:12 <Vorpal> Phantom_Hoover, somehow I read that as "pogobot" first. (as in pogo-stick)
10:33:29 -!- Wamanuz has joined.
11:24:24 <impomatic> Gregor: 19 months is for the new version of BFJoust. Can you remember when it supported the original?
11:24:58 <Gregor> This was the only version it ever supported.
11:25:04 -!- impomatic has quit (Read error: Connection reset by peer).
11:25:42 -!- impomatic has joined.
11:26:11 <impomatic> Firefox always crashes when I click a link in ChatZilla :-(
11:28:07 <Gregor> <impomatic> Gregor: 19 months is for the new version of BFJoust. Can you remember when it supported the original?
11:28:07 <Gregor> <Gregor> This was the only version it ever supported.
11:28:26 <impomatic> Gregor: sorry, I was thinking of the hill that used to be at http://faculty.washington.edu/kerim/nomic/bf/ :-)
11:28:47 <Gregor> Besides, my BFJoust hill is more fair :P
11:38:58 -!- cheater00 has quit (Read error: Connection reset by peer).
11:41:48 -!- cheater00 has joined.
11:42:46 -!- MigoMipo has quit (Remote host closed the connection).
11:55:45 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
12:00:17 -!- cheater00 has quit (Ping timeout: 240 seconds).
12:02:12 -!- MigoMipo_A has joined.
12:17:27 -!- Phantom_Hoover has joined.
12:17:40 * Phantom_Hoover boggles at the stupidity of Windows anti-virus software.
12:18:37 <Phantom_Hoover> It's not unknown for Norton to identify itself as a virus, and both McAfee and AVG have deleted essential Windows files which they thought were viruses.
12:42:37 -!- Sgeo has joined.
12:49:58 -!- cheater00 has joined.
12:50:56 <j-invariant> Phantom_Hoover: got any screenshots of Mt. Hoover?
12:56:03 <Phantom_Hoover> That's from a while ago; I've put a better lighting system in since and removed that small amount of dirt to the back of the room.
12:56:34 <Sgeo> Phantom_Hoover, did you read logs?
12:56:39 <Sgeo> [Nothing important]
12:57:07 <j-invariant> I love how this game is like lemmings: Stuff does not just fall down
12:57:19 <Sgeo> Sand and gravel does!
12:57:24 <Phantom_Hoover> (The better lighting system in question is a layer of glass with lava on top.
12:57:36 <Sgeo> And water and lava... are water and lava
12:57:39 <Vorpal> j-invariant, sand and gravel falls though
12:58:20 <Sgeo> Which is more worthless? Gravel or gold?
12:58:57 <Vorpal> Sgeo, probably gravel, unless you are draining. At least gold can be used for watches and you can also built nice looking thrones out of gold blocks
12:59:20 <Phantom_Hoover> Vorpal, gravel is the only source of flint, which is very useful.
12:59:24 <Vorpal> huh, seems like it snows, rains and hails at the same time.
12:59:34 <Phantom_Hoover> Gold can be used for nothing but watches and decoration.
12:59:35 <Vorpal> Phantom_Hoover, hm true
13:11:17 <Sgeo> And golden apples!
13:12:01 <Phantom_Hoover> Golden apples are good for bragging rights; that's it.
13:13:52 <Sgeo> That sounds almost like a quote from the wiki
13:18:07 <Vorpal> Phantom_Hoover, found it as a golden apple in a dungeon
13:18:23 <Vorpal> never found even a normal apple in any local game or on SMP
13:18:33 <Vorpal> Phantom_Hoover, no I mentioned it once. That was all
13:19:01 <Phantom_Hoover> You've probably secreted it in one of your super-secret underground bunkers in the wilderness.
13:19:45 <Vorpal> Phantom_Hoover, nah, it is pretty useless really. Who would want it?
13:20:51 <Sgeo> If golden apples didn't require as much gold to make, would they be worth it?
13:22:15 <Vorpal> Sgeo, I never found a normal apple yet and iirc they don't stack anyway
13:26:04 <Phantom_Hoover> Sgeo, no, because you can just go out and punch some pigs if you need gold.
13:26:28 <Sgeo> Are pigs a renewable resource?
13:26:54 <Sgeo> http://www.youtube.com/watch?v=wwo8qxUit00
13:27:05 <j-invariant> Phantom_Hoover: what do you do all night>?
13:27:35 -!- impomatic has left (?).
13:27:40 <Vorpal> <Phantom_Hoover> Sgeo, no, because you can just go out and punch some pigs if you need gold. <-- ??
13:28:18 <Phantom_Hoover> j-invariant, unless you're on the move, setting up a mine would be worthwhile.
13:29:09 <Vorpal> Phantom_Hoover, and they don't stack either. I suggest carrying a work bench and a stack of wheat when exploring. Maybe one or two ready breads in case you need them urgently
13:31:10 <Vorpal> j-invariant, if you aren't in a hurry to smelt and/or craft stuff, then deferring it to the night might relieve some boredom (and also let you get more stuff that needs daylight done during the day)
13:31:34 <j-invariant> oh I don't have any thing to smelt but I guess that's my problem
13:31:49 <j-invariant> I keep finding it before I learned how to make chests
13:31:51 <Vorpal> j-invariant, are you mining for it?
13:32:15 <Vorpal> j-invariant, why not go back to the coal you found back then?
13:32:41 <Vorpal> j-invariant, right then you used it I guess?
13:33:53 <Vorpal> j-invariant, well you are likely to find more underground than when wandering the surface. As long as you have some torches (if you don't and can't find any surface coal you might be in a bit of a deadlock) it should be reasonably safe to mine
13:34:08 <Vorpal> get some iron too, and make armour
13:34:56 <Vorpal> j-invariant, well try mining in the open. As in, dig down so you have sky visible at all times, rather than digging tunnels.
13:35:31 <Vorpal> j-invariant, a lot more work though
13:35:42 <Vorpal> but you will probably find coal soon enough
13:36:02 <Phantom_Hoover> Also, if you have monsters on securing the thing will be a pain.
13:36:21 <Vorpal> j-invariant, do this at close to sea level btw, not at a mountain top. Reason for this is that you won't find iron above a certain altitude
13:37:10 <Vorpal> Phantom_Hoover, you mean for the open thing. Well as soon as you find enough coal to make a handful of torches you can switch to a different mining system
13:37:36 <Vorpal> Phantom_Hoover, however, it seems a decent way to break the deadlock :P
13:38:28 <Vorpal> hm to have one chest for every block id define you would need 173 chests (twice if you want double chests of course)
13:38:38 <Vorpal> however, not all are possible to get
13:39:22 <Vorpal> (such as fire, redstone ore, redstone-placed-on-ground, or similar)
13:40:08 <Sgeo> <3 Fry & Laurie
13:40:16 <Sgeo> And elliott will kill me for liking something good
14:05:04 <j-invariant> I loaded up the game in the spawnpoint instead of my treehouse :(
14:05:48 <Vorpal> j-invariant, did you die?
14:10:24 <Sgeo> How do you avoid getting bored when hauled up in a 2x2x2 house at night?
14:11:04 <Sgeo> Wait, if I'm on Peaceful, I don't need to bother with that, do I?
14:18:25 -!- BeholdMyGlory has joined.
14:21:29 <j-invariant> I wonder how many bug reports he gets a day...
14:21:44 <Sgeo> Phantom_Hoover, while trying to keep the house small so mobs don't spawn?
14:21:56 <Sgeo> [Note: I have hard times finding coal in a rush]
14:22:47 <Phantom_Hoover> Pass, then: I've never stuck at it in a world where I didn't get coal quickly.
14:37:37 -!- TLUL has joined.
14:40:35 <Vorpal> hah, the fastest way to load all of minecraft world data into memory for map generation when it isn't cached into ram seems to be to prefetch it using find whatever/ -type f | xargs -P 4 -n 100 head -c1 > /dev/null. The files are small enough that this seems to load the entire files. And the parallel processes make it faster somehow (about 3.5 times as fast) . Could be NQC maybe, since I doubt a single
14:40:35 <Vorpal> head process would try to read one file while waiting for the previous one.
14:57:47 <j-invariant> I love teh way you make symbols in minecraft
15:18:56 -!- TLUL has quit (Quit: *disappears in a puff of orange smoke*).
15:25:09 -!- MigoMipo has joined.
15:37:49 -!- TLUL has joined.
15:49:53 -!- augur has quit (Ping timeout: 240 seconds).
15:53:23 -!- augur has joined.
15:56:23 -!- poiuy_qwert has joined.
15:59:53 -!- augur has quit (Ping timeout: 240 seconds).
16:00:59 -!- poiuy_qwert has quit (Client Quit).
16:03:31 -!- FireFly has joined.
16:05:14 -!- augur has joined.
16:13:53 -!- augur has quit (Ping timeout: 240 seconds).
16:18:45 -!- cheater00 has quit (Ping timeout: 240 seconds).
16:20:33 -!- elliott has joined.
16:20:41 <elliott> 21:55:27 <hagb4rd> have you been here before oklopol?
16:20:44 <elliott> hagb4rd: no, he's very new
16:21:15 -!- aloril has quit (Ping timeout: 248 seconds).
16:22:33 <j-invariant> a whole bunch of creepers blew up in my face and killed me
16:22:48 <j-invariant> but I went back to the spot to get my pick and they had revealed some coal
16:23:34 <elliott> 03:28:47 <Gregor> Besides, my BFJoust hill is more fair :P
16:23:38 <elliott> Gregor: They're MYYY rules!
16:23:48 <elliott> j-invariant: they destroy like 70% of blocks though
16:24:03 <elliott> j-invariant: p.s. you know you can fight from behind a door?
16:24:16 <elliott> if you place a door from the outside of your house, not the inside, then you can walk right up to it and hit things from there
16:24:23 <elliott> with a creeper you just keep whacking it with a sword until it goes away
16:26:14 <elliott> j-invariant: btw as far as finding coal goes
16:26:23 <elliott> j-invariant: you probably *really* want a mine of some kind
16:26:52 <elliott> j-invariant: the simplest kind is: just dig a shaft (doesn't matter how wide), diagonally, to bedrock (watch out for lava lakes near the bottom; you could stop there if you're lazy)
16:27:01 <elliott> j-invariant: then, you build 1-wide shafts off to the sides
16:27:07 <elliott> j-invariant: and then 1-wide shafts on both sides of *that*
16:27:11 <elliott> separated by, iirc, three blocks
16:27:27 <elliott> separated by one block I think
16:27:32 <elliott> j-invariant: and basically you just dig along _those_ shafts, and whenever you find ore, you dig out that area
16:27:34 <elliott> watch out for caverns though
16:27:41 <elliott> j-invariant: you get much more ore like 10 above bedrock
16:27:46 <elliott> j-invariant: this method of mining is a bit tedious though
16:27:53 <elliott> j-invariant: another way to do it is just spelunking
16:28:00 <elliott> j-invariant: find caves, light them all up, get all their ore
16:28:16 <elliott> j-invariant: in fact, you can even use a staircase mine to find caverns... they often appear underneath the shafts, and you fall down :>
16:30:08 <elliott> j-invariant: http://www.minecraftwiki.net/wiki/Tutorials/Mining_Techniques
16:30:11 <Vorpal> <elliott> separated by one block I think <-- err, 2 blocks seem saner
16:30:31 <Vorpal> more if you do a zip like layout
16:30:45 <Vorpal> where you alternate two alts, this stacks well
16:31:06 <elliott> Vorpal: no, that's overcomplicated
16:31:18 <elliott> j-invariant: the staircase mine method I mentioned, if done correctly, can have you see every block in the entire area
16:31:39 <Vorpal> elliott, not if you want to cover a specific altitude. sorry bbl
16:31:50 <elliott> sure, you do see everything
16:34:26 -!- aloril has joined.
16:38:15 <Vorpal> elliott, well yes but if you want to cover a narrow altitude range but one that is larger than 2 blocks high you have to dig away more blocks with your 2 wide separation scheme
16:38:40 <elliott> irrelevant, you still see it all
16:38:40 <Vorpal> elliott, also, do you shift the layers relative each other, or how do you take care of the non-visible corners?
16:38:52 <elliott> yes, each layer gets shifted right by one (IIRC)
16:39:39 <Vorpal> elliott, hm you need a separation of one for that to work
16:39:40 <elliott> i have this feeling that normal mining isn't too practical in general though
16:41:26 <Vorpal> elliott, actually the high density scheme works fairly well. Also it turns out that if you have a large area at your disposal, a less dense mining scheme which might miss some ores will yield more per dug away block. Due to that ores often comes in clumps.
16:41:57 <elliott> my staircase mining method is just as high density, but easier to keep track of :)
16:42:24 <elliott> I think spelunking is easiest
16:42:29 <elliott> caverns have shitloads of ore
16:43:19 <Vorpal> elliott, anyway this is why shifting by one won't work with separation of two: http://sprunge.us/TIUA
16:43:53 <elliott> right, so separate by two like i said
16:44:01 <Vorpal> elliott, err by one you mean
16:44:30 <Vorpal> elliott, the problem is finding good caverns. Some games you find lots in that go deep. Sometimes you hardly find any that goes deep enough to need torching
16:45:35 <elliott> and sometimes your mountain has little ore
16:49:25 <Vorpal> elliott, I have some single player games with awesome cavern systems though :)
16:50:08 <Vorpal> elliott, btw, my basic mining scheme is this: http://sprunge.us/gMZH While it is indeed more complicated and requires some care to get it right, it is faster due to mining far fewer blocks per blocks seen.
16:50:24 <Vorpal> of course, spelunking is probably the nicest way, at least on peaceful
16:50:44 <Vorpal> (not so good if the cavern is overrun with monsters)
16:52:56 <Vorpal> elliott, there was a quite interesting thread on the minecraft forums analysing this. I don't seem to be able to find it again though
16:54:07 <elliott> Vorpal: Someone needs to figure out the big-O of these mining schemes!
16:54:13 <elliott> So that the forum can say "lol 0x=0 u stupid"
16:54:18 <Phantom_Hoover> Vorpal, I think that mining scheme is implementable in a staircase mine.
16:54:39 <Vorpal> Phantom_Hoover, yes, I don't see any problem combining them
16:54:42 <elliott> Staircase mines with a drop shaft to the bottom are p. much the best!
16:55:22 <elliott> I think I might start playing MC in a new way: on peaceful until I get an iron sword and armour, and then on hard.
16:55:27 <Phantom_Hoover> Everything comes in clumps, so you can leave a line unchecked and not miss anything.
16:55:47 <Vorpal> Phantom_Hoover, anyway, I wouldn't use it except for the diamond ore altitude range. Because other ores tend to have large deposits so in practise you don't need to see every block to find a deposit. And the few 1x1 coal deposits out there aren't really worth the extra diggign
16:56:00 <olsner> hmm, so it's a ratio blocks seen/blocks mined that you want to maximize? (and the limit of that as you mine to infinity, of course)
16:56:12 <Vorpal> gah, don't say what I intend to say while I'm writing it. ;P
16:56:21 <j-invariant> minecraft is so addictive some people actually DO mine to infinity
16:56:44 <Vorpal> j-invariant, can't in this case since it is a side view. And that has a limited range
16:57:20 <olsner> at some point you'll want to factor in whatever random algorithm is used to place valuables in the ground
16:57:43 <j-invariant> I have this huge tunnel to a good place from the spawnpoint//
16:57:47 <elliott> Sgeo: stop making DCSS fanboi comments that i have to reply to
16:57:49 <Vorpal> olsner, yes quite. we did that :P
16:58:00 <Vorpal> olsner, when we noted the thing about those clumps
16:58:51 <elliott> i live on as little ore as possible due to laziness but let's pretend it's just my style
16:59:01 <elliott> if i need it i'll go get it!
16:59:29 <elliott> Phantom_Hoover: http://www.reddit.com/r/gaming/comments/eydlc/as_a_gamer_without_a_steady_internet_connection/c1bwz27
16:59:36 <olsner> elliott: hmm, doesn't that actually *make* it your style to use as little ore as possible?
16:59:51 <elliott> Phantom_Hoover: Worse — he's replying to threads about NetHack on reddit with random factoids about how Dungeon Crawl Stone Soup is so great.
17:00:00 <elliott> Which is just irritating, because (1) that's irrelevant and (2) it's a terrible game.
17:00:01 <Vorpal> elliott, yeah personally I do it like mplayer buffers (or at least how you claimed it appears to be buffering)
17:00:23 <Phantom_Hoover> elliott, I thought yu were talking about the decryptomatic thing.
17:00:30 <elliott> Phantom_Hoover: that's DeCSS :P
17:00:32 <elliott> mining is pretty much the most boring thing ever, so yeah i don't really do that
17:00:38 <elliott> spelunking can be fun once in a while
17:02:28 <olsner> it's slightly sad that this channel is now all about minecraft
17:02:47 <elliott> oklopol's random walk method is great, I just found the Stairs accidentally
17:02:55 <olsner> unless you're using minecraft for computation, because then it's suddenly on topic
17:03:03 <elliott> olsner: we did interesting stuff yesterday! esolang i mean
17:03:03 <Vorpal> olsner, there is that red stone CPU in it
17:03:18 <elliott> and yes, we d id interesting mc computation stuff yesterday
17:03:24 <elliott> me and Phantom_Hoover invented THE BEST CIRCUIT SYSTEM EVER
17:03:41 <Vorpal> elliott, how is redstone shit as such?
17:03:51 <olsner> oh, not *the* shit, but shit?
17:04:01 <elliott> we redesigned it ... and half the game, but
17:04:04 <elliott> Vorpal: it can hardly interact with the environment
17:04:08 <elliott> Vorpal: it has infinite power which is just no fun
17:04:15 <elliott> and every circuit is gigantic
17:04:18 <Vorpal> elliott, well true. There are mods for interacting with environment though.
17:04:27 <Vorpal> and yes circuits are large
17:04:59 <elliott> I am sad that civilisation gets little love now ... anyway
17:05:09 <elliott> olsner: we'd talk about interesting stuff if someone said anything, but nobody does :)
17:05:13 <Vorpal> elliott, one think I would like is a lever that affects a wire to blocks below. So you can place a lever on ground and hide the wires
17:05:48 <olsner> elliott: I know, sans the minecraft spam it'd just be completely quiet in here, and that could be more boring
17:05:52 <elliott> Vorpal: easy, since you can cover bluestone'd blocks with other blocks
17:05:58 <elliott> so just have a wire going underground and cover it with blocks :)
17:06:16 <elliott> olsner: it's not like we used to be more on topic before, it was just more varied offtopic
17:06:24 <Vorpal> elliott, sure you can use a 3 thick wall currently but that is not always a viable option. Such when I wanted a fire level on top of the wall of that fort.
17:06:47 <olsner> elliott: yah, probably
17:08:03 * Vorpal waits for on topicness
17:08:16 -!- luatre has joined.
17:08:27 <luatre> TypeError: can only concatenate list (not "int") to list :(
17:08:43 <Vorpal> elliott, which language?
17:08:54 <elliott> Vorpal: well, Clue plus my expression language
17:09:05 <elliott> Vorpal: the actual interesting parts are done with :: (or any combination of : and . resulting in 4 dots)
17:09:18 <elliott> five dots looks up the compiled form of a given function
17:09:24 <Vorpal> elliott, an esolang? It looks rather too sane for that
17:09:33 <elliott> that's just the expression language...
17:09:39 <elliott> this is oklopol's language :)
17:09:48 <Vorpal> okay likely extremely weird then
17:09:50 <elliott> make singleton ~ {. 1 -> [1]
17:09:50 <elliott> . [1, 2, 3] -> [[1, 2, 3]]}
17:09:50 <elliott> make singleton ~ <id>; cons; #[]
17:09:53 <elliott> ^ that's a function in clue
17:10:02 -!- cheater99 has joined.
17:10:13 <elliott> basically, clue is programmed by giving a bunch of examples, and then telling it what functions it needs to use
17:10:16 <elliott> and it solves all the rest by itself
17:10:18 <elliott> Vorpal: um a list containing just x
17:10:27 <Vorpal> elliott, oh so why the name singleton then
17:10:33 <elliott> Vorpal: because the list is a singleton
17:10:47 -!- TLUL has quit (Quit: *disappears in a puff of orange smoke*).
17:11:03 <elliott> more than 3 ~ <id>; #0; #1
17:11:17 <Vorpal> elliott, so.. how does it do this? Nearest example?
17:11:35 <Vorpal> elliott, I mean, how does it extrapolate from the examples
17:11:45 <elliott> Vorpal: something almost, but not entirely, like brute force
17:11:50 <elliott> it compiles the ski impl in 20 seconds
17:11:59 <elliott> tehre's special syntax for doing recursion
17:12:03 <elliott> j-invariant: basically, <id> means "branch using id"
17:12:09 <Vorpal> elliott, okay. But that doesn't answer my question on how.
17:12:15 <elliott> j-invariant: so, the first branches are the branches for 0, 1, 2, 3, because it infers the branch as id(param)
17:12:19 <elliott> j-invariant: the last branch is default
17:12:24 <elliott> and so contains everything above 3
17:12:29 <Vorpal> elliott, how do you define something like sin() in it?
17:12:36 <elliott> Vorpal: you don't, it just has integers and lists
17:12:48 <Vorpal> elliott, well lets say integer fixed point sin then :)
17:13:24 <elliott> i'll show you the compiles form of make singleton
17:13:45 <elliott> :: make singleton ~ {. 1 -> [1] . [1, 2, 3] -> [[1, 2, 3]]} make singleton ~ <id>; cons; #[]
17:13:46 <luatre> make singleton: [id(#0)] <= [[]] |.(_) => cons(#1 #0)
17:14:02 <elliott> ok, so that <= [foo] means that it gets [] as the first parameter, because we told it it was a constant it needed
17:14:13 <elliott> so in the function body, #0 is []
17:14:20 <elliott> but in the condition, #0 is the parameter
17:14:24 -!- cheater00 has joined.
17:14:27 <Vorpal> elliott, hm. Well what I'm trying to figure out is how it extrapolates. One obvious approach would be to use the examples to train an ANN for example. Another would be to compute a hyper-plane that separates the examples properly (this couldn't handle sin, or xor for example)
17:14:31 <j-invariant> elliott: I hope you're saving up all these discusfsions, where you show people how Clue works: And saving them into "clue.clue"
17:14:31 <elliott> so basically, we switch on the argument, but only have a default (this is the same as having no branch)
17:14:38 <elliott> then it just conses the param with the constant param ([])
17:14:44 <elliott> j-invariant: clog is doing that for me!
17:14:55 <elliott> Vorpal: ANN? no, no, this is precise
17:15:04 <elliott> Vorpal: the SKI implementation is a _real_ SKI implementation
17:15:08 <elliott> that can handle any SKI form
17:15:40 <Vorpal> elliott, so hm, what does it do when there could be several different alternatives that would fit the given examples?
17:15:55 <elliott> Vorpal: then your program is bad... but that's why you use hints
17:16:11 <Vorpal> elliott, will it error out or?
17:16:20 <elliott> i managed to implement subtraction and abs, fwiw, when all there was was add, and no negate
17:16:26 <elliott> thanks to help from oklopol
17:16:55 <elliott> Vorpal: no, if it manages to generate a function using the functions in the bag you specified, using the conditional function you specified, meeting your recursion scheme (if you have one), and fitting all the examples in their corresponding branches
17:17:05 -!- cheater99 has quit (Ping timeout: 240 seconds).
17:17:06 <elliott> Vorpal: then it'll use that function, but ... if you write it properly there's only one function it can really generate
17:17:13 <Vorpal> elliott, that more than 3, does it handle -1?
17:17:15 <elliott> that's the importance of the bag
17:17:27 <elliott> i think it'll say that -1 is more than three
17:17:42 <elliott> because anything that isn't 0, 1, 2, or 3 gets true, basically
17:17:44 <elliott> but you could easily fix it
17:17:54 <elliott> by having another case ... or even just a wrapper function
17:17:56 <elliott> that checks for negativity
17:18:01 <Vorpal> elliott, presumably you could make it extrapolate in both directions?
17:18:13 <elliott> it doesn't "extrapolate"...
17:18:17 <elliott> it is not guessing, it is very precise
17:18:19 <Vorpal> elliott, well, okay, bad word
17:18:34 -!- augur has joined.
17:18:46 <elliott> Vorpal: basically, no, because you'd still need to switch on whether it's negative
17:18:51 <elliott> :: more than 3 ~ {. 0 -> 0 } more than 3 ~ {. 1 -> 0 } more than 3 ~ {. 2 -> 0 } more than 3 ~ {. 3 -> 0 } more than 3 ~ {. 4 -> 1 . 5 -> 1 } more than 3 ~ <id>; #0; #1
17:18:51 <luatre> more than 3: [id(#0)] <= [0 1] |.(0) => #0 |.(1) => #0 |.(2) => #0 |.(3) => #0 |.(_) => #1
17:19:04 <elliott> right, i can see straight away that that will think -1 is more than three
17:19:20 <elliott> (if you can't, maybe you're not good enough at understanding my compiled syntax form)
17:20:47 <elliott> Vorpal: here's an implementation of negate, subtract, and abs http://sprunge.us/gOPE
17:20:54 <elliott> the :. : bit is the recursion schemes
17:21:20 <elliott> :: is negative? ~ {. -1 -> 1 . -2 -> 1 } is negative? ~ {. 0 -> 0 } is negative? ~ {. 1 -> 0 . 2 -> 0 } is negative? ~ <id>; compare; #0; #1
17:21:20 <luatre> is negative?: [id(compare(#0 compare(#0 #0)))] <= [0 1] |.(-1) => #1 |.(0) => #0 |.(1) => #0
17:21:31 <elliott> that compare(#0 #0) is quite amusing, it's 0 obviously
17:21:40 <elliott> but the brancher can't access the constants
17:21:43 <elliott> since it doesn't get them yet
17:21:47 <Vorpal> elliott, it doesn't use the examples in a very clever way it seems
17:21:47 <elliott> so it couldn't just use teh constant 0 it's given
17:21:50 <elliott> it figured out what 0 is :)
17:22:08 <elliott> you generally don't need many of them at all
17:22:19 <elliott> there's more in my negating functions because i made a mistake earlier
17:22:42 <elliott> Vorpal: take a look at this
17:23:04 <elliott> :: negate negative ~ {:. -5, -5 -> 5 : -4, -3 -> 5 :. -4, -3 -> 5 : -3, -1 -> 5 :. -3, -1 -> 5 : -2, 1 -> 5 } negate negative ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate negative ~ <is zero?>; inc
17:23:04 <luatre> Exception: Can't compile negate negative(is zero?) :(
17:23:19 <elliott> :: is zero? ~ {. 0 -> 1 } is zero? ~ {. 1 -> 0 . 2 -> 0 } is zero? ~ <id>; #0; #1
17:23:19 <luatre> is zero?: [id(#0)] <= [0 1] |.(0) => #1 |.(_) => #0
17:23:25 <elliott> :: negate negative ~ {:. -5, -5 -> 5 : -4, -3 -> 5 :. -4, -3 -> 5 : -3, -1 -> 5 :. -3, -1 -> 5 : -2, 1 -> 5 } negate negative ~ {. 0, 1 -> 1 . 0, 2 -> 2 . 0, 3 -> 3 } negate negative ~ <is zero?>; inc
17:23:25 <luatre> negate negative: [is zero?(#0)] |^(0) => #2 <= {(0,0): inc(#0); (0,1): inc(inc(#1))} |.(1) => #1
17:23:30 <Vorpal> elliott, well hard to explain what i mean
17:23:33 <elliott> Vorpal: see negate negative in that sprunge up there
17:23:37 <elliott> 17:22 luatre: negate negative: [is zero?(#0)] |^(0) => #2 <= {(0,0): inc(#0); (0,1): inc(inc(#1))} |.(1) => #1
17:23:43 <elliott> based on the recursion scheme and base case
17:23:48 <elliott> which is pretty good, if you ask me
17:23:55 <elliott> to translate that inferred function to haskell:
17:24:22 <elliott> negneg x y | not (isZero x) = negneg (x+1) (y+1+1)
17:25:14 <elliott> Vorpal: anyway it is the best and most expressive language ever :D
17:25:22 <Vorpal> elliott, well sure. But it takes rather a lot of code to do it
17:25:33 <Vorpal> elliott, and yes, sure it is nice.
17:25:40 <Phantom_Hoover> Not because of the anachronism, but because I thought that violated the BBC's anti-product-placement rules.
17:25:43 <elliott> i'll write negate negative shorter
17:25:59 <elliott> Vorpal: i added the extra test cases because i was paranoid when it broke once
17:26:19 -!- aloril has quit (Ping timeout: 248 seconds).
17:26:54 <elliott> :: negate negative 2 electric boogaloo ~ {:. -5,-5 -> 5 : -4,-3 -> 5 :. -4,-3 -> 5 : -3,-1 -> 5 } negative negative 2 electric boogaloo ~ {. 0,1 -> 1} negative negative 2 electric boogaloo ~ <is zero?>; inc
17:26:54 <luatre> TypeError: 'NoneType' object is not iterable :(
17:27:02 <elliott> :: negate negative 2 electric boogaloo ~ {:. -5,-5 -> 5 : -4,-3 -> 5 :. -4,-3 -> 5 : -3,-1 -> 5 } negative negative 2 electric boogaloo ~ {. 0,1 -> 1} negate negative 2 electric boogaloo ~ <is zero?>; inc
17:27:03 <luatre> TypeError: 'NoneType' object is not iterable :(
17:27:12 <elliott> :: negate negative 2 electric boogaloo ~ {:. -5,-5 -> 5 : -4,-3 -> 5 :. -4,-3 -> 5 : -3,-1 -> 5 } negate negative 2 electric boogaloo ~ {. 0,1 -> 1} negate negative 2 electric boogaloo ~ <is zero?>; inc
17:27:13 <luatre> negate negative 2 electric boogaloo: [is zero?(#0)] |^(0) => #2 <= {(0,0): inc(#0); (0,1): inc(inc(#1))} |.(1) => #1
17:27:22 <elliott> Vorpal: in long form, that code is just:
17:27:24 <elliott> negate negative ~ {:. -5, -5 -> 5
17:27:28 <elliott> negate negative ~ {. 0, 1 -> 1 }
17:27:30 <elliott> negate negative ~ <is zero?>; inc
17:27:57 -!- azaq23 has joined.
17:28:05 <Vorpal> <elliott> negate negative ~ <is zero?>; inc <-- inc?
17:28:22 <elliott> but what's more, i can prove it
17:28:24 <Vorpal> elliott, but why does it need to increment?
17:28:36 <elliott> Vorpal: um because the algorithm works by doing f (x+1) (y+2)
17:28:52 <elliott> :: succ ~ {. 0 -> 1 . 1 -> 2 . 2 -> 3} succ ~ <_>; inc
17:28:54 <luatre> succ: [_(#0)] |.(_) => inc(#0)
17:29:27 <j-invariant> and if you gave negate negative ~ <sqrt square>; it would fin dhe other program?
17:29:38 <elliott> j-invariant: what do you mean?
17:29:38 <j-invariant> sqrt(x^2) instead of if x<0 then -x else x
17:29:53 <elliott> j-invariant: well you would do <_>; sqrt square
17:29:54 <j-invariant> although sqrt may be difficult to implement
17:29:56 <elliott> j-invariant: but yes, it would probably get that
17:30:04 <elliott> oh you mean sqrt being separate
17:30:07 <elliott> j-invariant: well you would do <_>; sqrt; square
17:30:11 <elliott> it would probably get it, yes
17:30:14 <elliott> but doing sqrt would be a bitch
17:30:29 <elliott> Vorpal: here's the ski impl: http://sprunge.us/gdNj
17:30:37 <elliott> *impl: http://sprunge.us/gdNj
17:30:49 <elliott> Vorpal: would be much more readable if s, k and i could be something other than constant integers, but
17:31:01 <elliott> j-invariant: not really :) ... you could probably do newton's method?
17:31:29 <elliott> Vorpal: it's actually a wonderful program
17:31:38 <elliott> also note that :s after the first in a :. are ignored
17:31:49 <elliott> well... or i think they are tested
17:31:49 <Vorpal> elliott, just write a soft floating point library in it. In theory it is possible since it is TC. But likely infeasible.
17:31:53 <elliott> but they aren't used for generating the recursion scheme
17:32:00 <Vorpal> elliott, how long did ski take to compile?
17:32:18 <elliott> Vorpal: note that the implementation has many, many really stupid things
17:32:36 <elliott> if str(e)[-12:]=="not callable":
17:32:48 <elliott> and it also calls functions during compilation like 138917491238912379x more than itn eeds to
17:33:14 <Vorpal> elliott, how does that differ from normal python?
17:33:20 <elliott> # glue is just a helper for glue_
17:33:20 <elliott> # we add recipes to objects
17:33:20 <elliott> def glue(functions,applier,applicabler,objects,condition):
17:33:24 <elliott> for i in xrange(len(objects)):
17:33:26 <elliott> l=(lambda j:lambda app,*args:args[j])(i)
17:33:28 <elliott> objectswithrecipes.append((objects[i],l,"#"+str(i)))
17:33:29 <elliott> return glue_(functions,applier,applicabler,objectswithrecipes,condition,5,objects)
17:33:41 <Vorpal> Phantom_Hoover, but it uses the same interpreter as normal python?
17:33:54 <elliott> this is actaully not the most oklo python i've ever seen, that would be the oklotalk-- impl
17:34:17 <elliott> def funthatreturnsntharg(i):
17:34:17 <elliott> return lambda*args:args[i]
17:34:21 <elliott> that's my favourite name for a function tbh
17:34:25 <Vorpal> <elliott> # glue is just a helper for glue_ <-- that sounds like a weird naming scheme
17:35:09 <j-invariant> always seem to find coal if you just do it for long enough
17:35:20 <elliott> Vorpal: 17.8115589619 seconds
17:35:23 <elliott> to compile everything in that paste i showed
17:35:29 <Vorpal> elliott, on what sort of hardware?
17:35:33 <j-invariant> nice thing about Clue is you don't have to test the program!
17:35:47 <elliott> Vorpal: um 2.1ghz core 2, 4 gigs of ram... i don't think it's ram intensive
17:35:53 <j-invariant> "Tested by construction" as opposed to "Correct by construction" that we do in Epigram
17:36:40 <j-invariant> it's a whole program paradigm based around testing: I can hardly beleive it's not subsumed java/C# etc by now
17:36:43 <elliott> Vorpal: recompiling ski now so i can show the asts in my form
17:36:53 <Vorpal> elliott, knowing python you would probably get a 3x speed improvement if you switched to another language.
17:37:00 <elliott> which is actually less ghetto than oklopol's:
17:37:12 <elliott> Vorpal: you would get a 3x speed improvement just removing all the stupid shit from the impl
17:37:51 <elliott> |^(1) => #1 <= {(0,0): car(cdr(#0))}
17:37:52 <Vorpal> elliott, try it with pypy?
17:37:53 <elliott> |^(2) => #1 <= {(0,0): cadar(#0)}
17:37:55 <elliott> |^(3) => #3 <= {(0,0): pair(cadaar(#0) car(cdr(#0))); (1,0): pair(cadar(#0) car(cdr(#0))); (2,0): pair(#1 #2)}
17:37:57 <elliott> |^(4) => #2 <= {(0,0): car(#0); (1,0): pair(#1 car(cdr(#0)))}
17:38:02 <elliott> some simple memoisation would help.
17:38:10 <elliott> [id(cons(deep first(#0) make singleton(depth of first(#0))))] <= [0 1]
17:38:23 <elliott> |.(_) => deep first with cutoff(#2)
17:38:27 <elliott> it's pretty good at figuring out conditions :)
17:38:39 <elliott> the id(x) thing is just because this version of the lang is stupid
17:38:44 <elliott> the <foo> stuff is... basically totally unnecessary
17:39:02 <Vorpal> elliott, it should be able to automatically strip id() off anything
17:39:11 <elliott> Vorpal: no, it should just not need <foo>
17:39:16 <elliott> the reason it has id there is because oko did
17:39:23 -!- aloril has joined.
17:39:25 <elliott> because the normal conditional form can only handle one argument and shit
17:40:24 <elliott> |^(1) => inc(#2) <= {(0,0): car(#1)}
17:40:30 <elliott> |^(1) => #1 <= {(0,0): car(#0)}
17:40:32 <elliott> ---- deep first with cutoff
17:40:34 <elliott> [id(more than 3(depth of first(#0)))] <= [4]
17:40:40 <elliott> ^ that's quite an interesting block of functions.
17:40:49 <elliott> remember that in the body, rather than the brancher/conditional, the args are all N forward
17:40:52 <elliott> where N is the number of constants
17:40:57 <elliott> because the first N are the constants shown :)
17:42:41 <elliott> i should probably explain the ast format
17:43:05 <Vorpal> sure why not, got a bit busy RL now though
17:43:40 <elliott> i'll wait then, gotta have someone hearing my blabbering
17:57:38 <j-invariant> how the thell do I take a screenshot of minecraft/
17:59:30 <elliott> F1 to turn on camera, F2 to screenshot
17:59:34 <elliott> goes in ~/.minecraft/screenshots
18:05:58 <oklopol> "<Sgeo> Which is more worthless? Gravel or gold?" <<< gravel, you can make armor out of gold.
18:06:15 <elliott> oklopol: gold armour lasts like 0 seconds
18:11:45 -!- hagb4rd has quit (Ping timeout: 240 seconds).
18:19:44 -!- Slereah has quit (Ping timeout: 276 seconds).
18:22:14 <oklopol> "<elliott> also note that :s after the first in a :. are ignored" <<< that's not true!
18:22:36 <elliott> oklopol: they're tested but don't go towards making the recursion scheme
18:22:46 <oklopol> they are when recursion branches multiple times, like you'd expect
18:23:26 <elliott> negate negative ~ {:. -5, -5 -> 5
18:23:34 <elliott> oklopol: so is there a better way to write that
18:23:51 -!- Slereah has joined.
18:26:58 <elliott> oklopol: do prime factorisation
18:27:10 <elliott> j-invariant: you can do pretty much any recursive algorithm ... as long as each step can also be done ... prolly
18:27:34 <oklopol> "<elliott> oklopol: gold armour lasts like 0 seconds" <<< not really
18:27:49 <elliott> oklopol: don't you have...iron
18:27:55 <oklopol> and chainmail is between gold and iron
18:27:55 <elliott> iron is 100000x superior to gold
18:27:58 <elliott> and lasts like 100000x longer
18:28:06 <elliott> oklopol: chainmail is impossible to get without inventory editing
18:28:35 <oklopol> "<elliott> well...whatever :D" <<< it's just the way you explained it sounded like things like quicksort would indeed not be possible
18:28:57 <oklopol> i thought you thought you can't recurse multiple times, but just tail
18:29:08 <oklopol> hmm except not tail because many examples are non-tail
18:29:24 <oklopol> <elliott> oklopol: so is there a better way to write that <<< one or two examples is enough
18:29:33 <elliott> I just meant would : be useful
18:30:02 <oklopol> "<j-invariant> can you write prime factorization?" <<< i believe it's possible to compile a simple imperative language to this, and prove some sort of bound on compilation speed
18:30:10 <oklopol> erm, referenced bad line maybe
18:30:48 <oklopol> "<elliott> oklopol: don't you have...iron" <<< i have iron, yes. all i'm saying is if sand was much easier to find than gravel, would you say gravel is worthless because it doesn't fall
18:31:04 <oklopol> (because sand is easier to get and falls oh so much nicer)
18:31:21 <oklopol> if you have gold and gravel, and a bunch of creepers coming, gold is better.
18:31:37 <elliott> oklopol: certainly, but if i have iron and all the usual necessities,
18:31:41 <oklopol> and your life is more precious than emptying seas
18:31:44 <elliott> oklopol: then i'd rather have a bunch of gravel than gold ... probably ... maybe not
18:32:55 <oklopol> but it's clear that gold has no actual use, usually
18:33:36 <oklopol> anyway personally i'm more happy finding gold than gravel
18:33:44 <oklopol> and i'm sure i would be even if gold wasn't valuable irl
18:33:59 <oklopol> gold blocks are pretty, and gold is rare, that's enough.
18:34:58 <oklopol> but yeah i'm sure you all wouldn't even mine gold, just like you don't mine anything else you find
18:35:25 <oklopol> cuz you already have a lifetime stock of almost one whole stack of it
18:35:51 <oklopol> so seriously, i slept all day
18:36:04 <oklopol> i went to sleep at sunrise, and it's now been dark for a while
18:36:14 <oklopol> i have an exam on monday :(
18:36:19 <oklopol> i'll probably fail AS USUAL
18:36:30 <elliott> http://i.imgur.com/Q0GSe.jpg
18:36:45 <oklopol> after looking at the numbers, i notice chainmail is actually weaker than gold
18:36:48 -!- azaq23 has quit (Quit: Leaving.).
18:36:53 <elliott> oklopol: you fail exams? :P
18:37:03 <elliott> also, yeah, chainmail is weak, but ... dude, it stops all your damage
18:37:31 <oklopol> i actually failed an exam once, it was about using windows and unix
18:37:46 <oklopol> you had to get everything right, apparently i fucked something up in the excel part
18:38:01 <oklopol> or was it the unix part, maybe i wasn't able to unzip something
18:38:12 <oklopol> don't remember, i hate computers anyway
18:38:23 -!- azaq23 has joined.
18:38:52 <oklopol> but anyway not being able to solve a problem in the exam is as good as failing, and that i've done a lot
18:39:15 <oklopol> for instance, in a recent exam, there was this problem that i couldn't solve (and later proved impossible)
18:39:36 <oklopol> so everyone got a 100% from the prob
18:40:00 <oklopol> i said a whole bunch of things
18:42:21 <oklopol> so, basically what i could do is, instead of doing brute force search (which already discards multiples), i do a kind of variant of a*, so that if an operation *simplifies* another object, it's applied first
18:42:34 <oklopol> where list simplicity is just its size as a tree
18:42:40 <elliott> oklopol: um are you talking about clue now
18:42:55 <oklopol> this will later be made pure, since this is just a special case of a strategy
18:43:04 <oklopol> but for now, it's let me write things like quicksort
18:43:39 <oklopol> "yeah sure, you may interpret this as clue talk"
18:44:03 <oklopol> but surprisingly, there's also an implicit "yes"
18:46:21 <Vorpal> oklopol, hm, couldn't means-ends analysis work for clue (if that was it was about)
18:51:59 <elliott> Vorpal: so can i tell you ast yet
18:52:03 <elliott> or are you still real-life-crapping
18:52:31 <elliott> except life is boring so things=crap
18:52:50 <Vorpal> elliott, sure, tell me.
18:52:57 * Vorpal is now known as /dev/null
18:53:16 <elliott> Vorpal: psht fine then i won't
18:53:18 <Vorpal> elliott, or why not tell someone else, sure clue was interesting, the ast not so much
18:53:31 <elliott> Vorpal: the ast is just the shit that shows you waht it actually compiles to
18:53:34 <elliott> which is the only way to understand it
18:53:58 <Vorpal> elliott, so it compiles to ast? (what?)
18:54:06 <elliott> Vorpal: yes, before it compiles to a python function
18:54:21 <elliott> every clue function is of the form
18:55:07 <elliott> \a1 a2 a3 ... -> (\c1 c2 c3 ... a1 a2 a3 ... -> case B of x -> ...; y -> ...; z -> ...; [and optionally] _ -> ...) cv1 cv2 cv3 ... a1 a2 a3 ...
18:55:13 <elliott> c1,c2,c3 are the constants
18:55:17 <elliott> and cv1,2,3 are their values
18:55:23 <Vorpal> elliott, this is pseudo-haskell?
18:55:24 <elliott> B is the branching expression
18:55:38 <elliott> so, here, in this ghetto ast form, [x] in the top line is the branching expression (B)
18:55:51 <elliott> there are two constants; c1's value is 0, and c2's value is 1
18:55:57 <elliott> and these get passed as the first two arguments to the function itself
18:56:03 <elliott> whereas the branching expression just sees the actual arguments
18:56:05 <oklopol> the problem with inference atm, is that you have things that build bigger things in your bag, now say you want to find a certain thing inside a list, should be easy because even though you need a depth 3 expression for that, there's only a finite amount of sublists, so just look at them all; unfortunately, by simply using cons, at level 3, you'll be looking at millions and millions of lists
18:56:11 <Vorpal> elliott, you don't indent the ast to make it easier to follow?
18:56:17 <elliott> so, this switches on id(first arg), i.e. the first arg
18:56:27 <elliott> 0 to [first arg], same with 1 2 3; anything else to [second arg]
18:56:32 <elliott> in this case, the first arg is 0, and the second 1
18:56:34 <elliott> those are the two constants
18:56:41 <elliott> you can see this because after the branching expression it has "<= [0 1]"
18:56:43 <elliott> which is the list of constants
18:56:49 <oklopol> so really i could probably make it faster by *adding every sublist* in the set of objects currently usable in expressions
18:56:53 <elliott> functions all follow this form
18:57:30 <elliott> Vorpal: oh and function arguments are just written adjacent
18:57:32 <elliott> Vorpal: so, now, considering some recursion
18:57:40 <elliott> |^(0) => #2 <= {(0,0): inc(#0); (0,1): inc(inc(#1))}
18:57:44 <elliott> booleans are just done as integers here
18:57:49 <elliott> ^ means it's a recursive branch
18:57:53 <elliott> there are no constants here
18:58:02 <elliott> but we can see, if the parameter is zero, we just return the second parameter
18:58:06 <elliott> because #n is the nth parameter
18:58:12 <elliott> if it's not, we get recursion
18:58:22 <elliott> so, there's 1 recursion here
18:58:28 <elliott> so the first element of the recursion pairs is always 0
18:58:39 <Vorpal> elliott, this isn't the AST. This is a human representation of the AST. Or if it is the AST, why the hell are you working on it in a textual form in the program ;)
18:58:40 <elliott> (consider fib, which would have two, and so would have first-elements of 1)
18:58:47 <elliott> Vorpal: yes, it's the representation of the ast
18:58:51 <elliott> which is important for figuring out what the function does
18:59:06 <elliott> Vorpal: ok, so that list basically says: the first recursion has first parameter inc(#0) and second parameter inc(inc(#1))
18:59:12 <elliott> which is first param + 1, and second param + 2, respectively
18:59:15 <Vorpal> elliott, wouldn't looking at the compiled result work? Or is that unreadable?
18:59:33 <elliott> the result of this recursion is treated as an extra parameter to the function
18:59:43 <elliott> and in this case, we just return the subrecursion with no processing -- i.e. it's tail recursive
18:59:49 <Vorpal> elliott, so if ^ is recursive then . is a base case?
18:59:51 <elliott> Vorpal: this IS the compiled result
19:00:03 <oklopol> Vorpal: the ast is hard to follow because instead of writing it in sexp-like form, you name subtrees, and just say (cons #4 #6) where #4 and #6 are the fourth and sixth expressions defined
19:00:04 <elliott> Vorpal: the compiled-compiled result is just a python function which processes the ast list when called
19:00:06 <j-invariant> elliott: I can't deal with Haskell - Ishould program in Scheme
19:00:30 <elliott> j-invariant: http://esolangs.org/wiki/Brainfuck/w/index.php%3Ftitle%3DTalk:Brainfuck/index.php#Implementation proof that scheme is best language
19:00:31 <Vorpal> elliott, why not compile it to haskell or something
19:00:43 <elliott> Vorpal: um because the impl is written in python
19:00:58 <elliott> Vorpal: also because the language isn't lazy/
19:01:04 <elliott> that's a kinda stupid question.
19:01:07 <Vorpal> elliott, but the actual interpretation doesn't look complicated?
19:01:17 -!- augur has changed nick to fum.
19:01:20 <elliott> yes, that's why most of the code is the other parts.
19:01:30 <elliott> oklopol: i think i'm going to change the ghetto_ast to show recursion normally
19:01:36 <elliott> as in, as actual applications
19:01:38 <Vorpal> elliott, oh I thought it was. Well compiling to scheme then?
19:01:53 <elliott> Vorpal: that would require a python implementation _and_ a scheme implementation and vastly complicate everything
19:02:14 -!- fum has changed nick to augur.
19:02:17 <Vorpal> elliott, we could move away from python. This alone would speed it up
19:02:25 <oklopol> elliott: do you drop the main branch? i can't see it in "is zero?"
19:02:29 <elliott> Vorpal: yeah cuz scheme is sooooooooooooo fast
19:02:41 <Vorpal> elliott, well there is one compiler
19:02:42 <elliott> oklopol: the main branch being what in particular?
19:02:46 <Vorpal> elliott, forgot the name of it
19:02:50 <oklopol> tbh that was the first nontrivial one i actually gave some thought to, apart from "mm correct general feel"
19:02:58 <elliott> Vorpal: restricted subset of r4rs. also, oklo python is beautiful
19:03:11 <elliott> oklopol: what was the fisrt nontrivial one you actually gave some thought to
19:03:17 <oklopol> "is zero?" is, i just realized
19:03:19 <Vorpal> elliott, what is it that makes it oklo?
19:03:25 <oklopol> "is zero?", and not "negate negative"
19:03:28 <Vorpal> elliott, the weird thing with exception handling?
19:03:39 <elliott> oklopol: the main branch is between => and <=
19:03:45 <oklopol> i assumed it was negate negative, because of the incing twice
19:03:48 <elliott> oklopol: but i'm going to make it so that negate negative looks like this:
19:04:08 <elliott> |^(0) => recurse(inc(#0) inc(inc(#1)))
19:04:17 <elliott> except i'll give recurse a name
19:04:23 <elliott> oklopol: should the recursion function be @ or $
19:04:52 <Vorpal> elliott, well I don't know what in the code is oklo. Just saying oklo makes it oklo is a tautology..
19:05:28 <Vorpal> elliott, okay. But does it differ in coding style or something from normal python?
19:05:41 <Vorpal> elliott, or is it just defined by author being oklopol?
19:05:47 <elliott> oklopol: link me to your scheme interp again
19:06:16 <oklopol> "<elliott> oklopol: i think i'm going to change the ghetto_ast to show recursion normally" <<< should be done, yes, just a tiny amt of work so i skipped it
19:06:21 <Vorpal> elliott, so just wondering if you can give me some representative example showing what makes it oklo :)
19:06:40 <elliott> oklopol: limme scheme terp vjn prove Vorpal oklopy langue
19:07:13 <oklopol> elliott: so was that thing actually the is zero function or is it a part of negate negative
19:07:14 <Vorpal> elliott, your keyboard seems to have broken
19:07:26 <oklopol> it's negate negative clearly, that's why i'm asking
19:07:53 <oklopol> Vorpal: i usually have a rather unique way of writing in a language
19:08:07 <elliott> oklopol: it was zero yeah now link me to scheme terp
19:08:10 <oklopol> usually it's in the canonical ugly code direction
19:08:14 <elliott> ill make Vorpal rue day he evr asked
19:08:21 <Vorpal> oklopol, yes I understood that. But I was basically wondering unique in what way. :)
19:08:24 <elliott> oklopol: technically i'd prefer to show him the oklotalk-- impl but that's somewhere in space
19:08:25 <oklopol> elliott: scheme interp in what language?
19:08:31 <elliott> Vorpal: your smiling is creepy
19:09:05 <Vorpal> elliott, ooh, like a creeper?
19:09:43 <oklopol> elliott: that can not be the is zero function!
19:10:03 <oklopol> <elliott> |^(0) => recurse(inc(#0) inc(inc(#1)))
19:10:17 <oklopol> main branch is not in there
19:10:24 <elliott> oklopol: the main branch is just #2
19:10:33 <elliott> oklopol: the point is that i'm going to inline all the recursions
19:10:44 <elliott> unless it does like cons(#2 #2)
19:10:46 <oklopol> i didn't understand how tail recursion works
19:10:52 <oklopol> because it's a very new concept for me!
19:11:16 <oklopol> but right, when you write it in recurse(inc(#0) inc(inc(#1))) form, it's rather clear this function does not need cons
19:11:37 <Vorpal> oklopol, just remember the linking of code :)
19:12:01 <oklopol> anyway i want functions to return multiple values, that would fit the scheme so perfectly, especially since you don't actually ever *call* functions
19:13:14 <oklopol> trivia: you can write code that looks like you're returning multiple values now, but they are completely ignored in examples by parser
19:13:39 -!- Sasha2 has quit (Quit: NO U).
19:14:32 <elliott> |^(0) => @(inc(#0) inc(inc(#1)))
19:14:55 <elliott> actually i should probably drop the ^/. indicator
19:15:02 <elliott> since it doesn't actually help you understand it now
19:15:32 <oklopol> tusho: can't find it in there
19:15:55 <elliott> | 0 => @(inc(#0) inc(inc(#1)))
19:16:03 <elliott> | 0 => @(dec(#0) dec(dec(#1)))
19:16:07 <elliott> oklopol: ...are you back in time?
19:16:15 <elliott> HEY i JUST REALISED, i can replace constants like this
19:16:39 <oklopol> elliott: i was reading contents of vj.fi
19:16:46 <elliott> oklopol: is tusho there a lot?
19:16:57 <oklopol> i saw a folder named tusho...
19:17:44 <oklopol> ah the redirecting service
19:18:16 <oklopol> http://www.youtube.com/watch?v=OYws8biwOYc someone has redirected "awesome" to this
19:19:00 <oklopol> so even more 100% sure that it was not just a random internet guy
19:19:38 <oklopol> http://www.wellnowwhat.net/transfers/Tusho%20is%20a%20girl%20part%201.mov
19:20:05 <elliott> why can't we forget i was ever proved female
19:21:56 <elliott> [id(compare(#0 compare(#0 #0)))]
19:22:01 <elliott> ...can't believe this is actually kinda working :D
19:22:17 <elliott> oklopol: :( my ast is getting readable enough that i can't explain how amazing it is
19:22:48 <Vorpal> elliott, that statement made no sense
19:23:00 <Vorpal> unless unreadable == amazing
19:23:02 <elliott> before i could give a lesson on what each part ment and how it switched and stuff
19:23:06 <elliott> but now anyone can make sense of it...
19:24:09 <oklopol> i agree that's kind beautiful, as long as you have #x actually mean constants and arguments, and not named expressions
19:24:44 <oklopol> wait i guess it's just when the subrecursion inputs are calculated that new things are named?
19:25:02 <oklopol> bleh, i'll just let you figure this out, and complain about the obvious problems if there are any
19:25:47 -!- coppro has quit (*.net *.split).
19:25:50 -!- lambdabot has quit (*.net *.split).
19:25:55 -!- Leonidas has quit (*.net *.split).
19:25:57 <oklopol> yeah i guess the reason for named things is that that's actually how the computation goes, since it's faster not to compute things multiple times
19:26:05 <oklopol> of course, usually the named expression is only used once
19:26:43 -!- coppro has joined.
19:26:44 -!- lambdabot has joined.
19:26:44 -!- Leonidas has joined.
19:29:41 <elliott> | 4 => @(pair(#1 car(cdr(#0))))
19:29:46 <Vorpal> oklopol, is this for the compiled output or for the process of compilation? If it is for the compiled output, couldn't you keep a counter for each named expression and inline it just used once?
19:29:46 <elliott> this shit actually works :D
19:29:48 <oklopol> elliott: btw i think you can use constants when computing the condition, i think it's more likely that when it tries compare(#0 #0), it actually substitutes that for the code for generating the number 0 (which was the constant zero), because it noticed due to memoization that they have the same results.
19:30:03 <oklopol> because it can't actually measure whether constant 0 or compare(arg1 arg1) is faster
19:30:18 <elliott> depth of first isn't working i don't think, it's showing wrongly
19:30:27 <elliott> oklopol: no, you can't use such a constant
19:30:30 <elliott> oklopol: because it gets the first param as #0
19:30:32 <elliott> even if you have constants
19:30:38 <elliott> so clearly it doesn't get constants :)
19:30:40 <oklopol> elliott: what are #0 #1 and #2 in that, it's not clear.
19:30:48 <elliott> things...i'm trying to work it out
19:31:31 <oklopol> i'll look in the code to see if you're right about constants
19:31:39 <oklopol> i'm rather convinced you are
19:35:25 <oklopol> glue is not called with that information.
19:35:36 <oklopol> # find the code for determining branch
19:35:36 <oklopol> _,preprocessing,prepcode=glue(clue.bag,
19:35:36 <oklopol> (lambda f,args:stuff.getarity(f)==len(args)),
19:35:36 <oklopol> (lambda a:is_partition(stuff.apply_to_visible(clue.cond,[a]))))
19:35:52 <oklopol> should have constants before it
19:36:16 <elliott> oklopol: you should add that :P
19:36:32 <elliott> oklopol: should i patch it up to make it a little bit more efficient?
19:36:42 <oklopol> well, at least the great thing about clue is no programs should break
19:37:22 <oklopol> not many languages where you can start giving more unnamed args to functions, and they still work the same way
19:37:31 <elliott> | aaaaaaaaa3 => @(pair(#1 #2))
19:37:33 <elliott> | aaaaaa4 => @(pair(#1 car(cdr(#0))))
19:37:35 <elliott> now that's what i call debugging output
19:38:04 <oklopol> maybe i should fix it, that's so clearly an error
19:38:17 <elliott> oh man, this is quite impressively broken i think
19:38:32 <oklopol> but i wonder how localized i can make the change, i believe pretty localized, but hmmhmm
19:38:42 <elliott> oklopol: i can do it if you want, this is fun
19:39:18 <oklopol> copy paste the code for fixed_h_objs from some other func, unless you know what invisible_lists are
19:39:40 <oklopol> they are just when you want a vector such that all things are actually applied to their contents
19:39:56 <oklopol> so that we can have multiple examples, and functions apply to them separately
19:40:01 <elliott> i have never once wanted that
19:40:21 <oklopol> well, you need it for this
19:40:47 <oklopol> it's a rather common thing to need
19:41:14 <elliott> just as soon as i fix this abomination
19:42:41 <oklopol> see this way i can write glue (which is the only thing that does any search) in such a way that it doesn't have to know anything about multiple examples, or even what examples are, it's just looking for a path from A to B, for expressions A and B, and given operations for walking (contents of bag)
19:43:22 <elliott> oklopol: and yet it's a hideous function
19:43:26 <elliott> very true to the Clue spirit i feel
19:44:15 <oklopol> well there's tons of optimization
19:44:19 <oklopol> otherwise it's not that many lines
19:44:24 <oklopol> also some debugging stuff i haven't removed
19:45:02 <oklopol> the basic reason is the compiler actually compiles everything into a python function, the asts aren't actually executed
19:45:12 <oklopol> and of course i do this by building hideous lambdas
19:45:23 <oklopol> newobjrecipe=(lambda fun_,subsetrecs_ :
19:45:24 <oklopol> app(fun_,map(lambda o:o(app,*args),subsetrecs_))))(fun,subsetrecs)
19:47:29 <j-invariant> I just need a really simple (to specify) program -- but filling the details in (i.e. writing it) is a huge hassle
19:47:38 <elliott> j-invariant: that's why clue is great!
19:47:55 <elliott> j-invariant: figures out all the little details for you, so long as you specify them all in an unreadable form underneath the examples
19:48:31 <elliott> oklopol: can i have some coffee, i need it to understand clue
19:48:32 <oklopol> what makes glue hideous is that when it's building objects, it's actually building the actual python object, an ast explaining how it was made, and a python lambda that makes it from the arguments given to the original glue function
19:48:39 <oklopol> and then i have many lines that do the memoization stuff
19:48:55 <j-invariant> you should make a human powered web interface for Clue
19:48:56 <oklopol> and i have a big try catch thing that checks whether applications succeed
19:49:05 <j-invariant> or maybe a different language all together
19:50:13 <oklopol> and applying, being applicable, what we're looking for, what functions we may use are abstracted away
19:51:11 <oklopol> their exact semantics are not as pretty as they could be ofc, might take 10 minutes to see how to make that thing infer say brainfuck code
19:52:38 <oklopol> but basically you could have objects be contents of brainfuck tape, and asts be code that generates them, prolly just leave recs empty (or generate bytecode of some sort)
19:53:48 <oklopol> then give a bag of operations like -- could be applicable iff object (the tape) has more than one at current cell, and it would add -- to the end of ast, and would decrement current cell twice to get the new object
19:54:03 <oklopol> glue would automatically memoize away multiple ways to get the same tape contents
19:54:30 <elliott> oklopol: am i correct in thinking that hardcoding the brancher/conditional to <id> would be the best thing?
19:54:40 <elliott> oklopol: since it works perfectly fine when you do that, and is also a very common thing to do
19:54:43 <elliott> and just removing <> entirely
19:55:17 <oklopol> ilkka just put <id> everywhere and told me conditions are done in a stupid way
19:55:24 <elliott> oklopol: well yes, in that you'd have to strip <> from it
19:55:30 <elliott> and then also get rid of <id>; since it'd be redundant
19:55:36 <elliott> but other than that it should work perfectly
19:55:51 <oklopol> maybe have it as backwards compatibility :D
19:55:52 <elliott> oklopol: call it "clue 1.5" :P
19:56:10 <elliott> oklopol: the backwards compatibility is the fact that there's a file called clue.py.old
19:56:45 <oklopol> or "that old clue.rar on vjn server if i didn't overwrite it yet"
19:57:00 <elliott> oklopol: clue 1.5 — more powerful conditions, less thinking about the bag, and OPTIMISED!
19:57:07 <elliott> CONSTANTS IN THE CONDITIONAL
19:57:39 <oklopol> well if i make 1.5, it'll have a completely different condition system, not just dropping <id>
19:58:09 <oklopol> i don't think that's really necessary, just have <id> for now
19:58:12 <elliott> oklopol: I'm going to do it whether you want to bother or not, just tell me what version number to give it :P
19:58:22 <elliott> well i'm optimising it anyway...and putting constants in conditions
19:58:30 <oklopol> maybe i'll actually call mine 1.5
19:58:30 <elliott> so i might as well fix the condition system a little bit while i am at it?
19:59:07 <elliott> oklopol: make it always assume <id> is given, remove <> from the parser
19:59:11 <elliott> and then in the ast printer, just ignore condname
20:00:25 <oklopol> also how were you planning to optimize? my suggestion is you add a "size" function to glue, and it always makes sure all subobjects are in the bag
20:00:37 <oklopol> so that you don't make objects bigger, unless you really have to
20:00:59 <oklopol> this would be rather easy to do, and would probably make ski compile in a millisecond
20:01:27 <elliott> oklopol: i'll probably do that
20:01:35 -!- luatre has quit (Remote host closed the connection).
20:01:40 -!- luatre has joined.
20:01:44 <elliott> oklopol: first bit of optimisation was going to be "fix your stupid fucking is applicable" function though :D
20:01:54 <elliott> ok luatre now has nicer function printing!!!
20:02:05 <elliott> feed it something recursive
20:02:08 <oklopol> just do it without making glue dependent on the rest of the code, i'm very strict about the conceptual purity of code
20:02:31 <oklopol> what do you mean fix applicable function?
20:02:40 <elliott> where you call a function to see if it can be called.
20:03:10 <elliott> oklopol: um isinstance(f,types.FunctionType)
20:04:04 <oklopol> what if the function only works for integers?
20:04:13 <elliott> oklopol: irrelevant, you call it with no arguments
20:04:16 <elliott> so you can't find that out anyway
20:04:41 <elliott> ... length ~ {:. [1,2,3] -> 3 : [2,3] -> 2 :. [[],2,[1,2],3] -> 4 : [2,[1,2],3] -> 3} length ~ {. [] -> 0} length ~ <empty>; cdr; inc
20:04:41 <luatre> ValueError: substring not found :(
20:04:52 <elliott> .:. length ~ {:. [1,2,3] -> 3 : [2,3] -> 2 :. [[],2,[1,2],3] -> 4 : [2,[1,2],3] -> 3} length ~ {. [] -> 0} length ~ <empty>; cdr; inc
20:04:52 <luatre> DepthLimitException: depth limit exceeded (length) :(
20:04:54 <oklopol> call it with no arguments? applicabler(fun,subsetobjs)
20:05:00 <oklopol> you do not call it with no arguments
20:05:01 <elliott> .:. length ~ {:. [1,2,3] -> 3 : [2,3] -> 2 :. [[],2,[1,2],3] -> 4 : [2,[1,2],3] -> 3} length ~ {. [] -> 0} length ~ <empty>; cdr; inc; #0
20:05:02 <luatre> length: [empty(#0)] | False => inc(@(cdr(#0))) | True => 0
20:05:24 <oklopol> applicabler is one of the most important things in the whole system, currently of little use because you can't make your functions fail explicitly
20:05:29 <elliott> if str(e)[-12:]=="not callable":
20:05:45 <elliott> 20:04 elliott: .:. length ~ {:. [1,2,3] -> 3 : [2,3] -> 2 :. [[],2,[1,2],3] -> 4 : [2,[1,2],3] -> 3} length ~ {. [] -> 0} length ~ <empty>; cdr; inc; #0
20:05:45 <elliott> 20:04 luatre: length: [empty(#0)] | False => inc(@(cdr(#0))) | True => 0
20:05:47 <oklopol> i thought you wanted to remove applicabler from glue :D
20:05:53 <elliott> and you didn't even realise :D
20:06:06 <oklopol> well it uses python types directly
20:06:16 <elliott> oklopol: ok so here's what i'm planning to do for clue 1.25
20:06:16 <oklopol> you just don't have operations for them yet
20:06:20 <elliott> oklopol: optimisations and stuff
20:06:29 <elliott> oklopol: remove commas from lists :D
20:06:37 <elliott> oklopol: rename empty to empty? and make it return an int
20:06:41 <oklopol> yeah all those i agree with
20:06:45 <elliott> oklopol: and maybe add those neg/sub you have
20:06:53 <elliott> which implements them using my impls :D
20:07:05 <oklopol> although i doubt you'll be able to donate that many optimizations
20:07:09 <oklopol> that are actually relevant
20:07:14 <elliott> probably not, but who cares
20:07:15 <oklopol> well, except the one i just explained to you
20:07:25 <elliott> 19:59 oklopol: also how were you planning to optimize? my suggestion is you add a "size" function to glue, and it always makes sure all subobjects are in the bag
20:07:41 <oklopol> it can get slightly hairy, but shouldn't be that hard
20:09:21 -!- ais523 has joined.
20:09:23 <oklopol> O() wise, it's enough to check if at least one new object was added that was smaller than the ones it was derived from, and if such an object was added, skip adding the big stuff on this iteration
20:09:32 -!- oerjan has joined.
20:09:53 <oklopol> unfortunately, if not all things are added, it also means you should start checking that you're not doing redundant stuff
20:10:23 <oklopol> which leads to all kinds of very nice fastenings, but will also make glue also conceptually ugly.
20:10:51 <elliott> Exception: Can't compile cadar(<id>), deep first with cutoff(<id>), deep first(<is list?>), make singleton(<id>), cadaar(<id>), depth of first(<is list?>), more than 3(<id>), pair(<id>), ski type?(<id>), ski apply(<ski type?>)
20:10:57 <oklopol> currently, glue is basically just for all subsets of objects found so far, check what functions can be applied, apply them all, remove duplicates, add to known objects.
20:11:27 <elliott> i was just using the old ski
20:11:48 <oklopol> should probably change that
20:11:57 <elliott> oklopol: nah, you can't tell it's a condition in 1.25!
20:12:15 <elliott> oklopol: clue decided it didn't need _ :D
20:12:17 <oklopol> well <ski type?> = <id>; ski type?
20:12:47 <oklopol> would be fun to look at the actual python bytecode generated btw
20:13:08 <oklopol> and perhaps make a version of glue that writes java bytecode instead
20:13:15 <oklopol> or, abstract that away as well
20:13:22 <elliott> oklopol: don't you call clue functions as the lambda
20:13:29 <elliott> so the bytecode will just look like... a function call to the interpreter
20:13:49 <elliott> oklopol: ...it decided it didn't need "is zero?"
20:14:05 <oklopol> a function call to the interpreter?!?
20:14:11 <oklopol> IT ACTUALLY COMPILES TO PYTHON
20:14:18 <elliott> oklopol: to...python strings?
20:14:18 <oklopol> there is not interpretation
20:14:27 <oklopol> that's why glue looks ugly
20:14:27 <elliott> oklopol: it manually writes bytecode?
20:14:42 <oklopol> no, it writes a whole mess of lambdas.
20:14:56 <elliott> oklopol: ok, but the point is that the lambdas don't get inlined inside each other
20:15:04 <elliott> so it's still going to look like a single lambda with a big environment full of lambdas
20:15:19 <oklopol> well you'll get very fragmented and jumpy python bytecode, yes
20:15:32 <oklopol> but not a function call the an interpreter, because there isn't one
20:17:22 <oklopol> i could, i guess, make glue directly write bytecode, if i abstracted away code generation
20:17:26 <oklopol> which wouldn't be very hard
20:18:04 <oklopol> and i could then change tail recursion to an actual loop ofc
20:18:45 <oklopol> which happens outside glue ofc, glue never recurses into code that hasn't been completely inferred yet
20:19:13 <oklopol> yeah it doesn't understand recursion, i guess that's what my point was
20:19:40 <elliott> you'll be pleased to know, i've broken ski somehow
20:19:53 <oklopol> it wasn't very hard to write
20:21:10 <oklopol> maybe i should write a really simple and stupid version of that glue + size_functions
20:21:26 <oklopol> i basically just wanna see if pivot starts magically compiling fast
20:22:32 <elliott> incidentally why does make singletone exist
20:22:36 <elliott> you can do pair with just #[] and cons
20:23:04 <oklopol> or even just that functions can be neutral, building or demolishing
20:23:20 <elliott> oklopol: i'll be happy to incorporate those changes into 1.25 :P
20:23:26 <oklopol> elliott: because it was easier to make things compile that way
20:23:44 <elliott> oklopol: see with clue 1.25 it just works
20:24:01 <elliott> . [3], [4, 5] -> [[3], [4, 5]]}
20:24:12 -!- zzo38 has joined.
20:24:13 <oklopol> building and demolishing could easily be actual concepts you can have for your objects as well, it's clear what they are in general for inductive data structures
20:24:32 <elliott> oklopol: constructing, destructing
20:24:54 <elliott> mine have a nice balance :P
20:25:04 <oklopol> by which i mean oo uses constructing
20:25:27 <oklopol> oo doesn't really make inductive data structures very natural
20:28:06 <oklopol> i should also have some kind of "in-place" changing of things, that is, you don't have to demolish an object, get to one of its subobjects, change it, and build the original back, but instead, you can virtually demolish, and sort of just get an (object, pointer) pair, such that building something out of this new object actually builds something out of the subobject referenced by the pointer, and the actual object is built on top
20:28:35 <oklopol> as an implementation detail, since elliott claims he might want to do this kinda stuff
20:28:50 <elliott> well yeah if it's not too hard.
20:28:53 <oklopol> whereas it's clear i'll just do stuff in my head and then go all meeeeeeh code.
20:28:54 <zzo38> j-invariant: Which maze?
20:29:26 <oklopol> elliott: that thing i just mentioned might be a tad complicated to do in a nice way
20:29:26 <oerjan> <j-invariant> oklopol: introduction and elimination <-- that's more for type systems and logic deductions, isn't it?
20:30:01 <oklopol> the reason i like demolishing is that you actually destroy an inductive data structure *completely*
20:30:18 <oklopol> you don't just use it once or twice
20:30:32 <oklopol> i mean you will in the compiled prog, ofc
20:31:03 <oerjan> like if x :: a and y :: b then (x,y) :: (a,b)
20:31:05 <zzo38> j-invariant: Although the display-mode ("P") function doesn't work here, you can still use bombs and bullets. Also there are various fake walls.
20:31:24 <oklopol> elliott: or more like, easy to do in a nice way, but not at all easy to see how to actually have it make things fast, instead of just adding another exponential blow-up
20:31:40 <oklopol> or not, but i'm not gonna get into the details maybe
20:31:46 <elliott> oerjan: it's what dependent losers use :D like me!
20:33:16 <oklopol> maybe i'll add building and demolishing as quick hacks now, as poc
20:33:50 <oklopol> but the functions are actual python functions, so i can't just quickly add that info to them :(
20:33:54 <oklopol> or i can, but that sounds ugly
20:34:00 <j-invariant> zzo38: I am raelly stunned by this game btw
20:34:33 <zzo38> j-invariant: Yes that level with mirrors is not one of the best levels I have created. The other levels are better.
20:35:03 <oklopol> did j-invariant mention the mirror room at some point
20:35:37 <oklopol> would've been so classis zzo38 to guess a specific room you're referring to
20:36:44 <elliott> oklopol: i suggest rewriting it as an ast interpreter so that your structure easily allows compilation :}
20:36:52 <elliott> (just because an interp is easiest first)
20:37:38 * oerjan suddenly gets the idea of a codependent programming language
20:37:42 -!- Wamanuz has quit (Remote host closed the connection).
20:38:04 <zzo38> j-invariant: Still, the mirror maze is solvable with some trial/errors (other levels are better). Just some hints, use bullets/bombs in case you forget where you are. Another way is that some things will push you and you can hear the noise of pushing. And, you can pick up potions, too.
20:38:25 <oklopol> nono i just need to have a function that extracts "construction type" information from functions, unspecified for most functions, but specified as building or demolishing for certain stdlib functions, in glue
20:38:39 <oklopol> so basically i'd be done if i could just add a string of information to the stdlib functions
20:39:26 <oerjan> <j-invariant> zzo38: I am raelly stunned by this game btw <-- so it has lots of ufos?
20:39:31 <zzo38> (If you have a save game, you can restore the save game and try a different level if you don't like that one?)
20:39:47 <elliott> oerjan: read you as oklopol was like, what, that's too real for him to mention
20:41:10 <elliott> oklopol: so when does the depth limit get exceedemated
20:42:37 <oklopol> return glue_(functions,applier,applicabler,lambda a:None,objectswithrecipes,condition,5,objects)
20:42:49 <oklopol> return glue_(functions,applier,applicabler,cons_typer,objects+newobjects,condition,depth_lim-1,orig_objs,objectlookup)
20:43:16 <oerjan> elliott: that _doesn't_ make sense
20:43:25 <oklopol> later, it will only make 5 *build* rounds
20:43:35 <elliott> oklopol: if the depth limit gets exceeded
20:43:37 <elliott> what has clue failed to do
20:43:46 <oklopol> it has failed to find an implementatoin.
20:44:09 -!- Wamanuz has joined.
20:44:13 <oerjan> elliott: <elliott> oerjan: read you as oklopol was like, what, that's too real for him to mention
20:44:22 <elliott> oerjan: read your name as oklopol
20:44:29 <elliott> that's too real for him to mention
20:44:40 <elliott> oklopol: okay, so basically it means "im not smurf enough to this function?"
20:45:13 <elliott> where smurf is smart and to is to make
20:45:35 <elliott> oklopol: but that's...bad, yes
20:45:36 <oerjan> elliott: ufos are too real for oklopol to mention, gotcha
20:45:38 <oklopol> that it looks at the size 5 ball.
20:46:40 <elliott> oklopol: i think that <> is actually needed in some cases :D
20:46:43 <elliott> e.g. deep first with cutoff
20:46:47 <elliott> doesn't work without <id>...
20:46:59 <oklopol> it should, just slightly slower
20:47:09 <elliott> it's not actually slower, this
20:47:34 <oklopol> well obviously the functions that previously used something other than id will now be slower
20:47:42 <oklopol> because you're giving it the topmost function
20:47:45 <elliott> oklopol: nonono, this is confusing
20:47:47 <oklopol> instead of having it do that for you
20:48:36 <oklopol> so how do i add a bit of information to a function
20:48:46 <oklopol> i don't want to make my own function class or anything
20:50:46 <oklopol> AND THEN I'LL JUST MAKE A TRY CATCH BLOCK TO CHECK FOR THAT
20:51:18 <elliott> oklopol: getattr(func,'propname',default)
20:51:40 <elliott> aw man, it doesn't print I BARFED UP A YUPPIE
20:53:10 <elliott> oklopol: what the fuck is happening
20:54:15 <elliott> xDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
20:55:19 <elliott> oklopol: tl;dr without <>, you need more examples
20:55:24 <elliott> to stop the silly thing thinking it can do trivial shit
20:55:52 <elliott> oklopol: so uh... should i add more examples or restore <>
20:57:56 <oklopol> so erm how did you do the removal of <> exactly
20:57:58 <elliott> oklopol: i mean obviously the clue purist in me says, obviously, get rid of <> and just add more examples
20:58:04 <elliott> oklopol: i hardcoded the cond function to id
20:58:06 <elliott> and left all the rest as is
20:58:17 <elliott> so everything has <id> now basically
20:58:22 <oklopol> and deep first broke what was it using?
20:58:55 <elliott> oklopol: yeah... is list? is in the function list though
20:59:03 <elliott> oklopol: it just needs another example in one or both blocks
20:59:07 <elliott> oklopol: so that clue realises it needs is list
20:59:25 <oklopol> it's okay that it needs two examples for deep first imo
20:59:45 <oklopol> i mean, the correct thing to do is assume the first ones are hard coded things, and the last one is a default branch
20:59:59 <oklopol> if you're trying to find the easiest implementation of the given behaviour
21:00:18 <oklopol> so just add another example for the constant case, and is list? in the bag
21:00:35 <elliott> is list was already in the bag
21:00:40 <elliott> but yeah, it's the constant case that needs adding
21:00:52 <elliott> oklopol: maybe if clue can't use all the functions you provide it should error out
21:01:01 <elliott> "either you have useless code, or i wasn't smart enough"
21:02:12 <elliott> yay ski seems to compile now... I think either deep first or my printing function is broken though :)
21:02:15 <elliott> probably my printing function
21:02:20 <elliott> deep first ~ {:. [[1, 2], 3] -> 1
21:02:27 <elliott> is what seems to have fixed it
21:02:33 <oklopol> i mean for instance if you just go "this can prolly be done with car, cons and cdr but i can't ass thinking about it", and turns out you just need two of those, then i wouldn't call that a bad thing
21:02:46 <elliott> "hey, you might wanna remove these: "
21:02:53 <elliott> "or else if you know it's needed, lol, i fucked up, be more examply please"
21:03:08 <elliott> oklopol: omg i just invented SuperClue
21:03:15 <elliott> oklopol: every function defined so far is put into every bag
21:03:42 <oklopol> yeah yeah, remove the reason glue actually works, and it'll be even more beautiful
21:04:21 <elliott> oklopol: well ... who runs programs
21:04:25 <oklopol> but, anyway that might actually be feasible, when a very nice interp is made by a very smart person, and when there's a bit more stuff you can do to help compilation
21:05:00 <elliott> | 3 => @(pair(cadar(#0) ski type?(cdr(#0))))
21:05:04 <elliott> that looks very suspicious
21:05:12 <elliott> just my broken printing function again
21:05:13 <oklopol> i mean, i'm going to add a rather nice syntax for adding new inductive data structures, at some point.
21:05:21 <elliott> oklopol: and then remove built in lists and numbers, yes?
21:05:33 <elliott> oklopol: omg... if it actually did guessing based on the induction scheme of the structure
21:05:36 <oklopol> rather nice as in, clue should never start to look like an esolang... again conceptually
21:05:58 <oklopol> elliott: yeah that's the idea
21:06:29 <elliott> oklopol: ski compilation is over 2x slower :D
21:06:31 <oklopol> that you have something like "list tool bag", which is the basic operations of lists, and if you have lists as args, it's unioned with the bag by defauly.
21:06:47 <elliott> oklopol: but then again...
21:06:52 <elliott> oklopol: optimising over language purity is kinda
21:07:11 <elliott> oh man, it actually uses my cpu doing this
21:07:18 <oklopol> yes. conditionals are you writing actual code, doing some specific thing.
21:07:20 <elliott> variable: we've invented your language which takes ages to compile anything
21:07:29 <oklopol> they should not be allowed near clue.
21:07:41 <elliott> oklopol: well if conditionals could take multiple arguments. then i wouldn't mind nearly as much
21:07:44 <elliott> because you wouldn't have to do <id>.
21:08:12 <oklopol> i sort of mind them anyway, i mean next thing you know you'll want to say "...and this recursive case should cons two things together"
21:08:36 <elliott> oklopol: oh sertanly, i just meant i wouldn't HATE IT WITH ALL MY GUTS if they could take multiple args
21:08:42 <variable> I'll look in a bit - I can't talk now
21:08:49 <elliott> oklopol: also, i am going to add constant support for conditionals now ...
21:08:52 * variable is working on a unnecessary compiler in haskell
21:08:53 <elliott> oklopol: can we stop calling it a conditional?
21:09:33 <elliott> condcode=lambda*a:clue.cond(preprocessing(apply,*a))
21:10:18 <elliott> oklopol: i just wanna know where you create the conditional code :D
21:10:21 <elliott> so i can give it constant access
21:10:26 <elliott> although the inferrer would have to know about it too
21:11:12 <oklopol> giving it constant access is not that easy, because you also have to call it with constants then
21:11:18 <oklopol> which is done in a different place
21:11:28 <oklopol> and no, glue doesn't need to know about this.
21:11:39 <oklopol> glue has nothing to do with anything around it
21:11:53 <oklopol> well, it will when i add demolishing check, but glue_ will still not
21:12:27 -!- ais523 has quit (Ping timeout: 240 seconds).
21:12:36 <elliott> oklopol: clue is so awesome.
21:12:38 <oklopol> i keep tight track of logical dependancies, usually
21:14:37 <elliott> oklopol: you know what, you can add constants in conditionals :D
21:15:07 <oklopol> it's not actually that hard, but you need to wrap stuff in invisible lists a bit and such
21:16:28 <oklopol> essentially it's just giving glue the constants when you call it for conditional, in invisible lists full of that constant (for each example, that constant in the index of the invisible list reserved for that example), and then wait what?
21:16:31 <elliott> (lambda a:is_partition(stuff.apply_to_visible(clue.cond,[a]))))
21:16:35 <elliott> is it safe to turn this into uh
21:16:46 <elliott> say that clue.cond doesn't exist any more
21:16:53 <elliott> how can i rewrite that line?
21:16:56 <oklopol> and yeah then you need to find where the lambda is made that actually computes all of that stuff
21:17:55 <oklopol> i believe so, you can just check if the actual objects are a partition already
21:18:59 <oklopol> is_partition is... a bit involved is it...
21:19:26 <oklopol> it's because of default branches
21:20:06 <oklopol> is_partition actually checks if the list you give it is a partition, assuming one of the partition elements can be "default", so for instance [[1, 1, 1], [3, 3], [6, 5], [4, 4]] would be a partition
21:20:13 <oklopol> because only [6, 5] is default
21:20:29 <oklopol> yeah i believe that's how it works
21:21:05 <oklopol> so maybe just have is_partition as cond
21:21:08 <elliott> oklopol: okay so i just put the list in there directly.
21:21:19 <oklopol> instead of that whole lambda
21:22:44 <elliott> this is an achievement for me.
21:23:15 -!- Phantom__Hoover has joined.
21:23:15 -!- Phantom__Hoover has quit (Changing host).
21:23:15 -!- Phantom__Hoover has joined.
21:25:22 <elliott> oklopol: can i rename inc/dec to succ/pred
21:25:52 <oklopol> ski now compiles in 3 seconds
21:26:12 <elliott> oklopol: holy shit give me your new clue.py, i want to see if no-conditions could actually be fast
21:26:27 <elliott> oklopol: unless you're lying
21:26:51 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
21:26:53 <oklopol> http://www.vjn.fi/pb/p2721555448.txt
21:27:08 <elliott> you ... just changed stuff.py? not clue.py?
21:27:17 <oklopol> http://www.vjn.fi/pb/p1499968214.txt
21:29:02 <oklopol> it just does... well exactly what i explained earlier
21:29:22 <elliott> +def check_demolishing(f):
21:29:22 <elliott> + if getattr(f,'demolishing',None)==True:return True
21:29:28 <oklopol> note that functions are partitioned into demolishing and nondemolishing ones because i just wrote it where my cursor was :D
21:29:30 <elliott> oklopol: "return getattr(f,'demolishing',False)"
21:29:42 <oklopol> made me laugh when i saw what my fingers had done
21:30:06 <oklopol> but i wanted to leave it as a surprise for ya
21:31:01 <oklopol> hmm.... it's very likely i won't get pivot to work without the pointer idea
21:31:09 <oklopol> i wonder if there's some two line solution for that...
21:31:26 <oklopol> "<oklopol> note that functions are partitioned into demolishing and nondemolishing ones because i just wrote it where my cursor was :D" <<< you should be laughing at this instead of that two line demolishing check tho
21:31:55 <elliott> + for (funname,fun) in demolishingfuns+nondemolishingfuns:
21:31:57 <elliott> oklopol: that's the same as functions
21:32:26 <oklopol> unfortunately it does, see things are added one functions at a time
21:32:56 <oklopol> for a reason that is rather irrelevant at this point
21:32:58 <cheater00> might i just add that i hate humans
21:33:44 <elliott> oklopol: oaky, merged your changes in, time to test
21:34:38 -!- pikhq has quit (Ping timeout: 272 seconds).
21:35:35 <elliott> UnboundLocalError: local variable 'newobjects' referenced before assignment
21:35:39 -!- Phantom__Hoover has quit (Ping timeout: 240 seconds).
21:36:05 -!- pikhq has joined.
21:36:46 <elliott> oklopol: ski without conditionals
21:37:04 <elliott> oklopol: does that mean that removing conditionals has... made it go faster?
21:37:11 -!- sebbu2 has joined.
21:38:05 <oklopol> or maybe it means my computer is very slow
21:38:20 <elliott> oklopol: well okay but mine didn't do ski faster than 20s either
21:38:25 <elliott> oklopol: point is: hey removing conditions is practical!!
21:38:27 <oklopol> because it couldn't possibly be faster without conditionals
21:38:30 <oklopol> i mean compilation couldn't
21:38:40 <elliott> because the rest is so faster
21:38:41 <elliott> oklopol: has pivot compiled yet
21:38:53 <elliott> oklopol: i'll try with my faster computer? :p
21:39:17 -!- sebbu has quit (Ping timeout: 276 seconds).
21:39:32 <oklopol> http://www.vjn.fi/pb/p2549382249.txt
21:39:37 <oklopol> go ahead, code might be wrong as well...
21:39:52 <oklopol> but i think i've tested everything except pivot at least
21:40:00 <oklopol> i seriously need to add that :: thing
21:40:02 -!- sebbu has joined.
21:41:00 <elliott> oklopol: i could make a repl for luatrelang :P
21:41:32 <elliott> Exception: Can't compile caaar pivot helper(<id>), triple(<id>), cons to caaar(<id>), caaar with consed(<id>), make singleton(<id>), car pivot helper(<id>), caaar(<id>), pivot(<id>), cons to car(<id>), caar(<id>)
21:41:35 <elliott> i get to modify your code!!
21:41:40 <oklopol> it can't even compile the things outside pivot now, maybe ski just happened to be faster :\
21:41:56 <elliott> oklopol: i didn't save my old clue.py
21:42:03 <oklopol> it's the only list prog i have so hard to say
21:42:35 <oklopol> you can just comment car.demolishing = True.
21:42:58 -!- sebbu2 has quit (Ping timeout: 265 seconds).
21:43:03 <oklopol> if you comment that out, it's basically the same as earlier
21:43:10 <oklopol> it's just demolishing funcs are tried first.
21:43:42 <oklopol> so at all times, you will have, in the list of found objects, every object that's a subobject of it
21:43:50 -!- cheater99 has joined.
21:43:51 <elliott> oklopol: pivot still going, are you sure this will compile in finite time?
21:43:53 <oklopol> *for every object, every subobject that's a ...
21:44:25 * elliott tries to compile without pivot
21:44:29 <elliott> uh this is... uncharacteristically slow
21:45:05 -!- cheater00 has quit (Ping timeout: 240 seconds).
21:45:07 -!- sebbu2 has joined.
21:45:09 <oklopol> there should be an simple way to disable compilation of something
21:46:28 <elliott> oklopol: i don't think this change was a good idea :D
21:46:43 <elliott> oklopol: well this... definitely went faster before.
21:46:59 <oklopol> huh? you've compiled that before?
21:47:05 <zzo38> When a line of text is centered vertically in a box, should it use only the part above the baseline for centering the text?
21:47:08 <elliott> oklopol: well no. but it looks trivial.
21:47:11 <elliott> oklopol: i mean without pivot
21:47:18 <elliott> it still hasn't compiled such simple things as "car pivot helper"
21:47:55 <oklopol> what i should do, is make glue simply demolish the original objects completely
21:47:59 <oklopol> but then not demolish any of the new ones
21:48:22 -!- sebbu has quit (Ping timeout: 276 seconds).
21:48:24 <oklopol> then maybe you would get both speedy ski, and speedy other things
21:48:56 <elliott> my laptop is being a great heater right now
21:49:50 -!- Phantom__Hoover has joined.
21:53:44 <oklopol> changed, ski compiles at essentially same speed, no help with pivot :(
21:53:51 <j-invariant> spent ages defining polynomials in coq but I got into trouble with equality
21:55:04 <elliott> oklopol: to compile all the non-pivot functions in the file
21:55:09 <elliott> oklopol: note that they're all trivial :D
21:55:20 <oklopol> how long without demolishing?
21:55:35 <elliott> oklopol: just removing the .demolishing = True stuff for car and cdr you mean?
21:56:02 <oklopol> then it's what it was before, i recall even i could compile them
21:57:47 <elliott> oklopol: for all non-pivot functions
21:58:21 <oklopol> pivot should work faster with demolishing.
21:58:44 <elliott> oklopol: this is without conditionals btw
21:58:48 <oklopol> but i figured it can't actually *hurt* the others that much
21:58:53 <elliott> although it's equivalent for this file
22:00:39 <oklopol> so umm, wanna try adding demolishing just before pivot is compiled? :D
22:01:27 <oklopol> btw, as you may have guessed, that's essentially what strategies are, ugly workarounds so that you can help it look in the right direction
22:01:42 <elliott> oklopol: yeah, i oppose them vehemently
22:01:47 <elliott> oklopol: i do think you should replace the bag with something else though
22:01:51 <oklopol> although they have much higher ambitions than just guiding the search with utility functions
22:03:03 <elliott> oklopol: i think a form of strategies but purer
22:03:08 <elliott> oklopol: like, you describe what kind of algorithm is
22:03:11 <elliott> "depth first recursion" might be one
22:04:46 <oklopol> except that's much less pure than strategies
22:05:28 <oklopol> strategies are so abstract and complicated i can't even put my finger on them
22:05:29 <Sgeo> yay1 I slept all day!
22:06:24 <elliott> oklopol: it'd be describing the function
22:06:49 <elliott> oklopol: pivot still pivotoeing
22:07:09 <elliott> oklopol: are you sure this isn't in an infinite loop
22:07:21 <oklopol> it's not an infinite loop, no
22:08:10 <elliott> oklopol: greater-than-universe loop?
22:09:19 <oklopol> well it's superexponential
22:09:48 <oklopol> why do you think it's 5 instead of 100
22:09:48 <elliott> oklopol: why am i even running this then
22:10:02 <oklopol> because it might find the answer before doing the complete search
22:10:23 <oklopol> i have no idea how deep the answer lies!
22:10:29 <oklopol> actually i could just calculate i guess
22:10:43 -!- j-invariant has quit (Quit: leaving).
22:11:43 <elliott> oklopol: ...you adopted my indentation convention :D
22:12:27 <elliott> oklopol: i have a feeling it's actually harder to read, but who cares it's prettier
22:13:03 <oklopol> it should just infer constocaaar( car(#2) #3 ) :\
22:13:13 <oklopol> maybe something is very fundamentally wrong somewhere
22:13:24 <oklopol> or, i have no idea what it's finding hard to do
22:13:25 <elliott> oklopol: are you sure your search algorithm is working right :D
22:13:37 <elliott> oklopol: erm why not put a bunch of prints with the func and its arguments above suspect functions
22:13:41 <elliott> and then just look at what it's doing so much
22:13:45 <oklopol> FUCKFUCKFUCKFUCKFUCKUFKCUFKFJDKSF
22:13:49 <oklopol> FUCKFUFKFUKCUFUUFUCCKCFKJUFCKUCFKUCFUKCFUKCFUKCF
22:13:52 <oklopol> CFUJCFUJCFUKCFKCFKCFUKCFKUCFKUCFKUCFKUCFKUCFKUCFKU
22:14:49 <elliott> oklopol: oh my god the poor thing's been sitting there going WHAT CONDITION IS THIS WHAAAAAAT
22:14:59 <oklopol> run that search up to depth five and it's possible we'll know.
22:15:16 <elliott> oklopol: so uh. fix it? :p
22:15:19 <oklopol> yeah, that's the kind of thing the new conditionals will be able to do
22:15:25 <oklopol> now, it needs to be worked around
22:15:35 <elliott> oklopol: try not to work around it in a way that doesn't work without <> >_>
22:15:53 <oklopol> the problem is i didn't originally realize that i'll need cases for the recursive thing, and then i just split it in two cases without realizing CONDITIONS
22:16:07 <elliott> oklopol: right well... go fix
22:16:58 <oklopol> i actually have no idea how to fix that :P
22:17:06 <elliott> oklopol: rewrite from scratch? :P
22:17:22 <oklopol> what i have to do, obviously, is write the condition function
22:17:46 <elliott> oklopol: has anyone told you that you behave exactly like a really dim but hyper kitten somehow given silly amounts of intelligene?
22:19:36 <oklopol> no! actually no one *ever* told me that!
22:20:16 -!- oerjan has quit (Quit: leaving).
22:20:22 <elliott> oklopol: it has to be noted that i've been trying to think how to perfectly summarise how you act since, like, 2007
22:20:28 <elliott> so maybe everyone else just gave up sooner?
22:27:18 -!- augur has changed nick to |Rassilon|.
22:28:12 -!- |Rassilon| has changed nick to augur.
22:29:22 <oklopol> well fi:rassi is something you use to clean pipes
22:29:37 <oklopol> so isn't it fitting since augur is, well, you-know-what
22:30:02 <augur> sorry, i was reenacting the formation of timelord society in another channel
22:30:11 <oklopol> augur: ah, that was my second guess
22:30:51 * elliott waits for first night in first minecraft game on hard
22:30:56 <oklopol> i told my computer hey you silly little thing that cannot handle most flash games, have here this python program that constantly allocated more and more memory while doing this impossible search for a nonexistant thing
22:30:57 <elliott> i have a tiny house and no torches
22:31:19 <oklopol> yeah yeah once my computer starts working
22:33:01 <oklopol> i meant i told my computer i'll go elsewhere btw, in case that was what you were :(ing about
22:33:01 <elliott> oklopol im afraid of creepers
22:33:06 <elliott> and thinks taht make noise
22:33:21 <elliott> HOW DO I MAKE NIGHT BEARABLE
22:33:36 <oklopol> i find creepers even scarier during the day
22:33:46 <elliott> oklopol: also how do i get the courage to run outside on the first day
22:33:50 <elliott> all i have is a wooden fucking sword
22:34:03 <augur> in american parlance, a creeper is any guy who you're not attracted to who is attract to you
22:34:09 <elliott> auhttp://4.bp.blogspot.com/_oaOBSdwJP7k/TFfZbw0Py8I/AAAAAAAABFQ/crE_sdzUIR4/s1600/Twocreepers.png
22:34:10 <elliott> augur: http://4.bp.blogspot.com/_oaOBSdwJP7k/TFfZbw0Py8I/AAAAAAAABFQ/crE_sdzUIR4/s1600/Twocreepers.png
22:34:17 <elliott> in american-post-minecraft parlance
22:34:21 <elliott> is the worst thing in the world
22:34:26 <augur> oh, a mindcraft thing
22:34:36 <oklopol> augur: yeah creeper is a special case of that
22:34:41 <elliott> oklopol: also i have no food!
22:34:56 <elliott> oklopol: hi skeleton out the window
22:36:06 <elliott> oklopol: you mean my server? when i learn how not to be a pussy
22:36:20 <Vorpal> augur, hm what would a game called mindcraft do?
22:36:35 <elliott> oklopol: also also how do i look outside the window without getting scared shitless
22:36:40 <oklopol> and that's a fuckload for this computer
22:36:52 <augur> Vorpal: it'd be like minecraft only instead of building castles you stop being lame.
22:36:56 <elliott> "In SMP, other people can't see your pictures." :D
22:37:05 <elliott> augur: excuse me, minecraft is awesome?
22:37:15 <elliott> uncreative poops build castles
22:37:26 <augur> the only awesome thing about mincraft is that CPU someone built
22:37:37 <augur> and maybe some other shit i dont know about
22:37:43 <augur> but the overwhelming majority of minecraft is lame
22:37:43 <elliott> augur: excuse me i believe i am working on a 128x128x128 cube made out of glass lit by lava?
22:37:45 <Vorpal> <elliott> "In SMP, other people can't see your pictures." :D <-- further if the chunk unloads from your client the painting will be gone. If that is what you meant.
22:37:54 <augur> elliott: sounds pretty lame to me
22:38:19 <augur> i dont sound lame to me
22:38:43 <oklopol> yes, the majority of mc is lame from the outside, that's rather irrelevant. how much have you actually played?
22:38:49 <augur> yeah but you're lame so your opinion doesnt count
22:38:56 <Vorpal> <elliott> oklopol: also also how do i look outside the window without getting scared shitless <-- by making the walls out of obsidian and so on
22:39:15 <elliott> Vorpal: no i'm just scared of seeing things
22:39:15 <oklopol> 's contributions to the world are mostly uninteresting
22:39:20 <augur> oklopol: i've played absolutely none, which is why my opinion is valid. its objective and untainted by the brainwashing of minecraft usage
22:39:41 <elliott> i can say this 'cuz my mind is untainted
22:39:44 <Vorpal> elliott, make a obsidian window shutter on the outside then. Then you can see through the window and see nothing scary
22:39:56 <elliott> Vorpal: BUT THINGS ARE MAKING NOISJEFOISNKGDFH;S]
22:39:58 <augur> besides, everyone knows you're a gay, elliott
22:40:18 <Vorpal> elliott, hm. Make your house large enough that you can't hear anything outside when near the middle
22:40:23 <Vorpal> then never go near outer walls
22:40:27 <augur> are you a gay boy or a straight woman
22:40:28 <oklopol> augur: right, you should clarify that tho
22:40:36 <augur> both i should think
22:40:55 <augur> a superposition of both states, using the Quantum monad!
22:41:13 <oklopol> i'm fine with people hating on mc because you can't actually build anything interesting in it, it's just actually a fuckload of fun to do it, which is what makes the game a good one
22:41:17 <augur> is that a complement or a slight
22:41:27 <elliott> Vorpal: there is a skeleton like 5 blocks away from me fuck i can't see it aargh
22:41:29 -!- j-invariant has joined.
22:41:40 <augur> i actually dont give a shit about minecraft, i have no opinions of it
22:41:41 <elliott> j-invariant what did you do on your first night before you had stuff to make tools and shit
22:41:45 <Vorpal> elliott, not enough windows then!
22:41:51 <elliott> i'm in a really tiny house with a wooden sword looking scared out of my door with not orches
22:42:01 <augur> Phantom__Hoover: so a .. monad?
22:42:15 <Vorpal> elliott, and that is a problem.
22:42:16 <j-invariant> I died every night for the first 10 nights or something
22:42:33 <elliott> Vorpal: that's the best solution to my previous problem that i could cook up in ten minutes
22:42:44 <elliott> Vorpal: the previous problem was that i was in a dense forest with no good place for a house and basically nothing apart from wood and dirt.
22:42:48 <j-invariant> my world is quite habitable now, if you know the right places to go
22:42:52 <elliott> did i mention my house's bottom layer is made out of dirt
22:43:08 <Vorpal> elliott, wait, didn't you spawn on a beach?!
22:43:26 <elliott> but it was right next to a forest
22:43:31 <Vorpal> elliott, also digging down a few blocks will aways get to stone
22:43:33 <elliott> O FUCKING GOD THE SKELETON JUST WALKED PAST MY DOOR
22:43:40 <elliott> Vorpal: couldn't have got enough stone in time
22:43:56 <oklopol> "<elliott> j-invariant what did you do on your first night before you had stuff to make tools and shit" <<< it takes about 3 minutes to get rock tools
22:43:57 <Sgeo> elliott, on Peaceful, I shouldn't bother with lighting, should I?
22:43:59 <Vorpal> elliott, uh, you have 10 minutes from starting the first day until the first dusk
22:44:05 <Vorpal> elliott, what were you waiting for
22:44:13 <elliott> Sgeo: well. if you don't care about being able to see at night, sure.
22:44:23 <elliott> Vorpal: well first i had to walk to where there were trees, 30 seconds
22:44:41 <elliott> Vorpal: then i cut down two trees, waited for the saplings, and replanted (second one i looked for a big one) - 2 minutes about
22:44:47 <Vorpal> elliott, funny definition of "right next to" ;)
22:44:55 <j-invariant> is there a way to list you XYZ coordinates? or would that be cheating?
22:44:55 <elliott> ok it was actually 10 seconds.
22:44:57 <elliott> Vorpal: then i walked until i found some land that wasn't a fucking forest
22:45:13 <elliott> Vorpal: then i climbed to the top of it
22:45:16 <Vorpal> elliott, waiting for the saplings would be wrong thing to do at that stage unless it is the only tree near it
22:45:21 <elliott> Vorpal: then i cut down a biiig tree to make space for a house
22:45:23 <oklopol> "waited for the saplings"?
22:45:29 <j-invariant> ah great! that will make coordinate two tunnels much easier
22:45:40 <Vorpal> elliott, that was wasted time
22:45:41 <elliott> Vorpal: then i started building my house, about 2 to 3 minutes
22:45:58 <elliott> Vorpal: finally it was done, then all the way through this i crafted a few things
22:46:08 <elliott> that was about 2 minutes in total then
22:46:14 <elliott> so yes, it started getting dark soon after.
22:46:21 <elliott> oklopol: umm saplings spawn on leaves if you cut down a tree
22:46:25 <elliott> oklopol: then the leaves decay and they fall
22:46:25 <Vorpal> elliott, crafting takes 2-5 seconds usually
22:46:30 <oklopol> why didn't you just hack them?
22:46:31 <elliott> Vorpal: i meant crafting in total.
22:46:59 <elliott> oklopol: but you have to wait for the saplings to generate to get more
22:47:00 <Vorpal> elliott, sure that takes some times. But point is, you wasted time on waiting for saplings
22:47:09 <elliott> Vorpal: i.e. logs -> wood, wood -> sticks, -> workbench, -> pick, -> sword
22:47:10 <Vorpal> ignore them until you have a good shelter
22:47:13 <elliott> who cares, saplings took like 20 seconds in total
22:47:22 <elliott> also the craftings above weren't done all at once
22:47:28 <elliott> pretty much didn't stand around for a second.
22:47:40 <oklopol> elliott: you will get at least 2 saplings from a tree without any waiting
22:47:52 <elliott> come back you fucking skeleton i want to kill you
22:48:38 <elliott> did i mention i am on hard
22:48:52 <oklopol> skeletons are the same on hard
22:49:07 <oklopol> ...i mean CONGRATULATIONS! :)
22:49:17 <elliott> oklopol: their arrows deal greater damage
22:49:19 <Vorpal> elliott, suggestion for better first day handling: craft bench with first log, then axe with the next few. Cut down some more, craft pickaxe. Now build a shelter around the bench you placed, use wood and/or dirt or whatever is around. Doesn't matter if it is in wooded area, Way better that it is near spawn in case you die. Then you will have a nearby shelter
22:49:31 <Vorpal> elliott, then hunt coal
22:49:34 <oklopol> but that's less discouraging
22:49:51 <Vorpal> elliott, now, second day you look for a nice place for actual main base
22:49:56 <oklopol> also i didn't remember that, but that's not important.
22:50:35 <oklopol> another way to do things: take random direction, RUN
22:50:41 <Vorpal> elliott, you can craft the sword during the first night. Also keep track of time so you can get back to shelter in time
22:50:50 <oklopol> work all day, run all night
22:51:40 <elliott> oklopol: a creeper exploded me in the water
22:51:45 <elliott> and i had to get onto land or shit would happen
22:51:49 <elliott> because another was coming
22:51:55 <elliott> and then a zombie appeared
22:53:28 <oklopol> i would've survived all that.
22:53:36 <Vorpal> elliott, hm you never see any live humans. But there are skeletons and zombies. Presumably you are like the last man on earth. Post-apocalypse. Except scenery looks too untouched for that.
22:53:40 <elliott> oklopol: what would you have done, then
22:53:45 <elliott> Vorpal: there is one other ...
22:53:54 <oklopol> well you know, the usual i woulda killed them all
22:54:11 <elliott> oklopol: yeah i tried that, but they killed me
22:54:26 <oklopol> it's hard to explain, i'd have to show you
22:55:02 <Vorpal> elliott, oh wait, do you use that mod that adds him? IIRC there was some human-mob mod too. That added both friendly and enemy humans. That built stuff even.
22:55:29 <elliott> any mod to do it is probably not as good as it should be
22:55:40 <elliott> i doubt he cuts down trees, for instance
22:55:50 <Vorpal> elliott, they didn't add doors though iirc
22:55:51 <elliott> they, i mean a herobrine mod
22:55:56 <elliott> the human mob stuff you can go up to
22:56:01 <elliott> herobrine you can't get near
22:56:40 <elliott> Vorpal: he's always just out of reach.
22:56:44 <elliott> okay why do all the enemy mobs have such fucking terrifying noises
22:57:19 <elliott> http://twitter.com/notch/status/23849639551700992
22:57:56 <elliott> "Oh no, I don't have a sister called Sandra who killed 10 people and then became web-famous by pretending to be a fish. And she definitely isn't secretly half-black."
22:58:04 <elliott> (i feel this situation is comparable)
22:58:29 <elliott> Vorpal: http://manicdigger.sourceforge.net/news/
22:59:03 <elliott> someone showed that to notch on twitter and he's all ":|||"
22:59:22 -!- pikhq has quit (Ping timeout: 276 seconds).
22:59:24 <Vorpal> elliott, what does it do? It doesn't really say. Just news.
22:59:30 <elliott> Vorpal: um look at screenshots
22:59:36 <elliott> seems to be compatible with MC servers too, well, circa july
23:00:03 <elliott> heh apparently it's actually about as old as mc... presumably they, eh, realigned their priorities after MC got popular though
23:00:09 <elliott> probably better coded mind you
23:00:48 -!- pikhq has joined.
23:01:00 <Vorpal> <elliott> (i feel this situation is comparable) <-- not really no
23:01:37 <Phantom__Hoover> elliott, so is that the semi-mythical Minecraft Clone With A Chance?
23:01:48 -!- invariable has joined.
23:01:53 <elliott> Phantom__Hoover: It doesn't look good mind you.
23:01:54 <Vorpal> elliott, he stated he never had a brother except a half-one he never met. And that herobrine isn't real. Presumably in reply to someone?
23:02:01 <elliott> Vorpal: Herobrine is real.
23:02:05 <elliott> "Yeah, I pretty much live by XKCD" ————————————————————Notch~~~~~
23:02:11 -!- invariable has quit (Remote host closed the connection).
23:02:13 <elliott> (3) did i mention i hate you
23:02:29 <Vorpal> elliott, why not boycott the game then!
23:02:36 <Phantom__Hoover> Well, yes, but he's *Notch*. He always hates people who build on his work.
23:02:49 <elliott> if notch were a drug dealer
23:02:52 <Vorpal> Phantom__Hoover, none whatsoever :P
23:03:08 <elliott> Phantom__Hoover: http://www.minecraftwiki.net/images/6/68/1283223082465.jpg has photographic proof.
23:03:29 <Vorpal> Phantom__Hoover, well know hoax :P
23:04:07 <elliott> Phantom__Hoover: did you know: talking to people who refuse to not take anything seriously is like talking to Vorpal
23:04:37 -!- drakhan has joined.
23:04:50 <Sgeo> elliott, I don't take things too seriously
23:04:58 <Sgeo> Maybe I don't take things seriously enough...
23:05:03 <Sgeo> Am I the anti-Vorpal?
23:05:27 <Phantom__Hoover> elliott, are you saying that you aren't being serious about Herobrine?
23:05:46 -!- Sgeo has changed nick to AntiVorpal.
23:05:57 -!- elliott has changed nick to Sgeo.
23:06:05 <AntiVorpal> [Note: This nick should not be construed to mean that I hate Vorpal]
23:06:25 <Vorpal> AntiVorpal, you should ghost elliott now :P
23:06:27 <Sgeo> hmm, guess it broke again :D
23:06:35 <Sgeo> Vorpal: just steal my nick :{
23:06:38 <Sgeo> that is punishment enough
23:06:42 <Sgeo> to know the evil Vorpal is using my nick
23:06:49 <Vorpal> Sgeo, har, as if I would let myself be ghosted
23:07:07 -!- Sgeo has quit (Disconnected by services).
23:07:34 -!- MigoMipo has quit (Read error: Connection reset by peer).
23:07:34 -!- Sgeo has joined.
23:07:42 <Sgeo> so that's your password sgeo?
23:07:48 * AntiVorpal promises not to do that again, unless you actually get on my nerves
23:07:54 <Vorpal> + Sgeo (~elliott@unaffiliated/elliott) has joined #esoteric <-- except you aren't logged in as him
23:08:00 <Sgeo> i didn't bother
23:08:25 <Phantom__Hoover> (FWIW, the only evidence I would actually accept of Herobrine (or any other ultra-rare events in a moddable game) would be if someone actually pointed me to the exact line where it says addHerobrine() in the MC jar.)
23:08:47 <Vorpal> Phantom__Hoover, would you accept add_herobrine() instead?
23:10:03 <Sgeo> Phantom__Hoover: you DO realise that nobody believes herobrine?
23:10:09 <Sgeo> it is, and always has been, a joke
23:10:41 <Vorpal> Sgeo, this one: http://www.minecraftforum.net/viewtopic.php?f=25&t=111753
23:10:48 <AntiVorpal> Hey, when you pulled similar BS on me, you didn't admit it until I directly asked another channel and made a fool of myself there
23:11:07 <Sgeo> AntiVorpal: yes, because you believing that was hilarious in a pathetic kind of way.
23:11:10 <Sgeo> oklopol: done it yet?
23:11:13 <Vorpal> AntiVorpal, what do you expect from elliott?
23:11:24 <AntiVorpal> Vorpal, is consistency too much to ask?
23:11:37 <Sgeo> Vorpal: dude, he reacted to "#machomebrew" by asking whether Apple _really_ didn't let people run unsigned code on their computers
23:11:50 <Sgeo> and then kept believing it when me and Phantom__Hoover told him how, yes indeed, there were only a few interpreters and they only ran signed code
23:12:03 <AntiVorpal> Sgeo, what makes you think I actually believed it?
23:12:04 <Vorpal> Sgeo, I presume that channel is for their locked down products then?
23:12:13 <Sgeo> AntiVorpal: um because you've been offended by it ever since?
23:12:16 <Sgeo> Vorpal: no, it's a package manager.
23:12:28 -!- Phantom__Hoover has changed nick to elliott.
23:12:30 <Vorpal> Sgeo, well okay. Did he know this?
23:12:40 -!- elliott has quit (Disconnected by services).
23:12:49 <Sgeo> Vorpal: no. but it was damn obvious that we were mocking him.
23:13:00 <Sgeo> beyond even "moron in a hurry" level.
23:13:07 -!- elliott has joined.
23:13:08 -!- elliott has changed nick to Phantom_Hoover.
23:13:15 <Sgeo> darn, one second too quick
23:13:22 -!- Phantom_Hoover has quit (Changing host).
23:13:22 -!- Phantom_Hoover has joined.
23:13:30 <Sgeo> Phantom_Hoover: sgeo did it to me :)
23:13:44 <Sgeo> don't care, i just wanted to ghost you
23:13:51 <Sgeo> like herobrine
23:14:11 <AntiVorpal> Hey, I'm not threatening to ghost you again... until I get bored of this nick, at any rate
23:14:13 <Sgeo> i could have ghosted you again
23:14:51 <Sgeo> j-invariant: F1+F2
23:14:53 <Sgeo> didn't i tell you that
23:14:54 <Vorpal> whoever is the real elliott atm: http://www.minecraftforum.net/viewtopic.php?f=25&t=122479
23:15:00 <Sgeo> that's Phantom_Hoover
23:15:00 <Vorpal> you might be interested in that
23:15:27 <Sgeo> does it still authenticate you if you choose to stay back
23:15:41 <Sgeo> http://www.minecraftforum.net/download/file.php?avatar=49238_1293764836.jpg omg what are these, they look delicious
23:16:04 <Sgeo> lol one of the idlers in here replied to that thread
23:16:05 <Vorpal> okay sgeo is ehird I guess. *checks /whois*
23:16:20 <AntiVorpal> Vorpal, you weren't paying attention to the nick changes?
23:16:31 <Sgeo> reminds me of when Gregor and I were each other for like
23:16:33 <Sgeo> j-invariant: :D
23:16:35 <Sgeo> j-invariant: tree hideaway
23:16:39 <Vorpal> AntiVorpal, well not after "+ elliott is now known as Phantom_Hoover"
23:17:03 <Vorpal> j-invariant, switch to peaceful?
23:17:27 * Sgeo downloads the untested os x version
23:17:33 <Sgeo> j-invariant: why not build a house :P
23:18:04 <Phantom_Hoover> How do we end up with such an insane number of lurkers?
23:18:25 <Sgeo> aww hi creeper :3
23:18:28 <Sgeo> creepers are kinda cute
23:18:30 <Sgeo> i actually don't mind them
23:18:37 <Sgeo> i'd rather have all creepers and no zombies/spiders/skeletons
23:18:39 <Sgeo> creepers don't make scary noises
23:18:42 <Sgeo> and are relatively easy to deal withi
23:19:07 <Sgeo> how do you guys pick up enemy drops at night
23:19:12 <Sgeo> like i don't wanna lose this sulphur
23:20:15 <j-invariant> Sgeo: is there a way to deal with this?? http://i.imgur.com/KqQ16.png
23:20:25 <Sgeo> j-invariant: sure
23:20:30 <Sgeo> j-invariant: get close to it, bash with sword
23:20:42 <Sgeo> either he'll die or, worst case, explode further away from your structure
23:21:47 <Vorpal> <j-invariant> Sgeo: is there a way to deal with this?? http://i.imgur.com/KqQ16.png <-- your structure looks insufficiently secured?
23:22:00 <Sgeo> it's easy enough to deal with creeper
23:22:04 <Sgeo> and beauty takes priority
23:22:08 -!- MigoMipo_A has quit (Quit: Bye).
23:22:22 <Vorpal> well, what is it? not a shelter at least
23:22:32 <Sgeo> i think i'm going to build a house on top of a high stack of dirt
23:22:44 <Vorpal> Sgeo, and beauty comes second place to "does it's job well"
23:22:56 <Sgeo> Vorpal: it is obviously not meant for use at night
23:23:20 <Sgeo> j-invariant: :)
23:23:23 -!- Sgeo has changed nick to elliott.
23:23:29 <elliott> don't wanna not get credit for all this good advice
23:23:59 <Vorpal> Sgeo, and if being beautiful is the job then of course it comes in first place. By the same definition.
23:25:05 <elliott> you know what would be cool? an smp server which spawns everyone really far away from each other
23:25:24 <elliott> you'd have to set up a little empire and fort before you have enough materials and stuff to start finding other people
23:26:16 <elliott> "At the end of 2010, the "open-source" software movement, whose activists tend to be fringe academics and ponytailed computer geeks" — wall street journal. ha
23:26:31 -!- AntiVorpal has changed nick to Sgeo.
23:26:47 <Sgeo> elliott, somehow, I'm not scared
23:26:47 <elliott> stop stealing Sgeo's nick, antivorpal
23:27:09 <elliott> seth, gold, activeworlds... no passwords found yet
23:27:17 -!- ais523 has joined.
23:27:20 <Phantom_Hoover> <Vorpal> Sgeo, and beauty comes second place to "does it's job well"
23:27:57 <Phantom_Hoover> Vorpal, there is no actual need for walls when you're in the air.
23:28:11 <Vorpal> Phantom_Hoover, true. But how did the creeper get up?
23:29:07 <elliott> It's not on the structure.
23:29:26 <elliott> Phantom_Hoover: Omg, I should make a wall-less house.
23:29:42 <Phantom_Hoover> Incidentally, I gave Vegastrike a try and found it supremely boring.
23:29:42 <ais523> hmm, that was a power cut
23:31:06 <Vorpal> <elliott> It's not on the structure. <-- it is up in the tree however
23:31:34 <Vorpal> and actually very near the structure. In fact I think it is in it, it looks like it dips down there
23:32:01 <Sgeo> Yay at my step-mother calling me mentally ill
23:32:29 <Vorpal> Phantom_Hoover, it feels like it had potential to be a good game, but the project seems to have more or less died. Or seemed to when I last checked.
23:32:38 <Sgeo> elliott, my step-mother doesn't live here
23:32:42 <Sgeo> If she did, I'd go insane
23:33:28 <oklopol> elliott: i found an actual, meaningful error in the compile
23:33:44 <oklopol> one that's not a missed typo, but a complete failure of brianing
23:34:13 <Phantom_Hoover> Vorpal, yes... I think it's just a general lack of interest in space sims.
23:34:24 <oklopol> unless i'm mistaken, everything is completely wrong, although it's very hard to notice.
23:34:31 -!- augur has changed nick to augur[food].
23:34:56 <oklopol> like, i'm not sure multiple examples have actually helped the brancher at all, or something :D
23:35:03 <oklopol> not sure what the situ is yet
23:35:30 <Phantom_Hoover> Literally the only two I can think of in active development are Oolite (held afloat on a raft of nostalgia) and Infinity (depressingly near being vapourware).
23:36:05 <Vorpal> Phantom_Hoover, realistic space sims: too small market segment
23:36:09 <Phantom_Hoover> EVE does not count as a space sim here, since it's more of a MMO RTS.
23:36:44 <elliott> the great thing about asteroids ii is that it has great market potential!
23:36:49 <Vorpal> Phantom_Hoover, generic as in including unrealistic ones too?
23:37:02 <elliott> it's basically an insane shooter! but awesome!
23:37:14 <Vorpal> Phantom_Hoover, that's stranger.
23:37:37 <Phantom_Hoover> I'm defining space sim as "you have a spaceship which you fly around in a non-automated fashion".
23:37:57 <oklopol> is minecraft in that definition?
23:37:58 <Phantom_Hoover> Which excludes EVE etc. in one fell stroke, since their flight system is "right click".
23:38:27 <elliott> Phantom_Hoover: Have I mentioned that I am terrible at Asteroids?
23:38:36 <Sgeo> Maybe I should get involved with EVE?
23:38:52 <Sgeo> I like Shattered Galaxy a lot, except for having to decide what stats to put points into
23:38:52 <elliott> Sgeo: If you like spreadsheets.
23:38:58 <elliott> Sgeo: EVE has a lot of that.
23:39:06 <elliott> You "learn" automatically. Somehow.
23:39:07 <Sgeo> I don't like the thought of applying math
23:39:23 <Sgeo> Math for math's sake is fun. Math for gaming purposes is not.
23:39:26 <elliott> If you're not good at accounting EVE is probably going to be a bit of a drag, though.
23:39:43 <Sgeo> No EVE, then. Ok.
23:39:46 <elliott> Sgeo: BTW, if you're good enough, you can play for free. You can buy the monthly subscription with in-game money.
23:40:07 <elliott> You'd probably have to spend a few months paid and also be amazing to be able to do that exclusively, though.
23:40:22 <elliott> And you might have to blow up some ships and steal their money to do it.
23:40:35 <elliott> (Yes, this is legal in EVE.)
23:40:47 <Phantom_Hoover> It's sad, really: space sims are a venerable genre with a history going back nearly as far as the idea of using a computer to play games.
23:41:24 * Sgeo <3 Microsoft Allegiance
23:42:16 <elliott> "Allegiance, the multiplayer space-combat game from the minds of Microsoft Research, combines the challenges of tactical squadron-based combat, intense one-on-one space dogfights, and amazing graphical and sound effects into a space-action experience like nothing you've seen before."
23:42:19 <elliott> Like Asteroids II, but worse.
23:43:22 <Phantom_Hoover> I also get the sense that I am the only person under the age of 40 in the Oolite community.
23:43:24 <Sgeo> elliott, that website is dead
23:43:39 <elliott> Sgeo: It's probably not Newtonian, and it's also 3D.
23:43:39 <Sgeo> http://freeallegiance.org/
23:43:51 <elliott> Sgeo: It is, therefore, *vastly* inferior to Asteroids II.
23:44:03 <Phantom_Hoover> elliott, Newtonian 3D flight is not something with a good reputation.
23:44:13 <elliott> Phantom_Hoover: That's why Asteroids II isn't 3D.
23:44:28 <elliott> Phantom_Hoover: As far as I know a 2D Newtonian space shooter just hasn't been created yet.
23:44:32 <Sgeo> You do realize it's not a single-player game?
23:44:44 <elliott> Sgeo: Asteroids II doesn't even have a single player mode ... or if it does it's a very low priority.
23:44:53 <Phantom_Hoover> (I *really* want to give the ICP a spin, but it's Windows only and even on Wine it falls afoul of the Evil Graphical Glitch.
23:45:42 <elliott> Sgeo: Um, do you actually know what Asteroids II is?
23:45:45 <Phantom_Hoover> Notable for a) being the only solid evidence of progress and b) being Newtonian and 3D.
23:45:54 <Phantom_Hoover> Sgeo, http://au.gamespot.com/gamespot/features/pc/bestof_2000/p2_15.html
23:46:20 <elliott> Sgeo: It's a 2D multiplayer space shooter based on Newtonian mechanics with gravity (including orbits) and localised physics distortions (e.g. slowing down the speed of light to trap someone, then shooting the hell out of that bubble before they can escape).
23:46:27 <Vorpal> Phantom_Hoover, why newtonian?
23:46:28 <Phantom_Hoover> It's the awesome physics-based space shooter that me, elliott and (sort of) oklopol came up with.
23:46:48 <Vorpal> elliott, why not base it on general relativity?
23:46:55 <elliott> Vorpal: Ha ha ha ha ha ah a ha ha ha hahahaahahahahahahahaha
23:47:12 <Phantom_Hoover> Vorpal, because I do not actually have any idea what the hell a tensor is or what they do.
23:47:13 <Sgeo> elliott, I don't think Astroids II and Allegiance are in competition
23:47:22 <Sgeo> [Says the person who always abandons one language for another]
23:47:36 <elliott> Allegiance is a bad shooter that is neither Newtonian nor 2D.
23:47:39 <elliott> Asteroids II is therefore superior.
23:47:48 <Vorpal> elliott, why is being 3D bad as such?
23:47:57 <elliott> Vorpal: Because movement in 3D is a bitch and distracts from shooting shit.
23:48:01 <Phantom_Hoover> elliott, oi, those criteria include FS2 which was good.
23:48:02 <elliott> Also you can't do Newtonian well in 3D.
23:48:05 <Vorpal> elliott, uh. Joystick?
23:48:18 <elliott> Vorpal: Still not nearly as smooth as 2D.
23:48:35 <Vorpal> elliott, 3D is perfectly navigatable with joystick. Though not very much with just keyboard and mouse
23:49:03 <elliott> Vorpal: Regardless, 3D Newtonian is a bitch.
23:49:33 <elliott> 2D Newtonian hasn't been reacted-to yet because as of yet nobody has done it, as far as we know.
23:49:41 <elliott> However it's probably going to be superficially similar to Asteroids in how flight works.
23:49:45 <Vorpal> elliott, hm. Do you dislike realistic 3D sims in general?
23:49:51 <Vorpal> elliott, such as flightsims.
23:49:58 <elliott> (In that turning around doesn't actually stop you flying in the way you're flying.)
23:50:01 <elliott> Phantom_Hoover: Is it proper Newtonian?
23:50:09 <elliott> Or just a vague approximation?
23:50:23 <elliott> Phantom_Hoover: As proper as gravity.lisp.
23:50:33 <oklopol> star control had that yeah
23:50:33 <Sgeo> elliott, similar thing happens in Alleg. It's not Newtonian though, need thrusters to keep moving etc
23:50:33 <elliott> If not, as far as I'm concerned, gravity basically changes a lot.
23:50:43 <Phantom_Hoover> elliott, no, but the essential features are there, other than unlimited acceleration.
23:50:56 <elliott> Phantom_Hoover: Well, it's the little bits that'll be innovative. :p
23:50:57 <Sgeo> Also, why not a relativistic 2d game, instead of newtonian?
23:51:02 <Vorpal> <elliott> (In that turning around doesn't actually stop you flying in the way you're flying.) <-- well duh. Even EV Override does that. It's 2D. And it is hardly realistic when it comes to other stuff (no gravity from planets and so on)
23:51:03 <Phantom_Hoover> And Spacewar and Star Control both have (limited) gravitation.
23:51:04 <elliott> Sgeo: Because we're doing it on computers.
23:51:16 <Phantom_Hoover> Sgeo, because the calculations for that are sodding difficult.
23:51:20 <elliott> Phantom_Hoover: Ours isn't limited. :p
23:51:26 <elliott> Sgeo: Additionally multiplayer would be impossible.
23:51:30 <elliott> You need, like, perfect sync.
23:51:44 <Phantom_Hoover> "I cannot get even the vague gist of the equations" difficult.
23:51:50 <elliott> Phantom_Hoover: Anyway, physics distortion is innovative. :p
23:52:02 <Phantom_Hoover> "I do not understand the concepts behind the equations" difficuly.
23:52:07 <Sgeo> Is there any way I can help?
23:52:24 <Sgeo> <elliott> If Sgeo gets involved, I'm quitting
23:52:33 <elliott> Sgeo: Can you program in Amber?
23:52:42 <Sgeo> elliott, I'm sure I can learn Amber
23:52:45 <Vorpal> elliott, not fair. It is a new language you invented for this.
23:52:45 <elliott> OK, it's day. I'm going to go out there, sword in hand, try not to die, and punch some trees.
23:52:59 <elliott> Vorpal: My, my, life isn't fire, Vorpal.
23:53:02 <Sgeo> <Sgeo> elliott, I'm sure I can learn Amber
23:53:17 <elliott> Phantom_Hoover: No, but I hired you on other criteria.
23:53:19 <Sgeo> Phantom_Hoover, wha?
23:53:30 <Sgeo> Is only elliott _capable_ of programming in Amber?
23:53:35 -!- augur[food] has changed nick to augur.
23:53:38 <elliott> Anyone can, it's a trivial language :P
23:53:38 <Sgeo> That makes no bleeding sense
23:53:41 <Vorpal> Sgeo, elliott is making a new language just for this project
23:53:41 <Phantom_Hoover> Sgeo, I know nothing of it other than "it's C with GC and lambdas".
23:53:55 <Sgeo> C with lambdas ooh
23:53:57 <Phantom_Hoover> elliott has not actually defined it beyond some code snippets.
23:53:58 <Vorpal> Sgeo, thus only he knows it yet.
23:54:08 <Sgeo> Oh, "making", not "made"
23:54:11 <Vorpal> Phantom_Hoover, is he slacking?
23:54:13 <oklopol> adding GC doesn't really have to change anything
23:54:28 <elliott> oklopol: yeah it's just that the GC is precise
23:54:30 <Phantom_Hoover> He has concluded that CL is TOO SLOW and that I need to program 3 inches from the metal.
23:54:34 <elliott> oklopol: which you can't do in C without ugly annotations
23:54:44 <elliott> Phantom_Hoover: Too slow, not really, but without bindings to things we need, yes.
23:54:47 <Vorpal> Phantom_Hoover, based on profiling?
23:54:53 <elliott> Phantom_Hoover: Too slow, not really, but without bindings to things we need, yes.
23:55:04 <Vorpal> elliott, yes it arrived same second
23:55:05 <elliott> Also, as much as you love profiling, it is possible to use reason as well as blind testing.
23:55:11 <Sgeo> elliott, there are no good CL implementations with good ways to bind to ... what Phantom_Hoover said
23:55:16 <elliott> Phantom_Hoover: ...which is a large project in itself.
23:55:27 <elliott> Amber is explicitly designed to not require bindings.
23:55:39 <Phantom_Hoover> elliott, larger than writing your own language and using the C interface?
23:55:47 <Sgeo> Making it a perfect language for Active Worlds bots!
23:55:56 <elliott> Phantom_Hoover: Amber is also a nice language. :p
23:56:08 <elliott> Phantom_Hoover: ALSO: GC time.
23:56:17 <elliott> _Any_ GC that causes _any_ significant pause is completely unacceptable.
23:56:22 <elliott> Because the game will freeze.
23:56:30 <elliott> Gregor's generational GC is much faster than boehm.
23:56:39 <elliott> So hopefully it won't cause noticeable pauses.
23:56:52 <elliott> (If it does, I'll have to see if I can get a parallel GC.)
23:56:55 <elliott> Phantom_Hoover: Are stop-the-world.
23:57:07 <Vorpal> elliott, what about haskell gc
23:57:24 <elliott> Vorpal: A Haskell game would spend an upsetting amount of time in IO without FRP.
23:57:25 <Vorpal> Phantom_Hoover, I do not know the model of haskell's gc
23:57:28 <elliott> Phantom_Hoover: Yes. Well, maybe not Franz's.
23:57:37 <elliott> Vorpal: GHC's garbage collector is concurrent but I do not know that it's parallel.
23:57:47 <Sgeo> elliott, what's the best way for me to learn FRP?
23:58:04 <elliott> There are no useful implementations yet.
23:58:05 <Sgeo> elliott, why not?
23:58:07 <Vorpal> elliott, and why not use FRP then?
23:58:17 <elliott> Vorpal: There are no useful implementations yet. Well, a few contenders, but.
23:58:21 <elliott> Definitely nothing commercial-ready.
23:58:25 <elliott> coppro: functional reactive programming
23:58:33 <coppro> thanks for clearing it up
23:58:35 <elliott> j-invariant: did i mention i don't know where my house is
23:58:40 <Sgeo> Racket has an implementation?
23:58:41 <oklopol> elliott: yeah umm, can you get a "greater than?" function to compile? :D
23:59:00 <elliott> j-invariant: because i had to walk to somewhere with enough space for a house first day
23:59:01 <Phantom_Hoover> coppro, apparently it will make the entire world into kittens.
23:59:05 <oklopol> it seems conditions vs multiarg is completely wrong
23:59:11 <Vorpal> j-invariant, he can get lost inside a 3x3x3 room in minecraft :P
23:59:19 <elliott> FRP is what makes functional programming possible.
23:59:25 <elliott> Rather than functional core with imperative interface code.
23:59:44 <Vorpal> j-invariant, he is THAT bad at navigating. (Okay, slight exaggeration, but not much)
23:59:52 <Sgeo> Going to try MC again
23:59:56 <Phantom_Hoover> Goddamn it, I have the Star Control 2 Ur-Quan theme stuck in my head