←2007-01-17 2007-01-18 2007-01-19→ ↑2007 ↑all
00:00:40 <oklopol> <bsmntbombdood> <oklopol> hmm... do i do a generic number-> bsmntbombdood-code function or english?
00:00:43 <oklopol> what did you imply?
00:01:06 <bsmntbombdood> dude, you are a genious
00:01:12 <bsmntbombdood> That loop code works perfect
00:01:24 <oklopol> well, thank you
00:02:16 <bsmntbombdood> now I need to think about the math
00:02:35 <bsmntbombdood> and write a spec
00:03:43 <oklopol> god i love metaprogramming :O
00:03:49 <oklopol> how come i never did it before?
00:03:50 <oklopol> >>> def printnumsfromntozero(n):
00:03:50 <oklopol> return makenumber(n)+"[.1-].]"
00:03:50 <oklopol> >>> printnumsfromntozero(7)
00:03:50 <oklopol> '11g11g11g11g11g11g1------------[.1-].]'
00:03:50 <oklopol> >>> runsome("11g11g11g11g11g11g1------------[.1-].]")
00:03:52 <oklopol> 7.0 6.0 5.0 4.0 3.0 2.0 1.0 0.0
00:04:11 <oklopol> hmm
00:04:28 <oklopol> should open c++... i'll start liking that lang soon :<
00:04:54 <bsmntbombdood> hmmm
00:05:15 <oklopol> yeah, the ordo is not optimal
00:05:27 <oklopol> i mean O(n) to create a number
00:06:12 <bsmntbombdood> In the loop, you have to pop the stack
00:06:25 <oklopol> is that so?
00:06:47 <oklopol> my bot does that, believe, it's not that nice
00:06:51 <oklopol> *believe me
00:06:59 <oklopol> i'll get some coffee 8|
00:11:50 <oklopol> okay
00:11:53 <oklopol> added sqrt
00:11:55 <oklopol> as 'q'
00:12:04 <oklopol> now try 11g1--qg.
00:12:13 <oklopol> and wait 10 min for the generic one
00:15:06 <oklopol> hmm
00:15:27 <oklopol> does python have err... err.... err..... binary logical operators?
00:17:35 <oklopol> hmm i assumed being able to create 0.5 automatically makes it easy to create 0.25 etc :)
00:17:54 <oklopol> oh
00:17:56 <oklopol> it does...
00:19:12 <bsmntbombdood> argh
00:19:20 <bsmntbombdood> I can't figure out how to multiply
00:19:33 <lament> binary lowho?
00:19:35 <oklopol> loop
00:19:49 <bsmntbombdood> oklopol: no, with logs there's a better way
00:19:57 <oklopol> okay
00:20:01 <oklopol> what is it?
00:20:27 <oklopol> 11g1--qqqqg = 0.0625
00:20:34 <bsmntbombdood> ">g<g ADD" puts the log of the product on top of the stack
00:20:50 <oklopol> true
00:20:55 <bsmntbombdood> #define ADD > ZERO <--
00:20:59 <oklopol> then inverse would be nice
00:21:11 <bsmntbombdood> right, but I don't want to have to add another operation
00:21:26 <oklopol> trues
00:21:31 <oklopol> but, q is bad too?
00:21:44 <bsmntbombdood> yeah, I don't want any extra ops
00:21:44 <oklopol> makes fractions nice to do
00:21:48 <oklopol> okay
00:21:53 <oklopol> then it's loop
00:22:02 <bsmntbombdood> no
00:22:09 <bsmntbombdood> there has to be some way to do it with logs
00:22:20 <oklopol> yes
00:22:23 <oklopol> changing base
00:22:28 <oklopol> :\
00:22:33 <bsmntbombdood> ?
00:22:34 <oklopol> i can't think of anything else
00:22:44 <bsmntbombdood> What do you mean changing base?
00:22:47 <oklopol> hmm, i might be wrong
00:23:00 <oklopol> i'll test before i say anything more stupid
00:23:44 <bsmntbombdood> maybe inv. log (exponent) is needed
00:24:59 <oklopol> yeah
00:25:05 <oklopol> i was wrong
00:25:14 <oklopol> haven't fiddled with logarithms in ages
00:25:14 <bsmntbombdood> that makes me sad :(
00:25:22 <oklopol> :(
00:25:27 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
00:29:42 <oklopol> i thought there was a correlation between either logarithms with inverted base, but there seems not to be
00:29:53 <oklopol> (i'm not good at math, i just guess :))
00:30:17 <oklopol> yeah, the coffee >>
00:30:56 -!- sebbu has quit ("@+").
00:31:13 <bsmntbombdood> ok, for now i've added an operation "p", which inverts "g"
00:31:49 <bsmntbombdood> so now to multiply you can do ">g<g ADD p"
00:32:47 <oklopol> yeah ok
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