←2008-07-18 2008-07-19 2008-07-20→ ↑2008 ↑all
00:02:34 -!- RedDak has joined.
00:26:07 <augur> ooooookloooooopolllllllll!!! :D
00:31:14 -!- oerjan has joined.
00:41:11 * oerjan celebrates Irregular Webcomic's 2000th strip
00:41:52 <tusho> oerjan: It's "Irregular Webcomic!".
00:42:46 <oerjan> YOU BROKE MY CELEBRATION! MY VENGEANCE SHALL BE GRUESOME!
00:43:15 <oerjan> BUT, FULL OF EXCLAMATION MARKS!
00:43:33 <augur> surely it makes no sense to celebrate the 2000th strip of a comic called irregular
00:43:40 <augur> 2000 is so regular!
00:43:53 <augur> you should celebrate the 2031 strip.
00:44:12 <oerjan> well Irregular Webcomic! is one of the most regular webcomics out there
00:44:21 <augur> ironic
00:45:12 <oerjan> although i vaguely recall DMM hoping to pass Bill Watterson's Calvin and Hobbes score, which is surely more irregular
00:46:14 <oerjan> true geeks will also celebrate 2048, of course
00:46:42 <oerjan> although they will not call it irregular either
00:51:56 <tusho> http://www.irregularwebcomic.net/15.html
00:51:56 <oklopol> auuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuguuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuur
00:52:02 <tusho> you'dathought someone would have made it
00:52:23 <augur> :D
00:52:53 <oerjan> well that was a long time ago. someone might want to recheck.
00:53:06 <oerjan> not me, i don't read newsgroups any longer :(
00:53:25 <augur> http://www.irregularwebcomic.net/15.html
00:53:27 <augur> how poignant
00:53:29 <tusho> i checked
00:53:30 <tusho> it doesn't exist
00:53:41 <tusho> how do you make a usenet group again
00:53:42 <tusho> <.<
00:53:48 <oerjan> also, his website has its own forum (which, for some reason, i read)
00:53:55 <augur> when was that strip posted?
00:54:06 <augur> oh i see
00:54:09 <augur> 4 feb 03
00:54:10 <augur> shame
00:54:22 <augur> itd be more poignant if it was posted in the last week
00:55:05 <oerjan> well it cannot, since DMM is on the Infinite Plane of Death without computer access :D
00:55:07 <oklopol> oooooooo
00:55:33 <oerjan> pardon, the Finite Plane of Death with Two Features
00:55:47 <augur> i mean, am i the only one who thinks its ridiculous that half the ISPs in america are banning the alt hierarchy
00:55:48 <augur> ??
00:55:56 <oerjan> (it used to the Infinite Featureless Plane of Death, but then the Mythbusters got onto it)
00:56:09 <oerjan> *to be
00:56:33 <oklopol> HI EVERYBODY
00:56:56 <oerjan> (er, i guess i'm spoiling a lot here)
00:57:27 <oerjan> HI OKLOBEING
00:58:23 <oerjan> the alt hierarchy was always less distributed (when i read newsgroups)
00:58:40 <oerjan> and more noisy
00:58:41 -!- tusho has quit.
00:59:55 <augur> and now the alt hierarchy is nonexistant
01:00:07 <augur> ofcourse, none of it has to do with what they actually say its about
01:00:14 <augur> they wanted the alts shut down because of kiddie porn
01:00:37 <augur> but you wanna bet its the MPAA's hand trying to get it shut down because of movie sharing? :)
01:01:10 * oerjan might cough up a couple kroner for that bet
01:01:36 <oerjan> but then, it's probably both
01:03:19 <augur> well
01:03:27 <augur> ofcourse they got SOME worried parents to back it
01:03:40 <augur> but is it those parents that came up with the idea? lolno.
01:03:46 <augur> they probably dont even know what usenet is
01:14:03 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
01:14:56 <augur> "Irregular Webcomic: 500 Internal Server Error"
01:15:19 <augur> looks like the servers a bit ... IRREGULAR! bwahahahaha!!! XD!!!
01:15:28 <oerjan> hm? i am reading the forum at this moment.
01:15:29 <augur> *cough*
01:15:55 <oerjan> hm indeed the main page is down
01:16:43 <oerjan> database error, it says
01:16:47 <augur> you act as tho thats at all relevant to the humor :P
01:17:10 <oerjan> oh sorry, was in reading mode
01:17:37 <oerjan> i guess that means my brain is determined to seek out information
01:34:59 <lilja> waffles!
01:35:07 <lilja> hrrr!
01:35:10 <oerjan> :(
01:35:15 * oerjan has no waffles
01:35:37 <oklopol> cool waffles
01:35:42 <oklopol> so cool
01:35:49 <lilja> nope
01:35:53 <lilja> hot waffles
01:35:59 <oklopol> warm and cuddle
01:36:01 <oklopol> *cuddly
01:37:30 <augur> waffles are so tasty omg
01:38:29 <oerjan> maybe if i put some raspberry jam on this cardboard...
01:39:19 <oklopol> god i envy you
01:39:41 <oklopol> i remember i used to enjoy eating paper when i was a kid
01:40:40 <oerjan> HEY I'M TRYING TO PREY MERCILESSLY ON YOUR SYMPATHY HERE, DON'
01:40:45 <oerjan> T RUIN IT!
01:41:35 <oerjan> darn apostrophe so close to the return key
01:45:17 <oklopol> yeah, but the real wtf is that backspace is too.
01:45:37 <augur> paper huh
01:45:42 <augur> maybe you just needed some fiber
01:47:16 <oerjan> i have a feeling the backspace is less of a problem, perhaps because when i use it i'm snapping out of automatic touch mode anyhow
01:47:58 <oklopol> oerjan: good point, that may be the reason it's much less problematic in practise than you'd think
01:48:08 <oklopol> i have made some pretty nasty mistakes because of it though
01:48:28 <oklopol> since i often first type, then think, then rewrite
01:49:07 <oerjan> well i'm pretty sure i've done some of that too
01:49:22 <oerjan> this is all vague recall territory
01:49:58 <oerjan> <-- coffee
01:50:31 <oerjan> (not --> coffee as i already got it :) )
01:53:58 -!- Judofyr has quit.
01:57:22 <oklopol> hey i want coffee too
01:58:16 <oerjan> BWAHAHA now you just sit there with your waffles!
01:58:46 <oerjan> mind you it's just instant coffee
01:58:55 -!- adu has joined.
01:59:09 <adu> its funny how good news and bad news usually come at the same time
01:59:11 -!- Corun has quit ("This computer has gone to sleep").
01:59:26 <oerjan> like with the coffee and waffles?
01:59:56 <adu> no like promotions and responsibility
02:00:01 <oerjan> ah
02:00:21 <adu> :) :(
02:00:35 <adu> :/
02:00:42 <oerjan> :X
02:00:44 <adu> >:->
02:00:50 <adu> :P
02:01:08 <adu> those should all be vi commands...
02:01:28 <oerjan> should be or actually are?
02:02:08 <adu> speaking of which I just realized that the "yi" editor is indistinguishable from "vi" when displayed in a text box that's 5 pixels too small
02:02:45 * oerjan senses a use/mention error there
02:02:50 <adu> only the last one is a real command, probably short for :Print or something
02:03:05 <oerjan> not even :X ?
02:03:14 <adu> maybe :exit
02:03:22 * oerjan brings up vim
02:03:27 <adu> i don't know vi very well
02:03:37 <adu> I use emacs
02:03:49 <adu> 'yi' uses many emacs keybindings
02:03:54 <oerjan> :X is encryption
02:03:58 <adu> o heh
02:04:21 <adu> although "yi --as=vim" should set vi-like keybindings
02:04:41 <oerjan> :/ can start a command, since /.../ is a search that can give a line number
02:04:54 <adu> o wow
02:04:59 -!- GreaseMonkey has joined.
02:05:04 <adu> hi GreaseMonkey
02:05:28 <adu> i want to implement fancy keybindings
02:05:34 <GreaseMonkey> 'lo
02:05:36 <adu> like yi --as=xcode
02:05:53 <adu> or yi --as=kdevelop
02:06:15 <adu> or yi --as=vstudio
02:06:26 <oerjan> heh, :P "Just as ":print". Was apparently added to Vi for
02:06:26 <oerjan> people that keep the shift key pressed too long...
02:06:44 <adu> i was right!
02:07:32 <adu> no
02:07:46 <adu> :P is "Put the text before the cursor [count] times
02:07:50 <adu> "
02:08:03 <oerjan> no, that's P. :P is different
02:08:16 <adu> o hehe
02:08:25 <adu> i need to learn how to use vim :help :p
02:08:40 <oklopol> :H
02:09:15 <oerjan> :help :H shows an obscure :Hexplore command
02:09:37 <adu> my :help :H shows the help for :h
02:09:53 <adu> oklopol: !!
02:09:57 <oerjan> :help :h is different
02:09:59 <adu> hows the lang going?
02:10:03 <oerjan> (== :help)
02:10:28 <oerjan> hm :H actually _does_ seem to work as :help
02:11:31 <oerjan> it may be trying the case alternative if it finds nothing more precise
02:11:55 <oklopol> adu: which lang?
02:11:56 <oklopol> :)
02:12:50 <oklopol> i do vaguely recall our talk, but not what the language was
02:14:42 <adu> oklang?
02:15:12 <adu> hmm, unless you have multiple languages
02:15:41 <oerjan> oklopol has multiple _everything_
02:15:58 <adu> oklopol: do you have multiple girlfriends?
02:17:01 <adu> oklopol: so how many languages have you made?
02:18:11 <adu> oklopol?
02:18:36 <oerjan> inquiring minds want to know, and will soon start blowing things up if not
02:18:53 <adu> well
02:19:10 * oerjan does recall oklotalk
02:19:24 <adu> I wouldn't blow up, I'd just start talking about excrement and nasty stuff until oklopol decides to talk...
02:19:45 <adu> oklotalk! thats the one
02:19:47 <oerjan> this might actually chase away everyone _but_ oklopol
02:19:59 <adu> lol
02:20:27 <oerjan> and lament, who _might_ kickban you in extreme cases
02:20:42 <adu> i like lament
02:21:00 <adu> he is always sad in the most funny way possible
02:22:22 <oklopol> adu: i have made quite many languages
02:22:42 <adu> have you made it to oklotalk++ yet?
02:23:02 <oklopol> :)
02:23:08 <oklopol> i've only made oklotalk-- in fact
02:23:15 <adu> ic
02:23:18 <adu> even better!
02:23:32 <oklopol> http://www.vjn.fi/oklopol/oklotalk--.txt
02:23:36 <oklopol> not really :P
02:23:38 <adu> is that like C with closures, without closures?
02:23:47 <oklopol> it's a simplification of oklotalk, basically.
02:23:53 <oklopol> with a boring lisp-like syntax
02:24:11 <adu> you should haskell syntax
02:24:12 <oklopol> and no, not like C with & without anything
02:24:25 <oklopol> well oklotalk has a cool J-like syntax already
02:24:35 <oklopol> i have enough languages with haskell-like syntax
02:24:47 <adu> like jo98*&x0fkc9X;;g$[]
02:24:53 <oklopol> well i guess just graphica, and that's not all that close either
02:24:58 <oklopol> yes, something like that
02:25:10 <oklopol> every string is a legal oklotalk program
02:25:17 <adu> oo I just had a terrible idea
02:25:22 <oklopol> that was one of my design goals
02:25:22 <adu> Funge.NET
02:25:31 <oklopol> i don't know much about .net
02:25:37 <adu> its terrible
02:25:43 <adu> Funge would be the nice part
02:25:47 <oklopol> well yes i know that much
02:25:50 <adu> lol
02:25:55 <oerjan> o_O
02:26:09 <CakeProphet> oklopol, so since every thread only has a one-byte state... the way you do binary/triary operations is by having two bugs collide on top of the same instruction
02:26:15 <CakeProphet> (bugSophia here)
02:26:19 <CakeProphet> and... to make that sane
02:26:23 <oklopol> CakeProphet: yes, i know
02:26:37 <oklopol> so operators are fully symmetric on parameters?
02:26:38 <oklopol> err
02:26:39 <oklopol> i mean
02:26:40 <adu> oklopol: for library implementors its a nightmare, because of the magnitude of libraries you have to implement, and for a library user, its a nightmare, because of the magnitude of libraries you have to remember and search through
02:26:43 <CakeProphet> there's an instruction that's "move forward one step and halt until a non-halted bug collides with you"
02:26:44 <oerjan> sane? isn't this off-topic?
02:27:10 <oklopol> CakeProphet: alright
02:27:22 <oklopol> but, err
02:27:32 <oklopol> all operators can take their operands in any order?
02:27:41 <CakeProphet> ...if they can't, I'm boned.
02:28:03 <adu> CakeProphet: you're boned
02:28:13 * oerjan is suddenly reminded of the sentient ant colonies from Godel, Escher, Bach
02:28:14 <oklopol> well i guess - A B = + (- A) B and similar shit can be done for other non-symmetric things
02:28:19 <oklopol> err
02:28:25 <CakeProphet> oklopol: /if/ I allow negatives
02:28:28 <oklopol> - A B = + A (- B)
02:28:31 <CakeProphet> but current state is represented in bites
02:28:34 <CakeProphet> *bytes
02:28:36 <CakeProphet> which
02:28:37 <CakeProphet> are not negative.
02:28:50 <oerjan> bites would be more in keeping with the bug theme :D
02:28:55 <CakeProphet> ...not to my knowledge.
02:28:56 <oklopol> :)
02:29:06 <adu> lolol
02:29:14 <oklopol> CakeProphet: "byte" does not say anything about semantics really
02:29:24 <oklopol> you know 2's complement?
02:29:36 <CakeProphet> aye
02:29:45 <oerjan> 2's company
02:30:07 <CakeProphet> but I don't really feel like treating bytes as short integers for the purposes of having negatives.
02:30:11 <CakeProphet> I could just define them as "numbers"
02:30:24 <oklopol> well no need for negatives
02:30:28 <CakeProphet> in this implementation, Python integers.
02:30:40 <oklopol> ya
02:30:42 <CakeProphet> oklopol: for subtraction I'd need either negatives or some way to order the operands.
02:31:14 <oklopol> well not necessarily, you need decrement, and flow control
02:31:21 <CakeProphet> that will be had
02:31:36 <CakeProphet> I was thinking flow control could be implemented in the halting rules.
02:31:39 <CakeProphet> so, for example.
02:32:06 <oklopol> all you need to make sure is is that there is infinite space, the rest will come naturally :D
02:32:23 <adu> ya
02:32:25 <oklopol> *-is
02:32:36 <CakeProphet> if you had an operation that tested the equality of two threads...
02:32:41 <adu> FungeSpace + BigInteger
02:32:44 <adu> alll you need...
02:33:21 <oklopol> no need for bignums
02:33:27 <oklopol> fs is infinite
02:33:47 <CakeProphet> so that... when they both crossed the operation... a new threads are sent on all the non-taken paths containing either a 1 or 0
02:34:00 <CakeProphet> -a
02:34:04 <CakeProphet> and then
02:34:07 <adu> oklopol: fs?
02:34:12 <oklopol> fungespace
02:34:20 <CakeProphet> an operation that kills a thread if its 0... and an operation that kills a thread if its non-0
02:34:26 <oklopol> i assumed you'd get that as you capitalized the chars
02:34:33 <adu> oklopol: then what can each cell in fungespace hold?
02:34:41 <CakeProphet> you can essentially using the "halt until you cross a non-halted bug" rule to implement flow control / conditionals.
02:34:44 <oklopol> well i assume a fixnum
02:34:48 <adu> 16bit? 32bit? 64bit? which one? why? why not the others?
02:34:53 <oklopol> err
02:34:57 <oklopol> 32 perhaps
02:35:03 <adu> why not 64?
02:35:22 <CakeProphet> why not 256-bit?
02:35:24 <oklopol> i've never seen any need for anything other than bignum anywhere
02:35:27 <adu> CakeProphet: ya!
02:35:28 <oklopol> so don't ask me
02:35:30 <oklopol> i didn't make it
02:35:44 <oklopol> i believe in the 0/1/infinity rule
02:35:48 <adu> oklopol: you mean fixnum
02:36:04 <oklopol> what?
02:36:22 <adu> you said you though bignums were all you need
02:36:28 <adu> did you mean the opposite?
02:36:50 <oklopol> i meant exactly what i said
02:37:15 <oklopol> i meant, hard to answer why 32 instead of 64, when i find them both quite arbitrary
02:37:25 <adu> a ok
02:37:57 <adu> I personally thing all bignums should be encoded like UTF8
02:37:59 <oklopol> i don't really care much for the practical aspect of computers
02:38:12 <CakeProphet> so... if a quote creates a bug with a state of nil... and "e" tests the equality of up to 4 bugs, ~ is the "halt after one step" operator, and # is the "destroy if 0 or nil" operator.
02:38:19 <CakeProphet> then.
02:38:37 <CakeProphet> (oh... and ) is increment, and ( is decrement)
02:38:45 <adu> :)
02:39:28 <adu> CakeProphet: what was ":" do?
02:39:45 <oklopol> adu: anyway, about the languages of mine, http://www.vjn.fi/oklopol/ and see the ones after thue
02:40:14 <oklopol> not all, but most of what i have any kind of specs ready
02:40:32 <adu> is that a face?
02:40:32 <CakeProphet> v))<">))v
02:40:34 <CakeProphet> | |
02:40:36 <CakeProphet> >~e~<
02:40:38 <CakeProphet> ...
02:40:40 <CakeProphet> it would help
02:40:45 <CakeProphet> if this was fixed width
02:41:03 <CakeProphet> I shall pastebin it somewhere.
02:41:11 <adu> lol you implemented bf in cise? lol
02:41:41 <oklopol> yes, assuming that's correct
02:41:48 <CakeProphet> ...it's not
02:41:54 <CakeProphet> I hit enter too soon
02:42:21 <oklopol> adu: i'm more confident about the shorter programs
02:42:43 <oklopol> although all i've actually implemented abot cise is the parser
02:43:06 <adu> whats graphica?
02:43:16 <oklopol> my graph creation language
02:43:31 <oklopol> the sample is a binary hypercube
02:43:45 <oklopol> just had a long lecture about it like yesterday :P
02:44:17 <adu> i like straw
02:44:33 <oklopol> tried to make it a bit sane
02:44:55 <oklopol> straw is about clean side-effects when it comes to mutational changes in data structures
02:45:00 <oklopol> basically
02:45:09 <adu> ic
02:45:09 <oklopol> you can have a function to change an element in a list
02:45:16 <adu> have you heard of Disciple
02:45:20 <oklopol> no
02:45:30 <adu> it also takes in interesting approach to side effects
02:45:43 <CakeProphet> http://pastebin.ca/1076165
02:45:50 <CakeProphet> comments are like brainfuck comments.
02:45:52 <adu> you know how in Haskell, print :: a -> IO ()
02:46:04 <oklopol> yeah
02:46:09 <adu> in Disciple, print :: a -(IO)> ()
02:46:12 <CakeProphet> just make sure they don't include quotes anywhere otherwise you'll accidentally spawn off extra threads... (though no worries... they'll likely not get anywhere or do anything)
02:46:19 <adu> or something like that
02:46:34 <oklopol> basically, you can have a function to change an element in a list, but you can use this functionally, and create an imaginary copy of the list with just the element changed
02:46:35 <adu> side effects are put inside the arrow, essentially
02:46:41 <oklopol> but you can still use the original one too
02:46:49 <oklopol> the language keeps track of reverts to the original state
02:46:52 <oklopol> hmm
02:48:03 <adu> oklopol: interesting
02:48:10 <CakeProphet> the equivalent of a string in bugSophia would be make a bug travel down a path... splitting off copies of itself that "pick up" characters via a set-byte-value operator
02:48:17 <oklopol> i don't have anything pretty for the actual IO
02:48:30 <oklopol> and i will certainly have nothing like monads
02:48:36 <CakeProphet> and then moving those all towards a memory stream... which is some sort of Unicode character with a , (write operator) next to it.
02:48:48 <adu> oklopol: I actually perfer arrows to monads
02:48:58 <oklopol> arrows?
02:49:03 <oklopol> you mean what disciple does
02:49:20 <adu> Monads are like a safety net, Arrows are like 24/7 body guards
02:49:48 <CakeProphet> ...aside from being ridiculously concurrent, bugSophia isn't all that conceptually interesting. I kind of want to make it a bit weirder.
02:50:00 <adu> oklopol: no, Disciple just adds syntax to describe "->" more indepth
02:50:21 <adu> an Arrow is a Haskell type class, just as Monad is a Haskell type class
02:50:28 <oklopol> i need to watch some dark angel now, see you in a while
02:50:32 <oklopol> ah
02:50:32 <adu> ok
02:50:32 <oklopol> i see
02:50:38 <oklopol> but bye
02:50:43 <adu> l8r
02:53:01 <CakeProphet> ...perhaps I should have wormholes.
02:53:20 <CakeProphet> so that all the little - | > < wires don't get cluttered.
02:53:23 <oerjan> also, time travel
02:53:29 <CakeProphet> on it.
02:54:11 <CakeProphet> oklopol currently wins at interestingness. ;_;
02:54:14 <CakeProphet> the negative lists thing is epic.
02:55:34 <CakeProphet> I think I'll also a ; operator.... which is "write to a stream and then blocking-read"
02:55:51 <CakeProphet> so you can basically have
02:55:53 <CakeProphet> functions
02:56:08 <augur> oklopol also wins at sexiness.
02:56:17 <oklopol> mind you i've invented more interesting things than negative lists!
02:56:29 <augur> oklopol, you need to explain negative lists to me.
02:56:37 <CakeProphet> I might be able to explain it....
02:56:40 <oklopol> augur: see logs, it took a while to explain :P
02:56:46 <oklopol> that's another possibility
02:56:47 <CakeProphet> but I am not too confident
02:56:50 <augur> i refuse to look at logs.
02:57:06 <CakeProphet> augur: I beg to differ: http://i83.photobucket.com/albums/j316/adamadamadamamiadam/sepialol.jpg
02:57:16 <CakeProphet> that is pure sex.
02:57:23 <oklopol> CakeProphet: you?
02:57:28 <CakeProphet> mhm
02:57:34 <oklopol> god you've grown
02:57:51 <CakeProphet> rofl
02:57:52 <augur> no sorry
02:57:54 <augur> oklopol is hotter
02:57:55 <CakeProphet> it's been like... 2 years?
02:57:57 <augur> you have no lips
02:58:03 <augur> if you had lips you might be as sexy as oklopol
02:58:05 <augur> but you're not
02:58:15 <augur> i like your hair tho
02:58:20 <augur> also: shave dude.
02:58:30 <CakeProphet> TOO
02:58:32 <CakeProphet> LAZY
02:58:38 <oklopol> i don't shave either
02:58:48 <oklopol> augur is going by an old photo here :)
02:58:53 <augur> yeah but oklopol, you're hot.
02:59:01 <augur> give me more photos oklopol :D
02:59:29 <CakeProphet> I bet we both have very slavic noses.
02:59:47 <augur> oklopol has a 100% sexy nose
03:00:08 <CakeProphet> I sometimes think I spend too much time organizing my interpreter code.
03:00:25 <CakeProphet> I actually document it
03:02:42 <augur> oklopol!!!
03:02:45 <augur> pictures!
03:05:08 <oklopol> !!!!!!!!
03:05:34 <oklopol> augur: perhaps some day
03:08:14 <augur> *today
03:15:17 <CakeProphet> I believe I had @ as the thread terminator
03:15:18 <CakeProphet> as
03:15:21 <CakeProphet> it looks like a big hole
03:15:27 <CakeProphet> that they would fall in or something.
03:17:56 <adu> epic negative lists?
03:18:04 <adu> did I miss something?
03:18:36 -!- augur has quit (Nick collision from services.).
03:18:47 <oklopol> a concept i invented for nopol
03:18:58 -!- augur has joined.
03:19:10 <CakeProphet> rofl... go figure... the halting problem is computable for bugs.
03:19:30 <CakeProphet> if there is no ~... it's not going to halt (I don't think)
03:19:36 <CakeProphet> oh
03:19:38 <CakeProphet> hmmm
03:19:43 <CakeProphet> but you can't determine when they terminate
03:19:47 <CakeProphet> which is
03:19:49 <CakeProphet> what actual halting is.
03:19:51 <CakeProphet> ...
03:22:48 -!- augur has quit (Nick collision from services.).
03:23:10 -!- augur_ has joined.
03:31:52 <adu> oklopol: so whats a negative list?
03:32:00 <CakeProphet> ...lol
03:33:05 <oerjan> adu: -1. it's a list. -2. it
03:33:10 <augur_> please forgive adu, i think hes a noob.
03:33:13 <oerjan> 's negative.
03:33:17 -!- augur_ has changed nick to augur.
03:33:20 <CakeProphet> no
03:33:21 <oerjan> -3. darn apostrophe again
03:33:22 <CakeProphet> I was loling at
03:33:24 <CakeProphet> how long that will take to explain
03:33:46 <adu> noob? no no I'm a boon
03:33:47 -!- augur has changed nick to Guest802.
03:33:54 <Guest802> >O
03:33:55 -!- Guest802 has changed nick to augur_.
03:34:01 <augur_> >_<!
03:34:13 <adu> boon == good
03:34:17 <adu> noob == bad
03:34:40 -!- augur_ has changed nick to psygnisfive.
03:35:17 <adu> so 0 = [] and 1 = [[]], 2 = [[], [[]]]?
03:36:28 <psygnisfive> that makes no sense.
03:36:31 <CakeProphet> I enjoy writing Python code that only has like... 2 or 3 conditionals.
03:37:03 <CakeProphet> adu, nope
03:37:04 <oerjan> sure it does, standard von neumann numerals
03:37:07 <adu> oklopol: so you still haven't answered my question
03:37:15 <adu> i'm talking about negative lists
03:37:18 <CakeProphet> adu, I could explain if you like.
03:37:20 <adu> what are they?
03:37:26 <adu> CakeProphet: ok :)
03:37:30 <CakeProphet> so
03:37:42 <CakeProphet> if () is a list with a depth of 1
03:37:47 <CakeProphet> and (()) is a list with a depth of 2
03:37:53 <CakeProphet> ... then
03:38:00 <CakeProphet> <> will be a list with a depth of -1
03:38:05 <CakeProphet> and <<>> will be a list with a depth of -2
03:38:08 <CakeProphet> for our purposes
03:38:09 <psygnisfive> i dont know von neuman numerals
03:38:15 <adu> oooooooooooo
03:38:19 <CakeProphet> notation = helpful
03:38:31 <CakeProphet> are you familiar with how tree rewriting languages work?
03:38:32 <adu> so (a, b, <(c, d)>, e) == (a, b, c, d, e)?
03:38:48 <CakeProphet> ...unfortunately not with the current concept.
03:38:51 <adu> o
03:38:52 <adu> n/m
03:38:58 <CakeProphet> it would be nice though
03:38:58 <adu> I'm back to confusion
03:39:18 <CakeProphet> but anyways... are you familiar with how tree rewriting languages work?
03:39:35 <adu> I'm familiar with Haskell, Prolog and Mathematica
03:40:00 <CakeProphet> familiar with thue at least? that's string rewriting.
03:40:12 <adu> how do I find information about thue?
03:40:27 <CakeProphet> http://esolangs.org/wiki/Thue
03:40:35 <CakeProphet> it just helps to have a solid foundation on tree rewriting
03:40:36 <adu> ah
03:40:42 <CakeProphet> before you can understand why negative lists make sense.
03:40:52 <adu> well, Mathematica is a tree rewriting language
03:41:10 <psygnisfive> tree rewriting is just like string rewriting
03:41:17 <adu> I'm also familiar with the lisp ` ' ,
03:41:17 <psygnisfive> except in place of strings you use structures.
03:41:33 <CakeProphet> oh... alright.
03:41:35 <CakeProphet> so like
03:41:51 <adu> Mathematica and Lisp are very very similar
03:42:27 <adu> Every[Thing[In[Mathematica[Uses[Brackets[]]]]]]
03:42:33 <CakeProphet> for our purposes, we'll use => as a tree rewrite operator [A [B C] => [B [C A]]
03:42:35 <CakeProphet> for example.
03:42:48 <CakeProphet> ...actually
03:42:56 <CakeProphet> we'll use ()'s instead
03:43:00 <CakeProphet> to fit with our above notation.
03:43:01 <adu> (every(thing (in (lisp (uses (parent))))))
03:43:21 <adu> ok
03:43:31 <CakeProphet> so if you have the rule (A (B C) => (B (C A))
03:43:47 <CakeProphet> (add a ")" there)
03:43:53 <adu> ok
03:43:58 <psygnisfive> no, YOU add a ")" there!
03:44:12 <CakeProphet> and an initial state of... ((1 (2 3)) (3 (2 1))
03:44:14 <CakeProphet> )
03:44:52 <CakeProphet> after on step you'll get ((2 (1 3)) (2 (3 1)))
03:44:54 <CakeProphet> *one
03:44:58 <CakeProphet> ...alright... so yeah
03:45:00 <CakeProphet> you get that.
03:45:06 <adu> right
03:45:24 <adu> http://reference.wolfram.com/mathematica/ref/ReplaceAll.html
03:45:38 <CakeProphet> and you can define functions like (func (arguments) go (here and such)) =>(return value (goes here) and what not)
03:45:44 <CakeProphet> well
03:45:48 <CakeProphet> on top of all of that
03:45:56 <adu> right
03:46:00 <CakeProphet> we now have negative lists...
03:46:01 <CakeProphet> which
03:46:20 <CakeProphet> basically evaluate into positive lists... as I'll explain in a second.
03:46:48 <CakeProphet> alright... so if you <1 2 3>
03:46:50 <CakeProphet> +have
03:47:18 <psygnisfive> im going to check that production.
03:47:55 <CakeProphet> if D is the depth of the list, and N is the number of elements.
03:48:25 <CakeProphet> then you duplicate the list D steps above <1 2 3> and duplicate it N times.
03:48:47 <CakeProphet> *then you take the list D steps above <1 2 3> and duplicate it N times.
03:49:14 <CakeProphet> so for example.
03:49:49 <CakeProphet> (== (+ <1 2 3>)) would rewrite to
03:50:13 <CakeProphet> erm... bad example.
03:50:38 <CakeProphet> -thinks-
03:51:04 <CakeProphet> (== (+ <(2 2) (3 3) (4 4)>))
03:51:07 <CakeProphet> would rewrite to
03:51:41 <CakeProphet> (== (+ (2 2)) (+ (3 3)) (+ (4 4)))
03:51:57 <CakeProphet> which would then rewrite to
03:52:06 <CakeProphet> (== 4 6 8)
03:52:10 <adu> thats just a map
03:52:12 <CakeProphet> which would then rewrite to being patently FALSE.
03:52:15 <CakeProphet> ....righto.
03:52:27 <adu> so its like a list that is implicitly mapped over
03:52:33 <CakeProphet> ...yes.
03:52:36 <adu> ok
03:52:40 <CakeProphet> it took me much longer to explain
03:52:42 <CakeProphet> BUT
03:52:45 <CakeProphet> they do more than that.
03:52:52 <CakeProphet> I just explained that first
03:52:54 <CakeProphet> because its simple.
03:53:01 <adu> ok
03:53:13 <CakeProphet> what happens when you have two negative lists...
03:53:20 <CakeProphet> in the same list.
03:53:23 <CakeProphet> like such
03:53:25 <adu> its like map . map
03:53:38 <CakeProphet> yeah... it maps all the possible pairs more or less
03:53:48 <psygnisfive> that production from earlier doesnt work.
03:53:57 <adu> so more like the Haskell list monad
03:54:06 <CakeProphet> ...not familiar with Haskell
03:54:13 <adu> its da bomb
03:54:39 <psygnisfive> cakeprophet: that production from earlier doesnt work.
03:54:44 <CakeProphet> ( (== (+ <1 2 3> <1 4 5>) )
03:54:47 <CakeProphet> psygnisfive: which
03:54:53 <CakeProphet> actually...
03:54:54 <oklopol> haskell's list monad is very similar, yes.
03:55:01 <psygnisfive> the ((1 (2 3)) (3 (2 1)))
03:55:17 <CakeProphet> ( (== (+ <<1 2 3>> <<1 4 5>>) ) (I liked the thick list idea)
03:55:30 <adu> CakeProphet: my favorite Haskell code: nubBy (((>1) .) . gcd) [2..]
03:55:40 <oklopol> yeah he's gonna find that so interesting
03:55:43 <oklopol> :P
03:55:48 <CakeProphet> ...
03:56:02 <CakeProphet> I LIKE IT.
03:56:13 <psygnisfive> the production doesnt work, cake prophet.
03:56:15 <CakeProphet> but I am a still-toying-with-C-like-languages fag.
03:56:20 <CakeProphet> psygnisfive: I heard you.
03:56:28 <CakeProphet> and why not?
03:56:43 <oklopol> adu: nubBy?
03:56:58 <CakeProphet> adu: totally can't read that.
03:56:59 <psygnisfive> because the first transformation should result in (3 ((2 1) (1 (2 3))))
03:57:08 <adu> http://haskell.org/ghc/docs/latest/html/libraries/base/Data-List.html#v%3AnubBy
03:57:29 <CakeProphet> ...no
03:57:39 <CakeProphet> (A (B C) => (B (C A)
03:57:42 <CakeProphet> would not produce that.
03:57:49 <oklopol> adu: that doesn't by any chance calculate primes?
03:57:58 <adu> oklopol: yes it does
03:57:59 <psygnisfive> yes it would.
03:58:07 <oklopol> that's quite nice
03:58:13 <adu> :) its a classic
03:58:30 <psygnisfive> A = (1 (2 3)) b = 2, c = (2 1)
03:58:53 <oklopol> weird i never thought of doing it like that
03:59:07 <CakeProphet> not in ((1(2 3)) (3(21))
03:59:12 <psygnisfive> yes it does.
03:59:20 <CakeProphet> does anyone else agree?
03:59:29 <adu> CakeProphet: yes, i do
03:59:30 <CakeProphet> I'm new to this stuff so I could be wrong.
03:59:46 <adu> what am I agreeing to?
03:59:48 <psygnisfive> in (A (B C)) replace A with (1 (2 3)) and, B with 2, and C with (2 1) and you get ((1 (2 3)) (3 (2 1)))
03:59:58 <CakeProphet> yes
04:00:00 <CakeProphet> except that's not how they map
04:00:05 <psygnisfive> except it is.
04:00:11 <CakeProphet> k
04:00:23 <psygnisfive> i mean, how isnt it?
04:00:35 <CakeProphet> </conversation>
04:00:45 -!- lilja has quit ("KVIrc 3.2.0 'Realia'").
04:00:52 <psygnisfive> you can add restrictions to A B and C, that they be numbers, or non-lists, or something
04:00:59 <psygnisfive> which would indeed produce what you had earlier
04:01:01 <oklopol> in (A (B C)) replace A with (1 (2 3)) and, B with 2, and C with (2 1) and you get ((1 (2 3)) (3 (2 1))) <<< no.
04:01:19 <psygnisfive> sorry, B with 3
04:01:19 <psygnisfive> :P
04:01:28 <psygnisfive> i keep making typos.
04:01:34 <psygnisfive> you get the point :P
04:01:48 <oklopol> i did, and it was clearly a typo
04:01:59 <oklopol> but it was still wrong
04:02:00 <oklopol> !
04:02:03 <CakeProphet> ...oh lawl
04:02:13 <CakeProphet> I see.
04:02:13 <psygnisfive> :p
04:02:13 <psygnisfive> i love you oklopol :D
04:02:18 <oklopol> you should
04:02:21 <oklopol> now
04:02:25 <psygnisfive> but the point is, as you stated it, cakeprophet, the production was wrong.
04:02:27 <oklopol> i'm gonna sleep
04:02:32 <oklopol> ->
04:02:43 <psygnisfive> ::kisscheek:: night oklo.
04:02:50 <CakeProphet> psygnisfive: correct. but it still remains to be proven if I care.
04:02:55 <CakeProphet> night.
04:03:09 <psygnisfive> well you clearly care since you were using it as the basis of your example :P
04:03:18 <CakeProphet> I was using to demonstrate tree rewriting
04:03:21 <CakeProphet> in case
04:03:24 <CakeProphet> it wasn't understood
04:03:31 <psygnisfive> and it was an incorrect demonstration.
04:03:31 <CakeProphet> but yeah
04:03:36 <CakeProphet> it would help to be accurate
04:03:41 <CakeProphet> but it was mainly to describe it.
04:03:43 <CakeProphet> in any case.
04:03:45 <CakeProphet> this conversation sucks.
04:04:00 <psygnisfive> so lets assume, A, B, C <- Atoms
04:04:02 <oerjan> it would help to be a curate
04:04:06 <psygnisfive> then yes your example is fine.
04:04:29 <CakeProphet> psygnisfive: I can't be arsed to be pedantic right now. -tired-
04:04:33 <adu> oklopol: there is another version of the prime thing that uses 2:[3,5..] for speed
04:04:49 <adu> not that "speed" is an issue...
04:05:33 <adu> I noticed a couple days ago that when I wrote a hello world app in Haskell there were 200 symbols in the binary...
04:05:34 <CakeProphet> psh... if you want speed just compile Haskell to C.
04:05:45 <adu> CakeProphet: thats what GHC does
04:06:29 <psygnisfive> its not pedanticness.
04:06:32 <pikhq> Today, we are going to learn how to make plutonium from common household items.
04:06:39 * pikhq just watched UHF. :D
04:06:39 <adu> lol
04:06:44 <psygnisfive> if youre trying to explain something and you say something wrong, its wrong.
04:06:57 <psygnisfive> also, your explanation of how negative lists rewrite makes no sense.
04:07:07 <pikhq> Hrm. New people in the channel. . .
04:07:13 <adu> hi pikhq
04:07:15 <pikhq> Something of ours hit Digg or something again?
04:07:23 <adu> no, I'm just bored
04:07:27 <psygnisfive> who's new?
04:07:32 <adu> I'm old
04:07:38 <psygnisfive> you sound like a noob.
04:07:42 <adu> I've been here 5 times in the past year
04:07:51 <psygnisfive> you're a noob.
04:08:01 <oerjan> no one here is new. no one. the channel is DYING!
04:08:14 <adu> psygnisfive: I wrote a funge98 interpreter in Perl once, so I'm not a noob
04:09:18 <pikhq> Hrm.
04:09:20 <adu> pikhq: so what's up
04:09:29 <psygnisfive> youre still a noob :D
04:09:31 <pikhq> However, there are people who aren't here who used to be.
04:09:40 <pikhq> adu: Nothing much; just sitting here.
04:09:45 <adu> excuse me its _boon_
04:09:51 <adu> get it right
04:10:05 * pikhq mutters about the untimely 'death' of Sukoshi.
04:10:06 <psygnisfive> lmfao
04:10:16 <psygnisfive> noob.
04:10:20 <adu> boon.
04:10:30 <psygnisfive> and definitely not modest either.
04:10:40 <pikhq> Well, *I'm* no noob.
04:10:51 * CakeProphet is a oldbie noob.
04:10:51 <adu> hi pikhq, can I help you today?
04:11:07 <psygnisfive> adu are you crying for attention?
04:11:08 <pikhq> I wrote PEBBLE before you were born (you young wippersnappers)! :p
04:11:21 <adu> lol
04:11:28 <psygnisfive> get off my lawn!
04:11:37 <adu> psygnisfive: is there any other reason to go on irc?
04:11:42 * pikhq gets the self-aiming sprinkler
04:11:57 <CakeProphet> http://pastebin.ca/1076260 - the current state of my bugSophia interpreter
04:12:18 <CakeProphet> well-documented, incomplete, and most likely bugged.
04:12:29 <CakeProphet> like all my other programs.
04:12:39 <oerjan> i should sincerely hope it is bugged
04:13:01 <psygnisfive> bugged?
04:13:06 <psygnisfive> are the soviets listening in
04:13:07 <psygnisfive> ?
04:13:08 <adu> CakeProphet: is there a reason you use dict() instead of {}?
04:13:21 <CakeProphet> other than personal preference, no.
04:13:30 <CakeProphet> same thing semantically.
04:13:34 <oerjan> no, the north koreans and the zimbabweans
04:13:56 <oerjan> also, cthulhu
04:14:08 <psygnisfive> damn north koreans
04:14:10 <CakeProphet> if I had a reason... it'd probably be that I can actually type out dict() faster than I can type {}
04:14:17 <CakeProphet> because my curly bracket typing abilities are very slow.
04:14:28 <adu> CakeProphet: lol fair 'nuf
04:14:54 <adu> my parens typing abilities are slow
04:15:12 <adu> thats why I perfer Mathematica over Lisp
04:15:16 <CakeProphet> oh yeah... definetely bugged.
04:15:21 <CakeProphet> I didn't even do grids = []
04:15:24 <CakeProphet> somewhere at the top
04:15:55 <psygnisfive> lisp is sexier.
04:15:58 <psygnisfive> so uniform..
04:16:00 <psygnisfive> its beautiful T_T
04:16:17 <CakeProphet> I think Perl is pretty beautiful
04:16:23 <CakeProphet> for the exact opposite reason.
04:16:26 <CakeProphet> but so is Lisp
04:16:32 <psygnisfive> also, i use textmate which autobalances parens :D
04:16:35 <adu> I think Io is beautiful
04:16:52 <CakeProphet> ........oh yeah
04:16:56 <CakeProphet> I've never used it
04:16:58 <CakeProphet> but it looks really clean
04:17:01 <psygnisfive> io huh
04:17:17 <oerjan> Io sono bello
04:17:28 <CakeProphet> http://www.iolanguage.com/
04:17:33 <adu> I mean seeing "clone" instead of "new" or "class" just seems right...
04:17:41 <psygnisfive> it looks terribly eh.
04:17:54 <psygnisfive> adu: you'd like Self then.
04:18:16 <adu> you never know if you're subclassing or instantiating... all the same...
04:18:24 <adu> I'm not sure if thats a good thing, but its pretty :)
04:18:42 <psygnisfive> javascript is theoretically like that, but practically its not.
04:18:44 <CakeProphet> I like that it implements lazy evaluation of function arguments.
04:18:49 <CakeProphet> by default.
04:18:50 <psygnisfive> also, im never sure how copying works in prototype based languages.
04:18:58 <psygnisfive> atleast when it comes to object graphw
04:18:59 <psygnisfive> s
04:19:10 <psygnisfive> does a copy of an object also copy all the objects it references?
04:19:17 <psygnisfive> or does it only copy the object itself, and then copy the references?
04:19:49 <adu> psygnisfive: theres probably different methods for each
04:20:05 <adu> like copy and copy_recursive
04:20:13 <CakeProphet> I think its context sensitive
04:20:20 <CakeProphet> ...for io anyways
04:20:33 <CakeProphet> it would be a waste of memory to actually make copies of each function
04:20:40 <CakeProphet> a reference would be enough
04:21:28 <CakeProphet> but I think io actually makes clones of everything else.
04:21:34 <CakeProphet> so its a deep copy
04:21:42 <adu> psygnisfive: what's your favorite systems language?
04:21:51 <psygnisfive> "systems" language?
04:22:05 <adu> a language that an operating system has been made in
04:22:25 <adu> i.e. NOT html
04:22:40 <psygnisfive> who cares that an OS was made in it?
04:22:48 <adu> me
04:22:52 <CakeProphet> io is very nice...
04:23:02 <CakeProphet> control flow statements
04:23:04 <CakeProphet> and functions
04:23:06 <CakeProphet> are the same
04:23:09 <CakeProphet> which is very clean to me.
04:23:37 <CakeProphet> and it uses smalltalk message-pasing syntax, which always looked nice to me.
04:23:40 <CakeProphet> it lacks a lot of punctuation.
04:23:43 <psygnisfive> adu: thats a silly requirement.
04:23:49 <adu> psygnisfive: what's your favorite usability language?
04:24:03 <psygnisfive> whats my favorite language in terms of usability?
04:24:08 <adu> yes
04:24:08 <CakeProphet> ...I find Python the easiest used.
04:24:10 <CakeProphet> but
04:24:15 <CakeProphet> that's because it was my first
04:24:15 <CakeProphet> and I am most comfortable with it.
04:24:21 <psygnisfive> i like ruby.
04:24:26 <adu> nice
04:24:37 <adu> psygnisfive: what's your favorite obfuscation language?
04:24:41 <CakeProphet> Ruby is alright. Its syntax is a little weird, but I like some of its design.
04:24:48 <CakeProphet> adu, also Python.
04:24:56 <CakeProphet> Perl is next.
04:24:57 <psygnisfive> ruby syntax is.. very simple. o_O
04:25:02 <adu> python for obfuscation?
04:25:11 <psygnisfive> lets see
04:25:14 <CakeProphet> psygnisfive: it always reads weird to me... like "list.each do"
04:25:18 <CakeProphet> it's not conceptually difficult
04:25:21 <psygnisfive> why??
04:25:21 -!- oerjan has quit ("And your little dog too!").
04:25:22 <CakeProphet> it just sounds weird in my head. ;)
04:25:28 <psygnisfive> the each method takes a block argument
04:25:32 <adu> psygnisfive: I would say Python syntax is simple, Ruby syntax is versitle
04:25:38 <psygnisfive> its not list.each do
04:25:45 <psygnisfive> its list.each(do...end)
04:25:52 <CakeProphet> psygnisfive: not arguing with you there.
04:25:54 <CakeProphet> right
04:26:00 <psygnisfive> since parens are optional, each do...end
04:26:01 <CakeProphet> you don't actually need the parens there.
04:26:03 <adu> psygnisfive: what's your favorite compiled language?
04:26:04 <CakeProphet> yeah
04:26:05 <psygnisfive> is completely sensible.
04:26:11 <CakeProphet> ...it is, sematically.
04:26:18 <CakeProphet> but not in my head.... when I say it mentally-aloud.
04:26:25 <psygnisfive> obfuscation language: dunno, dont obfuscate.
04:26:30 <psygnisfive> compiled: well, lisp.
04:26:45 <CakeProphet> "list each do stuff end" doesn't even vaguely make sense in English
04:26:46 <psygnisfive> cakeprophet: well you need to mentally read differently
04:26:48 <adu> psygnisfive: you could have said lisp for systems language too
04:26:50 <CakeProphet> I'm used to Python
04:26:54 <CakeProphet> where everything reads nicely.
04:27:01 <psygnisfive> adu: ok?
04:27:03 <psygnisfive> and?
04:27:11 <psygnisfive> cakeprophet: ruby reads nicely too :P
04:27:24 <CakeProphet> -shrug- personal preference.
04:27:46 <adu> i like Ruby
04:27:55 <adu> i love Haskell, tho
04:27:58 <psygnisfive> cakeprophet: ruby practically reads like english. :P
04:28:03 <psygnisfive> hakell is nice too yeah
04:28:06 <psygnisfive> but up to a point.
04:28:08 * adu <3 Haskell
04:28:12 <CakeProphet> ....that, however, I will disagree with.
04:28:14 <psygnisfive> its too academic for me, too confusing
04:28:24 <CakeProphet> using the list.each do ... end example again.
04:28:43 <CakeProphet> explain how it reads like English.
04:28:53 <psygnisfive> well, if each were a function it'd be even more like english, yes i agree
04:28:58 <psygnisfive> each list do ... end
04:29:17 <psygnisfive> but its a method. so in that regard it has quantifier ordering reversed.
04:29:18 <CakeProphet> ...that would be odd.
04:29:25 <psygnisfive> why would that be odd?
04:29:30 <CakeProphet> it would read more like English, yes.
04:29:30 <psygnisfive> for each item in list, do ...
04:29:36 <CakeProphet> but the English that it reads like
04:29:40 <CakeProphet> would cease matching its semantics
04:29:54 <psygnisfive> how so?
04:30:08 <CakeProphet> because "each x" would suggest there are mulltiple x's being looped over.
04:30:11 <CakeProphet> when it is the thing
04:30:17 <CakeProphet> that the things come from
04:30:19 <adu> with (list) for (each) item in it, (do ... end)
04:30:24 <psygnisfive> uh.. no it wouldnt.
04:30:39 <psygnisfive> for each integer, double it.
04:30:43 <CakeProphet> I think it would make more since if it were a function like each(|dog|, pound, do ... end)
04:30:44 <psygnisfive> integer.each double
04:30:45 <CakeProphet> but then
04:30:47 <CakeProphet> I would stop liking Ruby.
04:31:21 <psygnisfive> integer is a collection
04:31:21 <psygnisfive> in english
04:31:21 <psygnisfive> thats how it works in english
04:31:21 <CakeProphet> -nod- it would vary by what you named the variable.
04:31:22 <psygnisfive> quantifiers like each, all, some, etc. all work on classes
04:31:22 <CakeProphet> I persoanlly like the {'s better
04:31:24 <psygnisfive> sets, if you will.
04:31:27 <CakeProphet> instead of do...end
04:31:33 <CakeProphet> for blah.each
04:31:36 <psygnisfive> thats an irrelevant choice. :P
04:31:44 <CakeProphet> because then the variable name is next to the each... and it makes more sense Englishly.
04:31:54 <CakeProphet> list.each {|item| ....}
04:31:58 <CakeProphet> or however the syntax is.
04:32:03 <psygnisfive> that is correct.
04:32:23 <adu> Englishly
04:32:26 <psygnisfive> it doesnt make it more englishy
04:32:34 <psygnisfive> its only more englishy if the english sentence uses a variable
04:32:37 <CakeProphet> ...but since I dislike {} for blocks... (because I type them slowly... which is why I use dict() instead of {})
04:32:38 <psygnisfive> which it doesnt, when you just use classes.
04:32:45 <CakeProphet> I would prefer instead indentation... because... I am a pythonfag.
04:32:51 <psygnisfive> for each integer do something to it
04:33:02 <CakeProphet> but indentation makes it weird to objectify blocks
04:33:03 <psygnisfive> that does not have the variable name
04:33:06 <psygnisfive> ofcourse you're right if you had
04:33:15 <CakeProphet> which is one of the "benefits" (advantages... or whatever) of Ruby.
04:33:17 <psygnisfive> for each n in integers, do ...
04:33:36 <CakeProphet> yeah
04:33:39 <CakeProphet> that's pretty much
04:33:47 <CakeProphet> the best English-reading syntax you could do.
04:33:49 <CakeProphet> but
04:33:51 <CakeProphet> it's not very terse.
04:33:52 <adu> i personally think all this talk about english is leaving other natural languages out in left field, isn't that unfair?
04:34:00 <CakeProphet> adu, noep
04:34:13 <psygnisfive> but noone would say that
04:34:15 <adu> CakeProphet: have you ever tried to tokanize Japanese?
04:34:16 <CakeProphet> they can get there own god damn languages. :P
04:34:18 <psygnisfive> they would just say for each integer, double it.
04:34:39 <psygnisfive> ive done formal semantics of japanese :D
04:34:39 <adu> token
04:34:44 <CakeProphet> adu, I'm assuming it takes a while? or is it easy because it's characters instead of words?
04:35:21 <adu> psygnisfive: anata no nihongo wa perapera desuka?
04:35:48 <CakeProphet> psygnisfive: yeah... not saying it should be English... I just like for things to make sense in my head. it's not really a fault of the language or anything.
04:35:49 <psygnisfive> perapera to shiranai no
04:35:50 <adu> CakeProphet: its impossible without a dictionary, because there are no spaces
04:35:56 <CakeProphet> I like Ruby's semantics.
04:36:12 <psygnisfive> cakeprophet: i suspect you would say "For each blah, do blah" as well
04:36:34 <psygnisfive> you're reflecting right now, which is iffy.
04:36:34 <CakeProphet> really in normal conversation
04:36:38 <CakeProphet> you'd just say double each integer.
04:36:43 <psygnisfive> well yes
04:36:44 <adu> psygnisfive: its ok, perapera == fluent
04:36:48 <psygnisfive> speaking off
04:36:58 <psygnisfive> thats the syntax i wanna use in my sexy sexy language
04:36:58 <CakeProphet> but that's not explicit enough for a programming language
04:37:03 <psygnisfive> cakeprophet: wanna make it? :D
04:37:08 <CakeProphet> double(x) each |x| integer
04:37:16 <psygnisfive> adu: no, i'm not fluent in japanese at all.
04:37:21 <CakeProphet> there's a missing implied variable there.
04:37:41 <psygnisfive> cakeprophet: cmon, lets make a language :D
04:37:48 <CakeProphet> -shrug- I have places to go.
04:38:14 <CakeProphet> to me... Perl's one-line control flow statements
04:38:19 <CakeProphet> and Python control-flow expressions
04:38:22 <CakeProphet> read the most like english
04:38:23 <CakeProphet> out of all of them.
04:38:27 <psygnisfive> i wanna make a language that has implicit ability to understand quantified nouns
04:38:30 <CakeProphet> (... for item in list)
04:38:33 <CakeProphet> in Python
04:38:35 <CakeProphet> and
04:38:44 <psygnisfive> which would make maps nice and each to see
04:38:59 <psygnisfive> as in your example, double each integer is equivalent to like
04:39:06 <psygnisfive> map double integers
04:39:19 <psygnisfive> if this were haskell
04:39:21 <CakeProphet> ...you can do that in languages already.
04:39:24 <CakeProphet> yes
04:39:32 <psygnisfive> but double 5 would just be 10
04:39:34 <adu> CakeProphet: which one?
04:39:36 <CakeProphet> or if you had a double function map(double, integer) in at least 10 languages.
04:39:47 <psygnisfive> sure but
04:39:49 <psygnisfive> the point is
04:40:07 <psygnisfive> double as a function would be taking as its argument a quantified noun
04:40:12 <psygnisfive> not being passed to a map function
04:40:17 <CakeProphet> ah
04:40:36 <psygnisfive> the interpreter would say, aha, this is an application to a quantified item
04:40:46 <psygnisfive> which means apply it to each item like a map, or some such
04:41:03 <CakeProphet> double (each integer)
04:41:18 <psygnisfive> yeah
04:41:33 <CakeProphet> well... if you had it so that each item in integer implicitly received all messages
04:41:35 <CakeProphet> that would work
04:41:38 <psygnisfive> even tho the double function would only ever be defined as int -> int
04:41:43 <CakeProphet> but it wouldn't work well for lots of other namings.
04:41:47 <CakeProphet> such as
04:41:49 <CakeProphet> doucle (each list)
04:41:52 <CakeProphet> *double
04:41:54 <psygnisfive> well yes
04:42:04 <psygnisfive> but thats your problem to name things correctly :P
04:42:18 <CakeProphet> it does not makes sense
04:42:21 <CakeProphet> to name a list
04:42:23 <CakeProphet> as integer
04:42:23 <psygnisfive> what?
04:42:26 <psygnisfive> well
04:42:28 <psygnisfive> integers
04:42:29 <CakeProphet> integer = []
04:42:30 <CakeProphet> ?
04:42:44 <psygnisfive> ofcourse you could use another quantifier
04:42:46 <psygnisfive> double all integers
04:43:02 <psygnisfive> but anyway
04:43:12 <psygnisfive> even "double each integers" is fine.
04:43:18 <psygnisfive> not perfectly english but so what
04:43:31 <psygnisfive> it reads pretty damn close
04:43:57 <psygnisfive> the point tho is quantifiers
04:44:11 <psygnisfive> even if it was dbl E ints
04:44:14 <psygnisfive> the point is the quantifiers. :P
04:48:19 <CakeProphet> ...if you wanted to break into english parsing.
04:48:34 <psygnisfive> actually ive got some ideas about using some of that stuff too ;)
04:48:34 <CakeProphet> you could have variables change form based on context.
04:48:40 <psygnisfive> tell me more.
04:48:43 <CakeProphet> rather than being a static name
04:48:56 <CakeProphet> like you could say
04:49:03 <CakeProphet> x is some integers
04:49:07 <CakeProphet> er...
04:49:17 <CakeProphet> I mean
04:49:27 <CakeProphet> integers refers to the whole
04:49:31 <CakeProphet> integer refers to parts
04:49:33 <CakeProphet> basically
04:50:20 <psygnisfive> well ive already got ideas about using predicate functions that are flagged as such
04:50:26 <psygnisfive> so that if you say something like
04:50:54 <psygnisfive> even? 5 == f
04:51:05 <CakeProphet> in which case each works a lot like implicit mapping.
04:51:15 <psygnisfive> where the ? is added in-system
04:51:30 <CakeProphet> so in a traditional programming language... if each were a keyword
04:51:30 <psygnisfive> whereas if you did just
04:51:31 <CakeProphet> and you said
04:51:34 <psygnisfive> even integers
04:51:35 <psygnisfive> its a filter
04:51:44 <CakeProphet> double(each integer)
04:51:47 <CakeProphet> or even
04:51:53 <CakeProphet> double(double(each integer))
04:52:03 <CakeProphet> it would be like
04:52:06 <psygnisfive> oh, no, i was thinking each would be some sort of function that produces a quantified expression.
04:52:12 <CakeProphet> map(double, map(double, integer))
04:52:24 <psygnisfive> granted, the sum total of it being quantified would simple be JUST (each integer) :p
04:52:32 <CakeProphet> ...anyways... I have to go.
04:52:39 <psygnisfive> ok see ya
04:52:42 <CakeProphet> thanks for the chat... think about it some more and see if you can make sense of it.
04:53:40 <adu> inght
04:53:44 -!- adu has quit.
04:54:54 <psygnisfive> sense of what? lol
04:54:58 <psygnisfive> theres nothing to make sense of. :P
05:33:47 -!- pikhq has quit ("leaving").
06:39:06 -!- CakeProphet has quit (Read error: 110 (Connection timed out)).
06:54:19 -!- cherez has quit ("Leaving.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:22:28 -!- tusho has joined.
10:22:49 <tusho> augur: i mean, am i the only one who thinks its ridiculous that half the ISPs in america are banning the alt hierarchy
10:22:51 <tusho> sucks
10:22:59 <tusho> i've never read a non-alt. group
10:23:00 <tusho> well
10:23:02 <tusho> comp.lang.*
10:25:13 <tusho> i know i'm responding to message from yesterday, but
10:28:16 <tusho> 19:36:28 <psygnisfive> that makes no sense.
10:28:28 <tusho> stop fsking saying that to mean "i don't understand negative lists"
10:28:32 <tusho> we get it already
10:31:38 <tusho> oklopol: (a b <c d> e f) -> ((a b c e f) (a b d e f))
10:31:53 <tusho> (a b <<c d>>) -> ???
10:32:39 -!- GreaseMonkey has quit ("HydraIRC -> http://google.com <- Go find something better").
10:32:40 <tusho> 20:05:34 <CakeProphet> psh... if you want speed just compile Haskell to C.
10:32:40 <tusho> 20:05:45 <adu> CakeProphet: thats what GHC does
10:32:42 <tusho> Incorrect.
10:32:47 <tusho> It uses its own code generator nowadays.
10:32:51 <tusho> Unless -fvia-c.
10:34:06 <tusho> 20:16:32 <psygnisfive> also, i use textmate which autobalances parens :D
10:34:13 <tusho> 70s abandonware does paren matching, psygnisfive.
10:34:24 <tusho> and autobalancing
10:35:35 <tusho> 20:25:28 <psygnisfive> the each method takes a block argument
10:35:35 <tusho> 20:25:38 <psygnisfive> its not list.each do
10:35:35 <tusho> 20:25:45 <psygnisfive> its list.each(do...end)
10:35:36 <tusho> FAIL
10:35:40 <tusho> blocks are actually 'special'
10:35:44 <tusho> you can't do (do...end)
10:35:58 <tusho> you can only pass one block to a function and it has to be outside any parens and after them
10:36:15 <tusho> and the function can't access it as a normal argument, it has to use 'yield' or have an argumen with & in front of it at the end
10:36:20 <tusho> which is bound to the block reified into a Proc.
11:23:49 -!- Judofyr has joined.
12:24:33 <AnMaster> morning tusho
12:24:40 <tusho> hi AnMaster
12:29:26 <oklopol> pikhq: Hrm. New people in the channel. . . <<< no new people
12:31:07 <oklopol> adu: CakeProphet: is there a reason you use dict() instead of {}? <<< there are a few problems with in-place changes with the latter
12:31:21 <oklopol> not that either of adu and CakeProphet are here
12:34:57 <tusho> oklopol: wtf?
12:34:59 <tusho> they're indentical
12:35:03 <tusho> :|
12:35:19 <tusho> dict(a=2, b=3) is {'a':2, 'b':3}
12:35:20 <tusho> always
12:37:39 <oklopol> psygnisfive: integer is a collection & psygnisfive: in english <<< i disagree
12:40:55 <oklopol> CakeProphet: really in normal conversation & CakeProphet: you'd just say double each integer. <<< 2 * \integers
12:43:04 <oklopol> psygnisfive: array-processing languages are basically based on the kind of implicit mapping you mentioned
12:43:38 <oklopol> CakeProphet: double (each integer) <<< you can define each to work like this in oklotalk, for an arbitrary iterable sequence
12:43:53 -!- Judofyr has quit.
12:46:05 <oklopol> tusho: (a b <<c d>>) -> ??? <<< this would not rewrite to anything
12:46:13 <tusho> ah of course
12:46:30 <tusho> (a b <(c d)> e) -> ((a b (c d) e))
12:46:31 <oklopol> the list cannot be eliminated, so the evaluation would be locked, program would terminate
12:46:31 <tusho> of course
12:46:42 <tusho> bit of a weird translation, but makes sense when the negative list has more stuff in
12:47:20 <oklopol> tusho: well
12:47:38 <tusho> oklopol: well
12:47:41 <tusho> what about this:
12:47:42 <oklopol> wait
12:47:44 <tusho> (a b <c d> e)
12:47:44 <tusho> ->
12:47:49 <tusho> ((a b c e) (a b d e))
12:47:50 <tusho> right?
12:48:07 <oklopol> hmm
12:48:11 <oklopol> yes exactly
12:48:20 <tusho> :D
12:48:22 <tusho> so
12:48:26 <tusho> if you have one term
12:48:31 <tusho> it's just ((a b TERM e))
12:48:38 <tusho> if it's special cased for one element, well, that's weird :)
12:48:39 <tusho> also
12:48:44 <tusho> (a b <> e) -> ()
12:48:45 <tusho> right?
12:48:52 <oklopol> the problem is, the negative lists are all kinda rewritten at the same time on one level, with the current semantics.
12:48:58 <tusho> well yeah
12:49:00 <oklopol> so there may be some problems
12:49:01 <tusho> but (a b <> e) -> ()
12:49:02 <tusho> right?
12:49:04 <oklopol> with complex things
12:49:06 <oklopol> err
12:49:20 <oklopol> yes, that's correct
12:49:28 <tusho> :D
12:49:30 <tusho> I get them now!
12:49:35 <oklopol> :)
12:49:39 <oklopol> did you get thick lists?
12:50:01 <oklopol> basically, you can have thinner and thicker lists, but thick negatives will only rewrite thick levels
12:50:18 <oklopol> this lets you do declarative programming without having to calculate your depths exactly
12:50:38 <tusho> hmm well i don't get it but it doesn't sound too complex
12:50:44 <tusho> but negative lists are cool
12:51:54 <oklopol> http://www.vjn.fi/pb/p366235241.txt <<< i was referring to this behavior, but right, it's not because you're changing the literal, it's because defaults are only evaluated once.
12:52:53 <oklopol> which is actually quite obvious seeing as they are part of the function's data
12:53:53 <tusho> oklopol: (<(<>)>) -> ((()))
12:53:54 <tusho> :D
12:54:21 <oklopol> umm
12:54:37 <tusho> it's true oklopol
12:54:37 <oklopol> (<>) -> (), yeah
12:54:40 <tusho> :D
12:54:46 <oklopol> and then the upper one
12:54:48 <tusho> yep
12:54:50 <tusho> fun
12:55:13 <oklopol> ya
12:55:14 <oklopol> but err
12:55:47 <oklopol> the "problem" is (a b (<e>) c d) -> (a b ((e)) c d), while there is some sense in the negativity, it's not at all pure
12:56:27 <tusho> (<e>) -> ((e)), that's trivial
12:56:29 <tusho> and makes sense
12:56:33 <tusho> and then you just embed it in another list
12:56:34 <tusho> so.
12:57:05 <oklopol> but it makes negatives impure!
12:57:27 <oklopol> well
12:57:33 <oklopol> of course it's just a name for the concept
12:57:37 <tusho> no it doesn't make them impure
12:57:45 <tusho> well, i mean, you could make it nesting negatives
12:57:46 <tusho> in which case
12:57:49 <tusho> i'd expect
12:58:05 <tusho> (a b (<e>) c d) -> ((a b (e) c d))
12:58:11 <tusho> that is, the <>s map the topmost list
12:58:12 <tusho> not the innermost
12:58:20 <oklopol> the semantics are already definitely impure for stuff like <<a b c
12:58:24 <oklopol> *<<a b c>>
12:58:50 <oklopol> <...> will always map just one list on top of it
12:59:00 <oklopol> that's where <<...>> comes in
12:59:43 <oklopol> anyway i should do something
12:59:45 <oklopol> perhaps read
13:00:31 <oklopol> i should really start playing with ai, i almost get a boner from even looking at c++ code describing a flock of birds
13:01:08 <oklopol> also i could probably do something spectacular with ob + simple 2d physics
13:07:42 -!- AnMaster has quit (Remote closed the connection).
13:45:10 -!- Judofyr has joined.
14:36:04 -!- CakeProphet has joined.
15:05:52 -!- lilja has joined.
15:10:22 -!- pikhq has joined.
15:10:34 <tusho> oklopol: i wish i knew pygame
15:14:28 <oklopol> it's not something you know, it's something you google and copypaste
15:15:50 <tusho> oklopol: yes but i still suck at it
15:18:46 <oklopol> well it's very, very simple
15:19:52 -!- AnMaster has joined.
15:21:24 <AnMaster> tusho, ais not here yet?
15:21:43 <tusho> no
15:27:04 -!- ihope has joined.
15:52:56 <tusho> AnMaster: it's saturday.
15:54:42 <AnMaster> tusho, and?
15:54:51 <tusho> and he is never here on a saturday
16:05:55 -!- Judofyr has quit.
16:15:16 -!- Slereah__ has joined.
16:21:04 <oklopol> ais is one weird dude.
16:23:48 <tusho> why?
16:27:36 <oklopol> not having an internet connection
16:33:09 -!- lilja has quit (Read error: 110 (Connection timed out)).
16:33:10 <tusho> oklopol: or a computer
16:33:15 <tusho> well i'm not sure
16:38:08 <oklopol> he does not have a connection, i don't know whether he has a computer
17:12:31 <ihope> ais523 has no internet connection?
17:12:38 <ihope> Our only hope is Norgg, then.
17:13:00 -!- Ilari has joined.
17:18:40 <oklopol> is there anything uglier than making a bot control it's own physics.
17:19:06 <oklopol> the answer is "no", five points for a "no", go for it.
17:19:49 <ihope> That's no uglier than how when you play Solitaire, you make yourself abide by the rules.
17:19:57 <ihope> If you're the type to do such a thing.
17:20:09 <ihope> And you are.
17:20:28 <oklopol> ihope: err no, that's different. no one mixes the physical game play with thinking about the strategy.
17:20:34 <oklopol> the cards are there to aid your memory
17:20:50 <oklopol> it's not about getting the cards to move correctly in order to win, it's about the tactics
17:21:00 <oklopol> of course, with many solitaires, there are no tactics, but anyway.
17:21:05 <ihope> What are you doing?
17:21:18 <oklopol> what am i doing?
17:21:41 <ihope> Having something to do with a bot that controls its own physics, I see.
17:22:21 <oklopol> i'm reading a book called programming game ai by example and wondering why the fuck i'm reading a book that starts by saying it's made for getting ai to look good in practise, not about beautiful academic shit.
17:22:39 <ihope> Ah.
17:23:00 <pikhq> "Could not create temporary file."
17:23:05 <pikhq> Fuck you, Mutt.
17:23:20 <ihope> I have "Artificial Intelligence: A Modern Approach", a.k.a. "Russell and Norvig's Big Green Book". Let's trade. :-P
17:23:34 <oklopol> yeah i'm planning to buy that
17:24:02 <oklopol> anyway the book does have some fun ideas, and seeing the ugly c++ code really inspired further development of Ob.
17:24:27 <oklopol> have you read aiama?
17:24:34 <ihope> Various bits of it.
17:25:06 <oklopol> i've just taken a few random glances inside it
17:25:26 <ihope> I've taken many random looks at it. :-)
17:27:21 <oklopol> anyway specifically, a soccer ai aims for a point near the goal, the random offset is not even abstracted away from the ai's main kickball method
17:27:30 <oklopol> it's there, as part of the fucking state machine
17:27:49 * oklopol rips something off something and throws something at something
17:58:59 <tusho> oklopol: ur
18:08:11 <oklopol> hu?
18:09:43 -!- Slereah__ has quit (Read error: 110 (Connection timed out)).
18:11:20 -!- tusho has quit.
18:12:04 -!- tusho has joined.
18:12:26 -!- tusho has quit (Client Quit).
18:12:45 <psygnisfive> tusho does grasp pedagogically relevant things.
18:12:47 <psygnisfive> :(
18:14:13 <psygnisfive> also, i dont get negative lists at all. :(
18:14:33 <psygnisfive> (1 2 <3 4> 5) i can get but not the others
18:14:41 <psygnisfive> since they dont seem to follow the same rule as that one :(
18:18:10 <psygnisfive> hm. ok so (1 2 <> 3) could make sense too if im interpreting it correctly.
18:18:58 -!- tusho has joined.
18:19:07 <psygnisfive> oklopol:
18:19:13 -!- Judofyr has joined.
18:21:27 <psygnisfive> if list = (... neg-list ...), then that evaluates to (list'0 list'1 ...) where list'0 = (... neg-list[0] ...), list'1 = (... neg-list[1] ...) and so on?
18:22:23 <psygnisfive> that is, a list containing a neg-list of length N evaluates to a list A of similar lists, of length N, where each similar list has one of the elements of the neglist in place of the the neglist.
18:22:24 <psygnisfive> yes?
18:23:13 <psygnisfive> hence the reasoning that (1 2 <> 3) would evaluate to () since the neglist has the same length as ()
18:23:15 <psygnisfive> yes?
18:24:59 <tusho> psygnisfive: well
18:25:00 <tusho> basically
18:25:11 <tusho> (a b <c d> e f) -> ((a b c e f) (a b d e f))
18:25:19 <tusho> you see how that works? <...> means 'one of these'
18:25:24 <tusho> and it produces a list of all possible choices
18:25:27 <tusho> filled in
18:25:34 <tusho> there's some nuances, but that's the basic idea
18:25:38 <tusho> and since <> is 'no choices'
18:25:39 <tusho> you get () back
18:26:16 <tusho> psygnisfive: does that make sense?
18:26:18 <tusho> it kinda -clicks-
18:26:20 <tusho> at one point
18:29:44 <psygnisfive> not with <>.
18:29:52 <psygnisfive> that was my first assumption but it does fail with <>
18:30:03 <psygnisfive> afk
18:35:02 <tusho> psygnisfive: no it doesn't
18:35:23 <tusho> (1 2 <3 4> 5) -> (For each thing in (3 4), (1 2 thing 5))
18:35:30 <tusho> For <>, that becomes 'For each thing in ()'.
18:35:35 <tusho> Thus, it never runs, and we get ().
18:35:54 <Judofyr> which language are we talking about?
18:37:25 <tusho> Judofyr: oklopol's negative lists
18:37:36 <tusho> psygnisfive contends they're impossible and meaningless or at least used to
18:37:41 <tusho> meanwhile, one more person gets them every day
18:37:42 <tusho> :)
18:38:35 <Judofyr> link?
18:39:08 <tusho> Judofyr: no link
18:39:18 <Judofyr> :(
18:39:24 <tusho> people://oklopol/mind/nopol/neglists
18:39:28 <tusho> have a URI
18:39:57 <AnMaster> <tusho> (1 2 <3 4> 5) -> (For each thing in (3 4), (1 2 thing 5))
18:39:58 <AnMaster> so...
18:40:10 <AnMaster> that is basically (3|4) in a regex?
18:40:15 <tusho> .........................................
18:40:16 <tusho> no
18:40:21 <AnMaster> but not a regex of course
18:40:33 <AnMaster> being expanded instead to all posibilities
18:40:42 <AnMaster> possibilities*
18:40:44 <AnMaster> tusho, no?
18:40:57 <tusho> >_<
18:41:09 <AnMaster> what?
18:42:07 <AnMaster> tusho, ?
18:42:27 <tusho> i'm not going to bother explaining because it's not worth it because oklopol is better at it than me
18:42:30 <tusho> ask him.
18:42:41 <tusho> also, you'll need a bit of a functional programming mind to grasp it.
18:42:41 <AnMaster> oklopol, explain!
18:42:44 <tusho> you might wanna work on that
18:43:10 <AnMaster> tusho, well I do understand some lisp but... no I don't have a functional mind...
18:43:36 <tusho> get one, then try again
18:43:47 <AnMaster> tusho, where can I get one?
18:43:58 <AnMaster> ;P
18:44:28 <tusho> yaht & r5rs
18:44:37 <tusho> & lc
18:44:55 <AnMaster> not at the local walmart?
18:45:16 <tusho> no.
18:45:22 <AnMaster> damn ;P
18:46:48 <psygnisfive> just because various people get them doesnt mean that they make sense
18:46:59 <AnMaster> thanks psygnisfive
18:47:08 <tusho> psygnisfive: so we're all hallucinating?
18:47:12 <psygnisfive> no.
18:47:24 <tusho> psygnisfive: i think what you mean is - they don't make sense to you
18:47:27 <tusho> and yeah, they didn't to me
18:47:30 <AnMaster> no of course not, only 12 year old girls are
18:47:31 * AnMaster runs
18:47:38 <tusho> but, objectively, they do make sense because, um, they exist, and oklopol's implemented them
18:48:09 <AnMaster> tusho, are you saying INTERCAL's random compiler bug make sense? or it's turning text thing for input/output
18:48:14 <AnMaster> they exist
18:48:35 <tusho> objectively, they 'make sense'
18:48:42 <tusho> because they are specifiable
18:48:44 <tusho> implementable
18:48:44 <tusho> and real
18:48:49 <tusho> subjectively, no, they don't ;)
18:48:52 <AnMaster> does TURKY BOMB make sense?
18:49:02 <tusho> AnMaster: partly
18:49:06 <AnMaster> hah
18:49:15 <AnMaster> did you ever get anywhere with implementing it?
18:49:19 <tusho> if you give it a liberal enough interpretation
18:49:46 <tusho> not really
18:49:52 <tusho> theoretically it can be taken as a spec for a TC language
18:49:55 <tusho> but in practice, well..
18:50:05 <AnMaster> give me half a bit ;P
18:50:09 <AnMaster> or was it 1/3rd of one?
18:50:39 <tusho> AnMaster: the point is that although you can't represent half a bit
18:50:44 <tusho> if you have, say, an array of two half-bits
18:50:49 <tusho> then you can represent it as one bit
18:50:57 <AnMaster> but you can't set each half
18:51:15 <AnMaster> I think you have to emulate it or something ;P
18:51:38 <AnMaster> say, store it internally in the interpreter as a whole bit
18:51:44 <AnMaster> or whatever
18:51:46 <tusho> AnMaster: yeah, pretty much
18:51:50 <tusho> you have to do some acrobatics
18:51:58 <tusho> AnMaster: like, e.g.
18:52:02 <AnMaster> is turky bomb actually TC?
18:52:04 <tusho> NEGATIVE AMICED is a negative amount of bits
18:52:06 <tusho> what you do
18:52:08 <tusho> is instead have AMICED
18:52:11 <tusho> with a postive amount
18:52:15 <tusho> and just make all operations on it negative
18:52:19 <AnMaster> yep
18:52:20 <tusho> and *turkey
18:52:23 <tusho> and well
18:52:24 <AnMaster> yes typo
18:52:25 <tusho> it's so vague
18:52:28 <tusho> you can make it tc
18:52:31 <tusho> if you take some liberties
18:52:42 <AnMaster> implement TURKEY BOMB in TURKEY BOMB!
18:52:43 <AnMaster> ;P
18:52:48 <tusho> it basically ends up as a computer simulation of the described drinking game
18:52:55 <AnMaster> haha
19:35:37 <psygnisfive> tusho, im not saying neglists, as oklopol implemented them, dont make sense
19:35:49 <psygnisfive> im saying neglists, as theyre being explained dont make sense to me.
19:36:25 <tusho> yeah.
19:36:28 <tusho> they're not easy to explain
19:36:28 <tusho> :P
19:36:33 <psygnisfive> also, by the normal reasoning about what (... <something> ...) does
19:36:40 <psygnisfive> (... <<something>> ...) should also do something.
19:37:03 <psygnisfive> if (... <a b> ...) => ((... a ...) (... b ...))
19:37:25 <psygnisfive> then (... <<a b> <c d>> ...) => ((... <a b> ...) (... <c d> ...))
19:37:46 <psygnisfive> => (((... a ...) (... b ...)) ((... c ...) (... d ...)))
19:39:14 <psygnisfive> this all looks terribly like non-deterministic things in Haskell.
19:39:31 <psygnisfive> or any system that allows non-deterministic filtering.
19:39:35 <psygnisfive> only its not filtering, its construction.
19:46:55 <tusho> its deterministic
19:46:55 <tusho> but yes
19:46:56 <tusho> similar to the list monad
19:47:04 <tusho> also, I believe <<>> does the same as <>, but one level up
19:47:26 <tusho> so (a (b <<c d>> e) f) -> ((a (b c e) f) (a (b d e) f))
19:47:27 <tusho> see?
19:47:33 <tusho> it jumps up a level before doing every possibility
19:49:13 -!- Slereah__ has joined.
19:51:00 <psygnisfive> i said it looks like deterministic stuff
19:54:10 <tusho> psygnisfive: this all looks terribly like non-deterministic things in Haskell.
19:54:10 <tusho> [19:39] psygnisfive: or any system that allows non-deterministic filtering.
19:54:19 <psygnisfive> yes?
19:54:25 <psygnisfive> "looks terribly like"
19:55:25 <psygnisfive> anyway
19:56:10 <psygnisfive> i would like to see formal rules for doing negative lists
19:56:12 <psygnisfive> itd help a lot.
20:07:30 -!- timotiis has joined.
20:10:03 <psygnisfive> oklopol! formalism!
20:10:05 <psygnisfive> now!
20:11:24 <oklopol> iuo
20:11:30 <psygnisfive> iuo?
20:11:32 <psygnisfive> :O
20:11:42 <psygnisfive> iuo means "kiss me" in my conlang
20:11:43 <psygnisfive> :o
20:12:35 <oklopol> psygnisfive: if list = (... neg-list ...), then that evaluates to (list'0 list'1 ...) where list'0 = (... neg-list[0] ...), list'1 = (... neg-list[1] ...) and so on? <<< ya.
20:12:44 <psygnisfive> ok.
20:12:49 <oklopol> psygnisfive: i know
20:12:55 <psygnisfive> so then by that reasoning
20:13:04 <psygnisfive> <<...>> should evaluate as I supposed above.
20:14:03 <psygnisfive> (x <<a b> <c b>> y) => ((x <a b> y) (x <c d> y)) => (((x a y) (x b y)) ((x c y) (x d y)))
20:14:07 <oklopol> psygnisfive: the normal rewrite rule is just the case where the negative list contains no negatives
20:14:16 <oklopol> well actually
20:14:32 <oklopol> basically, i have separate rules for when a negative list contains a singleton negative list
20:14:38 <psygnisfive> ok.
20:14:44 <psygnisfive> do you have ordered rules?
20:14:45 <oklopol> err, when a negative list is a singleton containing a negative list
20:15:02 <oklopol> yes, the rules are not all that beautiful mathematically.
20:15:02 <psygnisfive> because if the rule is (... neg-list ...) => ((... neg-list[0] ...) ...)
20:15:26 <oklopol> they are not just recursively defined with the simple rule
20:15:31 <psygnisfive> then the unwrapping of (x <<a b> <c d>> y) should unfold as i mentioned
20:15:35 <oklopol> yes
20:15:41 <psygnisfive> but if you have some other rule like
20:15:46 <psygnisfive> <... neg-list ...> => ...
20:16:00 <psygnisfive> and that rule has a higher precedence than (... neg-list...)
20:16:04 <psygnisfive> then i can see there being a difference
20:16:15 <oklopol> yeah, that's the case
20:16:29 <psygnisfive> ok. tusho never mentioned such a rule.
20:16:38 <oklopol> tusho may not have known about such a rule
20:16:41 <tusho> i didn't
20:16:53 <tusho> i just knew what you told me, you didn't really specify the exact singleton thing
20:16:54 <oklopol> anyway, there is no formal semantics for this, i go by my own intuition.
20:17:01 <psygnisfive> then negative lists are just non-deterministic elements.
20:17:06 <oklopol> tusho: yeah i just explained the gist of it
20:17:11 <oklopol> psygnisfive: exactly
20:17:12 <tusho> psygnisfive: except they make the list they're in turn into a list of all possibilities
20:17:14 <tusho> but yes
20:17:16 <psygnisfive> ok, thats simple enough.
20:17:17 <tusho> pretty much
20:17:23 <tusho> it makes sense to call them negative though psygnisfive
20:17:30 <tusho> because they "fold" into the thing they're in
20:17:34 <psygnisfive> i disagree but whatever.
20:18:02 <psygnisfive> they're just non-deterministic elements.
20:18:14 <oklopol> one way to see it
20:18:16 <oklopol> but
20:18:22 <psygnisfive> reminds me of haskell's filterM
20:18:22 <oklopol> it's not equivalent to that
20:18:45 <psygnisfive> it seems like it is :p
20:18:55 <psygnisfive> atleast for stuff like (... neg-list ...)
20:19:08 <psygnisfive> i dont know your semantics for <... neg-list ...> yet so.
20:19:20 <oklopol> well the difference is you get a *real* new list on the toplevel
20:19:28 <psygnisfive> what would
20:19:33 <psygnisfive> <a <b c> d>
20:19:34 <psygnisfive> eval to
20:19:40 <psygnisfive> and what are the steps and rules
20:19:54 <oklopol> nothing, you can't have negative lists without something surrounding them
20:20:11 <psygnisfive> what would (<a <b c> d>) evaluate to.
20:20:16 <psygnisfive> + rules and steps
20:20:56 <oklopol> ((a) (<b c>) (d)) -> ((a) ((b) (c)) (d)) i think
20:21:23 <oklopol> anyway, this is just basically an unclean way to get deterministic elements, i guess you could say
20:21:29 <psygnisfive> so its an evaluation no different that the standard (.. neg-list ..) evaluation
20:21:30 <oklopol> *nondeterministic
20:21:45 <psygnisfive> you unwrap the neglists top down.
20:21:59 <oklopol> psygnisfive: well indeed, the actual exception is when you have <neglist>
20:22:07 <oklopol> and not <... neglist ...>
20:22:12 <psygnisfive> (<<a b>>) => ?
20:22:35 <psygnisfive> or (<a b>) => ?
20:22:47 <tusho> (<a b>) = ((a b))
20:22:47 <psygnisfive> well, that last one is trivial nevermind
20:22:50 <tusho> that's obvious
20:22:50 <oklopol> first would fail, i think, latter would be triv
20:22:56 <psygnisfive> no tusho
20:22:58 <psygnisfive> thats wrong :)
20:23:04 <psygnisfive> (<a b>) => ((a) (b))
20:23:05 <oklopol> wrong, but triv still
20:23:14 <tusho> oh yeah
20:23:15 <psygnisfive> ok so whats the except with <neglist> ?
20:23:25 <oklopol> psygnisfive: basically, that you jump two levels up
20:23:32 <psygnisfive> example.
20:23:39 <psygnisfive> (a <<x y>> b)
20:23:44 <psygnisfive> => ?
20:24:10 <oklopol> (a (b <<e f g>> c) d) => ((a (b e c) d) (a (b f c) d) (a (b g c) d))
20:24:21 <psygnisfive> one step at a time oklopol, please. :P
20:24:26 <oklopol> that's one step
20:24:34 <psygnisfive> uh huh :P
20:24:35 <oklopol> you remove <<e f g>> from there
20:24:39 <oklopol> then rise two levels up
20:24:44 <tusho> yeah
20:24:46 <tusho> it makes sense psygnisfive
20:24:47 <tusho> basically
20:24:51 <tusho> when you do <...>
20:24:51 <psygnisfive> quiet tusho
20:24:52 <oklopol> and call the list lambda for each elem
20:24:53 <tusho> it cycles the choices
20:24:53 <psygnisfive> you're useless.
20:24:56 <tusho> in the topmost list
20:24:58 <oklopol> :D
20:25:00 <tusho> <<...>> does it two levels up
20:25:03 <tusho> <<<...>>> three
20:25:03 <tusho> etc
20:25:10 <psygnisfive> tusho
20:25:11 <tusho> isn't that fairly simple?
20:25:11 <psygnisfive> be quiet.
20:25:16 <tusho> psygnisfive: no.
20:25:27 <psygnisfive> you're fucking up the signal to noise ratio.
20:25:42 <oklopol> oh you
20:25:43 <oklopol> anyway
20:25:44 <tusho> it wasn't noise.
20:25:44 <oklopol> err
20:26:01 <tusho> <...> = cycle choices at the list we're in; <<...> = cycle choices in the list containing the one we're in
20:26:01 <tusho> etc
20:26:10 <oklopol> psygnisfive: i'd say it's simple to see what happens from the example, and i think tusho said it clearly
20:26:21 <oklopol> you rise two levels in lists
20:26:30 <oklopol> so you get on the (a ... d) level
20:26:36 <psygnisfive> ok i see now.
20:26:50 <oklopol> and you get the list lambda (a (b * c) d), which you call for each elem in <<e f g>>
20:27:05 <tusho> wowzers. psygnisfive gets neglists
20:27:09 <tusho> i thought i'd never see the day
20:27:10 <tusho> :)
20:27:21 <oklopol> you guys are funny :)
20:27:22 <oklopol> anyway
20:27:28 <oklopol> i'll go eat! ->
20:27:40 <psygnisfive> (a (b <<c d>> e) f) => (a <(b c e) (b d e)> f) => ((a (b c e) f) (a (b d e) f))
20:28:37 <psygnisfive> its almost distributive.
20:28:44 <psygnisfive> so lets see
20:28:57 <psygnisfive> (list a b c) => '(a b c)
20:29:06 <psygnisfive> (neg-list a b c) => '<a b c>
20:29:37 <psygnisfive> (list a (neg-list b c) d) => '(a <b c> d) => '((a b d) (a c d))
20:30:42 <psygnisfive> eh..
20:30:55 <psygnisfive> i dont know if its actually distributive but its close with the <<..>>
20:31:43 <psygnisfive> thats relatively straight forward, but its not what i would call a negative list.
20:31:49 <psygnisfive> since its not a list. :P
20:32:01 <tusho> psygnisfive: it's not a list, it's a negative list
20:32:12 <tusho> because it folds into the list its in
20:32:26 <psygnisfive> tusho, it's not what i would call a negative list.
20:32:33 <tusho> you're wrong! ;)
20:32:39 <psygnisfive> i cant be wrong.
20:32:45 <psygnisfive> since im not calling it a negative list.
20:32:52 <psygnisfive> and therefore it is true that i would not call it a negative list
20:33:03 <psygnisfive> and thus it is true that it's something that i would not call a negative list.
20:33:08 <psygnisfive> i dont see why this is so hard to grasp.
20:33:22 <tusho> it's not
20:33:34 <tusho> i just wanted you to have to explain it
20:33:35 <tusho> :D
20:34:14 <psygnisfive> stop trolling, tusho.
20:34:25 <tusho> you're wrong!
20:34:26 <tusho> :D
20:35:27 <psygnisfive> i'd just say they're non-deterministic list elements, where the number of angle brackets specifies how many items above the non-determinism applies to
20:35:28 <psygnisfive> brb
20:35:43 <Judofyr> the list is lie!
20:46:00 <psygnisfive> the lie is list!
20:46:40 <tusho> the negative list is a negative lie!
20:47:04 <psygnisfive> i mean, i can see why you're compelled to call it a negative list
20:48:57 <psygnisfive> since (a <b c> d) has an evaluated length greater than the external forms length, and therefore the external form has "negative" length
20:49:18 <tusho> not length psygnisfive
20:49:19 <tusho> it's not length
20:49:21 <tusho> it's depth
20:49:30 <tusho> (a) = 1 depth. ((a)) = 2 depth.
20:49:31 <tusho> etc.
20:49:36 <tusho> these are negative depth
20:49:38 <psygnisfive> whatever
20:49:40 <psygnisfive> thats not the point
20:50:20 <psygnisfive> the point is that i dont think it really qualifies as a list.
20:50:39 <psygnisfive> <a b c> is itself not the list. <a b c> only works in conjunction with some containing element
20:50:47 <psygnisfive> and is itself merely shorthand for non-deterministic elements
20:51:45 <psygnisfive> which is not terribly esoteric, in the grand scheme of things.
20:52:07 <psygnisfive> if anything it seems like something ruby or lisp might do.
20:53:11 <tusho> i'd say its pretty esoteric
20:53:15 <tusho> esp. when nopol _code_ even uses it
20:53:17 <tusho> and i have no idea how
20:53:37 <psygnisfive> nopol code is just lisp + some stuff right?
20:53:49 <oklopol> 22:34… psygnisfive: i'd just say they're non-deterministic list elements, where the number of angle brackets specifies how many items above the non-determinism applies to <<< make a noun out of that, and i can add it as an optional name in the nopol spec
20:53:50 <psygnisfive> i mean, it has the whole code-is-data-is-code thing right?
20:54:19 <psygnisfive> depth-specified non-deterministic elements.
20:54:29 <psygnisfive> or depth-specifying
20:55:32 -!- tusho has quit ("And then-").
20:55:33 <oklopol> well it was a joke, i don't give a fuck what you wanna call them, but yes, they are a form of non-deterministic elements, although i didn't know this at the time of inventing them
20:55:43 <psygnisfive> :p
20:55:45 -!- tusho has joined.
20:55:45 <oklopol> :p
20:55:57 <psygnisfive> the formal specification for them isnt that hard either
20:56:13 <oklopol> perhaps not
20:56:37 <psygnisfive> let L be (... (... (... N ...) ...) ...)
20:57:01 <psygnisfive> let N be the "negative list" containing a b and c
20:57:23 <psygnisfive> let B be the number of angle brackets in the negative list's enclosure
20:59:06 <psygnisfive> then L evaluates to a list L' such that the list enclosing N B levels up has the contents of N nondeterministically substituted
20:59:07 <psygnisfive> or something
20:59:16 <psygnisfive> i'd need to word it better in that last part but
20:59:57 <oklopol> well yeah and then just the fact all are rewritten at the same time, making the concept even closer to non-determinism
21:01:38 <psygnisfive> the explanations from earlier were rather confusing, tho.
21:02:05 <oklopol> perhaps, all i know is CakeProphet got it
21:02:18 <psygnisfive> the concept is simple enough.
21:02:48 <psygnisfive> cakeprophet and tusho got it because they're as warped and twisted as you are so it makes sense to them to think it warped and twisted explanations :P
21:02:57 <tusho> <3
21:02:58 <oklopol> true, but as it's not terrible context-insensitive inherently, it's hard to explain
21:03:21 <oklopol> that is, you can't show a simple rewrite rule
21:04:03 <psygnisfive> ofcourse not. the rewrite depends on numerous things, and it probably requires a Type 0 language to implement using rewrite rules
21:04:18 <psygnisfive> but the specification mathematically isnt terribly hard.
21:04:35 <oklopol> well yes, although i'm not sure what your point is
21:04:47 <oklopol> err, right, that it was confusing
21:04:52 <psygnisfive> :D
21:04:58 <psygnisfive> its not confusing! you just dont get it!
21:04:59 <psygnisfive> ;)
21:04:59 <oklopol> no one's blaming you for not grasping it from that
21:05:05 <psygnisfive> tusho is :(
21:05:14 <oklopol> well tusho is gay
21:05:23 <psygnisfive> hey, dont insult gay people.
21:05:23 <tusho> how did you know!
21:05:37 <psygnisfive> we knew because you look like a girl.
21:05:44 <psygnisfive> you girl.
21:05:47 <psygnisfive> GIRLY GIRL.
21:07:02 <oklopol> psygnisfive: its not confusing! you just dont get it! <<< err what?
21:07:13 <psygnisfive> i was pretending to be tusho.
21:07:16 <oklopol> :)
21:07:22 <oklopol> okay, sorry, i guess that was obvious
21:07:34 <tusho> oklopol: its not confusing! you just dont get it!
21:08:29 <oklopol> fuck you little brat you're so young i could be father's lover, stop making noise
21:08:31 <oklopol> *
21:08:34 <oklopol> *your father's
21:08:52 <psygnisfive> i bet his father was a girl too :O
21:08:58 <oklopol> *zing*
21:09:03 <psygnisfive> ;D
21:09:21 <psygnisfive> so besides boring "negative lists", anything interesting going on?
21:09:28 -!- Keymaker has joined.
21:09:32 <tusho> psygnisfive: You're only saying that because you're not comfortable with your own masculinity.
21:09:33 <tusho> OH SNAP
21:09:38 <tusho> On another topic, hi Keymaker
21:09:43 <psygnisfive> its true D:
21:09:51 <Keymaker> hello
21:10:14 <psygnisfive> keymaker, a little chinese man who sounds like hes trying to not be chinese way too hard.
21:10:33 <Keymaker> actually i got this name after seeing matrix ii :P
21:10:47 <psygnisfive> THANK YOU CAPTAIN OBVIOUS
21:10:55 <psygnisfive> am i the only one who thought that the keymakers accent was way to fucking weird?
21:11:06 <tusho> keymaker is cool.
21:11:08 <tusho> he makes quines.
21:11:18 <oklopol> hard to remember, matrix was like a decade ago
21:11:33 <psygnisfive> it sounded like they overdubbed him with a voice actor in order to make him sound completely unchinese
21:11:37 <oklopol> yeah Keymaker is awesome, unfortunately you never get to talk to him
21:11:49 <oklopol> probably writing /quit as i'm typing this
21:11:55 <psygnisfive> but they pushed him to like.. 120% non-chinese
21:12:36 <Keymaker> :D thanks. in fact the reason i came to visit was because i wanted to link my whirl quine i made about a week ago :D
21:12:38 <Keymaker> http://koti.mbnet.fi/yiap/programs/whirl/quine.wrl
21:12:51 <oklopol> well yeah, that's why you always come :P
21:13:06 <Keymaker> i also finished a collatz program in brainfuck just a few minutes ago: http://bf-hacks.org/hacks/collatz.b
21:13:12 <Keymaker> so i came to link both
21:13:32 <oklopol> Keymaker: i'm assuming that was by hand
21:13:52 <psygnisfive> there are no interesting esolangs :(
21:15:11 <oklopol> psygnisfive: eodermdrome is quite interesting imo
21:15:27 <psygnisfive> also, oklopol, im trying to figure out a CFG for reactance's shorthands and im finding it tricky. lol
21:15:38 <oklopol> been trying to come up with a way to build an arbitrary graph from a finite amount of initial nodes and finite rules
21:15:43 <Keymaker> i got so annoyed moving the whirls so i had to make a program to convert whirl ops to those 0s and 1s. that program took most of the time in the process... and as it was far from good i needed to create padding for jumps and various other things on my own.
21:15:59 <Keymaker> eodermdrome seems interesting, is there any examples?
21:16:07 <oklopol> Keymaker: the first phase of whirl is just a syntax replacement?
21:16:18 <oklopol> or is there an actual wheel when running?=
21:16:21 <psygnisfive> anyone have a link to eodermdrome?
21:16:27 <Keymaker> no, there's actual wheel
21:16:34 <oklopol> eodermdrome doesn't have examples, no
21:16:36 <psygnisfive> or to whirl?
21:16:44 <oklopol> been trying to get ais523 to write some
21:16:47 <psygnisfive> well how can i look into eodermdrome? :P
21:16:55 <Keymaker> so it's not just replacing stuff with 0 and 1. one has to move those wheels (which i caleld whirls) with them to choose instructions
21:17:05 <oklopol> psygnisfive: esolangs.org, i'd have to open a browser as well
21:17:16 <Keymaker> http://www.esolangs.org/wiki/Eodermdrome
21:17:27 <oklopol> i see, then it's a lot more interesting than i thought initially
21:17:41 <Keymaker> yeah, it is, and damn annoying for making jumps
21:18:12 <oklopol> and you fucker wrote a quine in it. can you elaborate on how?
21:18:16 <Keymaker> generally moving in memory and stuff isn't as easy as one'd think, as there's no way to change data between the two wheels other than setting it to memory and the reading in other whirl
21:19:06 <oklopol> hmm, there are multiple wheels? i guess i'm remembering the whole thing wrong
21:19:10 <Keymaker> two wheels
21:19:12 <oklopol> ah
21:19:22 <Keymaker> and each has different instructions, a few same, but essentially different
21:19:30 <oklopol> yeah i recall now
21:19:36 <Keymaker> yea
21:19:44 <psygnisfive> that sounds pointlessly silly. :P
21:20:08 <oklopol> Keymaker: how did you do the quine?
21:20:15 <oklopol> i've always found quines quite hard in general
21:20:22 <oklopol> especially with esolangs
21:20:52 <Keymaker> ah. first i created code snippets for memory storing (both 61 bytes)
21:21:04 <Keymaker> then i wrote the main code
21:21:10 <Keymaker> then i created data part of that
21:21:35 <Keymaker> (i mean the snippets/pieces were 61 per every 0 or 1)
21:22:03 <Keymaker> the data part is huge in this program...
21:22:11 <psygnisfive> the boring is spinning out of control :(
21:22:32 <oklopol> psygnisfive: buy a book
21:22:37 <oklopol> get a life
21:22:38 <psygnisfive> i have one :o
21:22:44 <psygnisfive> a book, i mean.
21:22:49 <psygnisfive> i dont have a life tho.
21:22:54 <Keymaker> my advice: go outside
21:23:09 <psygnisfive> coming from a guy who wrote a quine in whirl. :p
21:23:24 <oklopol> psygnisfive: stop being like that
21:23:41 <psygnisfive> crochetty?
21:24:10 <oklopol> Keymaker: anyway, err, so basically you have a way to write the data, then write the part that first writes the data as the code that makes it, then as it is, and you just put the program into the data
21:24:13 <Keymaker> yes, but i spend a lot time outside nonetheless :]
21:24:17 <oklopol> the way that one commented bf quine did
21:24:31 <oklopol> outside is boring
21:24:35 <psygnisfive> so do i! i went walking around lond and paris for like 8 hours every day for the last two weeks :O
21:25:32 <oklopol> the only difference between going outside to take a walk and writing a whirl quine is if you take the walk you don't get anything done
21:26:01 <Keymaker> hm, it isn't that to me. anyways, first part that writes the data in memory, then part that prints the data part, then parts that prints the data, then of those two parts is created the real datapart
21:26:02 <psygnisfive> and with a quine in whirl, you get negative amounts done? :P
21:26:30 <psygnisfive> hey, if you wrote a quine in whirl because it was listed in a negative list, would the negatives cancel out and result in being productive?
21:26:42 -!- lilja has joined.
21:27:54 <oklopol> god i hate it when people don't appreciate others' work on the grounds that it's not useful
21:28:16 <psygnisfive> its not that i dont appreciate his work because its not useful
21:28:26 <psygnisfive> i wasnt the one who even brought up getting things done! you were! :O
21:28:34 <oklopol> Keymaker: yeah that's the approach you usually use with esolangs i guess
21:28:42 <oklopol> well, same thing for all langs, but you don't see it as clearly
21:28:48 <psygnisfive> i dont appreciate it because it seems like a silly rehash of some boring old concept.
21:28:49 <Keymaker> in most of them yeah
21:29:13 <oklopol> psygnisfive: well yeah, i agree that's a problem with most esolangs
21:29:30 <psygnisfive> i mean, if you removed the "wheels" or "whirls" or whatever you want to call them
21:29:36 <psygnisfive> what distinguishes Whirl?
21:29:42 <Keymaker> (and anyways, my esoteric work is useful to me)
21:29:46 <oklopol> removed the wheels?
21:29:50 <psygnisfive> does it just become Brainfuck? a funge? a whatever?
21:29:52 <oklopol> aren't those the point
21:29:58 <psygnisfive> but ARE THEY?
21:30:02 <oklopol> it's not a syntactic substitution kid
21:30:12 <psygnisfive> i mean, the wheels have instructions?
21:30:26 <Keymaker> remember those old phones where you choose number by rotating a ring?
21:30:39 <psygnisfive> how do you select instructions? how do these wheels play into anything?
21:30:40 <psygnisfive> right, so its a rotary dial version of brainfuck
21:30:50 <Keymaker> whirl is a bit like that. it has two such rings with different commands, you have to move them. and different commands than brainfuck
21:30:54 <psygnisfive> which means that its a silly modification of branfuck.
21:31:08 <psygnisfive> it doesnt matter that it has different commands than brainfuck
21:31:25 <Keymaker> you could say then almost every language in the world is silly modification of brainfuck
21:31:28 <psygnisfive> its a silly hyperminimal tarpit
21:31:29 <oklopol> i'm pretty sure it becomes fundamentally different to program in with jumps
21:31:46 <oklopol> but i haven't tried
21:31:47 <psygnisfive> the wheels do absolutely nothing except make it hard to code in
21:32:02 <psygnisfive> and even then, it doesnt need to be since you can remove the wheels entirely
21:32:11 <psygnisfive> without actually removing them!
21:32:23 <Keymaker> how is that?
21:32:25 <oklopol> if you can do that trivially, then it's a syntactic thing
21:32:42 <psygnisfive> ofcourse it is, but the point is that the wheels themselves are a syntactic thing if thats the case.
21:32:52 <psygnisfive> keymaker, if your analogy to a rotary dial telephone is correct
21:33:14 <psygnisfive> then in some sense each position on the wheel, lets say each angle postion, 0 through 9, for instance, has an instruction, yes?
21:33:16 <oklopol> yeah, and they are not, because with jumps, the meaning of earlier code changes
21:33:32 <psygnisfive> so you do something akin to move forward n positions
21:33:36 <psygnisfive> move forward m positions
21:33:41 <psygnisfive> etc etc to get from one instruction to the next
21:33:42 <psygnisfive> yes?
21:33:55 <Keymaker> yes. you rotate ring with 1, 0 changes the direction, if there's 00 it changes the ring
21:34:01 <Keymaker> (and executes the chosen instruction)
21:34:11 <psygnisfive> so essentially to get to any instruction n
21:34:25 <psygnisfive> you can just replace n with n numbers of 1, 0, then n numbers of 1
21:34:27 <psygnisfive> that is
21:34:33 <psygnisfive> to get to instruction 5
21:34:42 <psygnisfive> 11111*011111
21:34:48 <psygnisfive> where * is used to indicate "do it" or whatever
21:34:53 <oklopol> so you just won't believe it's not like that?
21:35:01 <psygnisfive> which is fine
21:35:08 <oklopol> not that i'm sure it's not, but i've said it's not, and you have no reason not to believe that
21:35:23 <psygnisfive> but that means that the whole wheel gimmick is an obfuscation of instruction symbols since it can be trivially reduced to a 1-to-1 mapping.
21:35:33 <Keymaker> it can't be
21:35:41 <psygnisfive> but you just said it COULD.
21:35:50 <psygnisfive> its implicit in your design.
21:35:55 <oklopol> anything can be compiled to anything
21:35:58 <psygnisfive> 1 rotates the ring forward one instruction yes?
21:36:09 <psygnisfive> and 0 changes the direction of rotation, yes?
21:36:48 <psygnisfive> if thats so, then to access instruct n, from instruction 0, you need to go forward n times. that is you need a string of n 1's in a row.
21:36:54 <psygnisfive> to get to instruction 5, you need 11111
21:36:55 <psygnisfive> and so on
21:36:57 <psygnisfive> yes?
21:37:08 <oklopol> yeah
21:37:10 <psygnisfive> ok
21:37:12 <Keymaker> for jumps you need to create the value in memory by using those instructions, then you have to perform the jump somewhere, land to some place where the rings are in same position than where you jumped and where control is on the same ring than it changed to when you jumped, and most likely you need padding there with sequences that don't execute any instructions
21:37:32 <psygnisfive> so then if 0 reverses the direction of movement
21:37:40 <oklopol> yeah
21:37:43 <psygnisfive> you simply do undo all rotates after you do them
21:37:58 <psygnisfive> so that you get back to 0 every time
21:38:04 <psygnisfive> just like a rotary dial phone
21:38:19 <psygnisfive> and your instruction set maps cleanly to a binary string
21:38:29 <oklopol> so basically the interesting part of it is the same as with YABC
21:38:41 <psygnisfive> which means the wheel is nothing more than a gimmick.
21:38:49 <psygnisfive> its nothing interesting, just an obfuscatory mechanism.
21:38:52 <oklopol> you have to generate the jumps from calculations
21:38:52 <tusho> psygnisfive: you're wrong
21:38:54 <tusho> like usual
21:38:54 <psygnisfive> theres nothing new conceptually.
21:38:56 <tusho> :)
21:39:06 -!- lilja has quit ("KVIrc 3.2.0 'Realia'").
21:39:15 <psygnisfive> if keymakers description of how the language works is correct, then im not wrong
21:39:43 <Keymaker> you can read it here explained better: http://www.bigzaphod.org/whirl/
21:39:46 <oklopol> without flow control, yes, it's trivial
21:40:07 <psygnisfive> even assuming that the wheels are absolutely necessary to access the instructions
21:40:12 <psygnisfive> they're still an obfuscatory gimmick
21:40:27 <psygnisfive> because the whole thing just reduces to a complication of your instruction set
21:40:41 <psygnisfive> it introduces nothing fundamentally different in terms of computational perspective
21:40:43 <tusho> no
21:40:45 <tusho> not with jumps, psygnisfive
21:40:48 <oklopol> it's not something you can just remove as a separate step, man
21:41:05 <oklopol> you cannot make a trivial two-way compiler between that and, say, brainfuck
21:41:13 <psygnisfive> im not saying you could
21:41:15 <oklopol> even if you added the necessary shit to brainfuck
21:41:25 <Keymaker> and that wouldn't brainfuck then
21:41:26 <psygnisfive> im simply saying that the wheels seem to be a gimmick and nothing more.
21:41:40 <oklopol> but that it's just another esoteric language, new idea, but not the best ever?
21:41:44 <oklopol> what is your point
21:41:56 <Keymaker> in any case, this 1-to-1 mapping doesn't work with these jumps in whirl
21:42:01 <psygnisfive> my point is that its uninteresting and boring and gimmicky.
21:42:06 <tusho> oklopol: psygnisfive seems to hate anything that isn't a completely and utterly new paradigm which makes everything seem weird.
21:42:15 <tusho> because everything else is boring and gimmicky and YAWWWWWWWWWWWWN
21:42:16 <psygnisfive> its not that tusho
21:42:23 <tusho> really? 'cause it seems that way
21:42:30 <psygnisfive> if you just change brainfucks symbols, is it a new esolang?
21:42:30 <psygnisfive> no.
21:42:37 <psygnisfive> its a pointless gimmicky rehash of brainfuck.
21:42:47 <psygnisfive> whirl isnt brainfuck
21:42:48 <Keymaker> this isn't brainfuck, the instruction set is compeltely different
21:42:55 <psygnisfive> but it is pointless and gimmicky.
21:42:57 <oklopol> psygnisfive: many imperative esolangs are only fun and new in the sense that they are very different to program in, yes
21:43:05 <psygnisfive> anyway im off
21:43:06 <psygnisfive> bye
21:43:18 <tusho> maybe we can actually continue this discussion then, Keymaker :P
21:43:59 <oklopol> i would like to do something in eodermdrome, the problem is i want example programs first
21:44:05 <oklopol> since i'm sure my interp is crooked
21:44:18 <oklopol> and i can't really test my own code
21:44:30 <oklopol> i *can*, but it doesn't feel right
21:46:14 <oklopol> the thing i don't get about the whole everything-is-brainfuck mindset is, most esolangs actually differ a lot more in programming experience than, say, haskell and scheme.
21:46:36 <oklopol> the whole language is usually a completely new challenge by just a change of a few operations
21:46:37 -!- timotiis has quit (Connection timed out).
21:46:49 <Keymaker> yes, definitely
21:47:15 <oklopol> haskell and scheme are very different, but only when you start making something big; who the fuck makes anything big in esolangs anyway :)
21:47:19 <Keymaker> to me only things resembling brainfuck are those languages that are made to just replace brainfuck instructions
21:47:32 <oklopol> yeah
21:47:50 <tusho> yep
21:48:01 <Keymaker> and tusho, what was the discussion?
21:48:07 <Keymaker> :D
21:48:16 <oklopol> the discussion is a lie
21:48:18 <tusho> Keymaker: the one not involving psygnisfive saying how boring whirl was
21:48:40 <Keymaker> ah. so what was said last?
21:50:31 <oklopol> it is true of course that not many languages on the wiki have that "new computational model" feelign
21:50:33 <oklopol> *feeling
21:50:47 <oklopol> except for a few of ais's languages, and some other exceptions
21:51:20 <oklopol> it's been my lifelong dream to invent a computational model
21:51:45 <oklopol> but all the simple ones are already taken, and most things are trivially equivalent to them :<
21:52:03 -!- Corun has joined.
21:52:07 <Keymaker> i think there are many great language out there, but also too many that are purposefully made to be like brainfuck
21:54:02 <tusho> agreed
21:54:18 <AnMaster> night
21:54:51 <oklopol> n82u2
21:56:54 <Keymaker> has anyone ran that collatz program i linked? see if it works any fast
21:57:13 <Keymaker> i tried to make it so
21:58:24 <oklopol> i would have to write a bf interpreter
21:58:41 <oklopol> for some reason i never have one at hand even though i've written like a million of them
21:59:14 <Keymaker> and a million available in the net, so you wouldn't need to write
21:59:54 <oklopol> well yes but i don't like doing that
22:00:32 <oklopol> i'll write one now, a brainfuck interpreter a day is good for the health
22:01:58 <ihope> Invent a new computational model, eh?
22:02:13 <oklopol> well yeah
22:02:19 <ihope> Plain imperative and functional, then rewriting and cellular automata...
22:02:26 -!- calamari has joined.
22:02:59 <ihope> Though it's pretty easy to express all of those as rewriting.
22:03:15 <oklopol> well ef is a somewhat new paradigm, unfortunately you can think of it as a form of declarative programming.
22:03:16 <Keymaker> and isn't it possible as well?
22:03:54 <Keymaker> or well, maybe not. i didn't think enough...
22:03:57 <oklopol> but paradigm isn't exactly a computational model
22:04:15 <oklopol> isn't what possible as well?
22:04:40 <ihope> ef, eh?
22:04:56 * ihope compromises with "eg"
22:05:19 <Keymaker> expressing all the computational models in rewriting. but i was thinking more like implementing, so ignore what i said
22:05:19 <oklopol> ef is my fixed-point language
22:05:37 <oklopol> Keymaker: you can both express and implement, same thing really.
22:06:35 <ihope> Hmm. fix fix, fix (fix fix), fix fix (fix (fix fix)), fix (fix fix) (fix (fix fix)), fix fix (fix (fix fix)) (fix (fix fix))...
22:07:09 <oklopol> ihope: not exactly :)
22:07:16 <ihope> :-)
22:07:25 <oklopol> it's more like functional programming, but you always apply everything infinite times
22:07:43 <oklopol> also there is a quite intelligent pattern matching
22:08:05 <oklopol> so you express everything as finding a normal form
22:08:44 <oklopol> oh, right, the brainfuck
22:10:22 <ihope> Interesting.
22:10:51 <Keymaker> speaking of cellular automata, it isn't really used too much in esolanguages. i have practically never done stuff with it
22:10:55 <ihope> The fix function only takes one argument, of course.
22:11:11 <ihope> Keymaker: that's precisely why we need to create a programming language for cellular automata.
22:11:35 <Keymaker> quite right
22:12:57 <oklopol> ihope: there is no fix function
22:13:22 <Keymaker> easier said than done though... but also more esolanguages based on that could be interesting. i'll have to try something. i have many language plans but for some reason only few ever get done
22:13:22 <oklopol> and it would make no sense to introduce one, although you can implement it as, err, apply
22:15:33 <ihope> Suddenly, I get the idea for a programming language where you can apply any programming language any ordinal number of times...
22:17:42 -!- calamari has quit ("Leaving").
22:21:00 <oklopol> Keymaker: so which was i supposed to test?
22:21:43 <oklopol> found
22:24:57 <oklopol> http://www.vjn.fi/pb/p255422423.txt
22:25:02 <oklopol> hard to say about the speed of this
22:25:26 <oklopol> the numbers show quite fast on my screen, and it's written in python, so i guess it's fast
22:25:41 <oklopol> the extra output is just the number of cycles at different points of evaluation
22:25:45 <oklopol> i made it output @ newline
22:26:02 <Keymaker> ah, ok
22:27:13 <Deewiant> AnMaster: new Mycology's up, has the null-byte test someone (ais?) came up with
22:28:24 <ihope> An analog signal processing programming language would be interesting.
22:28:50 <oklopol> elaborate.
22:29:17 <ihope> I guess electronics is (are?) one of those.
22:30:23 * ihope tries to make a sine wave with DC
22:31:23 <oklopol> i'd say "is" is more used, but both are okay
22:31:32 <oklopol> but you're the native so who cares what i think
22:31:41 <oklopol> have fun
22:33:44 <ihope> :-)
22:34:05 <ihope> We care what you think when you tell us how to use "used to" correctly.
22:35:25 <oklopol> what?
22:35:37 <oklopol> that can mean a lot of things
22:36:55 <oklopol> a vacuum cleaner can be used to get rid of a penis / i used to put my penis in a vacuum cleaner as a kid / i'm used to having my penis sucked by a vacuum, cleaner
22:37:33 <oklopol> "vacuum, cleaner" may not be the best way to write that
22:40:26 <tusho> a vacuum cleaner can be used to get rid of a penis
22:40:27 <tusho> ...
22:40:53 -!- Corun has quit ("This computer has gone to sleep").
22:45:27 <oklopol> yes, tusho, i stand behind my words
22:45:53 <pikhq> Hmm. It appears my circadian rythym is a bit. . . Off.
22:46:15 <pikhq> Breakfast at 11, lunch at 3, dinner at (probably) 8 or 9. . .
22:46:18 <oklopol> happens to the best of us
22:46:34 <oklopol> i had breakfast at 20.00 or something
22:46:52 <tusho> i had breakfast like 10.30
22:46:53 <oklopol> woke up at 14.00
22:47:02 <tusho> lunch about three-five
22:47:09 <tusho> dinner, uhh, very recently
22:47:30 <oklopol> heh, i'm such a story-topper
22:49:25 <Keymaker> good bye. i'll return some day with some new programs
22:49:36 <tusho> Keymaker: aww
22:49:37 <tusho> come in tomorrow!
22:49:39 <tusho> we're fun!
22:49:53 <Keymaker> hah, sorry, i generally hate irc
22:50:01 <tusho> you hate us because we're FUN >:(
22:50:15 <Keymaker> :D
22:50:28 <oklopol> Keymaker: bye
22:50:30 <tusho> we'll teach you the secrets of being fun if you come in tomorrow
22:50:35 <tusho> that's how awesome we are.
22:50:36 <oklopol> well yes, that too.
22:50:37 <tusho> bye. :p
22:50:42 <Keymaker> bye :)
22:50:44 -!- Keymaker has left (?).
22:51:11 <oklopol> eyes are getting tired it seems, SparseGraph -> StereoTypical
22:51:18 <tusho> hahahaha
22:51:30 <oklopol> was a bit wtf to see that in the middle of code.
23:26:09 <psygnisfive> so tell me why jumps make keymakers language nothing more than a gimmick.
23:26:24 <tusho> oh no
23:26:26 <tusho> not this again
23:26:29 <tusho> anyway its not keymakers language
23:26:37 <psygnisfive> whatever
23:26:43 <psygnisfive> tell me how jumps make it not gimmicky.
23:28:54 * tusho rolls eyes
23:29:01 <psygnisfive> thats not an explanation.
23:29:09 <ihope> I suddenly realize I was trying to implement goto in Haskell.
23:29:16 <tusho> ihope: awesome. why.
23:29:17 <oklopol> keymaker's the one who's actually coded in it, so i'd say the onus is on you
23:29:23 <oklopol> psygnisfive
23:29:34 <psygnisfive> i already showed how its gimmicky.
23:29:39 <tusho> no you didn't.
23:29:42 <tusho> you just stated untrue things
23:29:45 <tusho> when we told you they weren't true
23:29:47 <psygnisfive> i did no such thing tusho
23:29:48 <tusho> you stated them again
23:29:53 <ihope> callCC (\cont -> let label = cont label in return label) was what I'd come up with; that's the same as callCC (return . fix).
23:30:01 <oklopol> psygnisfive: why not compile something into it and show us how it's done
23:30:03 <psygnisfive> all you said was that it wasn't gimmicky due to jumps.
23:30:22 <ihope> Oh, I know why.
23:30:30 <psygnisfive> the ring commands are mappable directly and trivially to individual non-ring based instructions.
23:31:11 <tusho> no
23:31:11 <tusho> th
23:31:11 <tusho> ey
23:31:12 <tusho> are
23:31:13 <tusho> not
23:31:16 <psygnisfive> yes, they, are.
23:31:16 <tusho> because
23:31:17 <tusho> they
23:31:17 <tusho> change
23:31:18 <tusho> the
23:31:19 <tusho> offset
23:31:21 <tusho> of
23:31:23 <tusho> jumps
23:31:25 <tusho> so
23:31:27 <tusho> you
23:31:29 <psygnisfive> tusho
23:31:29 <tusho> have
23:31:31 <tusho> to
23:31:32 <psygnisfive> did you read what i just said?
23:31:33 <tusho> think
23:31:36 <tusho> ahead
23:31:37 <tusho> a
23:31:39 <tusho> lot
23:31:41 <tusho> no
23:31:43 <tusho> its
23:31:45 <tusho> not
23:31:47 <tusho> the
23:31:49 <tusho> most
23:31:51 <tusho> imaginative
23:31:53 <tusho> paradigm
23:31:55 <tusho> ever
23:31:57 <tusho> but
23:31:57 <psygnisfive> tusho stop being a child.
23:31:59 <tusho> its
23:32:01 <tusho> marginally
23:32:04 <tusho> interesting
23:32:16 <tusho> so
23:32:16 <tusho> there
23:32:16 <psygnisfive> its not marginally interesting at all.
23:32:16 <tusho> psygnisfive: i just explained why jumps make it non-gimmicky
23:32:16 <tusho> psygnisfive: sorry. next time i'll follow your example and state the same thing over again
23:32:20 * ihope /ignores tusho's one-word-per-lineness
23:32:44 <psygnisfive> where do you see jumps in the spec, btw.
23:33:09 <tusho> psygnisfive: it obviously has control flow
23:33:12 <tusho> or it wouldn't be tc
23:33:22 <psygnisfive> do you mean if? ok. ill look at that.
23:33:29 <oklopol> If If memval is not 0, then add value to program position pointer (see PAdd).
23:33:50 -!- Judofyr has quit.
23:34:29 <oklopol> this is a computed goto, fairly interesting a thing in a tarpit
23:34:36 <oklopol> as it's not trivial to create the offsets
23:34:46 <tusho> exactly
23:34:52 <tusho> the wheel means that the offsets are very hard to calculate
23:34:56 <tusho> along with the fact that it's hard anyway
23:37:23 <oklopol> hmph, why do they call it dijkstra's algo, who hasn't invented that
23:37:42 <tusho> oklopol: names are useful.
23:37:45 <oklopol> i used that when i was like 13
23:37:46 <oklopol> well sure
23:37:47 <tusho> and dijkstra did it first.
23:37:50 <oklopol> but asjdfokajds still :)
23:37:55 <oklopol> yeah, yeah
23:38:09 <tusho> oklopol: remember, you only get these things easily because CS has advanced so much since then
23:38:12 <tusho> back then it wouldn't have been so trivial
23:38:20 <oklopol> i'm not saying it shuold actually be changed, i'm once again just wondering how great it would've been to have been born like 50 years ago.
23:38:31 <tusho> not very
23:38:31 <tusho> :p
23:38:45 <psygnisfive> the only things that modify memval are store, and intio.
23:38:57 <oklopol> i didn't know any cs when i was 13
23:39:03 <oklopol> i knew about arrays
23:39:12 <tusho> oklopol: well yeah but cs has effected programming
23:39:12 <psygnisfive> therefore the only things that can affect the way the if's evaluate are store and intio.
23:39:14 <tusho> affected
23:39:15 <tusho> whatever
23:39:40 <oklopol> tusho: i know i know, that's not the point
23:39:51 <oklopol> i'm just pissed off, i don't actually have a point! :D
23:41:40 <oklopol> psygnisfive: i believe keymaker over you in this issue, unless you actually show a bijection
23:44:20 <ihope> Upon seeing what Dijkstra's algorithm does, I immediately conceived of an algorithm that would do that. Now I'm reading to see if they're the same.
23:45:47 <ihope> Looks like it.
23:52:13 <oklopol> you have a priority queue containing nodes you haven't currently explored yet, and you just iterate: pop the queue, then add all the nodes connected to the popped one into the priority queue updating costs.
23:53:05 <oklopol> because you're always handling the node that, from all nodes that can be accessed right now, is found the "fastest", when it comes to total cost of the path to it, you find the shortest paths
23:53:32 <oklopol> easier to invent than understand, really
23:53:43 <ihope> Have some current nodes, each with a distance assigned to it; take the one with the smallest distance and make all the unvisited nodes next to it current, and make the original one uncurrent.
23:54:18 <psygnisfive> not that this is a proper example, since it doesnt touch on the if construct but
23:54:38 -!- lilja has joined.
23:55:03 <oklopol> ihope: yes
23:55:20 <oklopol> that's it
23:55:48 <psygnisfive> the example from that page, the do 1+1, can be summed up as nothing more than "swap not store add store swap one intio"
23:56:03 -!- calamari has joined.
23:56:24 <psygnisfive> where swap = 00, not = 11111111110000011111111110, store = 1100000110, add = 111000001110, one = 110000010, and intio = 11111111110000011111111110
23:56:26 <oklopol> priority queues are the main point there, though, that's where the interesting comes in
23:56:58 <oklopol> "swap not store add store swap one intio" <<< i don't get this
23:57:07 <oklopol> i'm assuming stack-based
23:57:10 <oklopol> swap errors in my head
23:57:13 <psygnisfive> see above.
23:57:13 <oklopol> intio makes no sense
23:57:15 <oklopol> hmm
23:57:17 <psygnisfive> swap is just shorthand for 00
23:57:23 <oklopol> ah.
23:57:26 <psygnisfive> not is just shorthand for 11111111110000011111111110
23:57:27 <psygnisfive> etc
23:57:30 <oklopol> ah, that kinda swap
23:57:35 <psygnisfive> swap rings
23:57:39 <oklopol> yeah
23:57:40 <psygnisfive> switch, if you want.
23:57:41 <psygnisfive> whatever.
23:57:45 <psygnisfive> it doesnt matter what you call it.
23:57:51 <oklopol> but, err, you just do some operations, that's just about rolling the wheels
23:58:05 <psygnisfive> i know. ill look at control flow in a bit.
23:58:08 <oklopol> as you said, right
23:58:14 <psygnisfive> but just from that its pretty trivial.
23:58:18 <oklopol> sorry, i'm reading bottom-to-top, it seems :P
23:58:26 <oklopol> well yeah, of course
23:58:38 <psygnisfive> i shall look at if in a moment tho.
←2008-07-18 2008-07-19 2008-07-20→ ↑2008 ↑all