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: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: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.
04:00:47 -!- SevenInchBread has quit ("haaaaaaaaaa").
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:58 <oerjan> ~exec execfile("/bot/scripts/bf.py")
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.
07:11:29 -!- anonfunc has quit.
07:12:03 -!- Sgeo has quit (Remote closed the connection).
07:30:59 -!- GregorR has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:08:07 -!- ShadowHntr has quit (Read error: 110 (Connection timed out)).
08:22:51 <oerjan> my keyboard isn't English :)
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:27:40 <oerjan> but the obvious answer is to create an esoteric language interpreter :)
08:28:52 <oerjan> or a compiler into C++
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?
09:36:07 -!- RoboMonkey has quit (Client Quit).
09:36:33 -!- RoboMonkey has joined.
09:56:18 -!- ShadowHntr has joined.
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 :)
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: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: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: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: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: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:50 <oklopol> i dunno if i make any sence :)
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:41:44 <oklopol> true, i like making new languages more than using the old ones though, even though it's rarely necessary :)
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:19 <oklopol> qs=: (($:@(<#[) , (=#[) , $:@(>#[)) ({~ ?@#)) ^: (1<#)
17:38:10 <oklopol> i managed to get it in 36 chars in oklotalk, i'm wondering if i have to improve that
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: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: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:53:41 <SimonRC> It assumes you've imported Data.List though, which most modules of a Haskell program will do anyway.
17:55:39 <oklopol> it's an apl derivative i've been making
17:55:51 <oklopol> though is a lot different from apl now
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:04:06 <SimonRC> A friend of mine invented the evil smiley
18:04:24 <SimonRC> If you want to know why it is evil, give it a filename:
18:08:38 <oklopol> another quicksort, oklotalk style {_~/*/`{!-_<!_}\1}
18:08:54 <oklopol> well, {_~$/*/`{!-_<!_}\1} actually...
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:45 <oklopol> so you can create a list that just explains a form of a list
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:13:25 <oklopol> it was sort, left for the interpreter to brute force :P
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:15:04 <oklopol> but, i don't think that feature can do anything this complicated, it'd prolly just crash
18:15:40 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
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> \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:56 <lament> You know what would be cool.
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:52 <oklopol> since it's applied as the first argument
18:41:22 -!- asiekierka has joined.
18:41:45 <asiekierka> i thought of doing a "Sexy esoteric language"
18:42:16 <oklopol> true, your mom might dislike it
18:42:49 <asiekierka> a "Quit" will look like this: -nakedfemale
18:43:24 <oklopol> "naked men" as commands might be a way to get more young women interested in esoteric programming
18:44:50 <oklopol> we'll promise to think about it
18:45:18 <asiekierka> It will be capable of writing only some words: naked, unnaked, female, male, idiot.
18:46:16 <oklopol> i think all esolangs have a recommended age of 15+
18:47:10 <lament> asiekierka: what's the recommended age of brainfuck?
18:47:22 <asiekierka> ... except "brainfuck" word it is 7+ i think
18:48:57 <asiekierka> http://tunes.org/~nef/logs/esoteric/06.08.10 - log when i was here.
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:27:47 <oklopol> can someone tell me a nice regex way to change all occurrances of more than one whitespace in a row into " "+(" "*(occurrances-1)) in php
20:34:12 -!- crathman has quit (Read error: 110 (Connection timed out)).
20:43:11 <oerjan> i don't know php but in perl you could do s/ ( +)/" "." "x length($1)/e;
20:46:39 <oerjan> (that last one after nbsp
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:55:16 <oklopol> hehe, they banned me on ircnet because of my nick :P
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:48 <lament> lexical scope: makes sense.
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:39 <oerjan> there are situations when dynamical scope is useful.
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:43:22 <oerjan> so f 1 x == f 1 3 == g 3 == 1+3 == 4
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:35 -!- crathman has joined.
22:45:25 <oerjan> there is a Haskell extension for dynamically scoped variables
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: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: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: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: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:58:52 -!- _0xff has joined.
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:01:29 <SevenInchBread> -shrug- mutable objects are the exception... but globals are still "in scope".
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: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:34 <lament> i'm not talking about child-proof
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:07:46 <lament> if you could say 'have all references to this object now point to that object'
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: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: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: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:15:32 <SevenInchBread> x := "There is a paradigm shift" ---both and |x| and |y| are changed.---
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:46 -!- sebbu2 has joined.
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 <oklopol> i had this idea of a reverse-pointer esolang
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: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:28 <lament> SevenInchBread: give one. :)
23:34:41 <oklopol> "A function that you want to redefine."
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: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:40:14 <lament> are you replying to me?
23:40:22 <oklopol> i think it'd be rude if pointers did not follow an object moving around in the memory :|
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: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: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: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: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: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: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:55:22 <oklopol> where can you get the interpreter?
23:55:29 <oklopol> and has anything been done with that?