00:28:30 -!- nazgjunk has quit ("Leaving").
00:33:46 <RodgerTheGreat> I don't think humans function in a non-axiomatic way, we're just orders of magnitude more complex than any AI ever constructed
00:43:32 <lament> humans function in a non-axiomatic way, unless you consider the laws of physics to be axioms.
00:43:51 <lament> humans, after all, are physical objects, and not mathematical abstractions like computer programs.
00:59:03 -!- sebbu2 has quit (Client Quit).
01:06:22 <SevenInchBread> I would say... equating human behavior to algorithmic processes is... dangerous
01:06:41 <SevenInchBread> but... highly common in this kind of area.
01:19:56 <bsmntbombdood> http://rendell-attic.org/gol/tm.htm
01:32:49 -!- wooby has joined.
01:39:36 <RodgerTheGreat> I don't see anything particularly problematic with saying that humans are axiomatic machines- we're complicated enough to make reliable modeling difficult, but it doesn't make us magical.
01:40:12 <bsmntbombdood> but we are
01:40:17 <bsmntbombdood> our axoims change
01:40:54 <RodgerTheGreat> any complex ordered system appears random when viewed without enough context
01:43:48 <RodgerTheGreat> things like intuition are simply algorithms that function below our level of consciousness. Just because we can do things without "thinking in algorithms" (at a high level) doesn't mean they don't exist.
01:45:30 <RodgerTheGreat> and I tend to write off the things that human brains are good at that conventional software fails at as a function of a dramatically different approach to the problem. Computers and brains do some of the same things, but they do so in completely different ways.
01:58:38 <lament> RodgerTheGreat: you can fuck with human brain in arbitrary ways and it still works.
01:58:42 <lament> RodgerTheGreat: it's a physical object.
02:09:52 -!- wooby has quit.
02:39:52 <SevenInchBread> One huge difference is the way signals are processed...
02:41:28 <SevenInchBread> Brains reconfigure their physical properties at frequent intervals... use electricity and chemicals to form reactions... and have totally different methods of operation.
02:41:57 <SevenInchBread> At a higher level these differences become less signifigant - however they are still there.
03:07:06 -!- Sgeo has joined.
03:17:24 <bsmntbombdood> SII(S(KK)(SII))
04:00:47 -!- SevenInchBread has quit ("haaaaaaaaaa").
05:11:40 <RodgerTheGreat> good night everyone
05:12:04 -!- wooby has joined.
05:19:04 -!- anonfunc has joined.
05:34:40 -!- oerjan has joined.
05:55:57 -!- ShadowHntr has joined.
06:08:16 * oerjan wishes to point out that the book "Maths made difficult", which started a discussion of how the word "maths" is ridiculous, actually is named "Mathematics made difficult".
06:11:40 -!- GreaseMonkey has joined.
06:19:32 -!- thematrixeatsyou has joined.
06:20:10 -!- GreaseMonkey has quit (Nick collision from services.).
06:20:44 -!- thematrixeatsyou has changed nick to GreaseMonkey.
06:21:15 -!- RoboMonkey has joined.
06:22:28 <oerjan> ~bf ,[.,]!Test
06:22:54 <GreaseMonkey> what bot is that for?
06:22:58 <oerjan> ~exec execfile("/bot/scripts/bf.py")
06:23:03 <oerjan> ~bf ,[.,]!Test
06:23:03 <bsmnt_bot> Test
06:23:06 <GreaseMonkey> k
06:36:06 <oerjan> darn it's annoying reading the logs when you want to comment on everything people said while you were asleep.  And now they are.
06:41:26 <GreaseMonkey> uhuh
06:54:36 <lament> your mom's asleep.
07:11:29 -!- anonfunc has quit.
07:12:03 -!- Sgeo has quit (Remote closed the connection).
07:30:59 -!- GregorR has joined.
07:58:02 <GreaseMonkey> afk, food
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:01:04 <oerjan> atk, coffee
08:08:07 -!- ShadowHntr has quit (Read error: 110 (Connection timed out)).
08:08:40 <GreaseMonkey> back
08:09:36 <oerjan> front
08:12:39 <GreaseMonkey> up
08:15:51 <oerjan> vinn
08:19:21 <GreaseMonkey> asdf
08:20:58 <oerjan> jkl
08:22:22 <GreaseMonkey> you forgot the semicolon
08:22:35 <oerjan> jklø
08:22:47 <GreaseMonkey> ;;;;;;;;;;;;;;;;;;;;
08:22:51 <oerjan> my keyboard isn't English :)
08:22:57 <GreaseMonkey> ok
08:23:08 <GreaseMonkey> yuiop
08:23:21 <GreaseMonkey> what keymap is it?
08:23:25 <GreaseMonkey> mine's qwerty
08:23:33 <oerjan> norwegian qwerty
08:23:40 <GreaseMonkey> oh ok
08:24:07 <oerjan> the numbers and english letters are in the same place
08:26:18 <GreaseMonkey> ok, i'm learning C++. any suggestions on what to do with it?
08:26:43 <oerjan> i don't know C++
08:27:40 <oerjan> but the obvious answer is to create an esoteric language interpreter :)
08:28:52 <oerjan> or a compiler into C++
08:31:43 <GreaseMonkey> C++ is esoteric enough
08:32:32 <oerjan> i'm not so sadistic as to suggest you write a C++ compiler
08:34:10 <oerjan> a cellular automaton perhaps?
08:49:02 <GreaseMonkey> hmmm...
09:36:07 -!- RoboMonkey has quit (Client Quit).
09:36:33 -!- RoboMonkey has joined.
09:56:18 -!- ShadowHntr has joined.
09:58:51 <GreaseMonkey> meh, i'm bored
09:58:53 <GreaseMonkey> \viagra
09:58:54 <RoboMonkey> GAY SEX BIG COCKS HORSE FUCK GOATSE.CX CHEAP XANAX HOT PR0N GAY SEX HORSE FUCK BRITNEY SPEARS POOOOOOOOORN RUB GAY BOYS POOOOORN FLIRT TAPE ERRECT1ON HORSE FUCK GOATSE
09:59:12 <oerjan> bored and perverted :)
09:59:33 <GreaseMonkey> it's me taking the mick out of spammers
10:00:55 <GreaseMonkey> there's 20 different messages
10:20:55 <GreaseMonkey> gonna go sleep, gnight
10:23:49 -!- GreaseMonkey has quit ("ext2 > ntfs").
10:23:57 -!- RoboMonkey has quit (Remote closed the connection).
10:24:50 -!- sebbu has joined.
10:29:19 -!- ShadowHntr has quit (Client Quit).
12:41:00 -!- sebbu has quit ("reboot").
12:57:37 -!- sebbu has joined.
13:56:00 -!- RodgerTheGreat has quit.
13:57:24 -!- oerjan has quit ("leaving").
14:23:06 <SimonRC> \help
14:23:14 <SimonRC> oh, it's gone
14:31:11 <oklopol> was thinking about the rubik's cube... and invented A TOTALLY NEW WAY OF PROGRAMMING WHERE YOU DESCRIBE A PROBLEM AND LET THE COMPUTER SOLVE IT ON IT'S OWN! then i come home and pick a fucking random book, and it's about prolog............
14:31:25 <oklopol> what are the odds :<
14:31:27 <oklopol> really
14:31:30 <oklopol> what are they?
14:32:30 <SimonRC> hehe
14:33:31 <SimonRC> I wouldn't say that humans had any more power than Turing machines.
14:33:47 <oklopol> i'm pretty sure i had a cooler way of describing problems of that nature... a rubik's cube is hell to describe to a computer in most languages
14:33:57 <SimonRC> Just look how long it took for us to solve Fermat's Last Theorem.
14:34:23 <oklopol> this is where oerjan comes in and shows me a haskell 2-liner making my language redundant
14:34:39 <SimonRC> heh
14:34:48 <SimonRC> hmm, rubik's cube...
14:35:28 <oklopol> "the haskell puzzle game library"
14:36:01 <oklopol> rubik's cube is hard to represent as linked lists (probably because i suck though)
14:36:17 <oklopol> because you get confused because there is no "up"
14:36:25 <oklopol> if you get my meaning
14:36:27 <SimonRC> actually...
14:36:39 <SimonRC> consider the bit of plastic in the middle...
14:36:54 <SimonRC> you can do any move while keeping that piece of plastic in the same position
14:37:37 <SimonRC> this suggest that a 3*3*3 array is a good representation
14:37:56 <oklopol> clever
14:38:23 <oklopol> but, no language i know of makes let's you define rules that understand the symmetry
14:38:44 <oklopol> i mean, you have to do some manual abstractioning to be able to use all rotates the same way
14:38:45 <oklopol> hmm
14:38:50 <oklopol> i dunno if i make any sence :)
14:39:26 <SimonRC> yes
14:39:38 <SimonRC> actually, no...
14:40:21 <SimonRC> I think you can write a function in Haskell that re-arranges the meaning of the axes for another function
14:40:30 <SimonRC> that helps a lot
14:41:44 <oklopol> true, i like making new languages more than using the old ones though, even though it's rarely necessary :)
14:42:41 <bsmntbombdood> GregorR: don't learn C++
14:42:52 <bsmntbombdood> oops, that was for greasemonkey
14:42:55 <bsmntbombdood> guess he's not here
15:27:44 -!- jix has joined.
15:42:28 -!- jix__ has joined.
15:50:57 -!- jix has quit (Read error: 113 (No route to host)).
15:52:11 -!- RodgerTheGreat has joined.
16:09:34 <oklopol> i'm pretty sure i could get prolog easier to program in... but even more sure it's already been done :)
16:10:01 <oklopol> since i don't really know any other lang like this but i hear there are such
16:58:55 -!- RodgerTheGreat has quit.
17:35:52 <oklopol> how short can quicksort be made if one can use any lang?
17:36:05 <oklopol> i can't find a K version
17:36:19 <oklopol> qs=: (($:@(<#[) , (=#[) , $:@(>#[)) ({~ ?@#)) ^: (1<#)
17:36:24 <oklopol> J sucked ass ^^^^^^
17:36:28 <oklopol> in being short
17:38:10 <oklopol> i managed to get it in 36 chars in oklotalk, i'm wondering if i have to improve that
17:45:48 <oklopol> 28 now
17:48:40 <SimonRC> qs(x:s)=(\(y,z)->y++x:z)$partition(<x)s;qs[]=[]    -- haskell
17:49:24 <oklopol> [18:35:11] <oklopol> can someone show me as short a haskell quicksort 
17:49:24 <oklopol> [18:36:22] <quicksilver> oklopol: qsort (x:xs) = qsort (filter (<x) xs) ++ [x] ++ qsort (filter (>x) xs); qsort [] = []
17:49:24 <oklopol> [18:37:36] <SamB> oklopol: well, that was probably about as short as it gets
17:49:29 <oklopol> #haskell
17:49:42 <oklopol> oh
17:49:48 <oklopol> indeed a lot of whitespace
17:50:13 <SimonRC> plus mine iterates through the input only once before recursing
17:50:19 <oklopol> i assumed they'd've understood what i meant by as short as possible (whoops cut the line in copy paste)
17:50:36 <SimonRC> actually...
17:51:35 <oklopol> i don't think yours works :\
17:51:36 <SimonRC> q(x:s)=(\(y,z)->q y++x:q z)$partition(<x)s;q[]=[]    -- haskell, now actually works
17:51:39 <oklopol> then again i don't know haskell
17:51:41 <oklopol> oki
17:51:42 <oklopol> :)
17:52:08 <oklopol> hmm
17:52:17 <oklopol> no hmm, sorry :)
17:52:19 <SimonRC> only 50 chars
17:53:02 <SimonRC> o mean, 39
17:53:41 <SimonRC> It assumes you've imported Data.List though, which most modules of a Haskell program will do anyway.
17:55:24 <SimonRC> oklopol: define: oklotalk
17:55:39 <oklopol> it's an apl derivative i've been making
17:55:46 <SimonRC> on the web/
17:55:49 <SimonRC> ?
17:55:51 <oklopol> though is a lot different from apl now
17:55:52 <oklopol> ?
17:55:55 <oklopol> not yet anywhere
17:56:00 <oklopol> i'm running it in my head 
17:57:20 <oklopol> it's more something between python and haskell now... since i don't like pure functionalism :|
18:00:02 <oklopol> i think it'd be {[]->[];x:s->{._+$x:.__}`{x>}PS}
18:00:23 <oklopol> with your code + haskell -> oklotalk
18:01:36 <oklopol> whoops, {[]->[];x:s->{'_+$x:'__}`{x>}PS} actually
18:01:37 <oklopol> :)
18:01:41 <oklopol> ' == outer lambda
18:01:48 <oklopol> . == this lambda :)
18:02:07 <SimonRC> bah
18:02:08 <oklopol> :<
18:02:32 <oklopol> you mother!
18:02:35 <oklopol> *your
18:02:50 <oklopol> *it is
18:04:06 <SimonRC> A friend of mine invented the evil smiley
18:04:07 <SimonRC> :>
18:04:24 <SimonRC> If you want to know why it is evil, give it a filename:
18:04:31 <SimonRC> :> /dev/kmem
18:04:41 <SimonRC> ok, maybe not that
18:04:57 <SimonRC> :> /vmlinuz
18:05:04 * oklopol has :> windows
18:08:38 <oklopol> another quicksort, oklotalk style {_~/*/`{!-_<!_}\1}
18:08:52 <SimonRC> !
18:08:54 <oklopol> well, {_~$/*/`{!-_<!_}\1} actually... 
18:09:04 <SimonRC> expln plz
18:09:17 <oklopol> but, it uses a few features i'm prolly never going to be able to implement :)
18:09:34 <oklopol> well, oklotalk has regexes extended to any lists
18:09:42 <SimonRC> like Haskerl?
18:09:45 <oklopol> so you can create a list that just explains a form of a list
18:09:47 <oklopol> maybe
18:09:51 <oklopol> i don't know haskell :)
18:09:59 <SimonRC> nonono, Haskerl
18:10:12 <SimonRC> anyway, ontinue expln
18:11:13 <oklopol> yeah, wait a mo
18:12:24 <oklopol> damn, i have to think this over, since i found an inconsistency :)
18:12:40 <oklopol> i forgot a func can be a part of a regex list as well
18:12:51 <oklopol> hmm, i'll explain after i've figured this out
18:12:52 <oklopol> anyway
18:13:03 <oklopol> it was not quicksort :)
18:13:25 <oklopol> it was sort, left for the interpreter to brute force :P
18:13:33 <oklopol> so not that great
18:13:34 <SimonRC> how
18:13:56 <oklopol> no way specified, the form of a sorted list is explained as a list regex
18:14:08 <oklopol> ~ mean 'make into form _ by reordering'
18:14:11 <oklopol> *means
18:15:04 <oklopol> but, i don't think that feature can do anything this complicated, it'd prolly just crash
18:15:32 <SimonRC> hm
18:15:40 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
18:19:40 <oklopol> k
18:19:45 <oklopol> i can flood explanations now
18:19:46 <oklopol> /*/({!-_<!_}\1) is the regexish list (where i had to add parens and remove a `)
18:19:46 <oklopol> /*/ in a list means 'any times the following'
18:19:46 <oklopol> `{} quotes a lambda
18:19:46 <oklopol> \1 is a list variable, kinda like in a regex
18:19:46 <oklopol> now if an unquoted function is encountered ({!-_<!_} here), it's added to a list of orred constraint lambdas
18:19:48 <oklopol> (a quoted function `{...} would just be a normal function value treated as a first-class citizen)
18:19:50 <oklopol> when the subexpression {!-_<!_}\1 is done, only \1 is left
18:19:51 <oklopol> this would mean ANY list without the lambda before it
18:19:54 <oklopol> it defines the value must return true assigned to it to be of that form (orred constraint lambda comes from that)
18:19:56 <oklopol> {!-_<!_} is a function that takes an iterator and tells whether the last index contains a smaller number than the next
18:19:59 <oklopol> _ is the iterator, -_ is the last place, !<any iterator> means value
18:20:53 <oklopol> but, since i specified how regex lists worked just now, they might be changed radically... for example i might make explicit lambdas are xorred (in case of more lambdas)
18:21:01 <oklopol> *make it explicit
18:21:56 <lament> You know what would be cool.
18:21:59 <lament> Lambada calculus.
18:22:25 <oklopol> but, a feature i know how to implement, list comprehensions, '1 1{!-_+!--_}' is the fibonacci series
18:22:40 <oklopol> (okay, i might die making infinite lists possible :))
18:24:43 <oklopol> (\0, not \1)
18:24:52 <oklopol> since it's applied as the first argument
18:41:22 -!- asiekierka has joined.
18:41:23 <asiekierka> Hi!
18:41:45 <asiekierka> i thought of doing a "Sexy esoteric language"
18:41:48 <asiekierka> with 2 words:
18:41:55 <asiekierka> "naked" "female"
18:41:57 <asiekierka> but i doubt
18:41:59 <asiekierka> i'm 10 yrs old
18:42:16 <oklopol> true, your mom might dislike it
18:42:32 <asiekierka> my dad wouldn't
18:42:36 <asiekierka> he likes that stuff
18:42:49 <asiekierka> a "Quit" will look like this: -nakedfemale
18:42:58 <asiekierka> "begin" = +nakedfemale
18:43:00 <asiekierka> XD
18:43:24 <oklopol> "naked men" as commands might be a way to get more young women interested in esoteric programming
18:43:46 <asiekierka> while naked woman - naked mens
18:43:55 <asiekierka> more like
18:43:57 <asiekierka> young man
18:44:03 <asiekierka> i wouldn't do it
18:44:05 <asiekierka> just giving out
18:44:07 <asiekierka> ideas for you
18:44:09 <asiekierka> guys to do
18:44:10 <asiekierka> it.
18:44:45 <oklopol> thank you
18:44:50 <oklopol> we'll promise to think about it
18:44:59 <asiekierka> ... tell me when done
18:45:08 <oklopol> ...will do
18:45:18 <asiekierka> It will be capable of writing only some words: naked, unnaked, female, male, idiot.
18:45:38 <asiekierka> so, to type: nake "naked male"
18:45:41 <asiekierka> will type naked male
18:45:50 <asiekierka> so it's working actually
18:45:54 <asiekierka> but 15+
18:46:16 <oklopol> i think all esolangs have a recommended age of 15+
18:46:33 <asiekierka> not all
18:46:40 <asiekierka> Brainf**k?
18:46:45 <asiekierka> Cat?
18:47:08 <asiekierka> what about PS2lang?
18:47:10 <lament> asiekierka: what's the recommended age of brainfuck?
18:47:13 <asiekierka> it wouldn't be esoteric
18:47:22 <asiekierka> ... except "brainfuck" word it is 7+ i think
18:47:29 <oklopol> not because of profanity
18:47:36 <asiekierka> ???
18:47:38 <asiekierka> i'm from poland
18:47:47 <oklopol> i'm from finland
18:47:54 <lament> i'm from blahland
18:47:57 <oklopol> bad words
18:47:58 <asiekierka> i'm from Mars
18:47:59 <oklopol> ==
18:48:01 <asiekierka> who cares?
18:48:01 <oklopol> profanity
18:48:11 <asiekierka> ok
18:48:12 <asiekierka> 12+
18:48:57 <asiekierka> http://tunes.org/~nef/logs/esoteric/06.08.10 - log when i was here.
18:51:12 <lament> who cares?
19:14:20 -!- helios24 has quit (Read error: 148 (No route to host)).
19:37:01 -!- crathman has joined.
19:44:07 -!- oerjan has joined.
20:04:10 -!- helios24 has joined.
20:16:29 -!- crathman_ has joined.
20:16:36 -!- crathman_ has quit (Remote closed the connection).
20:26:37 <oklopol> hmm
20:27:47 <oklopol> can someone tell me a nice regex way to change all occurrances of more than one whitespace in a row into " "+("&nbsp;"*(occurrances-1)) in php
20:34:12 -!- crathman has quit (Read error: 110 (Connection timed out)).
20:34:39 * SimonRC goes away
20:43:11 <oerjan> i don't know php but in perl you could do s/ ( +)/" "."&nbsp"x length($1)/e;
20:44:07 <oerjan> */eg;
20:46:02 <oerjan> *;
20:46:39 <oerjan> (that last one after nbsp
20:46:43 <oerjan> *)
20:53:23 <oklopol> well, someone in #php almost solved my problem, but it was close enough :)
20:53:54 <oklopol> i thought perl must have variables created for \1 etc
20:54:05 <oklopol> since it seems to like regexes
20:54:58 <oerjan> yep
20:55:16 <oklopol> hehe, they banned me on ircnet because of my nick :P
20:55:20 <oklopol> it was ^__^ though
20:55:36 <oklopol> bastards
21:17:17 -!- SevenInchBread has joined.
21:31:35 -!- asiekierka has quit.
22:35:39 <SevenInchBread> ...hmmm... I haven't figured out the difference between lexical scope and dynamic scope.
22:36:10 <SevenInchBread> anyone want to explain?
22:36:23 <oerjan> well..
22:36:36 <lament> well..
22:36:48 <lament> lexical scope: makes sense.
22:36:52 <SevenInchBread> ....
22:36:54 <lament> dynamic scope: doesn't
22:36:57 -!- RodgerTheGreat has joined.
22:37:04 <lament> do you need a more in-depth explanation? :)
22:37:09 <SevenInchBread> oh - all is revealed to me now - thanks lament.
22:37:14 <RodgerTheGreat> hi guys
22:37:29 <SevenInchBread> lament, preferably. :)
22:37:39 <oerjan> there are situations when dynamical scope is useful.
22:37:57 * bsmntbombdood doesn't know the distinction either
22:38:28 <oerjan> let's say you have a nested function like
22:38:56 <oerjan> f x = let g y = x + y in g
22:40:16 <oerjan> and consider the expression let x = 3 in f 1 x
22:42:01 <oerjan> with lexical scope, the x in the g definition will refer to the x parameter of f, whose definition contains the definition of g
22:42:17 <lament> ..i'm sure there's an easier way to explain this :)
22:42:25 <SevenInchBread> ...
22:43:11 <SevenInchBread> alright. I think I follow.
22:43:22 <oerjan> so f 1 x == f 1 3 == g 3 == 1+3 == 4
22:43:35 <bsmntbombdood> ok...
22:44:10 <oerjan> with dynamical scope, however, the x in the g definition will refer to whatever is x's value at the point g is _called_
22:44:31 <bsmntbombdood> oh
22:44:35 -!- crathman has joined.
22:44:35 <bsmntbombdood> that doesn't make much sense
22:44:36 <oerjan> which will be 3
22:44:40 <bsmntbombdood> what language uses that?
22:44:50 <oerjan> old style LISP
22:44:51 <SevenInchBread> hmmm....  I could see that being useful.
22:45:18 <SevenInchBread> for example. in places where you don't have closures.
22:45:25 <oerjan> there is a Haskell extension for dynamically scoped variables
22:45:27 <bsmntbombdood> even C isn't like that
22:45:52 <SevenInchBread> and you want to do something like a for loop as a function... but there isn't a closure construct.
22:45:56 <oerjan> eh, lexical scoping essentially _is_ closures
22:46:39 <SevenInchBread> hmmm... IO has blocks (dynamical scope) and methods (lexical scope)
22:47:24 <SevenInchBread> ALSO
22:47:50 <SevenInchBread> I found a nifty way to simulate lines without using lines in my Sophia language.
22:49:09 <SevenInchBread> functions that don't return values will simply return the calling context (the "self" variable from the calling scope)
22:49:47 <SevenInchBread> so any messages sent after that will be treated like a new line.
22:51:24 <oerjan> another way to look at dynamical scoping is that all variables are global, but are saved and restored on function calls
22:51:51 <oerjan> (this shows why they are very simple to implement)
22:52:04 <SevenInchBread> hmmm... kind of messy for functional languages... but it makes sense for procedural languages.
22:52:21 <lament> no it doesn't.
22:52:22 <SevenInchBread> or "stackless" languages..
22:52:41 <lament> it only 'makes sense' in that it's practically trivial to implement.
22:52:51 <oerjan> it makes sense for languages with absolutely no nesting, i suppose
22:53:26 * SevenInchBread sighs and shakes head at lament.... :/
22:54:24 <SevenInchBread> ...reminds me of myself back when I thought pointers were evil.
22:55:14 <lament> oh, i'm not saying it's evil
22:55:21 <lament> it is.... esoteric
22:55:28 <oerjan> but as said, it makes sense to have the option of having a variable dynamic
22:55:49 <lament> it goes against the way people normally think of programs.
22:55:58 <lament> thus, it makes programming harder.
22:56:07 <lament> same with pointers by the way.
22:56:11 <SevenInchBread> -snicker- I blame that on the programmer then.
22:58:46 <SevenInchBread> anything is alien until you get used to it.
22:58:52 -!- _0xff has joined.
22:59:16 <bsmntbombdood> pointers are fun
23:00:19 <lament> SevenInchBread: spaghetti techniques are not "alien", they're just impossible to organize nicely
23:00:19 <lament> SevenInchBread: dynamic scoping is a spaghetti technique
23:00:34 <SevenInchBread> One of the restrictions that I find with Python is that you can't alter anything beyond your scope... because there's nothing like a pointer.
23:00:57 <bsmntbombdood> SevenInchBread: globals, mutable objects
23:01:29 <SevenInchBread> -shrug- mutable objects are the exception... but globals are still "in scope".
23:01:40 <lament> um.
23:01:46 <lament> you are confused.
23:01:55 -!- _0xff has left (?).
23:01:59 <lament> in C, you can only 'alter' something on the end of a pointer if you get passed the pointer.
23:02:06 <lament> in Python, it's the same.
23:02:19 <lament> you can only alter something on the end of an object if you get passed the object.
23:02:51 <SevenInchBread> I'm talking about references... there's no way to say "make all references that point to this object now point to this object"... that's sometimes useful.
23:03:20 <lament> SevenInchBread: in C, you can't do that to pointers either.
23:03:40 <lament> but i see what you mean.
23:03:54 <SevenInchBread> I'm actually playing around with that a little... using ID numbers.
23:03:55 <lament> and Python doesn't have that for a very good reason.
23:04:04 <SevenInchBread> because Python is uber-conservative...
23:04:19 <lament> no, because python is well-designed.
23:05:26 <SevenInchBread> -chuckle- it's well-designed if you like everything child-proof.
23:05:30 <lament> no
23:05:34 <lament> i'm not talking about child-proof
23:05:40 <SevenInchBread> ?
23:05:56 <lament> it's well-designed conceptually
23:06:23 <lament> 1) everything is an object
23:06:29 <lament> 2) names are labels given to objects
23:06:53 <SevenInchBread> ....other languages don't do number 2?
23:07:03 <lament> not usually
23:07:05 <lament> Scheme does
23:07:20 <SevenInchBread> ...how else would it work?
23:07:24 <lament> well
23:07:46 <lament> if you could say 'have all references to this object now point to that object'
23:08:00 <SevenInchBread> ah...
23:08:02 <lament> that would be a more complex model
23:08:16 <lament> for one, you had to use the word 'reference'
23:08:38 <lament> i am lament
23:08:44 <lament> you could potentially have another irc user named lament
23:08:51 <lament> but you can't just go and have ME be NOT ME
23:08:52 <bsmntbombdood> yeah
23:09:19 <SevenInchBread> the way I've considered doing it... is to have an array of objects... with names being "symbols" that points to an index on the array. So swapping out objects is a matter of reassigning an index of this array. It's similar in certain regards to pointers - but less grounded in computerism.
23:09:44 <bsmntbombdood> that's exactly what pointers are
23:12:13 <SevenInchBread> -nod- different analogy... and different mode of operation on the end (instead of referencing and dereferencing addresses and the like you're assigning symbols or objects)
23:12:57 <lament> say in python, "a = 3" - it's better to think of it not as "a is pointing to 3", but as "a MEANS 3"
23:13:51 <SevenInchBread> |x| := 2      --assign the symbol x to 2
23:13:52 <SevenInchBread> x := 2         --assigns the object represented by x to 2
23:15:28 <SevenInchBread> |x| := "This is the text of the universe"
23:15:30 <SevenInchBread> |y| := x
23:15:32 <SevenInchBread> x := "There is a paradigm shift" ---both and |x| and |y| are changed.---
23:16:51 <bsmntbombdood> that's ugly
23:17:28 <bsmntbombdood> terribly so
23:17:44 <oerjan> i have considered a different model for Reaper and Forte.
23:18:12 <SevenInchBread> hmmm... it makes sense to me... if you think := being the method of an object.
23:19:15 <oerjan> with anything able to be redirected.
23:19:22 <SevenInchBread> and if you think of |x| as "the symbol x" and x as "the object represented by x"
23:19:36 <SevenInchBread> ...it makes perfect sense to me.
23:19:46 -!- sebbu2 has joined.
23:19:56 <bsmntbombdood> there's scoping problems too
23:21:18 <SevenInchBread> hmmm, what kind?
23:22:48 <bsmntbombdood> a variable means different objects in different scopes
23:24:19 <SevenInchBread> scopes are just objects... all variables pointing to "This is the text of the universe" are redirected to "There is a paradigm shift"... it's an absolute change in an objects identity - rather than a relative change in a names references.
23:25:13 <lament> an "absolute change in an objects identity" is a rather counter-intuitive operation, don't you think?
23:25:30 <lament> the whole point of OOP was that it was supposed to follow human intuition of "objects"
23:25:50 <SevenInchBread> no... pretty straight foreward. You have this entity that exists beyond all names, and it can be altered.
23:26:01 <lament> "an absolute change in an object's identity" only happens in fairy tales
23:26:15 <oerjan> and in Reaper and Forte.
23:26:16 <lament> when something gets turned into something completely different :)
23:27:00 <SevenInchBread> I see it being useful... where you have stuff that gets distributed around quite a bit and you don't wish to keep track of all the names.
23:27:30 <lament> SevenInchBread: give an example.
23:27:32 <oklopol> "make all references that point to this object now point to this object" << is there any language that provides this feature?
23:27:41 <oerjan> Reaper and Forte.
23:27:41 <oklopol> i had this idea of a reverse-pointer esolang
23:27:50 <GregorR> *whew*
23:27:55 <oklopol> you can do some neat stuff with that... though only some
23:27:59 <SevenInchBread> ...well, the concept of Sophia has it... but I haven't implemented Sophia yet
23:28:14 <lament> SevenInchBread: give an example of "object identity replacement" being useful
23:30:15 <lament> http://esolangs.org/wiki/Processor/1  -- how is that remotely esoteric?
23:30:32 <oklopol> i almost read about reaper... but the lesson ended
23:31:27 <lament> that page (Processor/1) is the only contribution by its creator...
23:31:45 <SevenInchBread> lament, a GUI.. where you store text in a string. A function that you want to redefine. If you have a listing of default values that are copied at multiple places - and you'd like to totally shift every variable that points to this default value. 
23:31:45 <oerjan> well reaper remains vaporware alas...
23:32:12 <oerjan> but ais523 implemented Forte.
23:32:52 <bsmntbombdood> lament: so?
23:32:56 <oklopol> oh forte looks cool, i didn't quite understand reaper from the definition on esolangs.org
23:33:44 <lament> bsmntbombdood: i think he might be confused over what's considered esoteric
23:34:03 <lament> SevenInchBread: i don't understand that.
23:34:17 <SevenInchBread> lament, it was three examples.
23:34:27 <SevenInchBread> ...just in case they semantically blurred together.
23:34:28 <lament> SevenInchBread: give one. :)
23:34:40 <SevenInchBread> ....but I did. o.o
23:34:41 <oklopol> "A function that you want to redefine."
23:34:47 <oklopol> this is kinda obvious
23:34:50 <lament> why would you want to redefine a function?
23:35:09 <oklopol> to make it faster and sexier
23:35:31 <SevenInchBread> -shrug- I've had situations where I'd want to alter a function in runtime. Not all applications are statically defined in source.
23:36:09 <lament> well, functions are inherently a bit tricky
23:36:10 <oklopol> mmm yeah i didn't fail, you often want to make a function faster at runtime :)
23:36:21 <oklopol> allll the time
23:36:24 <lament> because there's an issue of how are they represented as objects
23:36:38 <lament> if the function is a _method_, you can just change the method.
23:36:47 <lament> if it's an _object_, then that's a bit weird
23:36:49 <SevenInchBread> especially in programs who have the task of being programmable by themselves....
23:36:51 <lament> (python is a bit weird)
23:37:37 <lament> i'm not sure if it makes sense for functions to be objects.
23:37:39 <SevenInchBread> but see... a function can be dispersed across multiple names... not just the one you defined it as... thus it's handy to have an -identity replacement- ;)
23:38:37 -!- sebbu has quit (Connection timed out).
23:38:45 <lament> i think in this case our design is broken
23:38:56 <lament> it should still be the same function, but with a different behavior
23:38:57 <SevenInchBread> ...I don't really see too many uses for it... it simply arose naturally out of my attempt to objectitize the variable. :)
23:39:07 <lament> ie the function's _code_ should be a property of the function _object_
23:39:29 <lament> because otherwise hte operation of 'changing the function' doesn't make sense
23:39:55 <SevenInchBread> basically... it's similar to an in-place operation...
23:40:10 <SevenInchBread> just... with an entirely new object.
23:40:14 <lament> are you replying to me?
23:40:16 <lament> i guess not :)
23:40:22 <oklopol> i think it'd be rude if pointers did not follow an object moving around in the memory :|
23:40:45 <oklopol> it'd be all alone
23:41:19 <bsmntbombdood> dangling pointer
23:42:07 <GregorR> (Perverse)
23:42:21 <SevenInchBread> lament,  sure... there's a flaw in your design... if the language you're using to make the design isn't capable of doing things like that. 
23:42:31 <lament> i'm not using any language
23:42:41 <SevenInchBread> -nod- it was an "example you".
23:42:44 <SevenInchBread> as in "one"
23:43:24 <SevenInchBread> THE HYPOTHETICAL IDENTITY. :o
23:43:31 <lament> I still can't think of any case where it makes sense to change the identity of an object
23:43:47 <lament> as opposed to a property
23:43:49 <SevenInchBread> -shrug- me neither... not usually anyways. I just like it conceptually.
23:44:09 <lament> I don't, because it's unnaturaly.
23:44:10 <lament> -y
23:44:54 <lament> i think it's counterintuitive and not something my brain expects of everyday objects.
23:45:19 <lament> "Suddenly, the toaster in my kitchen becomes a shark swimming in the pacific ocean!"
23:45:30 <SevenInchBread> REALITY IS A CRUX
23:45:35 <SevenInchBread> WE ARE IN THE SURREAL WORLD
23:45:45 <SevenInchBread> WHERE THE IDENTITY IS MALLEABLE.
23:45:57 <lament> well, sure
23:46:10 <SevenInchBread> ABANDON ALL COHERANCY.
23:46:19 <lament> like i said, the best example of objects actually changing identity i can think of is fairy tales and magic :)
23:46:31 <SevenInchBread> ....order is for chumps anyways. and magic makes for a fun afternoon.
23:46:41 * SevenInchBread enjoys some good programming voodoo.
23:47:11 <lament> SevenInchBread: changing object identity also leads to horrible, horrible things such as changing 2 to 3
23:47:33 <oklopol> http://www.esolangs.org/wiki/Forte this is so cool <3
23:48:01 <SevenInchBread> lament, we should change 4 to 5... because 4 is a terrible number.
23:48:03 <lament> SevenInchBread: either you allow changing 2 to 3, or you place arbitrary restrictions on what can be changed and what can't
23:48:05 <SevenInchBread> I see nothing wrong with this.
23:48:50 <SevenInchBread> I'm something of a programmer liberal.... no restrictions on what's possible.
23:48:53 <oklopol> you might be able to change 2 to 3, then again in some languages you are allowed to segfault
23:48:57 <lament> well, it's not any more wrong than changing object identity in general :)
23:49:33 <lament> "I change 'hello' to be 'world'. World world!"
23:49:42 <SevenInchBread> Here's another use... if you represent string concatenations as objects in their own right.
23:49:51 <lament> i suppose that's exactly what forte does? heh
23:51:22 <lament> wow, forte IS cool.
23:51:31 <SevenInchBread> |x| = "o"
23:51:32 <SevenInchBread> |y| = "Hell" + x + "o, World!"
23:51:33 <oklopol> yep :P
23:51:34 <SevenInchBread> x = "p"
23:51:35 <SevenInchBread> y print   ---Hellp, World!---
23:51:42 <SevenInchBread> er... without the o in "o, world!"
23:52:26 <SevenInchBread> ...it kind of goes away from the traditional programmers concept of "operations return values"... now things become a matter of identity - and the parts it takes to construct the whole.
23:53:06 <lament> oh holy crap forte is awesome
23:53:23 <oklopol> :P
23:53:32 <bsmntbombdood> heh, forte look fun
23:55:22 <oklopol> where can you get the interpreter?
23:55:29 <oklopol> and has anything been done with that?
23:59:27 <oerjan> oh wait...