2008-06-10 - freenode:#esoteric

←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