2007-01-18 - freenode:#esoteric

00:33:54 <oklopol> but, if you need decimal numbers, i'd say square root being a sister operation of a 2-base logarithm would make a nice addition to the lang... unless there is a nice way to do numbers with logs

00:34:07 <oklopol> decimal numbers -> floating point values

00:34:19 <oklopol> -> rational non-integer numbers

00:34:29 <oklopol> -> the right term fuck it

00:35:03 <ryanakca> oklopol: back, sorry, kk, thanks

00:35:35 <oklopol> you need logs when calculating loans etc

00:35:35 <lament> what's a decimal number?

00:35:55 <oklopol> lament, i used the wrong term

00:36:13 <oklopol> a->v mean s/a/v

00:36:19 <oklopol> ...

00:36:22 <oklopol> s/v/b

00:36:39 <oklopol> ...someone kill me

00:36:59 * ryanakca gives oklopol a poison cookie :)

00:37:13 <oklopol> :)

00:40:07 <bsmntbombdood> argh, how to do this

00:40:08 <lament> so many people get the terminology wrong :(

00:40:10 <lament> they make me sad :(

00:41:31 <bsmntbombdood> aARARARaRARARAR

00:45:08 <oklopol> what, bsmntbombdood?

00:45:18 <oklopol> lament, i'm an idiot

00:45:27 <bsmntbombdood> inverting a logarithm

00:45:31 <oklopol> 2**...

00:45:39 <bsmntbombdood> I don't want to have an extra command

00:45:44 <oklopol> ah okay

00:45:51 <oklopol> you said something peeish

00:46:02 <bsmntbombdood> yeah

00:47:30 <bsmntbombdood> my source: http://bsmntbombdood.mooo.com/logfuck.py.txt

00:49:45 <oklopol> read

00:49:53 <oklopol> nice

00:50:03 <oklopol> all my iffy parts fixed

00:50:05 <oklopol> nice work

00:50:19 <oklopol> but, i had to make it in 10 minutes to be first :)

00:50:27 <bsmntbombdood> heh

00:50:50 * oklopol likes q :'(

00:50:51 <oklopol> :DD

00:51:25 <bsmntbombdood> You can compute square roots withs logs

00:52:30 <oklopol> ah okay

00:52:34 <oklopol> shomme!

00:54:42 <bsmntbombdood> one sec

00:54:45 <oklopol> k

00:54:50 <oklopol> darn

00:54:57 <oklopol> i'm gonna hate myself when i see it :)

01:01:53 <bsmntbombdood> hrm

01:02:32 <oklopol> does it work?

01:02:34 <bsmntbombdood> well, sqrt(x) == 2**(.5 * log(x))

01:02:43 <oklopol> :)

01:02:58 <oklopol> since sqrt is the only way to get 0.5, that's hard

01:03:03 <bsmntbombdood> no

01:03:03 <oklopol> you can get close tho

01:03:06 <oklopol> oh

01:03:15 <bsmntbombdood> #define DIV >g<g - p

01:03:23 <bsmntbombdood> #define ZERO 1g

01:03:23 <bsmntbombdood> #define TWO 1 ZERO 1--

01:03:25 <oklopol> well, with p, true :)

01:03:44 <bsmntbombdood> 1 TWO DIV

01:03:47 <bsmntbombdood> is .5

01:03:49 <oklopol> but, you see, then you don't need sqrt

01:03:54 <oklopol> ye

01:04:07 <bsmntbombdood> right

01:04:08 <CakeProphet> so...

01:04:13 <oklopol> so, it's p or q

01:04:15 <CakeProphet> floating points numbers are a tad... limited.

01:04:23 <oklopol> CakeProphet, you are limited

01:04:29 <oklopol> :D

01:04:29 <CakeProphet> LOL NO

01:04:31 <bsmntbombdood> oklopol: p can do more than q

01:04:37 <bsmntbombdood> CakeProphet: What's your point?

01:04:38 <oklopol> yes

01:04:43 <oklopol> much more

01:05:02 <bsmntbombdood> a ha!

01:05:08 <bsmntbombdood> got it

01:05:11 <oklopol> so, you are a stupid head

01:05:11 <bsmntbombdood> #define SQRT >1 TWO DIV<g MULT p

01:05:14 <oklopol> :O

01:05:27 <oklopol> yeah, okay

01:05:32 <oklopol> i can make a num conversion

01:05:52 <oklopol> and it'll make it to the spec and i'll be a hero -_____-

01:06:14 <CakeProphet> well...

01:06:16 <bsmntbombdood> What do you mean num conversion?

01:06:19 <CakeProphet> hrm..

01:06:29 <oklopol> conversion of a number into lf-code

01:06:44 <bsmntbombdood> oh

01:06:58 <oklopol> but, it wouldn't be very optimal

01:07:01 <oklopol> easy tho

01:07:10 <bsmntbombdood> I'm going to change output from decimal to ascii now I think

01:07:25 <oklopol> yeah, for non-integers

01:07:28 <oklopol> *integers

01:07:45 <CakeProphet> >>> float("0." + "".join(["565656534" for x in xrange(100000)]))

01:07:46 <CakeProphet> 0.56565653456565657

01:07:48 <CakeProphet> >>>

01:07:49 <CakeProphet> :(

01:07:57 <CakeProphet> I want giant floating point numbers!!!!

01:08:54 <bsmntbombdood> CakeProphet: gmp

01:09:01 <oklopol> i want 10-base to be illegalized

01:09:20 <CakeProphet> I want to use a base-5 numeral system!

01:09:24 <CakeProphet> THE LAW OF FIVES.

01:09:35 <bsmntbombdood> How do you implement dup in lf?

01:09:40 <bsmntbombdood> I can't figure it out

01:09:45 <oklopol> hmm...

01:10:02 <CakeProphet> you could consequitely move items from one stack to the next.

01:10:06 <CakeProphet> till you... get to the one you want?

01:10:12 <oklopol> dup

01:10:16 <oklopol> not lift

01:10:30 <CakeProphet> well...

01:10:32 <CakeProphet> it's close. :D

01:12:00 <oklopol> hmm

01:12:07 <bsmntbombdood> It's not turing complete unless I can implement dup I think

01:12:20 <bsmntbombdood> since [] is destructive

01:12:55 <oklopol> hmm, there is no way to use a number in a calculation without even then only having it in one place again... i think

01:13:08 <oklopol> you can only add a 1

01:13:21 <CakeProphet> Implement two stacks-of-queues.

01:13:24 <CakeProphet> like Stue. :D

01:13:29 <CakeProphet> except... two

01:13:31 <CakeProphet> TwoStueFuckLogs

01:13:36 <CakeProphet> you could call it.

01:13:41 <bsmntbombdood> no

01:13:42 <oklopol> and using that one IN ANY WAY with the number to duplicate will destroy the original number

01:13:43 <bsmntbombdood> too complicated

01:13:50 <oklopol> and you have the same prob with the new one

01:13:53 <bsmntbombdood> oklopol: yep :/

01:14:10 <oklopol> i think i can prove it's impossible... but that's all i can do :\

01:14:23 <bsmntbombdood> I could make > copy isntead of moving

01:14:26 <oklopol> ...if it's impossible, that's pretty obvious tho :)

01:14:30 <oklopol> yeah

01:14:43 <bsmntbombdood> but that causes other problems

01:14:58 <CakeProphet> such as.. not being able to remove items.

01:15:02 <CakeProphet> because it just copies.

01:15:11 <oklopol> you can.

01:15:15 <oklopol> oh

01:15:20 <CakeProphet> you could just have a copy command.

01:15:25 <bsmntbombdood> CakeProphet: no

01:15:28 <CakeProphet> that copies from stack to other stack

01:15:32 <bsmntbombdood> too many instructions

01:16:00 <oklopol> [ could copy the topmost, ] could pop :P

01:16:39 <oklopol> nah, wouldn't work... i think

01:16:42 <bsmntbombdood> hmmm

01:16:49 <oklopol> because you still couldn't dup for example

01:17:06 <bsmntbombdood> the dup would be ">0<[>]<"

01:17:11 <bsmntbombdood> s/the/then/

01:17:18 <bsmntbombdood> s/0/1g/

01:17:57 <oklopol> you're right

01:18:00 <bsmntbombdood> I think that works!

01:18:15 <oklopol> i didn't understand > and < right, yeah, it was good

01:18:26 <oklopol> s/understand/...grasp :)

01:20:51 <bsmntbombdood> crap, that doesn't work

01:21:09 <oklopol> :\

01:22:11 <oklopol> mine says list index outta range

01:22:18 <oklopol> but i didn't allow that anyway

01:22:24 <oklopol> so it should

01:23:18 <oklopol> [>0]<

01:23:24 <oklopol> that would dup right?

01:23:32 <oklopol> eh

01:23:41 <oklopol> yeah

01:23:43 <oklopol> i thnk

01:23:47 <bsmntbombdood> no

01:23:58 <bsmntbombdood> wait

01:24:43 <bsmntbombdood> no

01:24:56 <bsmntbombdood> that does nothing

01:26:08 <oklopol> n, -> (start of loop) n n, -> n, n -> (end of loop) n 0, n -> n, n -> n n,

01:26:09 <CakeProphet> hmm..

01:26:24 <CakeProphet> I wonder how you would use a tree as a languages data structure.

01:26:29 <oklopol> yes

01:26:33 <oklopol> my friend did that

01:26:49 <oklopol> it is nice

01:27:10 <oklopol> you can have tree data structures as vars then

01:27:14 <oklopol> very convenient

01:27:53 <CakeProphet> You could probably do something with genetics.

01:27:54 <CakeProphet> and trees.

01:27:59 <CakeProphet> and fractals.

01:28:01 <CakeProphet> and chaos

01:28:04 <CakeProphet> and evolution.

01:28:09 <oklopol> > goes left, < goes right, ^ goes up, so navigating is like bf but you can reserve infinite certain memory for vars

01:28:25 <CakeProphet> hmm...

01:28:27 <CakeProphet> that's cool.

01:28:36 <CakeProphet> you could take a lisp-ish approach and make the program a tree.

01:28:40 <oklopol> true

01:28:44 <oklopol> but he's not good

01:28:49 <CakeProphet> with the branches acting as... erm..

01:28:51 <oklopol> you could

01:29:01 <CakeProphet> conditional pathways?

01:29:07 <bsmntbombdood> aaagh

01:29:18 <oklopol> you could just code it as a tree, no ascii shit

01:29:31 <oklopol> i don't understand why everything must be coded in ascii...

01:29:36 <oklopol> or unicode

01:29:55 <oklopol> except for cellular automatons

01:29:56 <bsmntbombdood> ok

01:29:57 <oklopol> of course

01:30:04 <oklopol> bsmntbombdood, what?

01:30:05 <bsmntbombdood> We make > copy instead of move

01:30:09 <bsmntbombdood> < acts as normal

01:30:12 <oklopol> okay

01:30:17 <CakeProphet> could do something like wireworld... but different.

01:30:18 <oklopol> ah

01:30:21 <oklopol> yeah

01:30:25 <CakeProphet> electrical circuitry type programming.

01:30:32 <CakeProphet> make it a GUI

01:30:34 <CakeProphet> it could be fun. :D

01:30:36 <oklopol> how do you drp? bsmntbombdood

01:30:41 <bsmntbombdood> oklopol: []

01:30:46 <oklopol> yeah

01:30:58 <oklopol> what was wrong with my n, -> (start of loop) n n, -> n, n -> (end of loop) n 0, n -> n, n -> n n, tho?

01:31:05 <oklopol> what fails?

01:31:11 <CakeProphet> We should all COLLABORATE

01:31:11 <bsmntbombdood> the move

01:31:13 <CakeProphet> and make something sweet

01:31:22 <CakeProphet> but according to my vision..

01:31:24 <oklopol> why does it fail?

01:31:27 <CakeProphet> because I said so.

01:31:31 <oklopol> CakeProphet, sure :)

01:31:39 <bsmntbombdood> now [ pops

01:31:46 <CakeProphet> FRACTALIC SELF-REPRODUCING EVOLUTIONARY GENETICS CODE

01:31:49 <CakeProphet> now

01:31:51 <CakeProphet> how

01:31:53 <CakeProphet> think

01:31:58 <oklopol> but but, what was wrong with the move? :'(

01:32:14 <bsmntbombdood> It was destructive

01:32:31 <oklopol> okay

01:32:35 <oklopol> how would it go then?

01:32:41 <oklopol> if not like that

01:32:53 <oklopol> i did it destructively in n, -> (start of loop) n n, -> n, n -> (end of loop) n 0, n -> n, n -> n n, i think

01:33:06 <bsmntbombdood> write that in the language

01:33:06 <CakeProphet> I'd like to make an esolang larger than a few commands and a tiny interpreter.

01:33:17 <oklopol> i did, but it fails

01:33:22 <CakeProphet> like... a major project...

01:33:39 <bsmntbombdood> oklopol: exactly

01:33:43 <oklopol> but, why?

01:33:56 <oklopol> how do the stacks evolve then?

01:34:07 <bsmntbombdood> crap, borked

01:34:19 <oklopol> because making > copy is not nice if it's not needed

01:34:27 <oklopol> because it's not very intuitive

01:34:40 * CakeProphet is thinking.

01:34:47 <bsmntbombdood> Yeah

01:34:48 <oklopol> and i think an esoteric language should always be intuitive... according to it's own rules

01:35:03 <bsmntbombdood> now we can't drop

01:35:13 <oklopol> ah

01:35:15 <CakeProphet> a genetic language isn't coming into my head intuitively.

01:35:15 <oklopol> yeah

01:35:35 <CakeProphet> but it seems like it would be simple.

01:36:00 <CakeProphet> you have some stuff... and some other stuff... and some stuff that tests that stuff...

01:36:08 <CakeProphet> and something to put it all in... an environment.

01:36:13 <oklopol> that really sums it up :)

01:36:19 <CakeProphet> and stuff starts dying..

01:36:26 <CakeProphet> and stuff starts procreating.

01:36:28 <CakeProphet> yay... genetics.

01:36:37 <CakeProphet> which inevitably creates evolution.

01:37:04 <CakeProphet> AHA

01:37:04 <oklopol> i thought of making a language with the most basic component being flock movement... but if that's not done yet, i pity mankind

01:37:06 <CakeProphet> simplified DNA

01:37:18 <CakeProphet> a series of.... codes\

01:37:22 <CakeProphet> that determine shit

01:37:33 <CakeProphet> and make a bunch of them...

01:37:42 <CakeProphet> or better yet... just make one starting code... the source code.

01:37:55 <CakeProphet> which spawns off offspring..

01:38:05 <CakeProphet> two source codes?

01:38:07 <CakeProphet> yes.

01:38:09 <CakeProphet> two source codes.

01:38:11 <CakeProphet> that mate.

01:38:26 <oklopol> yeah

01:38:31 <CakeProphet> swap genes... reproduce... you have a bunch of source codes now.

01:38:39 <oklopol> first of all you need a lot of redundancy

01:38:48 <CakeProphet> and some start dying... the ones that you don't want.

01:38:52 <CakeProphet> nah... just two genetic strands.

01:39:16 <CakeProphet> but I don't want DNA.... the thought of coding in DNA-like language kinda makes me want to puke.

01:39:40 <oklopol> the codes you have first should be quines that are altered then executed until more new executable code is randomly created

01:40:00 <CakeProphet> maybe borrow some ideas from Thue-like-ness?

01:40:05 <oklopol> but, the language should aim at creating itself

01:40:05 <CakeProphet> but.. not direct string replacement.

01:40:09 <CakeProphet> yah.

01:40:26 <CakeProphet> I've been tossing through ideas like that.

01:40:37 <CakeProphet> a language that contains the instructions for creating itself

01:40:38 <oklopol> it need not have any other operation than cloning itself, changing thing to their "synonyms" etc

01:40:59 <CakeProphet> well... there needs to be some form of sexual interchange... otherwise you just have a bunch of clones.

01:41:19 <oklopol> well, yeah

01:41:26 <oklopol> we can leave out randomness then

01:41:29 <oklopol> which is good

01:41:36 <CakeProphet> could have it as an option.

01:41:40 <CakeProphet> non-determinism is cool sometimes.

01:42:16 <oklopol> because with one we'd need a seed, with two (that reproduce collaboratively) they are each others seeds, more sensible

01:42:21 <oklopol> yeah

01:42:29 <oklopol> but the seed could then be a random program

01:42:46 <oklopol> since all programs should of course be always-executing

01:43:01 <oklopol> but, redundant operations just wouldn't produce themselves

01:43:19 <CakeProphet> hmmm... the program instructions could correspond with each other...

01:43:23 <CakeProphet> like...

01:43:25 <oklopol> so there would always be a random amount of nops that always die

01:43:29 <oklopol> yes

01:43:35 <CakeProphet> do different things for two different pairings?

01:43:40 <CakeProphet> or... however we pair them up.

01:44:01 <oklopol> yes, these pair could be made so that best result i gotten

01:44:04 <oklopol> *pairs

01:44:07 <oklopol> *is

01:44:19 <oklopol> my s's are becoming extinct

01:44:25 <CakeProphet> haha... a self-optimixing language.

01:44:29 <oklopol> :)

01:44:36 <CakeProphet> fuck compilers.

01:44:39 <oklopol> did you coin that term just now?

01:44:42 <CakeProphet> just make the language do it itself.

01:44:57 <CakeProphet> ...well.. it was a typo.

01:44:59 <CakeProphet> but sure.

01:45:01 <CakeProphet> I coined it.

01:45:15 <oklopol> okay

01:45:22 <oklopol> i thought it was brilliant :)

01:45:37 <oklopol> since it mixes two progs while optimizing automatically

01:46:02 <oklopol> now, english again

01:46:06 <CakeProphet> by program.. do you mean hard file or... separate 'halves"

01:46:12 <CakeProphet> it could be either I guess.

01:46:19 <oklopol> i need more complicated english here than in my homework :\

01:46:21 <CakeProphet> you could have two different files get it on as well.

01:46:34 <CakeProphet> file-sex.

01:46:52 <oklopol> you could do like dna

01:47:10 <oklopol> each instruction is two bytes, like +/ () %% etc

01:47:24 <oklopol> and you know how it works

01:47:38 <CakeProphet> eh... my biology is fuzzy.

01:47:40 <oklopol> okay

01:47:42 <CakeProphet> but I get the picture.

01:47:45 <CakeProphet> they sort of... interchange right?

01:47:52 <oklopol> random one of the pair is picked

01:48:12 <CakeProphet> hmmm... I don't think randomality could produce optimizations... but... who knows.

01:48:39 <oklopol> mixing program "�� ## 1%" with "aG oo /\" could be "�G #o %\" for example

01:48:44 <CakeProphet> oooh..

01:48:48 <CakeProphet> the optimization wouldn't be there.

01:48:50 <oklopol> you could optimize it afterwards

01:48:54 <CakeProphet> it would be in the... massive amounts of this occuring.

01:48:59 <CakeProphet> and... which ones "live"

01:49:04 <CakeProphet> by being more efficient.

01:49:06 <CakeProphet> alright.. cool.

01:49:26 <oklopol> well, optimizing isn't really fair play in a sence... nature doesn't have it :P

01:49:39 <CakeProphet> it would be neat if you could strategically plan the flow of an evolution chain... to produce some desired result... but that sounds kind of far-fetched and vague.

01:50:07 <oklopol> we'd just have an algorithm to check for sanity in the program to skip evolution when a species is due to die pretty soon

01:50:10 <CakeProphet> what about environment... no environment? Should the programs start killing each other? What about a "species change"

01:50:21 <CakeProphet> :D

01:50:34 <CakeProphet> all is not always peachy in the wild.

01:50:38 <oklopol> you can always have a 2D map to emulate them living there...

01:50:42 <CakeProphet> haha

01:50:46 <oklopol> s/to/and

01:50:50 <CakeProphet> ah...

01:51:00 <CakeProphet> that could be another part of the program? or... too much?

01:51:12 <oklopol> hmm

01:51:14 <CakeProphet> like... the spaces could be different.

01:51:24 <oklopol> huh?

01:51:27 <CakeProphet> like a 2D language.

01:51:31 <oklopol> separate things

01:51:36 <CakeProphet> but with... programs running around in it. :D

01:51:53 <oklopol> you'd make programs (prolly at random), then put 10000 of them on the screen and see what happens

01:52:12 <oklopol> the dna would be executed differently when doing different thigs

01:52:14 <oklopol> *things

01:52:29 <oklopol> like, walking could be specified in a certain part of the code

01:52:37 <oklopol> all codes equal length for simplicity

01:52:43 <bsmntbombdood> http://bsmntbombdood.mooo.com/logfuck_spec.txt

01:52:48 <oklopol> you're fast

01:53:01 <CakeProphet> yah... I like complexity springing out of simplicity...

01:53:10 <CakeProphet> ah... how about functional?

01:53:12 <oklopol> yeah, ok, it's quite a simple lang :)

01:53:18 <oklopol> for bsmntbombdood

01:53:47 <CakeProphet> an organism is a set of functions... each being the original code we were talking about... pairs of opcodes.

01:53:51 <oklopol> functional is not that good since it needs what's it called...

01:53:55 <oklopol> ah yeah

01:53:59 <oklopol> but then no string

01:54:03 <oklopol> we can forget about it

01:54:06 <CakeProphet> I got the idea from when you mentioned walking.

01:54:08 <oklopol> a structure then

01:54:09 <CakeProphet> walking is a function. :D

01:54:42 <oklopol> a creature would map the command to walk in any function it wants

01:54:49 <oklopol> once again depending on it's code

01:54:57 <CakeProphet> hmm...

01:55:01 <oklopol> and, it would create functions at random

01:55:01 <CakeProphet> I kinda follow

01:55:26 <CakeProphet> and then there should be functions for EATING PEOPLE

01:55:50 <CakeProphet> I kinda liked having deterministic functions though... random could help spur on genetics.. somehow.

01:56:10 <oklopol> yes, once again it would be feeded all the necessary information, and requested what it'll do, it would map these commands into whatever functions it wants to

01:56:12 <oklopol> or smth

01:56:26 <oklopol> yeah

01:56:36 <oklopol> functions should be deterministic

01:56:45 <oklopol> but new ones could be created

01:56:49 <CakeProphet> Start off with just two creatures... and an environment source... either being in different files or in the same source... either way.

01:56:52 <CakeProphet> righto

01:57:02 <CakeProphet> ah.. I get what you mean.

01:57:38 <CakeProphet> The environment would provide much of the constaints... while perhaps evolving and changing itself. :)

01:57:48 <CakeProphet> as creatures effect it.

01:58:00 <oklopol> i loved making 2D life simulator when i was little (with set vars, not code)

01:58:09 <oklopol> little... i'm still little

01:58:11 <oklopol> smaller

01:58:49 <CakeProphet> the rest of the conditioning would come from interactions with creatures... collisions in the environment basically.

01:58:53 <oklopol> haha, plants that are creatures that lost the ability to move at some point :D

01:58:57 <oklopol> so cool

01:59:10 <CakeProphet> hmm...

01:59:12 <CakeProphet> yeah

01:59:22 <CakeProphet> hmmm.... energy?

01:59:30 <oklopol> like, hp? :P

01:59:39 <CakeProphet> might as well... while we're at it... planning a big-ass game of life.

01:59:45 <CakeProphet> well.. like... energy.

01:59:45 <oklopol> hehe :=)

01:59:53 <oklopol> i'd like their code to be eaten :)

02:00:09 <oklopol> no variables, just wrecking of each others functions when hit

02:00:34 <CakeProphet> stationary creatures would eventually get better at either eating other creatures or gaining energy from the environment (like a form of photosynthesis... although maybe not from any "light" source)

02:01:10 <oklopol> trues... the code could be in such a format that removing it would probably not change anything

02:01:39 <CakeProphet> should there be set functions for actions?

02:01:50 <CakeProphet> or... should it somehow determine which function to use?

02:02:11 <oklopol> i think it should do it's own mapping, but it's kinda too random then

02:02:14 <CakeProphet> well... there should be a "sex" function...

02:02:21 <CakeProphet> that... determines sex

02:02:26 <CakeProphet> male, female, asexual... something else.

02:02:30 <oklopol> :)

02:02:48 <oklopol> or, when encountering, a function to determine what they do to each other

02:02:53 <CakeProphet> yeah

02:03:10 <CakeProphet> but... I like gender too. :D

02:03:17 <oklopol> true

02:03:30 <oklopol> when actually implementing

02:03:37 <CakeProphet> when they collide... behavioristic traits determine what actions are taken... which are functions themselves.

02:03:39 <oklopol> a simpler one should be done first

02:03:44 <oklopol> with set functions prolly

02:03:47 <oklopol> and such

02:03:47 <CakeProphet> aha... "behaviors" are functions that determine what function is to be used!

02:03:56 <oklopol> yes

02:04:03 <CakeProphet> higher-order functions.

02:04:10 <oklopol> taking the other creatures functions to determine it

02:04:18 <CakeProphet> yeah.

02:04:27 <CakeProphet> so the functions would need to have some sort of manipulatable data.

02:04:37 <oklopol> they look at each others code, if it seems the other would attack, there's no use emitting seed on it

02:04:38 <oklopol> :)

02:04:40 <oklopol> okay

02:04:44 <CakeProphet> haha

02:04:45 <oklopol> far-fetched

02:04:56 <CakeProphet> it sounds do-able though.

02:04:57 <oklopol> we'll create the ultimate AI another time...

02:05:06 <CakeProphet> at least... basics.

02:05:09 <CakeProphet> basics first...

02:05:18 <CakeProphet> there will need to be a lot of modality in the source I think..

02:05:25 <CakeProphet> no simple universal commmand set like BF

02:05:26 <oklopol> the language should have a lot of functions for determining stuff about itself too :)

02:05:46 <CakeProphet> or at least... the symbols carry different semantics depending on where they're at.

02:05:54 <CakeProphet> a definetely like the idea of "behaviors" and "actions"

02:05:58 <oklopol> but, would this be a game for two ppl to play making their own populations and seeing which one wins or just experiment?

02:06:00 <CakeProphet> and maybe "traits"... for simple axiomatic shit.

02:06:17 <CakeProphet> I was kinda thinking you could use it to... compute shit...

02:06:27 <CakeProphet> far-fetch yeah... it sounds more like a fun game.

02:06:29 <oklopol> hehe :)

02:06:32 <CakeProphet> like corewars... but less competitive.

02:06:43 <CakeProphet> or.. more strategic.

02:07:17 <oklopol> i've not yet seen the real strategy in corewars, but i must've gotten something wrong, never played

02:07:55 <CakeProphet> so... traits (test functions), actions (executive functions that employ traits), and behaviors (functions that use traits, combined with the input of another creatures behavior function to trigger a specific action)

02:08:45 <oklopol> yeah, if those are made by the creator of the creature, would be cool

02:08:50 <CakeProphet> oh oh oh

02:09:00 <CakeProphet> environment... could be a set of symbols on a 2D space.

02:09:06 <CakeProphet> with each one mapping to a function..

02:09:10 <CakeProphet> or functions

02:09:44 <CakeProphet> or.. just like... basic commands and stuff

02:09:46 <CakeProphet> either works.

02:09:51 <CakeProphet> both maybe...

02:10:07 <oklopol> <<>.> okay, this is a nop since i should be doing my tasks :)

02:10:20 <CakeProphet> ...?

02:10:26 <oklopol> nopol <3

02:10:41 <oklopol> this discussion, i don't have time for it now :D or for anything

02:10:47 <oklopol> i have school in 4 hours

02:10:50 <oklopol> it 4 am

02:10:54 <oklopol> *it's

02:10:54 <CakeProphet> pfft... there's always time.

02:10:58 <CakeProphet> I've gone tons of shit I could be doing.

02:11:05 <oklopol> but... there are a lot of tasks :\

02:11:37 <oklopol> and if i don't get them before tomorrow, i'll not be able to do the matriculation exam of english this spring

02:11:50 <oklopol> (might be finland spesific)

02:12:06 <oklopol> because i forgot to do them when i should've

02:12:14 <CakeProphet> I have a tendency to... leave projects unfinished... and start a lot of stuff.

02:12:22 <oklopol> me too

02:12:23 <CakeProphet> and.. not finish crap because I get distracted by ideas.

02:12:34 <oklopol> i'll finish them usually when i can do it in 4 hours :)

02:12:40 <CakeProphet> yeah.

02:12:45 <CakeProphet> if you have to stop and continue later.

02:12:46 <CakeProphet> it kills it.

02:13:02 <oklopol> one time i took my 3 year old unfinished projects and finished them all during the afternoon

02:13:17 <oklopol> (but they were mostly hello worlds :))

02:13:55 <oklopol> yeah, i'm bad at continuing programming since i've already completed it in my head :\

02:14:06 <CakeProphet> I usually start bots, languages, weird quick mini-languages for parsiing, strange and useless "helper functions", etc

02:14:19 <oklopol> and of course sometimes i don't remember my idea that well

02:14:24 <oklopol> if i haven't thought about it

02:14:26 <CakeProphet> hmm... I like the idea of the environment code being basic... but some optional complexity.

02:14:45 <CakeProphet> you have some basic stuff... river, grass, mountain, weird-wall-thing..

02:14:52 <oklopol> okay, i have to go now, really :)

02:14:52 <oklopol> cu

02:14:54 <CakeProphet> and then you have "structures"... which are functions.

02:14:56 <CakeProphet> hahaha

02:14:58 <CakeProphet> alright

02:26:44 -!- anonfunc has joined.

02:27:23 -!- anonfunc has quit (Client Quit).

02:27:26 -!- anonfunc has joined.

02:41:35 -!- ryanakca has quit (Read error: 104 (Connection reset by peer)).

02:41:42 <oklopol> hmm

02:41:45 <oklopol> that was easy

02:41:52 <oklopol> i had one left :)

02:42:11 <oklopol> i'm good at assessing that, it seems

02:42:22 <oklopol> the number of items in a list

02:51:02 <CakeProphet> >.>>

02:51:11 * CakeProphet is still working out that idea...

02:51:16 <CakeProphet> it sounds feasible... surprisingly.

02:51:39 <CakeProphet> but with like... 4 languages...

02:51:42 <CakeProphet> at the least

02:51:44 <oklopol> i still have a word test tomorrow, gonna read for that after a little family guy + coffee break :)

02:51:50 <CakeProphet> hehe

02:51:51 <oklopol> 4 languages?

02:51:57 <CakeProphet> yeah.

02:52:22 <CakeProphet> So... behaviors conditional run through actions based on what's occuring... they'll use a very abstract language.

02:52:32 <oklopol> i already saw simpsons, futurama and friends, after fg i'll have nothing unless i start watching anime :\

02:52:36 <CakeProphet> actions will be somewhere inbetween... they perform manipulations on the source code of traits.

02:52:59 <CakeProphet> traits will be simple event-based programming... they perform actions based on how their own soruce code is manipulated.

02:53:01 <CakeProphet> by actions.

02:53:32 <oklopol> these are programmed initially by the programmer?

02:53:41 <CakeProphet> an action would be like... grazing...

02:53:49 <CakeProphet> and a trait like... grass (I'm assuming environment will be traits)

02:53:50 <oklopol> and they are altered when the thingies have fun?

02:53:51 <CakeProphet> yeah.

02:54:07 <CakeProphet> behaviors and actions will largely be altered by reproduction.

02:54:18 <CakeProphet> traits... I think... will be altered mostly through interaction.

02:54:58 <CakeProphet> It leads to some cool ideas.

02:55:29 <CakeProphet> I've never heard of a language that does operations based on how its source code is manipulated from an outside influence.

02:55:31 <oklopol> the 2d map exists too?

02:55:35 <CakeProphet> yeah.

02:55:38 <oklopol> good

02:55:42 <CakeProphet> it'll be a map of functions... basically.

02:55:49 <CakeProphet> and some primitive commands.

02:56:10 <oklopol> that is the main interface between creatures, it should be spec'd first

02:56:15 <oklopol> as much as possible

02:56:31 <CakeProphet> I was thinking it would be a big grid of symbols... followed by some function definitions.

02:56:39 <CakeProphet> for various symbols.

02:56:44 <CakeProphet> one character each

02:57:02 <oklopol> programmers can see the functions then ans decide their action on them?

02:57:04 <CakeProphet> it would most likely follow a language similar to the traits language... since the environment will be largely event driven.

02:57:21 <CakeProphet> Probably.

02:57:30 <CakeProphet> you would just need to peak under the soruce of the environment.

02:57:49 <CakeProphet> I see the environment being code that's mostly manipulated.

02:57:52 <CakeProphet> it makes a lot of sense.

02:57:56 <oklopol> hmm, prolly would be intentionally left for the programmers to see?

02:58:09 <oklopol> the code

02:58:13 <CakeProphet> Sure.

02:58:23 <CakeProphet> It's no fun poking in the dark.

02:58:28 <oklopol> frokfrokfrokfrokfrokfrokfrokfrokfrokrfokfrokfrokfrokfrokfrok

02:58:34 <oklopol> sorry

02:58:41 <oklopol> i'm a flooder normaly

02:58:42 <CakeProphet> hmm... let's call it Grass

02:58:44 <oklopol> *ll

02:58:48 <oklopol> hehe :)

02:58:50 <bsmntbombdood> I'm not sure what to do with logfuck

02:58:57 <CakeProphet> fuck it

02:58:57 <oklopol> why?

02:59:02 <oklopol> yeah

02:59:04 <oklopol> with your log

02:59:09 <CakeProphet> ...yup

02:59:13 <bsmntbombdood> heh

02:59:21 <oklopol> but, what ya mean?

02:59:27 <CakeProphet> well.. Grass was the name for a theoretical fractal-based Thue-like language I had in my mind.

02:59:28 <oklopol> or, just what to do?

02:59:31 <CakeProphet> because it was nature-ish

02:59:44 <bsmntbombdood> oklopol: Right now, it's not very usefull

02:59:46 <oklopol> fractal-based, i don't see that

02:59:53 <oklopol> bsmntbombdood, sure it is :)

03:00:07 <bsmntbombdood> I'm not sure how to do the looping operators

03:00:18 <oklopol> okay... they didn't work yet?

03:00:23 <bsmntbombdood> yeah, they work

03:00:32 <bsmntbombdood> The implementation is fine

03:00:39 <oklopol> > copies lead to both dup and drp?

03:00:44 <CakeProphet> well... fractal based as in... repeated self-similar manipulations of the source code (like Thue, but more complex logic involved) will produce any sort of arbitrary "bytecode"... that could be read by an image creator.

03:00:50 <bsmntbombdood> oklopol: no, that's the problem

03:00:58 <oklopol> okay

03:00:59 <bsmntbombdood> I think i'm going to have [ not pop

03:01:15 <oklopol> well, my bot has it like that :)

03:01:35 <CakeProphet> hmmm..

03:01:36 <oklopol> my bot's flooded our channel for 6 hours now, every 3 seconds

03:01:40 <oklopol> i love watching that

03:01:44 <CakeProphet> if we finish this lang... we could put it into a bot.

03:01:47 <CakeProphet> how awesome would that be

03:01:51 <oklopol> haha :D

03:01:53 <CakeProphet> a big database of creatures and maps.

03:02:23 <oklopol> tho, wouldn't be that interactive, i mean you couldn't see but the result

03:02:49 <CakeProphet> seems like a crude GUI would be the best result.

03:03:04 <oklopol> yes

03:03:16 <CakeProphet> or at most just a display

03:03:24 <oklopol> a screen and a bar for loading maps, creatures and opening a connection

03:03:26 <CakeProphet> of whats going on

03:03:37 <CakeProphet> heh.. I kinda like good ol' text files.

03:03:41 <CakeProphet> with the output being all fancified

03:04:16 -!- pikhq has joined.

03:04:17 <oklopol> i don't like the whole concept of having a graphical interface for a non-graphical operation

03:04:25 <oklopol> hey pikhq

03:04:26 <bsmntbombdood> I need to find out if logfuck is turing complete

03:05:48 <oklopol> make that... one lang

03:06:18 <oklopol> hmm, if it's final, i can try and make something outta it as well

03:06:27 <bsmntbombdood> It's not final

03:07:28 <oklopol> ah okay

03:07:34 <bsmntbombdood> I can't decide what to do with it

03:08:22 <oklopol> you don't have a list structure, so it's hard to make an interpreter

03:08:32 <oklopol> you could find an isomorphism tho

03:09:32 <oklopol> just list all basic operation sequences that do anything sensible and find a language proven turing complete that has them or just a subset of them

03:09:53 <oklopol> there was at least one... with i think less functionality

03:10:01 <oklopol> that was similar

03:10:03 <oklopol> very

03:10:07 <bsmntbombdood> well, two stacks make a tape

03:10:11 <oklopol> yeah

03:11:33 <bsmntbombdood> I can't figure out how to make cat

03:11:41 <oklopol> inc: 1g1--

03:11:48 <oklopol> dec: 1-

03:11:52 <oklopol> :DD

03:11:56 <bsmntbombdood> yeah

03:12:00 <CakeProphet> well..

03:12:03 <CakeProphet> you have a stack

03:12:12 <oklopol> [,.1] or smth wont work?

03:12:17 <oklopol> 1[,.1]

03:12:26 <bsmntbombdood> oklopol: that won't stop on eof

03:12:33 <oklopol> [,.]

03:12:36 <oklopol> then

03:12:41 <oklopol> 1[,.]

03:12:43 <bsmntbombdood> because the , pops the stack

03:12:56 <oklopol> huh?

03:12:59 <oklopol> why?

03:13:24 <oklopol> 1[1,.] if it pops

03:13:30 <oklopol> i'll check your spec

03:15:14 <oklopol> 1[,><.] should work if > copies, once again i don't remember, no copy in the reference

03:16:00 <bsmntbombdood> It doesn't copy

03:16:11 <bsmntbombdood> That messes stuff up

03:16:50 <oklopol> 1[,[>1g]<.] then?

03:17:21 <oklopol> read in, copy, move right, add a 0, pop it while ending loop, move copy back left

03:18:18 <bsmntbombdood> ?

03:18:35 <oklopol> doesn't work?

03:18:40 <oklopol> what is wrong?

03:18:41 <bsmntbombdood> EOF is -1

03:18:46 <oklopol> okay

03:19:08 <oklopol> 1[,[>1g]<.1g1--]

03:19:15 <oklopol> satisfied?

03:20:13 <bsmntbombdood> almost

03:20:20 <oklopol> what is wrong?

03:20:23 <bsmntbombdood> That prints an eof char

03:20:26 <oklopol> ah

03:20:30 <oklopol> yeah

03:21:09 <bsmntbombdood> whoa

03:21:12 <bsmntbombdood> you figured out dup

03:21:26 <oklopol> 1[,[>1g]<1g1--[1-.]]

03:21:31 <oklopol> how about now then?

03:21:45 <bsmntbombdood> nope

03:21:46 <oklopol> eof will jump off both loops

03:21:48 <oklopol> :(

03:21:53 <oklopol> what now?

03:22:32 <oklopol> eh

03:22:35 <bsmntbombdood> only prints one char

03:22:35 <oklopol> sorry

03:22:56 <oklopol> 1[,[>1g]<1g1--[1-.1g]]

03:22:57 <oklopol> now

03:23:02 <oklopol> since ] pops

03:23:50 <oklopol> okay

03:24:06 <bsmntbombdood> !!

03:24:08 <bsmntbombdood> workage

03:24:15 <oklopol> huh?

03:24:23 <oklopol> noooo!

03:24:25 <bsmntbombdood> it works

03:24:29 <oklopol> mine or yours?

03:24:32 <bsmntbombdood> yours

03:24:37 <oklopol> 1[,[>1g]<1g1--[1-.1g]] this?

03:25:00 <bsmntbombdood> yeah

03:25:04 <oklopol> AND I NEEDED ONLY 10 TRIES!!

03:25:11 <oklopol> :\\\\\\\\\\\\\

03:25:52 <oklopol> the spec should provide certain things that floating point arithmetic on a computer doesn't, normally

03:26:05 <bsmntbombdood> good job

03:26:09 <bsmntbombdood> what do you mean?

03:26:38 <oklopol> you use logs for multiplication, might be that the error margin grows with many operations

03:26:55 <oklopol> which one wouldn't expect normally in integer arithmetic

03:27:00 <bsmntbombdood> hmm

03:27:50 <oklopol> anyway, 0 as end condition should be abs(top)<0.00005 or smth :)

03:28:21 <oklopol> i dunno

03:28:25 <oklopol> not important

03:29:16 <oklopol> what i don't see is why EOF ends inputting since i only convert one of the dup'd values to (value+1) for testing :)

03:29:21 -!- CakeProphet has quit (Read error: 145 (Connection timed out)).

03:29:41 <bsmntbombdood> whats the 1g1-- for?

03:29:46 <oklopol> +=1

03:29:56 <oklopol> for -1 -> 0

03:30:03 <oklopol> ah

03:30:06 <oklopol> i see it now

03:30:14 <oklopol> [ never pops?

03:30:21 <bsmntbombdood> [ never pops

03:30:23 <oklopol> yeah

03:30:29 <bsmntbombdood> how does 1g1-- add one though?

03:30:46 <oklopol> 0 - 1 = -1. x --1 = x+1

03:31:20 <bsmntbombdood> oops

03:31:24 <bsmntbombdood> yeah, I read it wrong

03:31:43 <oklopol> with dup you can make a number n on the stack in O(logn)

03:31:47 <oklopol> tho it's complicated

03:31:49 <bsmntbombdood> I switched postfix and prefix in my head accidently

03:32:03 <oklopol> yeah, it's common :\

03:33:37 <bsmntbombdood> well, I'm satisfied now

03:33:42 <bsmntbombdood> (with the language)

03:33:56 <oklopol> how to add two topmost elements?

03:34:01 <oklopol> without inserting code

03:34:06 <oklopol> before them

03:34:16 <bsmntbombdood> >1g<--

03:34:28 <oklopol> yeah

03:34:29 <oklopol> true

03:34:57 <oklopol> i love the > and <, like get-outta-my-way commands

03:35:15 <oklopol> since only the stuff moves, you stay put (hmm, might be just me xD)

03:35:26 <bsmntbombdood> yeah

03:35:36 <bsmntbombdood> You always stay on the primary stack

03:36:28 <oklopol> i see the 1g as 0 now, forgot it means the same as everywhere else

03:36:44 <bsmntbombdood> wish it didn't need p :(

03:36:50 <oklopol> why g, by the way?

03:36:56 <bsmntbombdood> loG

03:37:06 <oklopol> yeah... but there is l, you know :)

03:37:13 <bsmntbombdood> l looks like 1, o looks like 0

03:37:27 <oklopol> _ could represent a log -__________-

03:37:41 <oklopol> just lying around...

03:37:45 <bsmntbombdood> heh

03:37:52 <oklopol> fuck :O 2� hours left

03:38:17 <bsmntbombdood> "-__-" == log base 2, "-___-" log base 3 ...

03:38:35 <oklopol> and i've not read yet, not watched my episodes and talking naked on IRC about programming 8||

03:38:39 <bsmntbombdood> I can't even remember why I chose 'p'

03:38:42 <oklopol> hehe :D

03:38:53 <oklopol> -__- is my other nick in quakenet!

03:38:57 <bsmntbombdood> maybe exPonent

03:39:03 <pikhq> You're doing nude IRCing?

03:39:04 <oklopol> yeah, third there too

03:39:17 <bsmntbombdood> pikhq, what do you think about my language

03:39:18 <oklopol> i'm always nude, if you can handle the knowledge :)

03:39:32 <oklopol> if not, then... i'm lying

03:39:57 <pikhq> bsmntbombdood: I think my brain is *dead*.

03:40:05 <pikhq> Give me a summary this weekend.

03:40:11 <bsmntbombdood> ok

03:40:20 <oklopol> hmm, you can't take the log of 0

03:40:21 <oklopol> ?

03:40:25 <oklopol> m i rihgt?

03:40:35 <bsmntbombdood> log 0 is undefinded

03:40:36 <pikhq> log(0) is undefined.

03:40:38 <oklopol> okay

03:40:42 <oklopol> thought so

03:40:50 <oklopol> you should define it

03:40:52 <oklopol> for fun

03:41:08 <bsmntbombdood> log(0) == -infinity

03:41:17 <oklopol> yeah

03:41:18 <pikhq> e^x=0. Solve for x.

03:41:27 <oklopol> 2^x=0

03:41:43 <oklopol> not ln, log2

03:41:54 <pikhq> Oh.

03:41:54 <bsmntbombdood> it's the same for all bases

03:42:10 <pikhq> Fine.

03:42:17 <pikhq> b^x=0, where b is your base.

03:42:20 <pikhq> Solve for x.

03:42:23 <pikhq> Have fun.

03:42:56 <oklopol> x=-oo

03:43:09 <oklopol> i think it's nice enough

03:43:19 <bsmntbombdood> lim_{x \to -\infty}{2^x} = 0

03:43:21 <pikhq> (lim x->-oo b^x)=0. . .

03:43:25 <oklopol> ye

03:43:30 <pikhq> Doesn't mean that b^-oo=0.

03:43:34 <pikhq> ;)

03:43:59 <bsmntbombdood> pikhq: LaTeX pwns j00

03:44:00 <bsmntbombdood> :P

03:44:01 <oklopol> true, i know that, just wasn't sure if i could represent it that formally

03:44:09 <oklopol> but, fortunately you BOTH did

03:44:36 <pikhq> bsmntbombdood: I don't remember the LaTeX syntax for limits; sorry.

03:44:47 <oklopol> latex?

03:44:49 <pikhq> (I've not had to use it)

03:45:04 <pikhq> oklopol: It's a typesetting system which excels at math.

03:45:12 * pikhq needs to leave

03:45:13 -!- pikhq has quit ("leaving").

03:45:47 <oklopol> :O

03:46:30 <bsmntbombdood> oklopol: lim_{x \to -\infty}{2^x} = 0 gets rendered to this:

03:46:40 <bsmntbombdood> http://www.mathbin.net/7252

03:47:11 <oklopol> i know

03:47:24 <oklopol> it was obvious from the syntax for one

03:47:33 <oklopol> plus i already knew what you meant :)

03:47:59 <oklopol> cool bin tho :\

03:48:38 <oklopol> okay, now i'm neither coding nor talking about coding

03:48:42 <oklopol> maybe i'll open the bool

03:48:47 <oklopol> ..........k

03:49:00 <oklopol> c u

03:49:17 <bsmntbombdood> bye

04:06:28 <bsmntbombdood> damnit

04:06:46 <bsmntbombdood> oklopol: That cat program doesn't work unless > copies

04:06:49 <bsmntbombdood> which it shouldn't

04:08:04 <bsmntbombdood> argh

04:20:21 <bsmntbombdood> heh, fun program: 1[11g1--11g1--11g1-->g<g>1g<--p>g<g>1g<--p1-.1]

04:21:05 -!- calamari has joined.

04:22:38 <bsmntbombdood> (that prints beep chars endlessly)

04:30:04 <oklopol> 1[,[>1g]<1g1--[1-.1g]] this? weird

04:30:13 <oklopol> it certainly won't work if > copies...

04:30:51 <bsmntbombdood> yeah

04:31:18 <bsmntbombdood> what?

04:31:19 <bsmntbombdood> no

04:31:28 <bsmntbombdood> It works only if > copies

04:32:57 <oklopol> 1:1 -> [:1 -> ,:1 I -> [:1 I I -> >:1 I, I -> 1:1 I 1, I -> g:1 I 0, I -> ]:1 I, I -> <:1 I I

04:33:04 <oklopol> if no copying

04:33:26 <bsmntbombdood> [>1g]< doesn't dup

04:33:39 <oklopol> 1:1 -> [:1 -> ,:1 I -> [:1 I I -> >:1 I I, I -> 1:1 I I 1, I -> g:1 I I 0, I -> ]:1 I I, I -> <:1 I I I

04:33:42 <oklopol> if dopying

04:33:44 <oklopol> *copying

04:33:54 <bsmntbombdood> I don't understand your notation

04:33:57 <oklopol> it triplicates if > copies

04:34:03 <bsmntbombdood> no

04:34:09 <oklopol> oper: stack1, stack2 -> next

04:34:29 <oklopol> I == input

04:34:37 <oklopol> what is wrong with it?

04:34:45 <oklopol> please tell me where it goes wrong

04:34:47 <oklopol> :\

04:35:10 <bsmntbombdood> [ = do nothing to stack

04:35:15 <bsmntbombdood> > move top over

04:35:22 <bsmntbombdood> 1g drop 0 on

04:35:29 <bsmntbombdood> ] pop zero off, end loop

04:35:32 <oklopol> ah

04:35:33 <oklopol> okay

04:35:35 <bsmntbombdood> < move back over

04:35:58 <oklopol> mine works if EITHER > copies or [ duplicates

04:36:07 <oklopol> but i meant it with [ duplicates

04:36:20 <bsmntbombdood> [ has never duplicated

04:36:21 <oklopol> if there is neither in the language, how do you duplicate?

04:36:23 <oklopol> okay

04:36:31 <oklopol> i just imagined it then

04:36:36 <bsmntbombdood> I'm starting to think there's no way to dup :(

04:36:40 <oklopol> okay

04:36:45 <oklopol> then make [ duplicate

04:36:57 <bsmntbombdood> That doesn't make sense

04:37:02 <oklopol> [ push ] pop

04:37:23 <bsmntbombdood> then there's no way to drop

04:38:20 <oklopol> yeah

04:38:27 <oklopol> same prob as before

04:38:49 <bsmntbombdood> If we got rid of p we could add a dup command

04:39:05 <oklopol> nooooooo

04:39:19 <oklopol> 2 log commands is better than stack opers

04:39:22 <oklopol> hmm

04:39:37 <oklopol> you did have [ duplicate at some point of testing

04:39:37 <bsmntbombdood> I'll keep trying to think of ways to emulate p

04:39:39 <oklopol> i'm sure

04:39:51 <bsmntbombdood> nope

04:41:17 <oklopol> okay

04:41:57 <oklopol> i just suggested that, you thought it didn't work, which it didn't

04:42:01 <oklopol> but i stuck with it :)

04:42:07 <oklopol> hard to change

04:42:15 <oklopol> anyways, that doesn't work now

04:42:40 <oklopol> i like [ duplicate more than > duplicate (you need one of them) because it's more logical

04:42:45 <oklopol> but then there's no drop

04:42:52 <oklopol> > copying you have both

04:42:56 <oklopol> ...no

04:43:08 <bsmntbombdood> yes, [] is drop

04:43:09 <oklopol> yes

04:43:12 <oklopol> esyesy

04:43:27 <bsmntbombdood> wait

04:43:41 <bsmntbombdood> nope

04:43:52 <bsmntbombdood> because [] will keep dropping untill it gets to 0

04:44:08 <oklopol> 01[]

04:44:11 <bsmntbombdood> and if > copies we have no way to put a 0 under the top

04:44:16 <oklopol> yeah

04:44:18 <oklopol> tru

04:44:18 -!- digital_me has quit ("leaving").

04:44:33 -!- digital_me has joined.

04:44:37 <oklopol> damn :D you're one step ahead of me all the time

04:45:15 <oklopol> what if

04:45:21 <oklopol> log 0 would be drop?

04:45:42 <bsmntbombdood> that doesn't make sense

04:45:55 <oklopol> i think it does, but maybe not :)

04:46:26 <bsmntbombdood> g should never take more than one off the stack

04:46:50 <oklopol> it wouldn't

04:46:57 <oklopol> it just wouldn't put anything back in

04:47:31 <oklopol> anyway, you could only wipe out numbers divisible by 2 :)

04:47:50 <oklopol> i meant if you tried 0g it would leave nothing there

04:48:00 <oklopol> then 2 would be dropped with gg

04:48:11 <oklopol> and 2.1 with infinite amount of ggggggg... xD

04:48:19 <oklopol> so no

04:48:29 -!- GreaseMonkey has joined.

04:49:30 <oklopol> hmm

04:49:45 <bsmntbombdood> how does one undo a log without a special function to do it...

04:49:49 <oklopol> you can make that work with many kinds of little nonsence

04:50:13 <oklopol> you could have [ not copy a 0 but pop it :)

04:50:26 <oklopol> so ig[ would start a non-dup loop

04:50:30 <oklopol> and [ a dup look

04:50:38 <bsmntbombdood> That wouldn't do anything

04:50:46 <oklopol> 1g[

04:50:53 <oklopol> wouldn't?

04:51:05 <oklopol> yeah, it wouldn't :)

04:51:57 <oklopol> well, add a drp, make [ or > push, then it'll work

04:52:18 <bsmntbombdood> I don't want more than 10 commands though :(

04:53:22 <oklopol> well, i think it'd a good way to handle log(0) to make it a drop that drops another from the stack :)

04:53:30 <oklopol> it's undefined

04:53:49 <bsmntbombdood> That would make g very very weird

04:53:50 <oklopol> so... why not

04:53:54 <oklopol> nah

04:54:03 <bsmntbombdood> g can't take more than one arg from the stack

04:54:11 <oklopol> why is that?

04:54:18 <oklopol> you don't take random logs from input

04:54:28 <oklopol> you always know when you put 0 in

04:54:36 <oklopol> and you always do it for dropping

04:54:41 <oklopol> it's true it's not intuitive

04:54:44 <bsmntbombdood> Because you can only take the log of one number

04:54:52 <bsmntbombdood> so g taking 2 numbers doesn't make sense

04:55:17 <oklopol> yes, but log(0) is an error, that would just be a try {} catch() to drop

04:55:23 <oklopol> -_______-

04:55:33 <GreaseMonkey> what's this lang?

04:55:46 <oklopol> logfuck :)

04:55:47 <bsmntbombdood> GreaseMonkey: http://bsmntbombdood.mooo.com/logfuck_spec.txt

04:56:00 <bsmntbombdood> GreaseMonkey: http://bsmntbombdood.mooo.com/logfuck.py.txt

04:57:48 <oklopol> basically, you have to choose between side-effects and overloading

04:57:54 <oklopol> if you don't want a new command

04:58:03 <oklopol> side-effects don't seem to do it

04:58:33 <oklopol> so... g could be overloaded for input it can't handle yet

05:01:14 <oklopol> 1[1,1g1--[1-.1g]] actually

05:01:21 <oklopol> no dup needed i think...

05:01:48 <oklopol> bsmntbombdood, try that!

05:02:37 <bsmntbombdood> !!!!!!!!

05:02:40 <bsmntbombdood> it works

05:02:47 <oklopol> goods

05:03:00 <oklopol> but, still, dup and drp, needed are

05:03:12 <oklopol> fuck 8|| i gotta go to school

05:03:21 <GreaseMonkey> school hols here :D

05:03:43 <bsmntbombdood> school :(

05:03:44 -!- Sgeo has quit ("Leaving").

05:03:46 <oklopol> school in an hour here and holidays in a few months

05:04:35 <bsmntbombdood> I don't see where that code drops out of the loop

05:04:37 <bsmntbombdood> on eof

05:11:36 <oklopol> it does, tho?

05:11:38 <oklopol> right?

05:12:38 <oklopol> 1[1,1g1--[1-.1g]] -1 won't go in the inner loop, [ won't drp it tho, so it'll go outta the outermost loop too

05:18:04 -!- digital_me has quit ("Lost terminal").

05:19:48 <oklopol> bsmntbombdood, please respond, it'll bug me the whole day otherwise :)

05:19:49 <oklopol> oh

05:19:59 <oklopol> i can dl the official code tho

05:22:43 <oklopol> i can't run it tho

05:22:44 <oklopol> :))

05:22:46 <oklopol> :)))))

05:30:11 <GreaseMonkey> i bags we make a massive BF-style lang with a shitload of instructions and call it BrainDead

05:31:32 <GreaseMonkey> afk food

05:39:45 <bsmntbombdood> oklopol: yes, it works

05:40:36 <bsmntbombdood> Why can't you run it?

05:41:15 <bsmntbombdood> anyway, bedtime

05:51:53 -!- calamari has quit ("Leaving").

05:57:33 <GreaseMonkey> b4x0r

06:18:14 -!- oklofok has joined.

06:19:46 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).

07:32:56 -!- oerjan has joined.

07:59:59 -!- clog has quit (ended).

08:00:00 -!- clog has joined.

08:00:47 -!- ShadowHntr has joined.

08:07:23 -!- sebbu has joined.

08:30:13 -!- oerjan has quit ("Delirium").

08:33:34 <GreaseMonkey> gtg zzz gnight

08:34:35 -!- GreaseMonkey has quit (".,,._ {o_O} _.,,.").

09:24:40 -!- ShadowHntr has quit ("End of line.").

10:16:29 -!- Asztal has quit ("closing VM").

11:39:57 -!- helios24 has joined.

11:55:13 -!- sebbu2 has joined.

12:14:28 -!- sebbu has quit (Read error: 110 (Connection timed out)).

12:36:59 -!- MM2 has quit (Read error: 110 (Connection timed out)).

13:02:33 -!- MM2 has joined.

13:03:41 -!- jix__ has joined.

13:17:41 <oklofok> i couldn't because i have an old version of python

13:17:51 <oklofok> i could dl a new one now

13:17:58 <oklofok> but i was in quite a hurry

13:23:25 -!- oklofok has changed nick to oklopol.

13:28:00 -!- anonfunc has quit.

14:10:57 -!- calamari has joined.

14:18:24 -!- calamari has quit (Read error: 104 (Connection reset by peer)).

14:20:20 -!- calamari has joined.

14:20:48 -!- MM2 has quit (Read error: 110 (Connection timed out)).

14:37:37 -!- sebbu has joined.

14:37:53 -!- Asztal has joined.

14:47:19 -!- calamari has quit ("Leaving").

14:52:00 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").

14:56:15 -!- sebbu2 has quit (Read error: 110 (Connection timed out)).

15:54:32 -!- tgwizard has joined.

16:00:07 -!- jix__ has joined.

16:06:30 -!- Asztal has quit (Read error: 110 (Connection timed out)).

16:18:59 -!- jix__ has quit (Read error: 54 (Connection reset by peer)).

16:19:15 -!- jix__ has joined.

16:37:02 <SimonRC> I think a major impediment to good esolanging is that we make stuff up.

16:37:26 <SimonRC> If we didn't just make stuff up, we could have invented stuff like this: http://home.pipeline.com/~hbaker1/Use1Var.html

17:06:02 -!- helios24 has quit ("Leaving").

17:16:32 <lament> okay, let's stop making stuff up.

18:22:13 <bsmntbombdood> making what up?

18:42:45 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").

18:48:59 -!- Asztal has joined.

19:04:17 -!- tgwizard has quit (Read error: 110 (Connection timed out)).

19:11:53 -!- tgwizard has joined.

20:18:44 <SimonRC> BTW, I recommend reading about single-use variables. They are fascinating

20:30:21 -!- sebbu2 has joined.

20:31:38 -!- sebbu has quit (Nick collision from services.).

20:57:26 -!- Asztal has quit (Read error: 110 (Connection timed out)).

21:05:48 -!- oerjan has joined.

21:06:48 -!- jix__ has joined.

21:21:03 <oerjan> For a language depending heavily on single use variables, check out Clean.

21:28:46 -!- Sgeo has joined.

21:33:11 -!- tgwizard has quit (Remote closed the connection).

21:40:12 <SimonRC> oerjan: Already done so.

21:40:24 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").

21:47:05 -!- RodgerTheGreat has joined.

21:48:29 <SimonRC> RodgerTheGreat: hi

21:49:03 <SimonRC> RodgerTheGreat: read about uniquiness types. They rock for esotericness!

21:49:14 <RodgerTheGreat> ok, cool.

21:49:19 <RodgerTheGreat> I'll look into it

21:51:23 <RodgerTheGreat> ooh

21:51:29 <RodgerTheGreat> yeah, that's a good idea

21:52:29 <SimonRC> now read this, which gives VM ideas: http://home.pipeline.com/~hbaker1/LinearLisp.html

21:57:30 -!- sebbu2 has quit (Connection timed out).

22:34:26 <bsmntbombdood> hmph

22:59:31 -!- pgimeno has changed nick to pgimeno42.

23:08:31 -!- pgimeno42 has changed nick to pgimeno.

23:20:13 -!- oerjan has quit ("Death").

23:22:38 -!- CakeProphet has joined.

23:23:04 <CakeProphet> MMM

23:23:30 <bsmntbombdood> mmm

23:43:33 -!- CakeProphet_ has joined.

←2007-01-17 2007-01-18 2007-01-19→ ↑2007 ↑all