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: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: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:41 <tusho> how do you make a usenet group again
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: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: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:56 <oerjan> (it used to the Infinite Featureless Plane of Death, but then the Mythbusters got onto it)
00:56:56 <oerjan> (er, i guess i'm spoiling a lot here)
00:58:23 <oerjan> the alt hierarchy was always less distributed (when i read newsgroups)
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: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: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:37:30 <augur> waffles are so tasty omg
01:38:29 <oerjan> maybe if i put some raspberry jam on this cardboard...
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: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: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:50:31 <oerjan> (not --> coffee as i already got it :) )
01:53:58 -!- Judofyr has quit.
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: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:14 <adu> maybe :exit
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: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:59 -!- GreaseMonkey has joined.
02:05:04 <adu> hi GreaseMonkey
02:05:28 <adu> i want to implement fancy keybindings
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:46 <adu> :P is "Put the text before the cursor [count] times
02:08:03 <oerjan> no, that's P. :P is different
02:08:25 <adu> i need to learn how to use vim :help :p
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:59 <adu> hows the lang going?
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:12:50 <oklopol> i do vaguely recall our talk, but not what the language was
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:36 <oerjan> inquiring minds want to know, and will soon start blowing things up if not
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: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:08 <oklopol> i've only made oklotalk-- in fact
02:23:18 <adu> even better!
02:23:32 <oklopol> http://www.vjn.fi/oklopol/oklotalk--.txt
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: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: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: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:37 <oklopol> so operators are fully symmetric on parameters?
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:32 <oklopol> all operators can take their operands in any order?
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:50 <oerjan> bites would be more in keeping with the bug theme :D
02:29:14 <oklopol> CakeProphet: "byte" does not say anything about semantics really
02:30:07 <CakeProphet> but I don't really feel like treating bytes as short integers for the purposes of having negatives.
02:30:24 <oklopol> well no need for negatives
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:36 <CakeProphet> I was thinking flow control could be implemented in the halting rules.
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: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: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:07 <adu> oklopol: fs?
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:48 <adu> 16bit? 32bit? 64bit? which one? why? why not the others?
02:35:03 <adu> why not 64?
02:35:24 <oklopol> i've never seen any need for anything other than bignum anywhere
02:35:27 <adu> CakeProphet: ya!
02:35:44 <oklopol> i believe in the 0/1/infinity rule
02:35:48 <adu> oklopol: you mean fixnum
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: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:37 <CakeProphet> (oh... and ) is increment, and ( is decrement)
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:41:11 <adu> lol you implemented bf in cise? lol
02:41:41 <oklopol> yes, assuming that's correct
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: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:30 <adu> it also takes in interesting approach to side effects
02:45:52 <adu> you know how in Haskell, print :: a -> IO ()
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: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: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:53:20 <CakeProphet> so that all the little - | > < wires don't get cluttered.
02:54:11 <CakeProphet> oklopol currently wins at interestingness. ;_;
02:55:34 <CakeProphet> I think I'll also a ; operator.... which is "write to a stream and then blocking-read"
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:40 <oklopol> augur: see logs, it took a while to explain :P
02:56:46 <oklopol> that's another possibility
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:58:03 <augur> if you had lips you might be as sexy as oklopol
02:58:15 <augur> i like your hair tho
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: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:15:17 <CakeProphet> I believe I had @ as the thread terminator
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:43 <CakeProphet> but you can't determine when they terminate
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: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:17 -!- augur_ has changed nick to augur.
03:33:21 <oerjan> -3. darn apostrophe again
03:33:46 <adu> noob? no no I'm a boon
03:33:47 -!- augur has changed nick to Guest802.
03:33:55 -!- Guest802 has changed nick to 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:31 <CakeProphet> I enjoy writing Python code that only has like... 2 or 3 conditionals.
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:20 <adu> what are they?
03:37:26 <adu> CakeProphet: ok :)
03:38:05 <CakeProphet> and <<>> will be a list with a depth of -2
03:38:15 <adu> oooooooooooo
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: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:35 <CakeProphet> it just helps to have a solid foundation on tree rewriting
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: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:43:01 <adu> (every(thing (in (lisp (uses (parent))))))
03:43:31 <CakeProphet> so if you have the rule (A (B C) => (B (C A))
03:44:12 <CakeProphet> and an initial state of... ((1 (2 3)) (3 (2 1))
03:44:52 <CakeProphet> after on step you'll get ((2 (1 3)) (2 (3 1)))
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:46:20 <CakeProphet> basically evaluate into positive lists... as I'll explain in a second.
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:52:10 <adu> thats just a map
03:52:12 <CakeProphet> which would then rewrite to being patently FALSE.
03:52:27 <adu> so its like a list that is implicitly mapped over
03:53:13 <CakeProphet> what happens when you have two negative lists...
03:53:25 <adu> its like map . map
03:53:38 <CakeProphet> yeah... it maps all the possible pairs more or less
03:53:57 <adu> so more like the Haskell list monad
03:54:13 <adu> its da bomb
03:54:39 <psygnisfive> cakeprophet: that production from earlier doesnt work.
03:54:54 <oklopol> haskell's list monad is very similar, yes.
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:56:15 <CakeProphet> but I am a still-toying-with-C-like-languages fag.
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:49 <oklopol> adu: that doesn't by any chance calculate primes?
03:57:58 <adu> oklopol: yes it does
03:58:13 <adu> :) its a classic
03:58:53 <oklopol> weird i never thought of doing it like that
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)))
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:48 <oklopol> i did, and it was clearly a typo
04:02:25 <psygnisfive> but the point is, as you stated it, cakeprophet, the production was wrong.
04:02:50 <CakeProphet> psygnisfive: correct. but it still remains to be proven if I care.
04:03:09 <psygnisfive> well you clearly care since you were using it as the basis of your example :P
04:04:02 <oerjan> it would help to be a curate
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: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: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:15 <pikhq> Something of ours hit Digg or something again?
04:07:23 <adu> no, I'm just bored
04:07:42 <adu> I've been here 5 times in the past year
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:20 <adu> pikhq: so what's up
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:40 <pikhq> Well, *I'm* no noob.
04:10:51 <adu> hi pikhq, can I help you today?
04:11:08 <pikhq> I wrote PEBBLE before you were born (you young wippersnappers)! :p
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:39 <oerjan> i should sincerely hope it is bugged
04:13:08 <adu> CakeProphet: is there a reason you use dict() instead of {}?
04:13:34 <oerjan> no, the north koreans and the zimbabweans
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:16:32 <psygnisfive> also, i use textmate which autobalances parens :D
04:16:35 <adu> I think Io is beautiful
04:17:33 <adu> I mean seeing "clone" instead of "new" or "class" just seems right...
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:50 <psygnisfive> also, im never sure how copying works in prototype based languages.
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:33 <CakeProphet> it would be a waste of memory to actually make copies of each function
04:21:28 <CakeProphet> but I think io actually makes clones of everything else.
04:21:42 <adu> psygnisfive: what's your favorite 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:23:37 <CakeProphet> and it uses smalltalk message-pasing syntax, which always looked nice to me.
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: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:25:02 <adu> python for obfuscation?
04:25:14 <CakeProphet> psygnisfive: it always reads weird to me... like "list.each do"
04:25:21 -!- oerjan has quit ("And your little dog too!").
04:25:32 <adu> psygnisfive: I would say Python syntax is simple, Ruby syntax is versitle
04:26:03 <adu> psygnisfive: what's your favorite compiled language?
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: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: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:08 * adu <3 Haskell
04:28:24 <CakeProphet> using the list.each do ... end example again.
04:28:53 <psygnisfive> well, if each were a function it'd be even more like english, yes i agree
04:29:17 <psygnisfive> but its a method. so in that regard it has quantifier ordering reversed.
04:30:08 <CakeProphet> because "each x" would suggest there are mulltiple x's being looped over.
04:30:19 <adu> with (list) for (each) item in it, (do ... end)
04:30:43 <CakeProphet> I think it would make more since if it were a function like each(|dog|, pound, do ... end)
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:44 <CakeProphet> because then the variable name is next to the each... and it makes more sense Englishly.
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:33:02 <CakeProphet> but indentation makes it weird to objectify blocks
04:33:15 <CakeProphet> which is one of the "benefits" (advantages... or whatever) of Ruby.
04:33:47 <CakeProphet> the best English-reading syntax you could do.
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: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: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:50 <adu> CakeProphet: its impossible without a dictionary, because there are no spaces
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:44 <adu> psygnisfive: its ok, perapera == fluent
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:16 <psygnisfive> adu: no, i'm not fluent in japanese at all.
04:37:41 <psygnisfive> cakeprophet: cmon, lets make a language :D
04:38:14 <CakeProphet> to me... Perl's one-line control flow statements
04:38:27 <psygnisfive> i wanna make a language that has implicit ability to understand quantified nouns
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: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:40:07 <psygnisfive> double as a function would be taking as its argument a quantified noun
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:33 <CakeProphet> well... if you had it so that each item in integer implicitly received all messages
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:42:04 <psygnisfive> but thats your problem to name things correctly :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:50:20 <psygnisfive> well ive already got ideas about using predicate functions that are flagged as such
04:51:05 <CakeProphet> in which case each works a lot like implicit mapping.
04:51:30 <CakeProphet> so in a traditional programming language... if each were a keyword
04:52:06 <psygnisfive> oh, no, i was thinking each would be some sort of function that produces a quantified expression.
04:52:24 <psygnisfive> granted, the sum total of it being quantified would simple be JUST (each integer) :p
04:52:42 <CakeProphet> thanks for the chat... think about it some more and see if you can make sense of it.
04:53:44 -!- adu has quit.
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:59 <tusho> i've never read a non-alt. group
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: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:47 <tusho> It uses its own code generator nowadays.
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: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: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: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:59 <tusho> they're indentical
12:35:19 <tusho> dict(a=2, b=3) is {'a':2, 'b':3}
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: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:42 <tusho> bit of a weird translation, but makes sense when the negative list has more stuff in
12:47:49 <tusho> ((a b c e) (a b d e))
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:52 <oklopol> the problem is, the negative lists are all kinda rewritten at the same time on one level, with the current semantics.
12:49:00 <oklopol> so there may be some problems
12:49:01 <tusho> but (a b <> e) -> ()
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: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:33 <tusho> and then you just embed it in another list
12:57:05 <oklopol> but it makes negatives impure!
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: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:20 <oklopol> the semantics are already definitely impure for stuff like <<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
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:27:04 -!- ihope has joined.
15:52:56 <tusho> AnMaster: it's saturday.
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: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: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: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: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:23:00 <pikhq> "Could not create temporary file."
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: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
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: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: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:23:13 <psygnisfive> hence the reasoning that (1 2 <> 3) would evaluate to () since the neglist has the same length as ()
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:34 <tusho> there's some nuances, but that's the basic idea
18:25:38 <tusho> and since <> is 'no choices'
18:26:16 <tusho> psygnisfive: does that make sense?
18:29:52 <psygnisfive> that was my first assumption but it does fail with <>
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:39:24 <tusho> people://oklopol/mind/nopol/neglists
18:39:57 <AnMaster> <tusho> (1 2 <3 4> 5) -> (For each thing in (3 4), (1 2 thing 5))
18:40:10 <AnMaster> that is basically (3|4) in a regex?
18:40:15 <tusho> .........................................
18:40:33 <AnMaster> being expanded instead to all posibilities
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:41 <tusho> also, you'll need a bit of a functional programming mind to grasp it.
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:46:48 <psygnisfive> just because various people get them doesnt mean that they make sense
18:47:08 <tusho> psygnisfive: so we're all hallucinating?
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: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:35 <tusho> objectively, they 'make sense'
18:48:42 <tusho> because they are specifiable
18:48:49 <tusho> subjectively, no, they don't ;)
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:52 <tusho> theoretically it can be taken as a spec for a TC language
18:49:55 <tusho> but in practice, well..
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: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: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:04 <tusho> NEGATIVE AMICED is a negative amount of bits
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: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:48 <tusho> it basically ends up as a computer simulation of the described drinking game
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:28 <tusho> they're not easy to explain
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: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:33 <tusho> it jumps up a level before doing every possibility
19:49:13 -!- Slereah__ has joined.
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:56:10 <psygnisfive> i would like to see formal rules for doing negative lists
20:07:30 -!- timotiis has joined.
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: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:32 <oklopol> basically, i have separate rules for when a negative list contains a singleton negative list
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:16:00 <psygnisfive> and that rule has a higher precedence than (... neg-list...)
20:16:38 <oklopol> tusho may not have known about such a rule
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:12 <tusho> psygnisfive: except they make the list they're in turn into a list of all possibilities
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:18:22 <oklopol> it's not equivalent to that
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:54 <oklopol> nothing, you can't have negative lists without something surrounding them
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:59 <oklopol> psygnisfive: well indeed, the actual exception is when you have <neglist>
20:22:50 <oklopol> first would fail, i think, latter would be triv
20:23:25 <oklopol> psygnisfive: basically, that you jump two levels up
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:35 <oklopol> you remove <<e f g>> from there
20:24:46 <tusho> it makes sense psygnisfive
20:24:52 <oklopol> and call the list lambda for each elem
20:24:53 <tusho> it cycles the choices
20:24:56 <tusho> in the topmost list
20:25:00 <tusho> <<...>> does it two levels up
20:25:11 <tusho> isn't that fairly simple?
20:25:27 <psygnisfive> you're fucking up the signal to noise ratio.
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: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: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: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:29:37 <psygnisfive> (list a (neg-list b c) d) => '(a <b c> d) => '((a b d) (a c d))
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: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: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:34 <tusho> i just wanted you to have to explain it
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: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:30 <tusho> (a) = 1 depth. ((a)) = 2 depth.
20:49:36 <tusho> these are negative depth
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: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:45 -!- tusho has joined.
20:55:57 <psygnisfive> the formal specification for them isnt that hard either
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: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: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: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:59 <oklopol> no one's blaming you for not grasping it from that
21:07:02 <oklopol> psygnisfive: its not confusing! you just dont get it! <<< err what?
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: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:38 <tusho> On another topic, hi Keymaker
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:55 <psygnisfive> am i the only one who thought that the keymakers accent was way to fucking weird?
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:32 <oklopol> Keymaker: i'm assuming that was by hand
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:34 <oklopol> eodermdrome doesn't have examples, no
21:16:44 <oklopol> been trying to get ais523 to write some
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:22 <Keymaker> and each has different instructions, a few same, but essentially different
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:52 <Keymaker> ah. first i created code snippets for memory storing (both 61 bytes)
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:23:09 <psygnisfive> coming from a guy who wrote a quine in whirl. :p
21:23:24 <oklopol> psygnisfive: stop being like that
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: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: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:42 <Keymaker> (and anyways, my esoteric work is useful to me)
21:29:50 <psygnisfive> does it just become Brainfuck? a funge? a whatever?
21:30:02 <oklopol> it's not a syntactic substitution kid
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:29 <oklopol> i'm pretty sure it becomes fundamentally different to program in with jumps
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: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:41 <psygnisfive> etc etc to get from one instruction to the next
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: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: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: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: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:43 <psygnisfive> you simply do undo all rotates after you do them
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: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: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: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: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: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: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:37 <psygnisfive> its a pointless gimmicky rehash of brainfuck.
21:42:48 <Keymaker> this isn't brainfuck, the instruction set is compeltely different
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: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: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:48:01 <Keymaker> and tusho, what was the discussion?
21:48:18 <tusho> Keymaker: the one not involving psygnisfive saying how boring whirl was
21:50:31 <oklopol> it is true of course that not many languages on the wiki have that "new computational model" feelign
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:56:54 <Keymaker> has anyone ran that collatz program i linked? see if it works any fast
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: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: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: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: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: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: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: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: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:34:05 <ihope> We care what you think when you tell us how to use "used to" correctly.
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: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:34 <oklopol> i had breakfast at 20.00 or something
22:46:52 <tusho> i had breakfast like 10.30
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:53 <Keymaker> hah, sorry, i generally hate irc
22:50:01 <tusho> you hate us because we're FUN >:(
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:44 -!- Keymaker has left (?).
22:51:11 <oklopol> eyes are getting tired it seems, SparseGraph -> StereoTypical
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:29 <tusho> anyway its not keymakers language
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:42 <tusho> you just stated untrue things
23:29:45 <tusho> when we told you they weren't true
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:30 <psygnisfive> the ring commands are mappable directly and trivially to individual non-ring based instructions.
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:33:09 <tusho> psygnisfive: it obviously has control flow
23:33:12 <tusho> or it wouldn't be tc
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: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:47 <tusho> and dijkstra did it first.
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: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: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: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: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: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:26 <psygnisfive> not is just shorthand for 11111111110000011111111110
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:18 <oklopol> sorry, i'm reading bottom-to-top, it seems :P