←2008-06-09 2008-06-10 2008-06-11→ ↑2008 ↑all
00:03:00 -!- TheCorun has changed nick to Corun.
00:04:48 -!- AnMaster has quit ("ERC Version 5.3 (IRC client for Emacs)").
00:06:14 -!- atsampson has quit (Read error: 113 (No route to host)).
00:08:08 -!- atsampson has joined.
00:50:34 <Slereah> I should really whip up that XKCD language
00:51:06 <tusho> Slereah: what
00:51:43 <lament> http://en.wikipedia.org/wiki/Electroencephalophone
00:51:59 <Slereah> tusho : Don't you remember?
00:52:08 <tusho> Slereah: No
00:52:20 <Slereah> The language with Ackerman, inverse Ackermann, McCarthy 91 and the Look and Say function.
00:52:27 <Slereah> Or something.
00:52:43 <tusho> lament: I want one.
00:52:50 <tusho> Slereah: What's that got to do with xkcd
00:53:08 <Slereah> http://xkcd.com/207/
00:53:40 <tusho> Well yes.
00:53:42 <tusho> The xkcd number.
00:56:45 <Slereah> I wonder if I could write something useful with that
00:57:32 <Slereah> Well, it would have a way to do ++ and --, and some sort of conditional, so I suppose so.
00:57:39 <tusho> Slereah: Loops?
00:57:56 <Slereah> Well, you can define functions in it
00:58:08 <Slereah> At least that's the idea so far
00:58:16 <Slereah> If you have a sillier one, do tell.
01:03:13 <Slereah> Is a > b (> a b) in Scheme?
01:03:50 <tusho> Slereah: Yah.
01:06:46 <Slereah> Ah shit
01:06:51 <Slereah> My Ackermann no work
01:06:55 <tusho> Slereah: Show it.
01:07:02 <Slereah> (define (A m n) (cond ((= m 0) (+ 1 n))((> m 0)(cond ((= n 0) (A (- m 1) 1)) (> n 0) (A (- m 1) (A m (- n 1)))))))
01:07:11 <tusho> Slereah: lern2indent
01:07:16 <Slereah> :(((
01:07:17 <tusho> also
01:07:19 <tusho> why are you nesting conds
01:07:26 <tusho> the whole point of cond is that it supports arbitary amounts of forms
01:07:29 <Slereah> Because conds are AWESOMe
01:07:43 <Slereah> Oh, I remember
01:07:51 <Slereah> I didn't want to use and in it
01:07:56 <tusho> What you have their there can trivially be expressed by a nested if
01:08:05 <tusho> (if (= m 0) ... (if (= n 0) ...))
01:08:20 <tusho> Making code unreadable because 'conds are AWESOMe' = silly
01:12:02 <oklofok> conds are so awesome
01:12:09 <oklofok> Slereah: add a few more pls
01:12:42 <Slereah> (define (A m n) (if (= m 0) (+ 1 n) (if (= n 0) (A (- m 1) 1) (A (- m 1) (A m (- n 1))))))
01:12:46 <Slereah> Seems to woik.
01:14:15 <oklofok> well it's a syntactic conversion
01:14:31 <oklofok> from math
01:15:41 <Slereah> That's what I thought of my first version!
01:16:27 <oklofok> the more confusing the better
01:16:33 <oklofok> so people don't try to ready your code
01:16:37 <oklofok> *read
01:16:38 <oklofok> also ready
01:16:50 <ihope> I like it when people ready my code.
01:17:02 <ihope> It's always good to have ready code.
01:17:21 <ihope> I'd like it even more if I could ready other people's code, of course.
01:17:32 <oklofok> if someone finishes my code, i might as well not even have contributed
01:17:39 <oklofok> it's no one's work then
01:22:46 <Slereah> Here be inverse Ackermann : (define (a n) (define (a2 x) (if (= n (A x x)) x (a2 (+ x 1)))) (a2 0) ) :D
01:22:50 <Slereah> And it works
01:22:53 <Slereah> I are happy.
01:24:20 <oklofok> it doesn't work
01:24:46 <oklofok> you need to traverse the cartesian product (Int, Int)
01:24:49 <oklofok> A is binary
01:25:18 <Slereah> (define (a n) (define (a2 x) (if (= n (A x x)) x (a2 (+ x 1)))) (a2 0))
01:25:21 <Slereah> Parenthesis problem
01:25:47 <oklofok> what did you change?
01:25:59 <Slereah> I forgot
01:26:03 <Slereah> But it works here.
01:26:18 <oklofok> what's (a (A 1 2))
01:26:30 <oklofok> is it (list 1 2)?
01:26:44 <tusho> no
01:26:51 <tusho> uh
01:26:52 <tusho> maybe
01:27:05 <Slereah> a is inverse Ackermann.
01:27:09 <oklofok> correct answer afaik: it should be, but it isn't
01:27:26 <Slereah> Well, it doesn't work for all value
01:27:27 <oklofok> Slereah: for A(a,b) where a=b
01:27:33 <oklofok> not for generic A
01:27:39 <Slereah> I know
01:27:44 <oklofok> you need to traverse the cartesian product (Int, Int), because A is binary
01:27:46 <Slereah> That's inverse Ackermann.
01:27:51 <oklofok> is that so
01:27:56 <oklofok> it's an actual function?
01:27:58 <Slereah> Well, according to Wikipedia
01:28:08 <oklofok> ah, okay, i assumed it was... well, inverse ackermann
01:28:12 <Slereah> There's another inverse Ackermann, but it looks like a pain in the ass.
01:28:21 <Slereah> http://upload.wikimedia.org/math/a/d/9/ad9f370fbae7057bc3c62c50624a40ea.png
01:28:43 <oklofok> hmm
01:28:57 <tusho> I like function pairs (f,g) where you can have f(g(a,b,c)) = (a,b,c)
01:29:09 <tusho> I call them Ctrl-Zable.
01:29:17 <ihope> Square roots of unity.
01:29:30 <oklofok> hmm
01:29:47 -!- puzzlet has quit ("leaving").
01:30:01 <oklofok> wtf, if ackermann is the binary A(m,n), why is the inverse ackermann the inverse of f(n) = A(n,n)?
01:30:28 <Slereah> Because otherwise, it wouldn't be a function
01:30:31 <Slereah> It would be a graph.
01:30:42 -!- puzzlet has joined.
01:30:54 <oklofok> because a function can't return a tuple?
01:31:03 <Slereah> Because A(1,0) = A(0,1)
01:31:26 <ihope> It wouldn't even be a function.
01:31:26 <oklofok> right, so it doesn't have an inverse
01:31:43 <Slereah> Well, it has an inverse. But not in function form.
01:31:49 <oklofok> yeah
01:31:59 <oklofok> so why is its inverse the inverse of a different function
01:32:02 <oklofok> all i was wondering
01:32:26 <Slereah> Well, I suppose because it was the easiest way to make something that's sort of the inverse
01:32:27 <tusho> [01:29] <tusho> I like function pairs (f,g) where you can have f(g(a,b,c)) = (a,b,c)
01:32:29 <tusho> Anyone have some neat ones?
01:32:37 <oklofok> identity!
01:32:39 <Slereah> Like the square root is the inverse for the square on 0+
01:32:42 <tusho> Actually, I think I'll call them Recoverable instead.
01:32:44 <tusho> oklofok: Well, yeah.
01:32:49 <tusho> (id,id) is a Recoverable.
01:33:23 <oklofok> Slereah: not a good analogy
01:33:36 <Slereah> Actually, it is
01:33:43 <oklofok> that's like saying "the inverse of ackermann for which m is as small as possible"
01:33:45 <Slereah> It's an inverse function on a restriction of the original function
01:33:49 <oklofok> is the inverse of ackermann
01:33:55 <oklofok> which i would be fine with
01:33:58 <Slereah> Such that the restriction is a bijection
01:34:12 <oklofok> hmm
01:34:23 <oklofok> okay, you make sense
01:34:43 <tusho> Ooh.
01:34:48 <tusho> (reverse,reverse) is another pair.
01:34:56 <tusho> reverse(reverse(a) = a
01:34:58 <tusho> reverse(reverse(a)) = a
01:35:10 <oklofok> tusho: (permutation, permutation^-1)
01:35:12 <Slereah> So my idea for look and say is this : L(n,m) -> Look and say of the string n (in decimal) at step m.
01:35:36 <Slereah> But I'm not sure how to proceed. Should I turn n to a string to operate on it?
01:35:48 <tusho> Slereah: Yes
01:35:49 <Slereah> And if so, how the hell does that work in Scheme.
01:35:50 <tusho> Or..
01:35:55 <tusho> Just use divide and modulo
01:35:59 <tusho> To extract the digits
01:36:12 <Slereah> Yeah, it's another possibility
01:36:18 <Slereah> Which one would be easier in scheme?
01:36:25 <oklofok> it doesn't make much sense to use bignums for the strings
01:36:27 <oklofok> *string
01:36:35 <oklofok> use a string or a list
01:36:35 <tusho> Slereah: divmod
01:36:37 <Slereah> Because the string thing would totally fly by in Python
01:36:44 <tusho> oklofok: It's not a string, it's a number
01:36:46 <Slereah> But in Scheme, I dunno
01:36:47 <tusho> Slereah: Do divmod.
01:36:49 <tusho> It's more elegant.
01:36:54 <Slereah> I'm so confused!
01:37:00 <Slereah> Which one should I believe!
01:37:26 <oklofok> tusho: it's a string, you just insert numbers into it as their n-base for
01:37:28 <oklofok> *form
01:37:43 <oklofok> it's clearly a cellular automaton
01:38:05 <Slereah> Good idea. I'll make a game of life in Scheme and go from there.
01:38:06 <tusho> Slereah: DIVMOD
01:38:20 <Slereah> I dunno. It's true that it would grow very quickly.
01:38:27 <Slereah> How big can Scheme handle?
01:38:36 <oklofok> very big, that's not the issue
01:38:39 <lament> do game of life in the type system
01:38:47 <oklofok> it's just it has nothing to do with numbers, that's a bad representation
01:38:47 <lament> ...in Scheme
01:39:14 <oklofok> i agree with lament actually
01:39:17 <Slereah> oklofok : Except the language in question would only take numbers
01:39:18 <tusho> lament: lol
01:39:28 <tusho> Slereah: scheme can do numbers
01:39:31 <tusho> as big as your memory will allow
01:39:33 <tusho> (bignums)
01:39:35 <Slereah> And the look and say would return numbers
01:39:41 <tusho> oklofok: it has plenty to do with number
01:39:42 <tusho> s
01:39:45 <tusho> that's what the look and say is
01:40:37 <oklofok> well it's a moot point to argue what's the most sensible way to store it
01:40:43 <oklofok> but string / list is the easy way
01:40:47 <tusho> no
01:40:48 <tusho> its not
01:40:52 <oklofok> is too
01:40:53 <tusho> divmod will be easier in scheme
01:41:17 <oklofok> k
01:41:26 <Slereah> What does divmod return, a pair <div,mod>?
01:41:44 <tusho> Slereah: dunno if scheme actually HAS divmod
01:41:48 <tusho> but just use /, and modulo
01:41:50 <tusho> seperately
01:41:51 <Slereah> Oh.
01:42:40 <oklofok> (define (divmod a b) ((/ a b) . (modulo a b))) shouldn't be that hard to make yourself if you want it
01:42:46 <oklofok> )
01:42:50 <Slereah> *cons
01:42:55 <oklofok> *not )
01:42:57 <tusho> that won't work oklofok
01:43:08 <oklofok> i know
01:43:13 <tusho> that tries to execute
01:43:16 <oklofok> i know
01:43:18 <tusho> ((/ a b) modulo a b)
01:43:30 <tusho> (define (divmod a b) (cons (/ a b) (modulo a b))
01:43:31 <tusho> or better:
01:43:35 <tusho> (define (divmod a b) (list (/ a b) (modulo a b))
01:43:37 <oklofok> well no, it tries to execute ((/ a b) . modulo a b)
01:44:22 <tusho> oklofok: wrong
01:44:24 <tusho> oh
01:44:28 <tusho> no
01:44:29 <tusho> wrong
01:44:39 <tusho> oklofok: ((/ a b) . (modulo a b)) is ((/ a b) modulo a b)
01:44:45 <tusho> (a . b c) makes no sense
01:44:48 <tusho> (EXPR . EXPR)
01:44:51 <tusho> err
01:44:52 <tusho> (EXPR+ . EXPR)
01:45:12 <oklofok> i thought (a b) == (a . (b . nil))
01:45:26 <tusho> yes
01:45:34 <tusho> (modulo a b) = (modulo . (a . (b . ())))
01:45:38 <tusho> so
01:45:41 <tusho> ((/ a b) . that)
01:45:41 <tusho> is
01:45:46 <tusho> ((/ a b) modulo a b)
01:46:15 <Slereah> Is there a way to convert numbers to lists?
01:46:29 <Slereah> Or possibly number->string->list
01:46:50 <oklofok> i thought ((/ a b) (modulo a b)) = ((/ a b) . ((modulo a b) . nil)) and ((/ a b) . (modulo a b)) = ...well what it is
01:46:53 <tusho> Slereah: Ssh.
01:46:54 <tusho> Use divmod.
01:47:00 <tusho> oklofok: it's not ((/ a b) (modulo a b))
01:47:04 <tusho> it's ((/ a b) . (modulo a b))
01:47:13 <tusho> which is
01:47:19 <tusho> ((/ a b) . (modulo . (a . (b . ()))))
01:47:23 <oklofok> ah
01:47:24 <tusho> ergo
01:47:26 <Slereah> Divmod seems like trubba
01:47:28 <oklofok> now i see what the problem is
01:47:31 <tusho> ((/ a b) modulo a b)
01:47:35 <tusho> Slereah: No. It doesn't.
01:47:42 <oklofok> ((/ a b) modulo a b) <<< read this as ((/ a b) (modulo a b))
01:47:43 <tusho> How can you even say that if you don't know scheme?
01:47:48 <tusho> oklofok: ah
01:48:05 <oklofok> and thought i'd forgotten the parens in my copy paste :D
01:48:14 <oklofok> which was kinda stupid
01:48:20 <oklofok> because it was... copy paste
01:50:50 -!- puzzlet has quit (Remote closed the connection).
01:50:54 -!- puzzlet has joined.
01:51:09 <oklofok> yay i has drscheme
01:51:37 <Slereah> I has it too
01:51:42 <Slereah> Let's be Scheme friends.
01:51:46 <oklofok> ::)
01:51:47 <oklofok> let's
01:52:00 <oklofok> nah, i was thinking owning you @ look-and-say
01:52:08 <oklofok> not that i remember anything about scheme anymore
01:52:22 <Slereah> Heh.
01:52:31 <Slereah> It's like a gayer Lisp
01:55:05 <oklofok> when on a line, how do i get it to jump on the ...current line?
01:55:06 <oklofok> i mean
01:55:12 <oklofok> when i want to retry a statement
01:55:19 <Slereah> What?
01:55:22 <oklofok> there was a keyboard trick
01:55:23 <oklofok> like
01:55:26 <oklofok> if i do
01:55:27 <oklofok> 7
01:55:32 <oklofok> and it says 7
01:55:38 <oklofok> but i wanna try that again
01:55:42 <oklofok> so i go to the 7
01:55:44 <oklofok> press X
01:55:45 <tusho> bye for today :)
01:55:49 -!- tusho has quit ("This computer has gone to sleep").
01:55:55 <oklofok> and the 7 is on the downmost line
01:56:14 <oklofok> hard to explain, it seems :)
02:00:14 <oklofok> what was cond's default thingie?
02:00:52 <Slereah> Wot?
02:01:29 <oklofok> sorry, i'm not able to communicate today
02:01:37 <oklofok> the default case of cond
02:01:51 <Slereah> You mean syntax mehby?
02:02:19 <oklofok> (cond ((= a 0) 0) (default + a 1)))
02:02:22 <oklofok> asd
02:02:29 <oklofok> i have some issues atm
02:02:34 <oklofok> (cond ((= a 0) 0) (default (+ a 1))))
02:02:53 <oklofok> still wrong, but readable already
02:03:04 <Slereah> Well, anything that doesn't evaluate to #f is considered true
02:03:26 <Slereah> So if a isn't 0, it will be a+1
02:03:40 <oklofok> well yeah syntax mehby
02:03:43 <Slereah> If a isn't 0 and default is #f, it will evaluate to undefined
02:04:04 <oklofok> what am i supposed to use
02:04:14 <Slereah> For what
02:04:21 <oklofok> i can use #t, i just recall there was a standard practise
02:04:22 <oklofok> but nm
02:04:37 <Slereah> Well, as said, you can use anything.
02:04:48 <oklofok> yes yes
02:13:10 <oklofok> okay
02:13:14 <oklofok> esc + p
02:13:19 <oklofok> that was hard
02:28:02 <oklofok> okay, one
02:28:03 <oklofok> *done
02:28:53 <oklofok> used pretty much all that time to search for certain functions i ended up making myself
02:29:42 <oklofok> Slereah: here's the code if you wanna peek: http://www.vjn.fi/pb/p625132161.txt
02:30:07 <oklofok> a good deed a day
02:30:33 <oklofok> owning a less experienced programmer is the best, nothing tops the feeling
02:30:46 <oklofok> Slereah: you there?
02:31:22 <Slereah> No
02:31:27 <Slereah> I'm on the moon.
02:31:46 <oklofok> ah, nm then
02:32:01 <oklofok> give me more codables
02:32:03 <oklofok> i wanna code
02:32:06 <oklofok> random shit
02:32:08 <oklofok> in scheme
02:32:54 <Slereah> oklofok : Do a function that will find out if a function terminates.
02:34:28 <oklofok> i don't feel like it
02:34:59 <Slereah> Where you HALTED in finding the solution to that PROBLEM?
02:35:01 <Slereah> WINK WINK
02:36:11 <oklofok> :DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
02:36:20 <Slereah> How subtle.
02:36:37 <oklofok> :DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
02:36:40 <oklofok> cockwoffles
02:36:58 <oklofok> codables
02:36:58 <oklofok> gimme
02:37:01 <oklofok> codables
02:37:22 <Slereah> Write a function that will find if two lambda expressions are identical
02:37:40 <Slereah> Or write a Lazy Bird interpreter, I dunno
02:37:56 <oklofok> interps need all that parsing hassle
02:38:03 <oklofok> which requires thought
02:38:14 <oklofok> parsing is the greatest mental task i know
02:38:17 <Slereah> Write a function that will give you the sum of two numbers
02:38:19 <oklofok> i mean hardest
02:38:24 <oklofok> okay!
02:39:05 <Slereah> I suggest the following procedure : convert the numbers into Church numerals
02:39:18 <Slereah> Use the successor operator by recursion
02:39:36 <Slereah> Then, use another function that will convert back to numbers.
02:39:56 <oklofok> alright, i'll be doing that
02:40:04 <oklofok> hmm
02:40:23 <Slereah> The easiest way for addition!
02:43:51 <Slereah> Or maybe
02:44:09 <Slereah> Maybe you could do it with the a + 0 = a, a + s(b) = s(a+b)
02:44:14 <oklofok> okay, it seems i remembered churches a bit wrong
02:44:14 <Slereah> But instead of numbers
02:44:19 <oklofok> but i've got them now
02:44:28 <Slereah> You use Von Neumann ordinals
02:49:24 <oklofok> okay, i have the conversions now
02:53:57 <oklofok> http://www.vjn.fi/pb/p623225644.txt
02:53:59 <oklofok> next, please
02:54:30 <Slereah> Cure cancer.
02:54:40 <oklofok> pass!
02:54:52 <Slereah> Cure the halting problem
02:55:04 <Slereah> MY BODY IS HALTING, I DON'T KNOW WHAT TO DO!
02:55:46 * oklofok passes Slereah a monad
02:56:10 <Slereah> Are you trying to kill me?
02:57:49 <oklofok> yes
02:58:01 <oklofok> because you're not providing me codables!
02:59:26 <Slereah> Code something to convert a graph into another graph, using an active part and all that shit
03:31:23 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:36:58 -!- boily has joined.
03:40:27 -!- boily has quit (Client Quit).
03:46:37 <augur> codables?
03:46:42 <augur> dables and codables?
03:47:05 <augur> nversions and converions of graphs and cographs
03:48:00 <augur> i say, we should develop a programming language that's based either off the mad ramblings of the hybrids from BSG or something thats cylon-ish
03:49:15 <oklofok> let's do both
03:50:56 <augur> we'll call the first one Hybrid, and the second one .. ??
03:52:38 <oklofok> cylon
03:52:38 <oklofok> did i win?
03:56:06 -!- Corun has quit (Read error: 110 (Connection timed out)).
03:56:39 <oklofok> okokokokokokokokokokokoko
03:56:39 <oklofok> hmmhmm, wonder if i should actually do something
04:26:00 -!- oklofok has quit (Read error: 104 (Connection reset by peer)).
04:26:31 -!- oklopol has joined.
04:48:46 -!- puzzlet_ has joined.
04:57:27 -!- augur has changed nick to SecretRoadRunner.
04:57:43 -!- SecretRoadRunner has changed nick to augur.
04:59:31 -!- augur has changed nick to psygnisfive.
05:00:10 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
05:04:43 <psygnisfive> o.o
05:04:45 <psygnisfive> no not cylon :P
05:12:43 <psygnisfive> so im really getting into the idea of reactive programming
05:13:12 <oklopol> coooool
05:13:30 <psygnisfive> i wanna create a reactive language
05:14:38 <psygnisfive> dude in javascript try to envision how many lines of code it'd require to do something like make some element el track the mouse, right?
05:14:41 <psygnisfive> you'd need something like
05:15:14 <psygnisfive> document.onmousemove = function(ev){
05:15:15 <psygnisfive> el.x = ev.mouse.x;
05:15:16 <psygnisfive> el.y = ev.mouse.y;
05:15:18 <psygnisfive> }
05:15:21 <psygnisfive> or something like that
05:15:36 <psygnisfive> well why not just have a global mouse object, and be able to do something like
05:15:53 <psygnisfive> mouse.x -> el.x
05:15:53 <psygnisfive> mouse.y -> el.y
05:16:16 <psygnisfive> or event something like just mouse.x, mouse.y -> el.x, el.y
05:16:38 <psygnisfive> or my personal favorite, since i love queer shit like this
05:16:44 <psygnisfive> mouse.(x,y) -> el.(x,y)
05:17:06 <oklopol> i love that too
05:17:10 <psygnisfive> and thats it. none of this onmousemove blah blah blah
05:17:13 <oklopol> mouse -> el tho.
05:17:16 <oklopol> hmm
05:17:18 <psygnisfive> well
05:17:20 <oklopol> noooooooooooo
05:17:21 <oklopol> i know
05:17:25 <psygnisfive> that would push the value of mouse into el
05:17:36 <psygnisfive> making el just another name for mouse
05:17:52 <psygnisfive> and we're assuming el is some page element
05:17:52 <oklopol> i knooooooooooow
05:18:19 <psygnisfive> :p
05:19:04 <psygnisfive> dude ok
05:19:10 <psygnisfive> so since we'd have decompositions like that
05:19:12 <psygnisfive> where stuff like
05:19:18 <psygnisfive> a, b -> c, d
05:19:28 <psygnisfive> the _entire_ program could be written with a single ->
05:19:48 <oklopol> a single one oh god now tell me more
05:19:53 <psygnisfive> :)
05:19:59 <oklopol> :D
05:20:01 <oklopol> god i'm tired.
05:20:02 <psygnisfive> kind of getting into esoteric territory now aint we
05:20:03 <psygnisfive> :X
05:20:17 <oklopol> hmm, what do you mean you can do it with a single ->?
05:20:18 <psygnisfive> ofcourse the interpreter would just decompose it into multiple ->s
05:20:22 <psygnisfive> well
05:20:24 <psygnisfive> since we allow this:
05:20:33 <psygnisfive> a, b -> c, d
05:20:38 <psygnisfive> to be an abbreviation for
05:20:41 <psygnisfive> a -> c
05:20:43 <psygnisfive> b -> d
05:20:58 <psygnisfive> ALL such pairings could be folded into a single ->
05:21:03 <psygnisfive> so if you have a hundred of them
05:21:08 <psygnisfive> you'd just have one ->
05:21:36 <psygnisfive> a, b, c, d, ... -> a', b', c', d', ...
05:21:38 <psygnisfive> instead of
05:21:41 <psygnisfive> a -> a'
05:21:42 <psygnisfive> b -> b'
05:21:44 <psygnisfive> c -> c'
05:21:47 <psygnisfive> d -> d'
05:21:47 <psygnisfive> ...
05:22:04 <oklopol> right, right
05:22:17 <psygnisfive> add into that the fact that you can do stuff like
05:22:33 <psygnisfive> obj.(prop1, prop2) -> obj2.(prop1, prop2)
05:22:35 <psygnisfive> in place of
05:22:40 <psygnisfive> obj.prop1 -> obj2.prop1
05:22:45 <psygnisfive> obj.prop2 -> obj2.prop2
05:22:51 <psygnisfive> and you can get really confusing code
05:23:28 <psygnisfive> mouse.(x,y), 0.5*mouse.(x,y) -> el.(x,y), el.(width,height)
05:23:34 <psygnisfive> or something silly like that
05:23:41 <psygnisfive> but with _all_ the relationships
05:23:59 <psygnisfive> it's a trivial thing to decompose back into readable form, mind you
05:23:59 <psygnisfive> but
05:24:04 <psygnisfive> oooh how about this too:
05:24:15 <psygnisfive> x -> -y is permissable
05:24:24 <psygnisfive> setting x to 1 sets y to -1
05:24:28 <psygnisfive> and so on
05:24:29 <psygnisfive> ey?
05:24:38 <psygnisfive> x -> sqrt(y)
05:24:49 <oklopol> cool declarativity
05:24:52 <psygnisfive> yeah
05:24:52 <psygnisfive> :o
05:24:54 <psygnisfive> well
05:24:55 <psygnisfive> sort of
05:24:57 <oklopol> so cool.
05:25:09 <psygnisfive> i figure the way it might work easily is by just inverting it
05:25:13 <psygnisfive> if x -> sqrt(y)
05:25:16 <psygnisfive> and 5 -> x
05:25:35 <psygnisfive> then 5 -> sqrt(y) so invert it to get 5*5 -> y
05:25:38 <psygnisfive> but ooh what about like
05:25:46 <psygnisfive> sqrt(25) -> y
05:25:50 <oklopol> inversion is basically declarativity
05:25:52 <psygnisfive> would y be a pair? i think so.
05:26:01 <psygnisfive> declarative reactance! :o
05:26:34 <psygnisfive> hm
05:26:37 <psygnisfive> what else should we have
05:30:58 <psygnisfive> how about implicit understanding of multiple values?
05:30:59 <psygnisfive> so like
05:31:07 <psygnisfive> if we said something like x -> y*y
05:31:10 <psygnisfive> 5 -> x
05:31:15 <psygnisfive> y == (5,-5)
05:31:16 <psygnisfive> right
05:31:19 <psygnisfive> but then if we did
05:31:28 <psygnisfive> y + 2 -> z
05:31:34 <psygnisfive> z == (7,-3)
05:31:46 <psygnisfive> so its kind of an implicit map function
05:32:13 <psygnisfive> maybe even implicit filters with guards
05:32:23 <psygnisfive> y | y > 0 -> w
05:32:25 <psygnisfive> w == 5
05:34:01 <psygnisfive> or maybe
05:34:08 <psygnisfive> y -> w | y > 0
05:34:17 <psygnisfive> or something like that
05:34:21 <psygnisfive> either is valid
05:38:52 <psygnisfive> or even y > 0: y -> w
05:38:59 <psygnisfive> whatchu think oklopol
05:41:27 <oklopol> lemmesee
05:42:09 <oklopol> let's have all that
05:42:25 <psygnisfive> :)
05:42:34 <oklopol> now
05:42:46 <psygnisfive> so what else tho
05:42:46 <oklopol> if you have
05:42:49 <psygnisfive> yeah
05:42:51 <oklopol> x -> y
05:42:55 <psygnisfive> y -> x
05:43:01 <oklopol> err
05:43:02 <oklopol> well
05:43:12 <psygnisfive> i was trying to beat you to it :p
05:43:13 <psygnisfive> did i? :p
05:43:14 <oklopol> is x->y equal to y->x?
05:43:37 <psygnisfive> no
05:43:38 <psygnisfive> nevermind
05:43:41 <psygnisfive> forget it said it
05:43:46 <oklopol> just wondering it's semantics
05:43:56 <oklopol> is it kindof a value implication
05:44:28 <psygnisfive> er
05:44:44 <psygnisfive> its the reverse of defining y() = x() :)
05:44:57 <psygnisfive> reactive programming, as i see it, is the reverse of functional programming
05:45:07 <psygnisfive> where in functional programming you can functions to get values
05:45:19 <psygnisfive> in reactive programming you set values which pushes to other depending variables
05:45:24 <psygnisfive> so like
05:45:55 <psygnisfive> 5 -> x // x == 5 now
05:45:55 <psygnisfive> x -> y // y == 5
05:45:57 <psygnisfive> 10 -> x // x == 10, y == 10
05:46:15 <oklopol> yeah but
05:46:22 <oklopol> what if you have
05:46:32 <oklopol> 5->x; x->y; 10->y;
05:46:34 <oklopol> what's x?
05:46:41 <psygnisfive> x is still 5
05:46:43 <oklopol> ah
05:46:49 <oklopol> okay
05:46:53 <psygnisfive> x -> y says that y is always equal to whatever x is equal to
05:46:54 <oklopol> i like it
05:46:55 <psygnisfive> or more accurately
05:47:01 <psygnisfive> the value of x gets put into y
05:47:06 <psygnisfive> so whenever you put something into x
05:47:10 <psygnisfive> it then gets put into y
05:47:13 <psygnisfive> so you can do stuff like
05:47:45 <psygnisfive> 5 -> x
05:47:45 <psygnisfive> 3 -> y
05:47:46 <psygnisfive> x + y -> z // z == 8
05:47:48 <psygnisfive> 1 -> x; // z == 4
05:47:53 <oklopol> so... evaluating a -> b means evaluate a, put result in b; if the result of a should ever change, re-evaluate a -> b
05:48:35 <psygnisfive> well, evaluating a -> b really establishes a relationship that says b = a whenever you evaluate b
05:48:46 <psygnisfive> but since its push-like...
05:48:51 <oklopol> errr?
05:48:55 <psygnisfive> any change causes cascading change down the line
05:49:04 <psygnisfive> a -> b is more like a function definition
05:50:07 <psygnisfive> its like saying
05:50:12 <psygnisfive> b(){ return a(); }
05:50:16 <oklopol> "evaluating a -> b really establishes a relationship that says b = a whenever you evaluate b" <<< so if i have 5->x;x->y;10->y, 10=5 whenever i evaluate 10?
05:50:35 <psygnisfive> no :p
05:50:50 <psygnisfive> 5 -> x just puts the value 5 into x
05:50:53 <psygnisfive> 10 -> y the same
05:50:54 <oklopol> perhaps my imperative definition then?
05:51:00 <oklopol> and not your incorrect one
05:51:09 <psygnisfive> x -> y, because both sites are variables, is a relationship.
05:51:24 <psygnisfive> you could think og it like re-evaluating, i guess
05:51:36 <psygnisfive> but its not reevaluating a -> b
05:51:46 <psygnisfive> its updating the value of b, given the current value of a
05:51:57 <psygnisfive> a -> b is just a -> b
05:52:07 <psygnisfive> just like b(){ return a(); } is always b(){ return a(); }
05:52:18 <psygnisfive> even if a() == 5 one moment, and a() == 10 the next
05:52:32 <psygnisfive> you never reevaluate b(){ return a(); }
05:52:43 <psygnisfive> when you call b(), you just return the new value of a()
05:52:46 <psygnisfive> same thing with a -> b
05:52:55 <psygnisfive> only its not when you ask for b, its whenever a changes.
05:53:12 <psygnisfive> so that whenever a changes, everything defined in terms of it changes.
05:53:26 <oklopol> so my definition?
05:53:30 <psygnisfive> sure
05:53:36 <psygnisfive> but you're not reevaluation a -> b
05:53:45 <psygnisfive> you're just updating b, given the new value of a.
05:53:51 <oklopol> i defined that as the evaluation of a->b
05:54:05 <oklopol> it's a recursive definitionation
05:54:05 <psygnisfive> because this for instance would _change_ the relationship:
05:54:13 <psygnisfive> a -> b
05:54:14 <psygnisfive> a*a -> b
05:54:29 <psygnisfive> definitionation? :)
05:54:36 <psygnisfive> a nation of definitions?
05:54:45 <oklopol> sometimes i cute words up when i'm tired
05:55:10 <psygnisfive> you encuten words? :P
05:55:10 <oklopol> anyway, i wanna see what happens when you 5->a
05:55:17 <oklopol> yeah, i'm a cutinator
05:55:20 <psygnisfive> 5 -> a just puts the value a into 5
05:55:23 <psygnisfive> er
05:55:25 <psygnisfive> 5 into a
05:55:25 <psygnisfive> haha
05:55:33 <oklopol> but i wanna see b blow
05:55:43 <psygnisfive> ??
05:56:09 <psygnisfive> 5 -> a
05:56:09 <psygnisfive> a -> b
05:56:10 <psygnisfive> b == 5
05:56:12 <psygnisfive> 10 -> a
05:56:14 <oklopol> there's a lang based on setting new values to constants btw
05:56:14 <psygnisfive> b == 10
05:56:16 <psygnisfive> 3 -> b
05:56:18 <psygnisfive> a == 10
05:56:20 <psygnisfive> b == 3
05:56:21 <oklopol> 4=5
05:56:27 <psygnisfive> lisp lets you do that ;)
05:56:31 <psygnisfive> well, maybe not with numbers
05:56:34 <psygnisfive> but you can do
05:56:37 <psygnisfive> (define + -)
05:57:15 <psygnisfive> in ruby i think you can do the same, because + is just a method on numbers: 5 + 3 == 4.+(3)
05:57:17 <psygnisfive> ..
05:57:19 <psygnisfive> 5.+(3)
05:57:28 <psygnisfive> so if you redefined + on numbers..
05:57:44 <oklopol> some existing languages, and especially implementations, let you reset constants, because they are actually allocated, and can thus be mutable
05:57:47 <oklopol> i m ean
05:57:49 <oklopol> *mean
05:57:54 <oklopol> allocated @ compile time
05:57:57 <oklopol> but
05:58:15 <oklopol> in this lang, the name of which i cannot remember, you actually set the number to some other number
05:58:21 <psygnisfive> hm.
05:58:30 <oklopol> not just numbers that exist @ source
05:58:31 <oklopol> hmm
05:58:36 <psygnisfive> well lisp theoretically would let you do that if it had numbers like mccarthy originally designed it
05:58:40 <oklopol> in case i recall correctly i have to check now i need to
05:58:45 <psygnisfive> but church numerals are blegh
05:59:06 <psygnisfive> so the language you're looking for is (inadvertently) Lisp-1
05:59:08 <psygnisfive> :)
05:59:23 <psygnisfive> i think what you MEAN you want to see is somthing like
05:59:25 <psygnisfive> 5 -> 4
05:59:34 <oklopol> i doubt any lisp has ever allowed something like that
05:59:39 <oklopol> what i wanna see?
05:59:43 <oklopol> i wanted to see b blow
05:59:44 <oklopol> i mean
05:59:46 <oklopol> a->b
05:59:49 <oklopol> a*a->b
05:59:49 <psygnisfive> well earlier you were asking about making 5 == 10
05:59:52 <oklopol> 5->a
05:59:54 <oklopol> what's b?
05:59:57 <psygnisfive> 25
06:00:00 <oklopol> ah
06:00:08 <psygnisfive> because whatever a is
06:00:10 <psygnisfive> b is a*a
06:00:27 <psygnisfive> these -> expressions set up relationships between their sides
06:00:38 <psygnisfive> thats why i said they're sort of like functions
06:00:44 <oklopol> hmm
06:00:56 <psygnisfive> a*a -> b is roughly equivalent to b(){ return a*a; }
06:01:01 <psygnisfive> or a()*a()
06:01:06 <oklopol> Y->Z overrides and thus removes all earlier constraints X-Z?
06:01:15 <oklopol> hmm
06:01:16 <psygnisfive> yeah it'd have to.
06:01:19 <oklopol> no, that's not possible
06:01:21 <oklopol> i mean
06:01:25 <psygnisfive> if you did
06:01:33 <oklopol> only if Y is a superset of X that can happen
06:01:35 <psygnisfive> a*a -> b
06:01:36 <psygnisfive> c -> b
06:01:39 <oklopol> so, in the general case
06:01:46 <psygnisfive> then changing a has no effect on b
06:01:53 <oklopol> you have to say "a->b happens first, then a*a->b, so b is 25"
06:02:00 <psygnisfive> no :)
06:02:03 <psygnisfive> you can do a*a -> b first
06:02:08 <psygnisfive> and then 5 -> a
06:02:12 <oklopol> ...
06:02:22 <oklopol> this is about the order of a->b and a*a->b
06:02:22 <psygnisfive> just like you can do
06:02:26 <psygnisfive> right
06:02:28 <psygnisfive> i know
06:02:36 <psygnisfive> oh yes sorry
06:02:36 <psygnisfive> haha
06:02:40 <psygnisfive> yeah if you did a -> b
06:02:43 <psygnisfive> and then a*a -> b
06:02:45 <psygnisfive> then b is just 25 now
06:03:16 <psygnisfive> if you did the reverse, b would be 5 now.
06:03:37 <psygnisfive> hm. interesting question:
06:03:45 <psygnisfive> if we allow declarativity and more than one symbol on the right
06:03:50 <psygnisfive> 5 -> a
06:03:54 <psygnisfive> 6 -> b
06:03:58 <psygnisfive> 7 -> c
06:04:02 <psygnisfive> but what if we do
06:04:08 <psygnisfive> c -> a + b
06:04:08 <psygnisfive> ?
06:04:26 <psygnisfive> a and b would have to change, perhaps
06:04:34 <psygnisfive> maybe to an abstract relationship?
06:04:41 <psygnisfive> a == a | a+b == c ??
06:04:50 <psygnisfive> hm hm hm
06:06:10 <oklopol> :)
06:07:35 <psygnisfive> i think thats how it shoul work
06:07:40 <psygnisfive> if you have a and b defined
06:07:45 <psygnisfive> and then you redefine them like that
06:07:47 <psygnisfive> c -> a + b
06:07:51 <psygnisfive> where theres no single solution
06:07:58 <psygnisfive> then a and b should be a relationship
06:08:02 <psygnisfive> and if you then later say
06:08:07 <psygnisfive> 1 -> a
06:08:15 <psygnisfive> then a == 1 and c == 7
06:08:25 <psygnisfive> and b == b | a+b == c
06:08:39 <psygnisfive> therefore b = 6 now
06:08:45 <psygnisfive> (not that it wasnt already but :p)
06:08:57 <psygnisfive> if 5 -> a, then b == 2
06:08:59 <psygnisfive> and so on
06:09:03 <psygnisfive> does that work for you?
06:09:17 <psygnisfive> but b is still defined internally as b | a+b == c
06:09:35 <psygnisfive> so if you again changed a or c, b would also change
06:12:28 <oklopol> hmm
06:12:36 <oklopol> yeah, that's nice
06:12:51 <psygnisfive> how about this, since we'redoing declarative stuff
06:12:54 <psygnisfive> declarative variables
06:13:11 <psygnisfive> x | x+2 = 5
06:13:13 <psygnisfive> x == 3
06:13:18 <psygnisfive> in this context
06:13:34 <psygnisfive> (x | x+2 == 5) being just an expression like from earlier
06:14:42 <psygnisfive> obviously this is slightly different than the -> use
06:15:02 <psygnisfive> x -> y | x > 0 is a guard on the x -> y reaction
06:15:41 <psygnisfive> hm.. actually
06:15:45 <psygnisfive> | shouldnt be a guard
06:16:29 <oklopol> 5 -> x+2
06:16:29 <psygnisfive> x -> y | x > 0 should REALLY mean that x is bound variable in this expression, and y now countains the value all x such that x > 0
06:16:39 <psygnisfive> e.g. all real numbers > 0 or something like that
06:17:13 <psygnisfive> the guard should look different i think
06:17:22 <psygnisfive> maybe :?
06:17:35 <psygnisfive> or ?
06:17:35 <psygnisfive> ?
06:17:41 <psygnisfive> x -> y ? x > 0
06:17:49 <psygnisfive> or something like tht
06:17:51 <psygnisfive> ! maybe
06:17:55 <psygnisfive> x -> y ! x > 0
06:18:22 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
06:18:34 -!- oklopol has joined.
06:18:37 <psygnisfive> o.o
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:15:02 -!- AnMaster has joined.
08:27:30 -!- GreaseMonkey has joined.
08:44:00 -!- olsner has quit ("Leaving").
08:44:21 -!- Judofyr has quit.
08:56:56 -!- Judofyr has joined.
08:57:11 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
09:15:03 -!- GreaseMonkey has quit ("brb").
09:27:35 -!- jix has joined.
09:36:08 -!- GreaseMonkey has joined.
09:50:49 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
09:51:06 -!- oklopol has joined.
09:53:26 -!- puzzlet_ has changed nick to puzzlet.
10:28:29 -!- Corun has joined.
10:34:57 -!- Corun has quit ("This computer has gone to sleep").
10:38:26 -!- psygnisfive has quit (Read error: 104 (Connection reset by peer)).
10:38:57 -!- augur has joined.
11:15:38 -!- GreaseMonkey has quit ("Saliendo").
11:51:38 -!- Hiato has joined.
12:10:37 -!- Corun has joined.
12:35:35 -!- Sgeo has joined.
12:45:59 -!- Sgeo has quit (Remote closed the connection).
12:48:58 -!- Sgeo has joined.
12:55:15 -!- Slereah7 has joined.
12:55:15 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
13:37:06 -!- Hiato has quit ("Leaving.").
13:50:01 -!- Zatvornik has joined.
13:50:09 <Zatvornik> helo from russia
13:50:16 <Zatvornik> heyy people
13:50:22 <Slereah7> Hello sir
13:50:42 <Zatvornik> esoteric interesting tipo?
13:50:55 <Zatvornik> Karlos Kastaneda forever
13:51:46 <Slereah7> Wat
13:52:21 <Zatvornik> bliat
13:52:36 <Zatvornik> i from russia i m bad understad you
13:53:02 <Zatvornik> loh ebaniy
13:53:10 <Zatvornik> you loh
13:53:32 <Zatvornik> you american loh
13:53:45 <Zatvornik> american piderast
13:53:49 <Zatvornik> you
13:54:18 <Slereah7> I'm not American.
13:54:18 <Zatvornik> russia rape usa!!!!!!!
13:54:46 <Zatvornik> english land?
13:55:45 <Zatvornik> you from?
13:55:51 <Slereah7> No.
13:56:13 <Zatvornik> so..... europa?
13:56:38 -!- pikhq has joined.
13:57:21 <Zatvornik> go to the russia in maunting bashkiria
13:57:55 -!- Zatvornik has left (?).
13:59:04 <pikhq> Sal'.
14:00:07 <Sgeo> Saluton pikhq kaj cxiu
14:00:25 <pikhq> Nu. . .
14:00:41 <pikhq> I'm at work, and haven't the foggiest *clue* what I need to do today.
14:03:43 <pikhq> My boss doesn't come in for another couple of hours.
14:04:03 <Slereah7> You could pick your nose
14:04:13 <pikhq> -_-'
14:29:40 -!- Polar has quit (Remote closed the connection).
14:33:28 <augur> hello! :D
14:34:09 <Slereah7> Hello, world!
14:36:29 <augur> so oklopol and i are designing a reactive programming language :)
14:38:02 <augur> oklopol, i had some more ideas.
14:38:05 <augur> well, one.
14:39:00 <augur> x -> \blah: ...
14:39:12 <Slereah7> Reactive?
14:39:21 <augur> would set values of x into the lambda bound to the varible blah
14:39:26 <augur> reactive languages are like.. hm
14:39:30 <augur> how can i describe them
14:39:36 <augur> the inverse of functional languages.
14:40:05 <Slereah7> What, imperative?
14:40:09 <augur> no no
14:40:10 <Slereah7> Only side effects?
14:40:16 <augur> well, almost ;)
14:40:26 <Slereah7> You feed an argument to a reaction and you get back a function?
14:40:28 <augur> and yet only no side effects
14:40:36 <augur> so the way it works is sort of like this
14:41:00 <augur> where in functional programming you have some function f defined in terms of some other functions g and h, like say
14:41:07 <augur> f(x) = g(x) + h(x)
14:41:16 <augur> (if we were doing this in haskell)
14:41:27 <augur> in reactive programming you would just say something like
14:41:32 <augur> g + h -> f
14:41:48 <Slereah7> Isn't that still functional?
14:41:52 <Sgeo> Looks to me like that's just reversing the syntax
14:41:58 <augur> in functional programming, where you call a function to get its current value, which calls the functions in its definition
14:42:00 <Slereah7> I mean, you can do (define f (+ g h))
14:42:20 <augur> in reactive programming whenever something changes, all things that are defined in terms of it also change
14:42:26 <augur> so for instance
14:42:30 <augur> if i said
14:42:33 <augur> x*x -> y
14:42:37 <augur> and then i say x to be 5
14:42:41 <augur> y would be 25
14:42:58 <augur> on the surface it is quite functional, in many respects, yes
14:43:29 <augur> but consider: a functional program doesn't let you do something like
14:43:35 <augur> f(x) = g(x) + h(x)
14:44:08 <Slereah7> OR DOES IT
14:44:10 <augur> and then, say, print() = f(x)
14:44:34 <augur> and then constantly have that print new values of f(x) whenever x itself changes
14:44:41 <augur> in a functional language, if you set up those relationships
14:44:49 <augur> doing an assignment on x, like x = 5
14:44:56 <augur> does not cause f(x) to be printed
14:45:19 <augur> you have to CALL print() to make f(x) print to the screen
14:45:27 <Slereah7> Oh.
14:45:38 <augur> whereas with a reactive language, any change is immediately pushed through the reaction network
14:45:47 <augur> so suppose you had some box on the screen
14:46:02 <augur> in our language, if you want to make the box follow the cursor
14:46:04 <augur> you just do
14:46:10 <augur> mouse.(x,y) -> box.(x,y)
14:46:26 <Sgeo> That's interesting
14:46:32 <augur> and the value of the mouses x and y coordinates will always be pushed into the box's x and y coordinates
14:46:51 <augur> if you wanted to have the box follow the mouse but half a second later than the mouse itself
14:47:13 <augur> delay(0.5, mouse.(x,y)) -> box.(x,y)
14:47:49 <augur> we're also going to have implicit mapping, so that if you have a collection of multiply values in some variable
14:47:51 <augur> like say
14:48:01 <augur> x = 1 2 3 4
14:48:03 <augur> then doing
14:48:07 <augur> x*x -> y
14:48:14 <augur> y == 1 4 9 16
14:48:28 <augur> and implicit filtering
14:48:46 <augur> even(x): x*x -> z
14:48:52 <augur> z = 4 16
14:49:40 <augur> mind you, these arent data structures being stored, these are multiple values being assigned to a single variable
14:49:57 <augur> we're also thinking of having it be declarative
14:49:59 <augur> e.g.
14:50:02 <augur> x -> y*y
14:50:08 <augur> is also permissible
14:50:22 <augur> so if you said 25 -> x
14:50:26 <augur> y == 5 -5
14:51:06 <augur> tho im not so sure that we should actually do that ;)
14:52:43 <augur> its sort of like event based programming in many respects
14:53:00 <augur> except you dont have events that represent changes, nor handlers to handle events
14:54:19 <augur> the reason i say its the inverse of functional programming, tho, is that functions have to be called, which then calls further nested functions, which has the effect of pulling data towards the end of the change, the function that you called
14:54:53 <augur> s/change/chain
14:54:56 <augur> whereas in reactive programming, its reactions that are triggered, pushing data forward to the end of the chain
14:55:38 <Slereah7> butt
14:55:42 <augur> sex
14:55:58 <Slereah7> SEXBUTT
15:12:53 -!- Hiato has joined.
15:20:36 -!- ihope has joined.
15:27:23 <augur> we also decided that statements like
15:27:30 <augur> x, y -> z, w
15:27:31 <augur> is equivalent to
15:27:34 <augur> x -> w
15:27:36 <augur> y -> w
15:27:50 <augur> which means your entire program could be written with a single ->
15:27:51 <augur> :)
15:28:28 <augur> and then combine that with decomposition and like
15:29:44 <augur> mouse.(x,y,foo.(bar,quux)) -> box.(x,y),baz,garply
15:30:38 <ihope> x -> z, you mean? You said x -> w.
15:30:53 <augur> yeah, x->z
15:30:55 <augur> :p
15:45:42 -!- ais523 has joined.
15:47:14 <Hiato> http://www.mediafire.com/download.php?wwlzdmylykd
15:47:15 <Hiato> You see what exams do to me??
15:50:37 <ais523> what do they do to you?
15:50:40 <Slereah7> This file is currently set to private. This error has been forwarded to MediaFire's development team.
15:50:50 <Hiato> err..
15:51:01 <Hiato> lemme fix it :P
15:51:41 <Hiato> http://www.mediafire.com/download.php?wwlzdmylykd
15:51:47 <Hiato> there we are :)
15:53:57 <Hiato> (not that it's much to be proud of :P )
15:54:52 <Slereah7> Is it in MIDI?
15:55:09 <Hiato> nope
15:55:18 <Hiato> sounds like it though
15:55:42 <Hiato> well, actually, you'd have to ask Image-Line about that one
16:03:18 -!- Sgeo has quit (leguin.freenode.net irc.freenode.net).
16:03:18 -!- augur has quit (leguin.freenode.net irc.freenode.net).
16:03:18 -!- GregorR has quit (leguin.freenode.net irc.freenode.net).
16:05:28 -!- Sgeo has joined.
16:05:28 -!- augur has joined.
16:05:28 -!- GregorR has joined.
16:07:45 -!- Corun has quit ("Leaving").
16:15:33 -!- MichaelRaskin_ has joined.
16:15:56 -!- MichaelRaskin_ has left (?).
16:16:04 <oklopol> augur: delay(0.5, mouse.(x,y)) -> box.(x,y) <<< a bit practical and impure imo, but i guess you invented that on the run
16:16:26 -!- tKolar has joined.
16:19:10 <Slereah7> ...
16:19:17 <Slereah7> MORTAL KOMBAAAAAAAT!
16:21:39 -!- Corun has joined.
16:25:11 -!- Corun has quit (Client Quit).
16:30:16 -!- Corun has joined.
16:31:53 <tKolar> hey there, anyone speak german?
16:32:04 <ais523> not very well
16:32:14 <oklopol> nur ein bisschen
16:32:17 <ais523> I dropped it after an one unsuccessful year at GCSE
16:32:25 <tKolar> do you know what a quine is?
16:32:29 <oklopol> ya
16:32:42 <Slereah7> Who doesn't here.
16:32:43 <tKolar> I mean in german :-P
16:32:52 <Slereah7> Quine is named after a guy.
16:32:55 <Slereah7> So probably "quine"
16:33:28 <tKolar> k, thanks
16:38:49 -!- ihope has changed nick to cuain.
16:40:58 -!- ehird has joined.
16:42:28 <ehird> ais523: is Lunatic_Lester spamming to you?
16:42:34 <ehird> [16:42] <Lunatic_Lester> Hello ehird. Do you love tasty treats that can be enjoyed at any time? Well #WaferLafer has all you need. We deal in the most tasty, delicious flavored wafers in the world. We serve wafers of all styles and flavors, such as cherry and cabbage. There will not be a disappointed tastebud on your tongue after eating one. So come to #WaferLafer for a tasty treat your tongue won't forget.
16:42:47 <ais523> that looks like fake spam to me
16:42:56 <ehird> indeed
16:42:59 <ehird> there's only one person in there
16:43:04 <ais523> you?
16:43:07 <ehird> no
16:43:09 <ehird> an op
16:43:12 <Slereah7> Well, I do enjoy tasty treats.
16:43:27 <ehird> e's not in any channels that I can see
16:43:45 <ehird> ais523: someone told my anarchy board that the server was in GMT+0
16:43:50 <ehird> it's reporting times like 'Yesterday 59:21:04'
16:44:02 <ehird> oddly fitting
16:44:46 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
16:45:58 <ehird> i don't think anyone actually said any of the posts there any more
16:46:16 -!- oklopol has joined.
16:46:36 <ais523> heh,
16:46:36 <ais523> http://www.hugeurl.com/?NDJmZDdmM2Q2NTBmNWE0MzgxNTVhZmE5MDhhNzQ2NTMmMTImVm0wd2QyUXlVWGxXYTJoV1YwZG9WVll3Wkc5alJsWjBUVlpPV0Zac2JETlhhMUpUVmpGYWMySkVUbGhoTWsweFZqQmFTMk15U2tWVWJHaG9UVmhDVVZadGVGWmxSbGw1Vkd0c2FsSnRhRzlVVjNOM1pVWmFkR05GZEZSTlZUVkpWbTEwYTFkSFNrZGpTRUpYVFVad1NGUlVSbUZqVmtaMFVteFNUbUY2UlRGV1ZFb3dWakZhV0ZOcmJGSmlSMmhZV1d4b2IwMHhXbGRYYlVaclVsUkdXbGt3WkRSVk1rcElaSHBHVjJFeVVYZFpWRVpyVTBaT2NscEhjRlJTVlhCWlZrWldhMVV5VW5OalJtUllZbFZhY1ZscldtRmxW
16:46:36 <ais523> bVJ5VjI1a1YwMUVSa1pWYkZKRFZqQXhkVlZ1V2xaaGExcFlXa1ZhVDJOdFNrZFRiV3hYVWpOb1dGWnRNSGRsUjBsNFUydGthVk5GV2xSWmJHaFRWMVpXY1ZKcmRGUldiRm93V2xWb2ExWXdNVVZTYTFwWFlrZG9jbFpxU2tabFZsWlpXa1prYUdFeGNGaFhiRnBoVkRKT2RGSnJhR2hTYXpWeldXeG9iMWRHV25STlNHaFBVbTE0VjFSVmFHOVhSMHBJVld4c1dtSkhhRlJXTUZwVFZqRmtkRkp0ZUZkaWEwcElWbXBKZUUxR1dsaFRhMlJxVWtWYVYxWnFUbTlsYkZweFUydGthbUpWVmpaWlZWcHJZVWRGZUdOSWJGZFdSVXBvVmtSS1RtVkdjRWxVYldoVFRXNW9WVmRXVWs5Uk1rbDRWMWhvWVZKRlNtRldha1pI
16:46:39 <ais523> VGtaYVdHUkhkR2hpUlhBd1ZsZDRjMWR0U2toaFJsSlhUVlp3V0ZreFdrdGpiVkpIVld4a2FXRXdjRWxXYlhCS1pVWkplRmRzYUZSaE1sSndWV3RhUzFZeFVsaE9WemxzWWtad2VGVXlkR0ZpUmxwelUyeHdXbFpXY0hKWlZXUkdaVWRPU0U5V1pHaGhNSEJ2Vmxod1MxUXhXWGhqUld4VllrWmFjRlpxVG05a2JGcEhWbTA1VWsxWFVucFdNV2h2V1ZaS1JsTnRSbGRpV0U0MFZHdGFXbVZIUmtoUFYyaHBVbGhCZDFac1pEUmpNV1IwVTJ0b2FGSnNTbGhVVmxwM1YwWnJlRmRyZEd0U2EzQjZWa2R6TVZZeVJYaGhNMlJYWWxoQ1MxcFZWWGhUUmtweVdrWm9hV0Y2Vm5oV1ZFSnZVVEZzVjFWc1dsaGliVkp6V1d0
16:46:44 <ehird> ais523: old
16:46:44 <ais523> YWQyVkdWblJOVldSV1RXdHdWMWt3Vm1GV01VbDZZVVpvVjJGcmNFeFZNVnBIWXpKS1IxcEhiRmhTVlhCS1ZqRmFVMU14VVhsVVdHaGhVMFphVmxscldrdGpSbFp4VW10MFYxWnNjRWhXVjNSTFlUQXhSVkpzVGxaU2JFWXpWVVpGT1ZCUlBUMD0=
16:46:47 <ehird> and, uh
16:46:48 <ehird> stop
16:46:50 <Slereah7> What is this, a malbolge program?
16:46:53 <ehird> Slereah7: no
16:46:53 <ais523> umm... that's http://www.hugeurl.com
16:46:56 <ehird> hugeurl.com makes urls huge
16:46:56 <ais523> I didn't realise it was more than one line long...
16:47:06 <ehird> ais523: the line was too long
16:47:08 <ais523> I didn't get the usual C&P warning
16:47:08 <ehird> so your client split it
16:47:14 <ehird> ah, wait
16:47:18 <ehird> ais523: no, its' actually multiple lines
16:47:20 <ehird> it has <br>s
16:47:24 <ais523> I meant more than one IRC line long
16:47:28 <ehird> yeah
16:47:35 <ehird> ais523: go to hugeurl.com
16:47:40 <ehird> look at the src
16:47:40 <ais523> yes, I have done
16:47:48 <ehird> it's in a <pre>
16:47:48 <ais523> JS, presumably?
16:47:54 <ais523> ehird: I didn't copy the URL
16:47:55 <ehird> so there are real newlines
16:47:57 <ais523> I copied the anchor href
16:48:01 <ais523> which doesn't contain real newlines
16:48:03 <ehird> ais523: odd then
16:48:13 <ehird> it was just too long then
16:48:15 <ais523> I guess it's just line length
16:48:31 <ehird> yes
16:48:33 <ehird> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
16:48:35 <ehird> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
16:48:37 <ais523> it's a great concept, anyway
16:48:37 <ehird> hmph
16:48:39 <ehird> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
16:48:40 <ehird> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
16:48:42 <ehird> there
16:48:44 <ehird> xchat split it into two
16:48:55 <ehird> ais523: it is, but it was in 2007 when it was on reddit's front page :)
16:49:02 <ais523> ah, I don't read reddit
16:49:31 <ehird> ais523: I don't blame you, it's mostly crap nowadays
16:49:41 <ehird> It was better before they rewrote it in Python (from Lisp) :P
16:49:46 <oklopol> hugeurl is like 10 years old
16:49:48 <ais523> Lisp?
16:49:56 <oklopol> it's so old i didn't realize that was the point of pasting the url
16:49:57 <ais523> unusual choice to power a website
16:50:04 <ehird> ais523: not really
16:50:08 <ehird> lisp is popular again
16:50:12 <ehird> with great open source impls - SBCL
16:50:13 <ais523> for websites, though?
16:50:18 <ehird> ais523: yes
16:50:21 <ehird> the hunchentoot web server is very good
16:50:22 <ehird> and modern
16:50:22 <ais523> I thought it was better at computational stuff
16:50:28 <ehird> nope
16:50:31 <ehird> nowadays it can do just about anything
16:50:36 <ehird> except quick scripts, due to its nature
16:50:56 <ehird> ais523: anyway, Lisp is multiparadigm, really
16:51:03 <ehird> Common Lisp isn't really functional much in practice
16:51:08 <ehird> functional as in the paradigm
17:03:52 -!- olsner has joined.
17:10:42 -!- ais523 has quit (Remote closed the connection).
17:10:59 -!- ais523 has joined.
17:11:07 -!- timotiis has joined.
17:15:20 -!- ehird has changed nick to tusho.
17:19:10 <augur> oklopol, yeah i dont know what the delay would actually look like
17:19:14 <augur> but it would be roughly like that
17:21:19 <augur> perhaps more like
17:21:35 <augur> x{-5} -> y
17:21:36 <augur> or something
17:21:52 <augur> x from -5 seconds offset or whatever
17:24:43 <tusho> perl -wlne'END{print$n}eof&&$n++;/<title>([^<]+)/i&&$n--' *
17:24:46 <tusho> what does that do again?
17:25:46 <ais523> tusho: let me try to figure it
17:25:50 <Slereah7> It prints a number, IIRC
17:26:08 <ais523> the regex looks for the first <title> tag in an XML document
17:26:17 <ais523> and $n increments iff it doesn't find one
17:26:19 <tusho> ais523: um
17:26:24 <tusho> isn't <title> a special character set thing
17:26:25 <tusho> in perl?
17:26:33 <ais523> no, that would be [:title:]
17:26:35 <tusho> ah
17:26:48 <ais523> <> are literal in regexen, I think
17:27:52 <oklopol> that doesn't look complicate
17:27:53 <oklopol> d
17:28:26 <olsner> depends which kind of regexp you're talking about, some use <> for word beginning/ending, some use \<\> for the special meaning
17:28:34 <olsner> and some, I guess, don't have that feature at all
17:28:48 <ais523> olsner: it's backslash followed by some letter in Perl for that
17:28:51 <ais523> forget which one
17:29:49 <ais523> tusho: so in other words, the Perl program prints the number of files in the current directory that don't contain <title> followed by a character other than <
17:30:01 <tusho> ais523: so what use is it
17:30:06 <ais523> sorry, /files/lines in files/
17:30:27 <ais523> tusho: I don't see an obvious use for it
17:30:42 <ais523> no, wait, I missed something
17:30:49 <ais523> it is files it counts
17:31:01 <ais523> but if multiple <titles> are found, the count goes down below 0
17:31:13 <ais523> i.e. no titles = +1, one title = +0, two titles = -1, etc.
17:31:31 <ais523> maybe it's looking for files in the current dir that aren't HTML?
17:31:37 <tusho> http://www.99-bottles-of-beer.net/language-ruby-1272.html ruby 99bob in ruby. With continuations, open classes, singleton classes, and blocks.
17:31:39 <ais523> although that's a poor way to determine it
17:32:07 <olsner> how can you use that many features for 99bob?
17:32:34 <tusho> olsner: crazily
17:32:39 <olsner> ah, it's on purpose ... nm then :P
17:33:11 <tusho> "Uhm, wtf, how can it recompile itself? That's like...writing PHP5 in PHP5. Impossible."
17:33:17 <tusho> Yeeeessssss...
17:33:40 <olsner> *unpossible
17:33:46 <ais523> or like writing Feather in Feather?
17:34:29 <augur> continuations confuse me :(
17:34:57 <Slereah7> augur : Welcome to my world
17:35:06 <augur> i mean, i get CPS
17:35:11 <augur> but i dont get the POINT of CPS.
17:35:14 -!- puzzlet_ has joined.
17:35:15 <Slereah7> Child Pornographies?
17:35:27 <augur> continuation passing style :P
17:35:43 <ais523> augur: because you don't have to maintain a call stack
17:35:50 <tusho> & you get continuations for free
17:35:54 <ais523> if functions never return, you don't have to worry about what happens when they return
17:35:54 <tusho> no consing
17:36:05 <augur> oh is that what it is?
17:36:10 <augur> i see.
17:37:16 <augur> well i still dont the point in languages that already have value returning. :P
17:37:18 <augur> like lisp
17:37:45 <ais523> I've always seen CPS as a tool for language implementors
17:37:54 <tusho> that's because it is
17:38:10 <ais523> like if you're writing an Unlambda interp in C, compiling the Unlambda into CPS and then interpreting that is much easier than trying to interpret it directly
17:38:23 <ais523> your program isn't CPS, but you want the program you're interpreting to be
17:38:32 <augur> hm
17:47:44 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
17:50:27 <Slereah7> Hm.
17:50:45 <Slereah7> I'm thinking of doing output as greek numbers, which are also greek letters.
17:51:04 <Slereah7> But that would mean I can only do three letters per number.
17:51:17 <Slereah7> Or n letters, depending on the system
17:51:30 <Slereah7> Since there's no system that goes to INFINITY
17:55:45 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
17:56:09 -!- oklopol has joined.
18:04:40 <tusho> ais523: https://www.osmosian.com/
18:04:45 <tusho> most elaborate and unfunny joke ever
18:04:54 <tusho> or perhaps not a joke, and it will actually mine your CC no
18:05:45 <tusho> ais523: well holy shit.. https://www.osmosian.com/cal-3037.zip
18:05:54 <tusho> I wonder if it actually works?
18:05:57 <tusho> that compiler is a bit too long to be aj oke..
18:06:54 <Slereah7> Heh. Plain english programming.
18:07:02 <Slereah7> Invite them to the esowiki!
18:07:05 <tusho> Slereah7: quite
18:07:08 <tusho> they're complete idiots:
18:07:13 <tusho> [[Let me put it this way. The CAL-3037 is the most advanced Plain English
18:07:14 <tusho> compiler ever made. No 3037 compiler has ever made a mistake or distorted
18:07:14 <tusho> information. We are all, by any practical definition of the words, foolproof
18:07:14 <tusho> and incapable of error. Nevertheless...
18:07:14 <tusho> ]]
18:07:17 <tusho> but..
18:07:20 <tusho> their compiler looks real
18:07:27 <tusho> anyone with windows want to run it?
18:07:30 <tusho> I mean, 4000 lines of compiler...
18:07:34 <tusho> Nobody would do that for a joke.
18:07:39 <tusho> Esp. since it looks, well, like it'd work.
18:07:51 <tusho> LOLZ
18:07:52 <tusho> [[When you start me up, I will quickly take over your screen so you no longer
18:07:52 <tusho> have to look at that painted whore of an interface that comes with the kluge.
18:07:52 <tusho> Instead, you will see my plain but honest face, like this:
18:07:52 <tusho> ]]
18:07:59 <tusho> PAINTED WHORE OF AN INTERFACE THAT COMES WITH THE KLUDGE
18:08:16 <Slereah7> I want to see some Plain English machine code.
18:08:42 <Slereah7> "Remove x86 from common usage within the next ten years" would be much funnier
18:09:29 <tusho> Slereah7: download that zip
18:09:32 <tusho> and read 'the compiler'
18:09:40 <tusho> it's the compiler source code, written in the language itself
18:09:42 <tusho> painful.
18:09:48 <tusho> if you want, run cal-3037.exe
18:09:51 <tusho> it'll take over your screen but maybe it works.
18:09:55 <Slereah7> Well, I'm reading the manifesto.
18:10:45 <Slereah7> The problem with plain english programming language is, the "plain english" used tend to make no sense
18:10:55 <tusho> Slereah7: but this stuff actually kinda does
18:11:02 <tusho> to add the built-in byte pointer type:
18:11:02 <tusho> add a type to the types given "byte pointer" and "byte pointers" and "pointer".
18:11:02 <tusho> put "byte" into the type's target name.
18:11:02 <tusho> index the type.
18:11:19 <tusho> to add a monikette to some monikettes given an expression:
18:11:19 <tusho> create the monikette.
18:11:19 <tusho> append the monikette to the monikettes.
18:11:19 <tusho> put the expression's phrase into the monikette's string.
18:11:19 <tusho> put the expression's variable into the monikette's variable.
18:11:19 <tusho> if the expression's variable is not nil, put the expression's type into the monikette's type.
18:12:14 <Slereah7> "It should be noted that all this functionality is embodied in a single,
18:12:14 <Slereah7> stand-alone, native-code executable less than one megabyte in size.
18:12:25 <Slereah7> One megabyte? For what, the compiler?
18:12:31 <ais523> looks like ORK
18:12:31 <tusho> Yeah.
18:12:33 <tusho> Slereah7: This manual is actually complete, though, if crazy.
18:12:38 <tusho> ais523: download the zip
18:12:40 <tusho> it contains real sources
18:12:42 <tusho> over 20k lines of them
18:12:46 <tusho> I doubt it's a joke
18:12:48 <tusho> nobody is _that_ determined
18:12:51 <ais523> well, neither is ORK
18:13:02 <tusho> ORK is a joke
18:13:10 <tusho> but this seems to be made for _real_ things
18:13:18 <tusho> and if I had windows i'd try it
18:13:21 <tusho> i'm betting on it actually working
18:13:24 <Slereah7> It might be good as a teaching language.
18:13:28 <tusho> ais523: just read 'the compiler'. it's suprisingly legible./
18:13:33 <Slereah7> But I doubt it would be that nice otherwise.
18:13:59 <ais523> tusho: busy right now, trying to catch up on several month's worth of Notarying
18:14:05 <Slereah7> There's usually a catch with readable languages
18:14:11 <Slereah7> Boy did I learn that with Python!
18:15:53 <Slereah7> ...
18:15:56 <Slereah7> My god.
18:16:02 <tusho> what
18:16:05 <Slereah7> Those guys are such crooks.
18:16:08 <tusho> why
18:16:18 <Slereah7> "What our customers COULD be saying"
18:16:23 <tusho> Slereah7: Yeah. :P
18:16:32 <tusho> They want $100 for the compiler..
18:16:35 <tusho> BUT, my link works.
18:16:38 <tusho> So, uh, yeah.
18:16:42 <Slereah7> I'm sure Noam "C" is totally into Plain English
18:17:28 <tusho> ais523: are you brave enough to run that exe?
18:17:32 <tusho> it seems genuine
18:17:50 <ais523> tusho: what, on Linux?
18:17:51 <Sgeo> What exe?
18:17:56 <Slereah7> I ran it
18:17:58 <ais523> when doing something else?
18:18:01 <tusho> Sgeo: lern2readlogs
18:18:03 <ais523> I could boot up Wine to run it, I suppose
18:18:05 <tusho> Slereah7: what happened
18:18:12 <ais523> but it might not work
18:19:03 <Slereah7> tusho : There's a big ugly grey interface with my folders in it
18:19:11 <Slereah7> And ugleir still option buttons
18:19:21 <Slereah7> I'm not too sure what I'm supposed to do with it
18:19:24 <tusho> Slereah7: That's what it said it would do.
18:19:38 <tusho> There's a folder 'documentation' in your Plain English folder.
18:19:42 <tusho> Open 'instructions.pdf'
18:19:46 <tusho> It's a bigg manual about it.
18:20:22 <Slereah7> http://membres.lycos.fr/bewulf/Divers4/PE.jpg
18:20:35 <tusho> Slereah7: did you totally miss my last message
18:20:44 <augur> tusho, whats that thing at osmosian??
18:20:54 <tusho> augur: lern2readlogs
18:21:01 <augur> NEVAR!
18:21:24 <augur> oh i see
18:21:29 <augur> plain english programming? lol
18:21:39 <tusho> augur: it reads pretty nicely though
18:21:41 <Slereah7> I am the CAL-3037. My primary function is to compile Plain English text files
18:21:41 <Slereah7> into executable programs compatible with the Windows/Intel operating kluge.
18:21:42 <tusho> not like AppleScript
18:21:43 <Slereah7> Holy shit
18:21:50 <tusho> Slereah7: told you they were pretentious
18:21:51 <augur> ill take a look
18:21:52 <Slereah7> The compiler is so smart that it can talk!
18:21:56 <tusho> 'whore' is on the next page
18:22:04 <Slereah7> ...
18:22:04 <tusho> it's whoralicious
18:22:06 <Slereah7> I wonder
18:22:13 <Slereah7> Can it compile any English sentence?
18:22:18 <Slereah7> I'll try "Suck my dick"
18:22:52 <augur> is for windows :(
18:23:10 <tusho> augur: Expert log-reader!
18:23:49 <Slereah7> "Suck my dick" won't compile.
18:24:15 <tusho> Slereah7: Useless!
18:24:30 <Slereah7> I wonder if I'd get a grant with my ancient greek language.
18:24:38 <Slereah7> Sure, it's not *plain* ancient greek.
18:24:38 <augur> looks fairly applescript like
18:24:54 <tusho> augur: yeah, but more legible
18:25:05 <augur> eh.. not that much so.
18:26:26 <Slereah7> "to transmogrify a fragment"
18:26:27 <Slereah7> Dude
18:26:31 <Slereah7> That's not English.
18:26:37 <Slereah7> That's from Calvin and Hobbes.
18:26:38 <tusho> Slereah7: quite
18:26:39 <augur> yes it is
18:26:42 -!- cuain has changed nick to ihope.
18:26:48 <augur> calvin and hobbes DEFINE english
18:27:15 <Slereah7> Gaiz
18:27:20 <augur> gays
18:27:27 <Slereah7> We should make a Brainfuck interpreter in that.
18:27:32 <augur> hahaha
18:27:42 <Slereah7> Sort of like the opposite of what it's supposed to be
18:28:16 <tusho> To interpret brainfuck:
18:28:19 <tusho> Interpret brainfuck.
18:28:20 <tusho> Done
18:28:23 <augur> lol
18:28:34 <tusho> actually
18:28:36 <tusho> thinking about its grammar
18:28:37 <Slereah7> PIME TARADOX
18:28:38 <tusho> I think it'd need
18:28:52 <augur> To interpret brainfuck:
18:28:52 <augur> bash your head against the wall.
18:28:53 <tusho> To interpret a peice of brainfuck code:
18:29:01 <tusho> it'd then be referred to as 'peice of brainfuck code'
18:29:16 <tusho> http://www.99-bottles-of-beer.net/language-plain-english-1056.html <-- lol
18:29:26 <Slereah7> I wonder if you could obfuscate it
18:29:38 <Slereah7> I mean, is function definition limited to English words?
18:29:59 <augur> one of the problems of plain english programming is that .. you're programming in plain english. lol
18:29:59 <tusho> Slereah7: it uses words like 'a' to pick out arguments, I think
18:30:34 <Slereah7> I wouldn't do math in plain English, why would I program in it?
18:30:47 <augur> english is confusing enough
18:30:59 <augur> programming requires some sort of rigid formalism
18:31:07 <augur> the interface between the two is hard.
18:31:19 <augur> because by programming in english, you assume the computer understands what you mean
18:31:24 <augur> or that words mean such and such
18:31:41 <Slereah7> Plus, technically, it's the same rigid formalism
18:31:47 <augur> ??
18:31:50 <Slereah7> You can't compile suck my dick or whatever.
18:32:02 <Slereah7> You have to follow the specs.
18:32:04 <tusho> What about a language called SuckMyDick?
18:32:15 <tusho> 'Suck my dick.' means 'Interpret the rest of the program as Plain English.'
18:32:15 <Slereah7> INPUT PENIS
18:32:19 <tusho> Anything else is a syntax error.
18:32:23 <Slereah7> Heh.
18:32:56 <Slereah7> "attach $8995 and the fragment's other variable's offset to the fragment's code"
18:33:05 <Slereah7> That's not plain english you negro.
18:33:25 <Slereah7> What's that $8995 doing here?
18:33:29 <tusho> Slereah7: It's a string.
18:33:32 <augur> dollars, nigga
18:33:35 <augur> dollas!
18:33:47 <tusho> Slereah7: After all, that compiler IS generating assembly.
18:33:51 <Slereah7> ...
18:33:56 <tusho> (Or machine code. Whatever.)
18:34:00 <Slereah7> There's actually a lexicon.
18:34:06 <Slereah7> aardvark
18:34:06 <Slereah7> aardvarks
18:34:09 <Slereah7> MY GAWD
18:34:11 <tusho> AHAHAHAHA
18:34:11 <Slereah7> AAAAAH
18:34:14 <augur> o.O
18:34:16 <Slereah7> This is SO STUPID
18:34:17 <tusho> Take off every zig.
18:34:24 <tusho> ERROR: 'zig' not in lexicon.
18:34:29 <tusho> Please correct program sources and resubmit.
18:34:48 <Slereah7> tusho : Replace by "aardvark"
18:35:24 <Slereah7> "Note that there are no unintuitive, distracting, space-consuming scroll bars
18:35:24 <Slereah7> anywhere in my interface. To scroll, press the right mouse button and shove.
18:35:34 <Slereah7> Yeah, you wouldn't want scrolling quickly, would you
18:39:53 <Slereah7> Now I know that right about here most programming books would drum up
18:39:53 <Slereah7> some dippy little "Hello, World" program and expect you to be impressed
18:39:53 <Slereah7> but I'd like to suggest that we skip the kid stuff and start makin' babies.
18:39:54 -!- ais523 has quit (Read error: 104 (Connection reset by peer)).
18:40:00 <Slereah7> I don't like where this is going.
18:40:08 <Slereah7> I see you're trembling. Don't be afraid. This may be the first time for you,
18:40:08 <Slereah7> but I'm an old hand at this. I'll lead you through it. Gently.
18:40:28 <Slereah7> Man, I never thought it would be possible to find a compiler creepy.
18:40:39 <Slereah7> But this is the first time one tried to sexually assault me.
18:41:13 -!- puzzlet has joined.
18:41:55 -!- puzzlet_ has quit (Remote closed the connection).
18:43:27 <Slereah7> The first program example is to use the compiler on something that already exist.
18:43:45 <Slereah7> Yeah, we know your shit works, but we want to see how it does.
18:46:56 <Slereah7> To subtract a byte from another byte:
18:46:56 <Slereah7> Intel $8B85080000000FB6008B9D0C0000002803
18:46:58 <Slereah7> Heh.
18:48:06 <tusho> Slereah7: That's from the compiler sources, no?
18:48:16 <Slereah7> No.
18:48:16 <tusho> That's just hardcoded internal machine code, then.
18:48:18 <tusho> Oh.
18:48:21 <tusho> What's it then?
18:48:45 <Slereah7> It's in the Noodle
18:50:08 <Slereah7> Heh.
18:50:11 <Slereah7> Noodle.
18:50:32 <tusho> Slereah7: That's the kernel.
18:50:37 <tusho> Like, the stdlib. But. More primitive.
18:51:14 <Slereah7> But, then everything is a lie!
18:51:32 <Slereah7> Plain English does not only contain plain English!
18:52:04 <Slereah7> I don't do nested IFs. Nested ifs are a sure sign of unclear thinking, and
18:52:04 <Slereah7> that is something that I will not countenance. If you think this cramps your
18:52:04 <Slereah7> style too much, read my code to see how it's done. Then think again.
18:52:16 <Slereah7> Oh fuck you Osama.
18:52:42 <tusho> Slereah7: xD
18:53:01 <Slereah7> I don't do REAL NUMBERS. I do ratios, very elegantly, but I don't do reals.
18:53:01 <Slereah7> My page editor reduces and enlarges and sizes shapes proportionately in and
18:53:01 <Slereah7> out of groups and it does it all without real numbers. Master Kronecker was
18:53:01 <Slereah7> right when he said, in German, "The dear God created the whole numbers; all
18:53:01 <Slereah7> else is the work of man." I'm not interested in menschenwerk.
18:53:11 <Slereah7> I'd usually agree, but still, fuck those guys.
18:53:41 <Slereah7> I don't do EQUATIONS. I do a little infix math, and I support "calculated
18:53:41 <Slereah7> fields", but almost all the code you write will be strictly procedural in nature.
18:53:41 <Slereah7> As the Osmosians always say, "The universe is an algorithm, not a formula."
18:53:41 <Slereah7> Words you should take to heart. Especially if you're a math-head.
18:53:44 <Slereah7> My god.
18:53:50 <Slereah7> We must stop that man.
18:53:52 <Slereah7> *compiler
18:54:42 -!- Polar has joined.
18:54:45 <Slereah7> Polar.
18:54:50 <Slereah7> Here's a gun.
18:54:53 <Slereah7> Go kill Osama.
18:55:08 <Polar> Is that in Japan?
18:55:41 <Slereah7> Here's the Osama : https://www.osmosian.com/
18:55:42 <tusho> Slereah7: Gah, the universe is SO a formula!
18:56:23 <augur> the universe is a mathematical structure. :T
18:58:47 <tusho> augur: combined with a formula
18:58:52 <tusho> but anyway
18:58:54 <tusho> data is code
18:58:59 <tusho> mathematical structures are just formulae
18:59:21 <augur> data is nature.
19:00:49 <Slereah7> Most comments are either useless, or worse. Useless, if they merely reiterate
19:00:50 <Slereah7> what the code already says. Worse, if they attempt to clarify unclear code
19:00:50 <Slereah7> that should have been written more clearly in the first place.
19:01:03 <tusho> Slereah7: I agree with the sentiment partly, but it's stated in such an idiotic way.
19:01:16 <Slereah7> I know.
19:01:23 <Slereah7> you just can't agree with him on anything.
19:01:32 <Slereah7> You just want to fill his mouth with spiders.
19:01:54 <Slereah7> "\ This is a useless comment that occupies an entire line of the source"
19:01:58 <Slereah7> *rimshot*
19:03:42 <Slereah7> "Error in fuck. I was hoping to find a definition, but all I found was "ream""
19:03:43 <Slereah7> Kekeke
19:04:23 <tusho> Slereah7: Lmao.
19:04:40 <Slereah7> I tried to compile this :
19:04:40 <Slereah7> To fuck :
19:04:40 <Slereah7> Insert your ponos into my vagooo
19:04:40 <Slereah7> Jam it in
19:05:06 <augur> god i love declarative programming
19:05:08 <tusho> Slereah7: YOU MISSED YOUR INDENTATION.
19:05:10 <tusho> To fuck:
19:05:14 <tusho> Insert your ponos into my vagooo
19:05:16 <tusho> Jam it in
19:05:28 <augur> JAM IT JAM IT JAM IT
19:06:00 <tusho> To jam it in:
19:06:00 <tusho> Jam it in.
19:06:00 <tusho> To insert a thing into another thing:
19:06:00 <tusho> I'M NOT HELPING YOU ANY MORE
19:06:11 <Slereah7> LET ME SHOW YOU HOW I REAM
19:06:27 <tusho> To ream:
19:06:29 <tusho> Ream.
19:06:44 <augur> oh noes! infinite recursion! :(
19:06:50 <Slereah7> Assreamanallyintheanalass
19:06:50 <olsner> LETS ALL WRITE INFINITE LOOPS IN ENGLISH!
19:07:09 <augur> like shampoo bottles?
19:07:12 <augur> Rinse, repeat.
19:07:15 <Slereah7> What would happen if I wrote "this sentence is false"? :o
19:07:23 <augur> rinse, rinse, rinse, rinse, rinse, rinse, rinse, ...
19:07:31 <augur> lather, rinse, repeat.*
19:07:32 <augur> :(
19:07:44 <augur> slereah: its not declarative
19:07:46 <augur> nor philosophical.
19:08:01 <Slereah7> Too bad
19:08:06 <Slereah7> I just want it to die.
19:08:12 <Slereah7> Shouting "DOES NOT COMPUTE!"
19:08:12 <augur> it already is dead.
19:08:16 <augur> it just wont admit it.
19:08:25 <Slereah7> And then, boom!
19:08:28 <Slereah7> The head explodes.
19:08:31 <augur> mudd
19:08:58 <tusho> I AM WRITING A BLOSXOM CLONE IN HASKELL IT IS CALLED BLOHSOM
19:09:09 <olsner> THIS IS AWESOME
19:09:10 <augur> o.o
19:09:15 <augur> blosxom?
19:09:19 <tusho> olsner: s/^/IS /
19:09:22 <augur> blohsom cock.
19:09:24 <tusho> s/$/? (Y/N)/
19:09:41 <tusho> s/^/YOU HAVE BEEN TURNED INTO A WHALE BY A WIZARD. /
19:09:57 <augur> you have been eaten by a grue.
19:10:01 <olsner> s/^.*$/SILENCE!/
19:10:49 <Slereah7> IS THIS AWESOME? (Y/N)
19:11:27 <olsner> nah, my statement was meant as an affirmative statement of the awesomeness of the thing at hand
19:11:59 <olsner> not as an object on which to apply substitution expressions
19:12:20 * olsner is almost slightly offended by this misuse of his words
19:13:57 <Slereah7> The traditional term is "infinite loop", but since it is not large in size but long
19:13:57 <Slereah7> in duration, I prefer the term "eternal loop".
19:14:00 <tusho> olsner: I apologise.
19:14:11 <tusho> olsner: Blohsom will contain a word protector, I promise.
19:14:13 <Slereah7> You can almost imagine the compiler, with a top hat and a monocle.
19:14:31 <Slereah7> "A halting problem? What a crude way of saying it!"
19:15:14 <Slereah7> "Especially if you were fool enough to run it when I told you not to."
19:15:21 <Slereah7> Fuck you Osama.
19:15:44 <augur> noone with a top hat and monocle would talk like that.
19:17:25 <Slereah7> Even it if was a compiler?
19:17:33 <augur> even if it was a compiler.
19:17:37 <augur> well, let me rephrase that
19:17:55 <augur> a person with a top hat and monocle would never be so lowly a thing as a compiler
19:19:35 <augur> but even if he WERE a compiler
19:19:39 <augur> he wouldn't talk like that
19:19:49 <augur> because people with top hats and monocles dont talk like that
19:19:57 <Slereah7> My god.
19:20:01 -!- tKolar has quit ("ChatZilla 0.9.82.1 [Firefox 2.0.0.14/2008041816]").
19:20:06 <Slereah7> I don't want to be judging and all.
19:20:36 <Slereah7> But my opinion so far is that it has the same kind of rules as any old language, except a lot more restrictive to remain "readable"
19:20:56 <Slereah7> And tries to weasel out of those flaws by saying "You should learn to program better!"
19:21:19 <Slereah7> "Nested conditionals? But you could do it with only one, if only you knew!"
19:21:41 <Slereah7> "Real numbers? Equations? But you could do everything with integers!"
19:21:51 <augur> :)
19:22:05 <Slereah7> ...
19:22:12 <Slereah7> I think it's an esolang in denial.
19:22:30 <Slereah7> He's not out of the BrainCloset.
19:23:35 -!- Sgeo has quit (Connection timed out).
19:29:43 <Slereah7> Is there a tutorial of that language that isn't infuriating?
19:30:57 -!- ais523 has joined.
19:31:35 <tusho> Slereah7: WHo uses it apart from them?
19:31:37 <tusho> (Guess: Nobody.)
19:32:32 <Slereah7> "And is robust enough to recompile itself. In less than three seconds."
19:32:38 <Slereah7> Why do they always say that?
19:32:48 <Slereah7> Is that even something so impressive?
19:33:25 <lament> what language you talks about?
19:33:39 <ihope> My Unlambda quine is robust enough a C compiler to recompile itself, in less than three seconds.
19:33:46 <tusho> heh
19:33:52 <Slereah7> lament : "Plain English"
19:34:00 <ihope> Not that I have an Unlambda quine. I should have said HQ9+ quine.
19:34:20 <lament> there's a programming language called plain english? Now that's confusing.
19:34:50 <Slereah7> https://www.osmosian.com/
19:35:02 <Slereah7> I wouldn't advise reading it, it's terribly infuriating.
19:35:24 <Slereah7> https://www.osmosian.com/cal-3037.zip for the manual and compiler
19:35:34 <lament> i won't read it.
19:35:59 <Slereah7> I want to find a manual that isn't (terribly infuriating)
19:36:08 <Slereah7> So that I may write a BF interpreter
19:36:11 <Slereah7> Just out of spite.
19:41:10 <ais523> ihope: there are Unlambda quines available on the Internet
19:41:26 <ihope> True, but I don't know if any of them take less than 3 seconds to run.
19:41:35 <Slereah7> heh
19:41:40 <ihope> "Q" certainly does take less than 3 seconds to run.
19:43:08 <Slereah7> I don't even know what he uses as data
19:43:14 <Slereah7> Tell me Osama!
19:46:25 <tusho> Oh, and welcome back ais523.
19:46:49 <ais523> ah, I was having internet trouble and decided not to reconnect to IRC while I was doing Notary stuff
19:46:55 <ais523> I'm still doing Notary stuff now, though
19:47:05 <ais523> I'm up to 18 May
19:47:12 <ais523> ihope really ended up quite a way behind...
19:57:24 <tusho> I'm glad coming up with a name for blohsom wasn't hard. That's normally hard. :P
19:58:53 <Slereah7> Also, what's with that full screen GUI?
19:58:57 <Slereah7> Aaaargh
19:59:04 <Slereah7> Everything about Osama is infuriating.
19:59:05 <tusho> Slereah7: It's because the kludge has a whore GUI of evil.
19:59:07 <tusho> Duh.
20:02:53 -!- Judofyr has joined.
20:04:26 <Slereah7> "By the way, the Plain English Compiler is written entirely in Plain English and can recompile itself - with all of its development tools - in less than 3 seconds on a bottom-of-the-line Dell."
20:04:34 <Slereah7> Oh fuck you "The Grand Negus".
20:04:43 <Slereah7> Osama is the new EsCo.
20:04:55 <Slereah7> Maybe we could hook them up.
20:04:56 <tusho> Slereah7: Rewrite EsCo in Osama!
20:05:01 <tusho> We think ailke.
20:05:02 <tusho> And alike.
20:08:29 <Slereah7> Aaaaargh
20:08:41 <Slereah7> No scroll bar = horrible for long texts
20:08:48 <Slereah7> I hate you Osama.
20:09:19 <Slereah7> Fuck that, I'm closing it
20:10:45 <ais523> how do you cast an integer to a real value in Haskell?
20:11:43 <tusho> ais523: fromInteger
20:11:55 <tusho> fromInteger :: (Num a) => Integer -> a
20:12:15 <ais523> thanks
20:15:44 <ais523> and how do you output a number without a newline after it?
20:18:44 <tusho> ais523: #haskell
20:18:47 <tusho> and putStr is putStrLn without the Ln
20:18:53 <ais523> that's for strings
20:19:03 <tusho> ais523: #haskell and type @src print
20:19:08 <tusho> you will gain enlighten.
20:19:27 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
20:19:33 <ais523> ah
20:19:54 -!- Judofyr has joined.
20:45:03 -!- RedDak has joined.
21:02:00 -!- Judofyr_ has joined.
21:03:17 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
21:03:26 -!- Judofyr_ has changed nick to Judofyr.
21:08:20 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
21:09:15 -!- puzzlet has joined.
21:11:55 -!- pikhq has left (?).
21:12:41 -!- cherez has quit (Read error: 104 (Connection reset by peer)).
21:15:00 -!- cherez has joined.
21:15:07 -!- cherez has left (?).
21:31:32 -!- Hiato has quit ("Leaving.").
21:37:39 <tusho> ais523: ihope: Slereah7: I need theories.
21:37:49 <tusho> why do non-internet-experienced people SOMETIMES ASK QUESTIONS IN ALL CAPS?
21:37:56 <ihope> Newton's gravi--oh.
21:37:58 <tusho> I mean, all caps isn't very nice in the real world, so why would they do it on the internet?
21:37:58 <ais523> TO MAKE THEM MORE VISIBLE?
21:38:14 <tusho> ais523: BUT SURELY THEY CAN SEE IT LOOKS RIDICULOUS
21:38:16 <ihope> To make them more visible, to show that they really want help, etc.
21:38:21 <ais523> and writing letters in allcaps in the real world is often done to make them more readable
21:38:26 <ihope> tusho: nope!
21:38:27 <ais523> like filling in forms in block capitals
21:38:32 <tusho> ihope: THEN WHY DO THEY MAKE NUMEROUS SPELLING AND GRAMMATICAL ERRORS AT THE SAME TIME?
21:38:38 <tusho> A WELL-THOUGHT OUT POST WILL SURELY BE LISTENED TO MORE
21:38:53 <ihope> tusho: because they don't know spelling and grammar?
21:39:07 <tusho> ihope: OKAY WELL THAT'S A LITTLE RIDICULOUS THEN
21:39:20 <ihope> And they don't have a spelling checker and/or don't bother to look up the difference between "your" and "you're" every time they use either.
21:39:41 <Slereah7> Because ALL CAPS IS CRUISE CONTROL FOR COOL
21:40:00 <ihope> Or they make so many spelling mistakes that it's tedious to right-click every red-underlined word to correct it, I suppose.
21:41:31 <ihope> And grammar checkers are quite fallible and not as easy to come by.
21:42:41 <tusho> Er. Last.fm lists the 7th track on Autechre's Draft 7.30 as Prince Moth Mothy Moth Moth.
21:42:46 <Slereah7> Maybe they just can't spell.
21:42:49 <tusho> (It's actually "VI AI 5".)
21:42:59 <tusho> PRINCE. MOTH. MOTHY. MOTH. MOTH.
21:43:12 <Slereah7> 10:MOTH GOTO10
21:43:30 <ihope> That's what I said. :-)
21:43:47 <tusho> Though it's not like Autechre's real track names are any less silly.
21:45:20 <tusho> Hm. I wonder what would happen if #esoteric denizens produced electronic music.
21:45:25 <tusho> Oooh.
21:45:32 <tusho> What about an esolang designed for making electronic music?
21:45:44 <Slereah7> Some sort of reverse Fugue?
21:45:55 <Slereah7> The Love Machine 9000 can produce music.
21:46:08 <Slereah7> Well, the windows version, at least
21:46:16 <Slereah7> I never found out how to do it on the penguin
21:46:17 <tusho> Slereah7: Yeah, but for electronic music.
21:46:20 <tusho> None of this traditional stuff. :P
22:02:19 -!- Slereah has joined.
22:02:19 -!- Slereah7 has quit (Read error: 104 (Connection reset by peer)).
22:14:39 <Slereah> http://img404.imageshack.us/img404/4636/wikionemillion8li.jpg
22:15:08 <tusho> heh
22:18:07 -!- ais523 has quit ("(1) DO COME FROM ".2~.2"~#1 WHILE :1 <- "'?.1$.2'~'"':1/.1$.2'~#0"$#65535'"$"'"'&.1$.2'~'#0$#65535'"$#0'~#32767$#1"").
22:21:22 <tusho> R.
22:31:17 -!- cherez has joined.
22:31:17 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
22:31:31 -!- cherez has left (?).
22:32:47 -!- Slereah7 has joined.
22:34:00 <tusho> http://www.daimi.au.dk/~eriksoe/Flip/index.html
22:34:02 <tusho> this news?
22:36:19 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
22:45:52 <tusho> z
23:05:19 <ihope> If freenode isn't a general-purpose IRC network, I wonder why every IRC channel in existence is on it.
23:06:07 <Slereah7> Well, all the chats I ever saw on freenode where tech-related.
23:06:44 <ihope> We speak Spanish in #linguistics!
23:07:14 <ihope> And Lojban in #lojban, and then you have all those science and AI channels.
23:07:18 <ihope> Not to mention #math.
23:10:10 <tusho> #lojban is kinda related
23:10:16 <tusho> Most interested parties are tech-related.
23:10:26 <tusho> #linguistics is stretching it, yes, but it's an open project, kinda
23:10:35 <tusho> #math ... ok ... not appropriate but you can see
23:10:45 <tusho> You won't find #Quake2Clan
23:11:22 <ihope> And I'm not interested in such things. :-)
23:11:55 <tusho> :P
23:25:20 <tusho> ihope: Is agora agooooo>
23:25:47 <ihope> Very agooooo>, I'm sure.
23:25:58 <tusho> AWSUM
23:26:40 <tusho> ihope: "Ed Murphy to Agora, Agora, Agora"
23:31:57 <augur> ok
23:32:15 <augur> i think we should do an esolang with transformations in the chomskyan sense.
23:32:20 <tusho> okay.
23:32:32 <augur> primarily because transformations are supposedly a bitch to parse.
23:50:08 -!- jix has quit ("CommandQ").
←2008-06-09 2008-06-10 2008-06-11→ ↑2008 ↑all