←2007-10-30 2007-10-31 2007-11-01→ ↑2007 ↑all
00:09:57 <ehird`> hmm
00:11:48 <lament> oerjan: if smetana+1 compacts the infinite smetana program to finite size, then it's obviously turing-complete
00:12:43 <lament> oerjan: the question is whether we can consider smetana to be turing-complete, despite infinitely large programs
00:14:11 <lament> and "smetana+1 is just a notation" would be a good argument for that.
00:15:15 <ehird`> if it is turing complete
00:15:19 <ehird`> it can hardly be said to be just a notation
00:15:59 <lament> ehird`: that doesn't make any sense.
00:20:49 <pikhq> ehird`: Any more pebble.bfm insanity?
00:20:55 <ehird`> pikhq: damnit!!! i forgot
00:21:02 <ehird`> pikhq: =(
00:21:18 <ehird`> pikhq: it'll also be harder than i thought due to lack of strings in pebble
00:21:37 <pikhq> Meaning that you'd have to do string functions first.
00:21:44 <ehird`> yes
00:21:56 <ehird`> the hardest part would be coming up with an efficient representation
00:22:16 <ehird`> i mean, H1e1l1l1o1w1o1r1l1d is... bigger than neccessary
00:24:30 <lament> Only by a constant factor.
00:24:38 <lament> i mean linear.
00:24:43 <pikhq> And "Hello world\0x00" is. . . Not useful for string insertion in Brainfuck. ;)
00:25:38 <ehird`> lament: yeah well :(
00:25:51 <ehird`> i guess, i'll do the swapping-algorithm
00:25:55 -!- jix has quit ("This computer has gone to sleep").
00:25:55 <ehird`> Helloworld0
00:25:58 <ehird`> to insert to string
00:26:15 <ehird`> make 0 the index of the string from the end you want to access
00:26:19 <ehird`> swap and -1 repeatedly
00:26:37 <ehird`> of course, to iterate
00:26:43 <ehird`> just go from H until you find 0
00:27:51 <ehird`> good algorithm?
00:27:57 <ehird`> though the swapping could be inefficient
00:29:18 <ehird`> pikhq: lament: comments?
00:29:41 <lament> i bought sheet music paper!
00:30:02 <ehird`> related comments?
00:30:33 <lament> 10 staves per sheet, 40 sheets (related to my previous comment)
00:31:00 <ehird`> related to my algorithm
00:32:19 <ehird`> :)
00:36:57 <ehird`> i guess the swapping would be slow
00:36:58 <ehird`> no?
00:40:03 -!- RedDak has quit (Read error: 113 (No route to host)).
00:51:15 <ehird`> no/yes? ;) (lament,pikhq)
00:55:59 <ihope> Are you looking for minimal Turing-complete systems?
00:56:21 <ehird`> and PEBBLE in PEBBLE
00:59:25 * ihope creates a parser called convertNewZealand
00:59:35 <ehird`> haha, what
00:59:39 <ehird`> oh -- welcome back
00:59:43 <ehird`> hm
00:59:45 <ihope> Ello. :-)
00:59:55 <ihope> It converts from unary to decimal with New Zealand.
00:59:57 <ehird`> is the unary->anything converter actually possible/easy in your subst lang?
01:00:03 <ihope> It's certainly possible.
01:00:04 <ehird`> hahahaha
01:00:04 <ehird`> one second difference
01:00:18 <ehird`> so how does it utilize new zealand
01:00:40 <ihope> By New including a Zealand if the string is "".
01:00:57 <ihope> ...including New Zealand, I mean.
01:01:23 <ehird`> so what is a New Zealand
01:01:25 <ehird`> apart from a country
01:01:40 <ihope> A backronym for "no zero".
01:01:57 <ihope> And now for another regex mnemonic: "Look up there! It's money!"
01:02:10 <ehird`> I'm dumb. explain
01:02:22 <ehird`> (By the way, what regexps do you use? Custom?)
01:02:24 <ihope> "" is converted to "" instead of "0".
01:02:30 <ihope> Undefined, really.
01:02:39 <ehird`> ah
01:02:43 <ihope> Though $ is a pretty important part of it.
01:04:21 <ehird`> Does your language have a way of putting anything to the screen?
01:04:35 <ehird`> A primitive or something, that does no substitutions, but has a side effect of output
01:04:44 <ihope> It could easily be extended to include one.
01:05:03 <ihope> Input as well.
01:05:32 <ehird`> Because you could make a program basically identical to fibonacci.b
01:05:41 <ihope> bleach(): {/[ab]/; "w" + bleach()}
01:05:42 <ehird`> Writes out fibonacci numbers in decimal, one per line, until halted.
01:05:51 <ihope> (With an invisible period on the end.)
01:05:58 <ehird`> ihope: what does that do?
01:06:07 <ihope> It replaces a and b with w.
01:06:15 <ehird`> And... why.
01:06:22 <ihope> ...and gives an error when it reaches the end of the string.
01:06:46 <ihope> It was going to make input more friendly for convertNoZero, but I just realized it's actually completely unnecessary.
01:07:08 <ehird`> Just match . instead of w :-)
01:07:31 <ihope> Well, I was thinking [ab].
01:07:34 <ihope> But yeah.
01:07:39 * ihope ponders
01:07:47 <ehird`> You want it to be generalized
01:07:53 <ihope> I guess so.
01:08:05 <ehird`> since unary is just a way of encoding a string as its length, the actual contents is arbitary
01:08:27 * ihope nods
01:10:06 * ihope decides to go for little-endian increment
01:10:29 <ehird`> So what is your language called?
01:10:32 <ehird`> is it implemented?
01:11:11 <ihope> No implementation. I think I'll call it Redivider.
01:11:26 <ehird`> It's really interesting, I might implement it :)
01:11:44 <ihope> Should I finish the program or the spec first?
01:11:45 <ehird`> Does it have a spec or similar? I mean, defining regexps beyond the basics could be hard...
01:11:49 <ehird`> hahah
01:11:53 <ihope> :-)
01:11:54 <ehird`> <1 second difference
01:12:01 <ehird`> and program! :)
01:12:10 <ihope> Will do!
01:16:13 <ihope> Is it okay if I use the word "guts" in the spec? :-P
01:16:28 <ehird`> Sure
01:16:29 <ehird`> :P
01:16:31 <ihope> As in <regex> ::= "/" <regexguts> "/"
01:16:35 <ehird`> But I want to see the program first!
01:16:37 <ehird`> oh
01:16:40 <ehird`> as long as you define regexguts
01:16:41 <ehird`> ;)
01:16:42 <ihope> Yes, I'm still doing that.
01:16:49 <ihope> Pff, why would I do that? :-)
01:17:01 <ehird`> because otherwise i won't implement it, having no spec :P
01:17:08 <ehird`> i'm not going to use a third-party regexp spec
01:17:11 <ihope> Okay.
01:17:14 <ehird`> that'd be inconsistant with other implementations!
01:17:19 <ihope> I'll write my own minimalistic one, then.
01:17:22 <ehird`> think of all the regexp libs... you gotta define your own for portability ;)
01:17:28 <ehird`> just give it enough to be comfy for use
01:17:33 * ihope nods
01:17:41 <ihope> Ranges, exclusion...
01:17:51 <ihope> Plus /[]/, the regex that doesn't match.
01:17:53 <ehird`> there's not much to regexps
01:18:11 <ehird`> So is Redivide TC?
01:18:21 <ehird`> i doubt it, personally, but..
01:18:34 <ehird`> I might try and write a bf interp in it. :)
01:18:46 <ihope> Redivider is almost certainly TC.
01:18:48 <ehird`> hm, i think that would be possible
01:18:50 <ehird`> even simple
01:18:52 <ehird`> that would be cool :)
01:18:55 <ihope> If http://pastebin.ca/679421 has no bugs, it is.
01:19:09 <ehird`> Of course.
01:19:11 <ehird`> But brainfuck = far more fun
01:19:12 <ehird`> ;)
01:19:46 <ehird`> very crazy suggestion for regexps
01:20:08 <ehird`> <x> means "anything function x matches"
01:20:20 <ehird`> this would make, e.g. parsing brainfuck braces trivial
01:20:24 <ihope> That sounds rather complicating.
01:20:25 <ehird`> though perhaps it's too bloated in your mind ;)
01:20:35 <ehird`> i don't know, it'd just make a lot of stuff you could think of easier
01:20:49 <ihope> This language is inspired by Parsec, which is a completely ordinary combinator parser as far as I can tell :-)
01:21:28 <ehird`> Well, yeah, but with parsec you could insert random haskell in the middle
01:21:33 <ehird`> Something like (i don't know haskell)
01:21:44 <ehird`> match "abc" ++ callParser ++ match "def"
01:21:48 <ehird`> with these regexps, you can't
01:22:02 <ihope> I think you can still do that here.
01:22:20 <ehird`> Hmm
01:22:20 <ehird`> how?
01:22:32 <ihope> /abc/ + parser() + /def/ will work and return "abcwhatevertheparserreturneddef".
01:23:04 <ehird`> oh, cool
01:23:04 <ehird`> so
01:23:11 <ehird`> /[/ + bf() + /]/
01:23:11 <ihope> First it runs /abc/, which consumes the abc and returns "abc", then it runs parser(), which consumes something and returns something, then it runs /def/, which consumes the def and returns "def".
01:23:14 <ehird`> should parse braces?
01:23:18 <ehird`> right?
01:23:22 <ihope> Yup.
01:23:46 <ihope> If bf() parses "foo" into "bar", that'll parse "[foo]" into "[bar]".
01:24:23 <ihope> If you don't like the brackets around it, then there's {/[/; x <- bf(); /]/; x}
01:24:29 <ehird`> hmm
01:24:35 <ehird`> what is a function that parses nested parens with anything in
01:24:36 <ehird`> i.e.
01:24:36 <ihope> That parses "[foo]" into "bar".
01:24:53 <ehird`> (abc) ((ab)c) (a(b)(c((d)))) parses, (a etc don't
01:25:05 <ehird`> More importantly: some way to get the inner contents
01:25:09 <ehird`> (abc) returns abc
01:25:14 <ehird`> ((ab)c) returns (ab)c
01:25:22 <ehird`> but, of course, ONLY if the whole thing has well-formed braces
01:25:25 <ehird`> Is it possible?
01:25:26 <ihope> What does (ab)c return?
01:25:32 <ihope> Possible, yes. Probably easy, too.
01:25:33 <ehird`> ihope: ab
01:25:35 <ehird`> well
01:25:37 <ehird`> i guess that's undefined
01:25:45 <ehird`> but yeah ab
01:25:52 <ehird`> i just mean, if you can do that, then you can parse brainfuck
01:26:13 <ihope> check(): /(/ + check() + /)/ + check() | /[^()]/ + check()
01:26:16 <ehird`> if you have "code[SENTINEL]tape", then you can run a brainfuck program trivially, iirc
01:26:19 <ihope> ...with that invisible period.
01:26:28 <ihope> That just checks for well-formedness.
01:27:08 <ihope> grab(): {/(/; x <- check(); /)/; x}
01:27:13 <ehird`> Cool.
01:27:17 <ihope> ...period again, gah.
01:27:21 <ehird`> So what are these "x"s etc?
01:27:28 <ehird`> Just arbitary variables that are "" by default?
01:27:36 <ihope> By default, they're errors.
01:27:40 <ihope> Otherwise, yes.
01:27:46 <ehird`> So how does grab(): {/(/; x <- check(); /)/; x} work
01:27:48 <ihope> They always hold strings, never parsers.
01:28:23 <ihope> It runs /(/ and throws away the result, then runs check() and stores the result in x, then runs /)/ and throws away the result, then runs x and returns the result.
01:28:31 <ihope> A string is the same thing as a parser that does nothing and returns that string.
01:28:35 <ehird`> But what is x
01:28:40 <ehird`> It should be an error
01:28:43 <ihope> x is a local variable, I guess.
01:28:43 <ehird`> You did not define it
01:28:55 <ihope> x <- check() is what introduces it.
01:28:56 <ehird`> <- is append right?
01:29:09 <ihope> No, it stores.
01:29:12 <ehird`> Ah
01:29:14 <ehird`> How do you append?
01:29:15 <ihope> Or creates or some such.
01:29:17 <ehird`> x <- x + y?
01:29:21 <oerjan> <- is obviously borrowed from haskell's do notation
01:29:32 <ihope> I guess you can do it that way. You might as well do z <- x + y, though.
01:29:49 <ihope> These behave pretty much exactly the same way as in Haskell's do notation, yeah.
01:29:56 <ehird`> Why, ihope? Why have unneeded vars?
01:30:20 <ihope> Less confusion, I guess, if you find that sort of thing confusing.
01:31:53 <ihope> I think this is right, apart from the fact that it outputs the numbers all smooshed together if output doesn't automatically add a newline: http://pastebin.ca/755940
01:32:25 <ehird`> a few questions
01:32:43 <ehird`> is main a special name? or is it just what you called it as a convention? and, what's []?
01:33:03 <ihope> There's not necessarily anything special about it.
01:33:24 <ihope> foo()[blah] makes foo parse blah; otherwise, it parses from whatever it's called in.
01:33:32 <ehird`> Could you like put it in the spec? "If there is a main function, it is called at runtime, otherwise you are dropped in to a REPL?"
01:33:39 <ihope> The "current string", I guess.
01:33:44 <ihope> Sure.
01:33:48 <ehird`> foo()[blah]... why not just foo(blah)?
01:33:53 <ehird`> I can't see the ()s being used for anything else there
01:34:13 <ehird`> Plus it would look nicer.
01:34:41 <ihope> They're for when you want parsers to take parameters other than the current string.
01:35:07 <ehird`> so foo(extra)[str]?
01:35:13 <ehird`> If so, may I humbly suggest just foo(str, extra)?
01:35:25 <ihope> Good idea, yes.
01:35:30 <ehird`> :)
01:35:37 <ihope> Though I rather feel foo(extra, str) would be better.
01:35:46 <ehird`> Although... What if you want extra args, but default string?
01:35:54 <ehird`> Maybe some kind of seperator
01:35:57 <ehird`> foo(str | extra)
01:36:05 <ehird`> no, no... that won't work nicely
01:36:06 <ehird`> hmm
01:36:13 <ehird`> how to resolve that?
01:36:22 <ihope> Extra arguments but the default string would just be foo(extra).
01:36:37 <ehird`> How can it tell the difference between foo(str) and foo(extra)?
01:37:04 <ihope> Each parser has a parameter number. If it's given that many parameters, then they're all actually parameters; if it's given one more, the last one is the input string.
01:37:28 <ehird`> Parser with 1 parameter number:
01:37:30 <ehird`> foo(str)
01:37:34 <ehird`> I just want to pass it a special string.
01:38:03 <ihope> If foo's parameter number is 1, then str is the parameter.
01:38:16 <ehird`> Right! BUt I don't want it to be.
01:38:21 <ihope> If foo's parameter number is 0, then str is the input string.
01:38:24 <ehird`> I just want to pass it an extra string, with no extra parameters.
01:38:29 <ehird`> Foo's parameter number is 1.
01:38:31 <ehird`> Tell me how.
01:38:41 <ihope> If foo's parameter number is 1, then use foo(parameter, inputstring).
01:38:49 <ehird`> I don't want to give it an extra parameter
01:39:03 <ihope> If foo's parameter number is 1, it must take a parameter.
01:39:09 <ehird`> Ah, ok.
01:39:12 <ehird`> No optional parameters
01:39:14 <ihope> Right.
01:39:46 <ihope> If you like those optional parameters, go the Haskell Way and use foo("J" + parameter) or foo("N") :-)
01:39:47 <ehird`> I suggest making inputstring the first
01:40:02 <ehird`> It feels like it's what the parser is being called /with/
01:40:06 <ehird`> Everything else is just additional info
01:40:15 <ehird`> Also, it makes sense.
01:40:25 <ihope> I sort of have the opposite opinion for the same reason.
01:40:28 <ehird`> For increasing parameter num: foo(str), foo(str,1), foo(str,1,2) etc
01:40:41 <ehird`> str - the main part of the parser, it's what its actually parsing - moves, in your smantics
01:40:43 <ehird`> which is not nice
01:41:19 <ihope> Well, if parameter numbers can vary, you need some way of differentiating a parameter from an input string.
01:41:32 <ehird`> First parameter: string
01:41:38 <ehird`> Rest: parameters, function dependena
01:42:01 <ihope> Function what?
01:42:13 <ehird`> dependant
01:42:21 <ehird`> The string is there regardless of the function
01:42:25 <ehird`> The rest is stuff added on "after the tail"
01:42:36 <ihope> The input string's being optional is sort of necessary.
01:42:36 <ehird`> It makes so much more sense for the string to be first.
01:43:27 <ihope> You need some way of making reference to the current string... or maybe this could be done without the current string stuff? Hmm.
01:43:42 <ehird`> look:
01:43:47 <ehird`> func() # current string
01:43:54 <ehird`> oh
01:43:55 <ehird`> wait
01:43:59 <ehird`> i get you
01:44:04 <ehird`> you can call a function with a parameter
01:44:06 <ehird`> but with the current string
01:44:10 <ehird`> OK, you're right, yours is better
01:44:19 <ehird`> Hmm.
01:44:22 <ehird`> Some way to mark it
01:44:23 <ehird`> How about
01:44:32 <ehird`> [abc] means "abc as string argument"
01:44:38 <ehird`> and can be anywhere, but is generally at the start
01:44:46 <ehird`> for a function with parameter value 2:
01:44:49 <ehird`> func(1,2) # normal
01:44:53 <ehird`> func([str], 1, 2) # using str
01:45:07 <ihope> How would varying numbers of parameters work, anyway?
01:45:12 <ehird`> They wouldn't
01:45:15 <ehird`> I'm not talkng about that
01:45:18 <ehird`> But,
01:45:22 <ehird`> func(1,2) and func(1,[str],2) would work
01:45:28 <ehird`> i.e. [] just mean "string argument"
01:45:34 <ihope> Seems a little pointless.
01:45:34 <ehird`> func2(str) # I guess, for parameter value 0, the []s would be optional, for nicety
01:45:52 <ehird`> so, progression: func(str) func([str],1) func([str],1,2)...
01:46:09 <ehird`> ihope: Well, it's nicer than allowing one additional argument. Think of the bugs - it's just not obvious at a glance
01:46:28 * ihope ponders
01:46:41 <ehird`> I think it's nicer, IMO
01:46:42 <ehird`> Just cleaner.
01:46:44 <ehird`> More free-form
01:46:45 <ihope> Well, the input string is quite a bit like just another parameter.
01:47:02 <ehird`> Yes, but:
01:47:06 <ehird`> func(1,2,oops-an-additional-arg)
01:47:11 <ehird`> That could so easily be a bug.
01:47:15 <ehird`> And explicitness is better, I'd say
01:47:18 <ihope> Indeed, it could.
01:47:29 <ehird`> func(1,2,oops) would be an error - "too many arguments, perhaps you need []?"
01:47:38 <ehird`> func(1,2,[oops]) would do what you intend
01:47:43 <ihope> Though I like the look of semicolons better.
01:47:51 <ehird`> (Probably [] would by convention go at the start, though - func([oops], 1, 2))
01:47:56 <ihope> func(1, 2, oops;) and func(1; 2, oops) and such.
01:47:57 <ehird`> So, I think that'd be good.
01:48:03 <ehird`> but [oops] at the start or end by convention?
01:48:11 <ehird`> ihope: Well, it just seems not noticable enough to me
01:48:25 <ihope> Hmm...
01:48:40 <ihope> "It's an esoteric language; get over it"? :-P
01:48:51 <ehird`> Esoteric language != unplanned language
01:49:02 <ehird`> I think that [] here makes more sense
01:49:13 <ehird`> OK, How about this
01:49:20 <ihope> How about func(1, 2; oops] and func[oops; 1, 2)?
01:49:23 <ehird`> Instead of func()[blah]
01:49:29 <ehird`> func[blah]()
01:49:32 <ehird`> or just func[blah]
01:49:33 <ehird`> yeah
01:49:34 <ehird`> so:
01:49:36 <ehird`> func[blah]
01:49:37 <ehird`> func()
01:49:41 <ehird`> func[blah](1,2)
01:49:47 <ihope> Ah, I like that.
01:49:55 <ehird`> func[blah] would be sugar for func[blah](), since the former looks nicer
01:50:01 * ihope nods
01:50:09 <ehird`> Though maybe func[blah]() would be nicer, as its more consistant - func[blah] is the parser that matches on blah
01:50:31 <ehird`> Hmm
01:50:42 <ihope> Well, there are no first-class parsers here.
01:50:46 <ehird`> output[reverse[unary()]] output[reverse[unary()]()]()
01:50:49 <ehird`> The former is definately nicer
01:50:50 <ehird`> OK
01:50:52 <ihope> Yeah.
01:51:00 <ehird`> a[b] is a[b]()
01:51:05 <ehird`> a() is a[current_str]()
01:51:07 <ihope> Hey, maybe we could get rid of () entirely.
01:51:12 <ihope> I mean, make it optional.
01:51:14 <ehird`> a[b](c,d) is what you expect
01:51:21 <ehird`> a(b,c)[d] is an error
01:51:22 <ehird`> And how?
01:51:28 <ehird`> a[b],c,d? Ugly.
01:51:36 <ehird`> I think the above is probably the best
01:51:40 <ihope> I mean just (), not (stuff).
01:51:49 <ihope> No foo(); just foo.
01:51:49 <ehird`> run(): {x <- step(); output()[reverse()[unary()]]; run()[x]}.
01:51:49 <ehird`> ->
01:51:56 <ihope> output[reverse[unary]]
01:51:57 <ehird`> run(): {x <- step(); output[reverse[unary()]]; run[x]}.
01:52:01 <ehird`> Hmm
01:52:08 <ehird`> ihope: I think in that case () provides more information
01:52:13 <ehird`> Because, otherwise
01:52:17 <ehird`> You could mistake it for a variable.
01:52:25 <ihope> Yes, that's true.
01:52:36 <ehird`> I'll rewrite your paste using that proposed syntax
01:53:04 <ehird`> http://pastebin.ca/755956
01:53:10 <ehird`> IMO, it looks really clean and easy to understand. Very nice.
01:53:36 <ehird`> Likewise, func[a](b,c) follows naturally from that syntax.
01:53:38 <ihope> Yes, you're right.
01:53:40 * ihope nods
01:53:41 <ehird`> OK.
01:53:49 <ehird`> So, can I expect a spec tomorrow maybe? ;)
01:53:50 <ehird`> I'm going now
01:53:57 <ihope> Yup. Bye.
01:53:59 <ehird`> Very interesting langugae
01:54:05 <ehird`> It's esoteric but looks really easy to program in too
01:54:09 * ihope nods
01:54:16 <ehird`> OK. Leave me a memo with MemoServ if you get it done :)
01:54:20 <ihope> Will do.
01:55:20 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
04:25:58 -!- tokigun has joined.
04:51:12 <GregorR> THIN FUNCTIONS WILL BE THE DEATH OF ME
04:52:52 <oerjan> GAUNT ZOMBIE FUNCTIONS, LOOKING FOR BRAINS...
04:56:22 <GregorR> Unfortunately, I believe that the solution is to abandon my dictum that all blocks are functions :(
04:56:50 <pikhq> You *could* do it as Tcl does. . .
04:57:08 <pikhq> Provide an "uplevel" command, which executes something up a level in the stack.
04:57:21 -!- ihope has quit (Read error: 110 (Connection timed out)).
04:57:40 <GregorR> Wow that's gross >_>
04:58:19 <oerjan> that's not very higher-order. a function should not necessarily know where it was called.
04:58:23 <pikhq> I guess it's not Plofy, though.
04:58:28 <GregorR> Mind you, it's better than thick and thin :P
04:59:52 <pikhq> But not much better.
05:01:51 <oerjan> hm... isn't a thick function essentially one that binds its escape continuation to return?
05:19:05 <GregorR> That's a truly bizarre way of looking at it :P
05:19:46 <GregorR> A thick function is the point in the call stack that a return will drop do.
05:33:48 <oerjan> alternately, a thick function is one which catches the return exception. you could generalize that.
05:33:57 <oerjan> and good night.
05:34:03 -!- oerjan has quit ("leaving").
05:34:38 <GregorR> Oooh, that's a good way to think about it.
05:34:43 <GregorR> Returns become throws with special syntax.
05:35:01 <GregorR> Thick functions are just functions with implicit try/catch blocks.
05:35:18 <GregorR> Now, how can I use that to get rid of thick functions :P
06:58:56 -!- staplegun_ has joined.
06:59:47 -!- staplegun_ has changed nick to i4nic8.
07:00:55 <i4nic8> howzit
07:03:24 -!- i4nic8 has quit (Client Quit).
07:03:44 -!- i4nic8 has joined.
07:05:10 <i4nic8> piss
07:17:54 -!- i4nic8 has quit ("ChatZilla 0.9.78.1 [Firefox 2.0.0.8/2007100816]").
07:26:42 -!- puzzlet has quit (Remote closed the connection).
07:26:50 -!- puzzlet has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:20:10 <ttm> Hm.
10:26:33 -!- puzzlet has quit (Remote closed the connection).
10:26:37 -!- puzzlet has joined.
10:32:34 -!- puzzlet has quit (Remote closed the connection).
10:32:40 -!- puzzlet has joined.
11:09:34 -!- bsmntbom1dood has joined.
11:21:20 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
11:49:14 -!- jix has joined.
11:49:24 -!- jix has quit (Remote closed the connection).
11:49:51 -!- jix has joined.
12:15:15 <oklopol> o
12:37:45 -!- Tritonio has joined.
13:56:49 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
13:58:26 -!- puzzlet has joined.
15:08:29 -!- ehird` has joined.
15:12:55 <ehird`> GregorR: that try/catch idea for thick functions is good but it doesn't help you vanquish thick/thin functions
15:13:25 <GregorR> Hence, "<GregorR> Now, how can I use that to get rid of thick functions :P"
15:13:52 <ehird`> :P
15:13:59 <ehird`> in fact it probably complicates it
15:14:07 <ehird`> because you introduce syntactic sugar etc and even more thick/thin semantics
15:14:28 <ehird`> ok, show me a recursive factorial again so i can see thick vs thin and i'll try and figure out a way to resolve it
15:16:23 <ehird`> :)
15:16:24 <GregorR> http://www.pastebin.ca/756432
15:23:32 <oklopol> GregorR: make it always run the program with every single combination of thick and thin functions at the same time, and introduce another, declarative, language, you have to use with the actual plof code to tell the interpreter what the correct behavior is; it can then resolve the right combination of thick/thin functions automatically
15:23:38 <oklopol> you're welcome.
15:23:50 <ehird`> wow
15:24:25 <ehird`> so
15:24:27 <ehird`> {} = thin
15:24:32 <ehird`> :{} = thick
15:34:32 <ehird`> right? GregorR?
15:34:55 -!- Tritonio has quit (Read error: 110 (Connection timed out)).
15:36:16 <ehird`> pikhq: pebble.bfm will be called Calculus ;) I'm working on it no
15:36:17 <ehird`> w
15:36:20 -!- Tritonio has joined.
15:48:44 -!- bsmntbombdood has joined.
15:48:55 -!- oerjan has joined.
15:57:39 <ehird`> pikhq: how does eval work? does it run at compile-time?
16:00:02 -!- bsmntbom1dood has quit (Read error: 110 (Connection timed out)).
16:24:18 * GregorR reappears.
16:24:20 <GregorR> ehird`: Yes.
16:24:21 <GregorR> oklopol: No.
16:24:32 <ehird`> :D
16:24:42 <ehird`> GregorR: How about
16:24:49 <ehird`> If {} is seen in the context of an assignment
16:24:54 <ehird`> It's thick
16:24:56 <ehird`> Otherwise, it's thin
16:25:03 <ehird`> You still have thick/thin, but it's internal only.
16:25:05 <GregorR> The first argument to 'if' is thick.
16:25:14 <ehird`> it does not need to be, though.
16:25:26 <GregorR> Yes it does, it returns a value that 'if' needs to catch.
16:25:40 <RodgerTheGreat> wait, is this a new language?
16:25:44 <ehird`> Yeah, but {value} works
16:25:47 <ehird`> You don't need to use "return"
16:25:50 <ehird`> RodgerTheGreat: plof is not new
16:25:59 <RodgerTheGreat> oh, ok- false alarm
16:26:08 <ehird`> RodgerTheGreat: there is a new language though!
16:26:13 <RodgerTheGreat> :D
16:26:22 <GregorR> ehird`: Well, in Plof2, returning and evaluating to a value are identical, but I suppose that doesn't need to be the case :)
16:26:34 <ehird`> GregorR: Exactly.
16:26:35 <GregorR> So, lemme mull over cases where that might be wrong.
16:26:49 <ehird`> GregorR: return will zoop down the stack, but a value at the end will just evaluate to it.
16:26:55 <GregorR> Right
16:27:11 <GregorR> "zoop" being of course the technical term.
16:27:17 <ehird`> RodgerTheGreat: It's ihope's. It's called Redivide, and it's a turing complete substitution language. Fibonacci numbers: http://pastebin.ca/755956
16:27:48 <ehird`> http://pastebin.ca/679421 SK calculus implementation
16:27:53 <ehird`> Actually
16:27:53 <ehird`> no
16:27:57 <ehird`> that syntax is the old version
16:28:03 <ehird`> I'l update it (the SK calculus one)
16:28:03 <RodgerTheGreat> interesting
16:28:24 <ehird`> http://pastebin.ca/756513 new SK calculus
16:28:37 <ehird`> to explain () vs []:
16:28:50 <ehird`> [x] means "parse string x", it defaults to the current string if not speciified
16:29:01 <ehird`> you can also pass extra parameters (if defined in the function) with (a,b...)
16:29:08 <ehird`> but, you cannot omit both [] and ()
16:29:35 <ehird`> so, parser() for no arguments, parser(a) for one argument, etc. or with a different string: parser[str] (note no () - it looks nicer), parser[str](a), parser[str](a,b) etc
16:29:48 <ehird`> apart from that, the rest is pretty self-evident I think
16:30:25 <bsmntbombdood> zomg halloween
16:30:30 <ehird`> main(), of course, is run with an empty string by default if it's there, when interpreting/running the compiled version
16:30:34 <ehird`> if it's not there, it drops into a REPL.
16:30:42 <ehird`> A full spec is being written by ihope, it should be ready sometime today
16:30:46 <ehird`> But I thik it's very interesting.
16:37:46 <oerjan> bsmntbombdood: BOO!
16:37:53 <bsmntbombdood> eek!
16:38:01 <ehird`> :O
16:58:32 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
17:11:34 -!- jix has quit ("CommandQ").
17:15:19 -!- jix has joined.
17:26:56 -!- jix has quit (Nick collision from services.).
17:27:06 -!- jix has joined.
18:03:05 -!- jix has quit ("CommandQ").
18:09:09 -!- jix has joined.
18:58:49 -!- RedDak has joined.
19:33:29 -!- oerjan has quit ("leaving").
19:55:33 <ehird`> lalaalalalalala
19:57:03 <oklopol> i wish i could fly
20:07:19 -!- sebbu2 has joined.
20:27:19 -!- sebbu has quit (Connection timed out).
20:37:26 -!- Tritonio_ has joined.
20:37:33 -!- Tritonio has quit (Read error: 110 (Connection timed out)).
21:23:45 <ehird`> oi
21:23:47 <ehird`> er
21:23:50 <ehird`> typo
21:40:58 -!- bsmntbombdood has joined.
21:42:18 -!- sebbu2 has changed nick to sebbu.
21:44:16 -!- ehird` has quit ("Leaving.").
21:45:45 -!- ehird` has joined.
22:00:37 -!- ihope has joined.
22:03:25 -!- ihope has quit (Client Quit).
22:12:33 -!- ihope has joined.
22:15:24 <ihope> Ello!
22:15:34 <RodgerTheGreat> !ollE
22:15:38 <EgoBot> Huh?
22:16:19 <ehird`> ihope: yay
22:16:20 <ehird`> you're here
22:16:31 <ihope> Yup.
22:16:40 <ehird`> any work on the redivide spec? :)
22:17:46 <ihope> I'm still working on it.
22:17:48 <ehird`> woo
22:18:00 <ehird`> RodgerTheGreat said that redivide was interesting earlier today :P
22:18:16 <ihope> Yay.
22:18:41 <ehird`> one comment though
22:19:14 <ehird`> output[str] gets away from non-purity by saying "Does no substitutions. (In an interactive interpreter, this is printed as debug output)" sneakily,
22:19:17 <oklopol> hah, i said it was interested before it was famous!
22:19:20 <ehird`> but what about input()?
22:19:31 <oklopol> *interesting
22:19:35 <ehird`> oklopol: I was interested in it when ihope first mentioned it ages ago
22:19:38 <ehird`> I just didn't mention it at the time :P
22:19:43 <oklopol> heh
22:20:07 <ihope> ehird`: can't input() be the same way as output()?
22:20:24 <ehird`> ihope: Well, no, because it has to return the string from input.
22:20:41 <ehird`> ihope: You can't get away from non-purity there, unlike my above output[] definition
22:20:53 <ihope> Oh, right.
22:21:02 <ihope> Who cares about purity? :-P
22:21:12 <ihope> Evaluation order already matters.
22:21:18 <ehird`> Well, if it's a substitution language it's expected that you know what's happening to the program :P
22:21:37 <ehird`> You know what I mean? It's like a list of rules... putting non-purity in there (that isn't carefully worded) could damage that
22:21:44 <ihope> Hmm...
22:22:23 <ihope> I still don't think there's much of a problem if evaluation order already matters.
22:23:25 <ehird`> I guess
22:24:50 <oklopol> multithreaded parsing!
22:25:00 <oklopol> ihope: please add thread support <3
22:25:07 <ihope> NO!
22:25:14 <oklopol> </3
22:25:30 <ehird`> ihope: you should at least allow multi threading
22:25:33 <ehird`> but
22:25:35 <ehird`> implicit
22:25:43 <ehird`> so an implementation can run it concurrently! :D
22:25:50 <ihope> In a way that doesn't affect semantics, you mean?
22:25:53 <oklopol> hmm, how exactly would that be possible :P
22:26:01 <ehird`> ihope: yeah!
22:26:22 <oklopol> the fastest parser gets the string!
22:26:32 <ihope> foo(bar(),baz())
22:26:40 <ihope> Evaluate bar() and baz() simultaneously if possible.
22:27:21 <oklopol> hmm, it's pretty hard to evaluate two parsers simultaneously unless you know how much they'll gorge already
22:28:14 <ehird`> ihope: yeah#
22:28:42 <ehird`> since there's no first-class parsers there's another easy thing
22:28:45 <ehird`> forbid it if IO is done
22:29:02 <ehird`> (no first class parsers = you can just check for output/input in them)
22:34:02 <ihope> Hmm. Is it okay if .|*()[ are the only special characters outside brackets and \^-] the only special characters inside brackets for regexes?
22:34:30 <ehird`> Um, I guess
22:34:32 <ehird`> :P
22:34:37 <ehird`> You need \ everywhere, though
22:34:42 <ehird`> if you can't escape something in any place, fix that
22:35:09 <ihope> ...er, yes, \ outside brackets as well.
22:35:51 <ihope> Now lemme take 37.5 moments to reboot.
22:37:15 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
22:38:42 -!- oerjan has joined.
22:39:51 <GregorR> 37.5 moments = 56.25 minutes
22:39:57 <GregorR> Apparently it takes ihope nearly an hour to reboot.
22:40:07 <ehird`> what?
22:40:13 <ehird`> (9:46:17 PM) ihope: Now lemme take 37.5 moments to reboot.
22:40:16 <ehird`> (9:50:17 PM) GregorR: 37.5 moments = 56.25 minutes
22:40:26 <ehird`> that's not nearly an hour
22:40:59 <oerjan> he may have meant moment in the sense of rotation physics. maybe he passed out from it.
22:41:07 <ehird`> heh
22:41:09 <GregorR> :P
22:41:20 <GregorR> ehird`: How is 56.25 minutes not nearly an hour?
22:41:24 <GregorR> It's only 3.75 minutes short
22:41:38 <ehird`> GregorR: ... ihope said blah blah reboot at 9:46
22:41:42 <ehird`> you said that at 9:50
22:41:46 <ehird`> 4min != 1hr
22:42:10 <GregorR> ihope isn't back yet ..
22:42:22 <ehird`> yes but it has not been nearly an hour
22:42:44 <GregorR> "Moment" used to be a defined unit of time measurement being 1.5 minutes.
22:42:48 <GregorR> 37.5 moments = 56.25 minutes
22:48:30 -!- ihope has joined.
22:48:36 <ihope> Okay, so maybe that was actually 387.98 moments.
22:48:58 <ihope> That's slow even for my Windows machine.
22:48:58 <bartw> GregorR: defines a moment as about 1.5 minutes
22:49:19 <ihope> Oh, I see.
22:50:05 <ihope> You calculate how many moments that actually was.
22:51:57 <GregorR> From now on, I will assume that all users choose their nickname in the same way that I do.
22:52:14 <GregorR> e.g. Ihop Erickson and Ehird `-$*@/\\\
22:52:52 <ehird`> hah
22:52:58 <ehird`> Actually my nick is ehird
22:53:03 <ehird`> ehird` is just because ehird got stolen :(
22:53:06 <ehird`> so Ehir Dick
22:53:10 <ehird`> or something
22:53:14 <GregorR> Well, then Ehir Dickinson :P
22:53:18 <GregorR> At least make it a last name ;)
22:53:25 <oerjan> ehird`'s real name is not particularly secret
22:53:25 <ehird`> but I am a dick.
22:53:26 <ihope> Erickson and Dickinson?
22:53:27 <GregorR> (Which apparently means ending it with "son")
22:53:30 <ehird`> oerjan: :P
22:53:45 <ehird`> oerjan: how come? i haven't told anyone in here it, i don't think...
22:53:49 <ehird`> (it's Elliott Hird anyway)
22:53:58 <ihope> What's your obsession with ck and son?
22:54:09 -!- ihope has changed nick to IhopE.
22:54:49 -!- ehird` has changed nick to ehirD.
22:54:52 -!- ehirD has changed nick to EhirD.
22:54:56 <EhirD> Damnit
22:55:12 <GregorR> Van Von O'McSonovichstein
22:55:13 -!- EhirD has changed nick to EhirD`.
22:55:25 <EhirD`> oerjan: so how is it not particularly secret? :P
22:55:33 <IhopE> Maybe it's Ehir Donald `-$*@/\\\.
22:55:42 <oerjan> EhirD`: well i did know it didn't i?
22:56:10 <EhirD`> oerjan: i think so, but how? :P
22:56:12 <EhirD`> it's not in my whois atm
22:56:21 <oerjan> maybe it was before
22:56:27 <EhirD`> probably
22:56:40 <IhopE> Your name is purple?
22:56:46 <IhopE> My.
22:56:57 <EhirD`> no
22:57:03 <EhirD`> pidgin->libpurple
22:57:05 <EhirD`> default name = purple
22:57:16 <EhirD`> GregorR: So what is RodgerTheGreat's name?
22:57:36 * RodgerTheGreat grins
22:58:21 <EhirD`> Rodger Therrickson Handlebrock Entrepreneur Gullible Russell Ensonava Aeota Therrickson?
22:58:50 <GregorR> "Gullible" = awesome name :P
22:59:01 <EhirD`> "Wow. My name isn't in the dictionary"
22:59:12 <RodgerTheGreat> "Gullible is one of my middle names"
22:59:15 <GregorR> "What's your name?" "Gullible." "Really? Wow!" "No, gotcha bitch!"
22:59:24 <EhirD`> "...actually, yes it is."
22:59:26 <RodgerTheGreat> haha
22:59:29 <oerjan> EhirD`: hm, you actually don't have a presence on the esolangs wiki?
22:59:39 <oerjan> thought that might have been it
22:59:43 <IhopE> Rodger Thomas Harry Elliot Graetz-Russell-Erickson-Aritz-Thomson!
22:59:58 <GregorR> I'm totally renaming myself Gregor Van Von O'McFitzsonovichstein
23:00:06 <RodgerTheGreat> believe it or not, my name in real life *isn't even Rodger!*
23:00:14 <EhirD`> RodgerTheGreat: WHAT
23:00:17 <GregorR> It's Susan.
23:00:23 <EhirD`> wait
23:00:26 * EhirD` is gullible
23:00:32 <EhirD`> ... i think?
23:00:36 <IhopE> Or Rodger Tokigun Helios EgoBot Gregor-Reddak-Ehird-Anmaster-Tritonio, which would be very weird.
23:00:47 <RodgerTheGreat> IhopE: indeed
23:00:50 * EhirD` has a reflex that coils on sight of "Elliot" and corrects people to "Elliott"
23:00:55 <oerjan> RodgerTheGreat: of course not, your real name is Spot
23:01:00 <IhopE> But it's "Elliot"!
23:01:06 <EhirD`> my name is Elliott
23:01:07 <EhirD`> :<
23:01:14 <IhopE> Well, too bad! :-P
23:01:46 <RodgerTheGreat> today's special VISUAL CLUE!
23:01:46 <RodgerTheGreat> http://rodger.nonlogic.org/dump/images/1190852142-understanding.png
23:01:51 <oklopol> i knew EhirD`'s name.
23:02:04 <EhirD`> yes but that's because its littered in various code and i might have told you
23:02:35 <oerjan> EhirD`: maybe i got it from your code too
23:02:44 <EhirD`> i doubt it, though
23:02:48 <EhirD`> i haven't shown all that much code here
23:02:50 <oerjan> that was my second theory anyway
23:05:08 <oklopol> EhirD`: perhaps, although i'm pretty sure i've just deduced it from your behavior, just like i did with GregorR
23:05:24 <EhirD`> you deduced Elliott Hird from my behaviour?
23:05:31 <EhirD`> well, of course you could deduce E Hird
23:05:34 <EhirD`> But Elliott? i doubt it
23:05:42 <oklopol> RodgerTheGreat: olds!
23:05:50 <RodgerTheGreat> olds?
23:05:53 <oklopol> EhirD`: no no i'm pretty sure
23:05:57 <oklopol> i mean, i've seen that :P
23:06:08 <RodgerTheGreat> I'm aware
23:06:10 <EhirD`> oklopol: james randi might want to giv e you $1mil
23:06:22 <RodgerTheGreat> fine, have some doodles from my statistics class today: http://nonlogic.org/dump/images/1193866302-sket2.png
23:06:25 <EhirD`> i'm pretty sure being able to determine names from behaviour is psychic
23:06:26 <RodgerTheGreat> http://nonlogic.org/dump/images/1193866315-sket1.png
23:06:26 <oklopol> i don't like randy men
23:07:16 <oklopol> hehe, a guy in my class does that too
23:07:22 <EhirD`> IhopE: how's the spec going?
23:07:37 <oklopol> if there's a pause in taking notes, he draws a random picture
23:08:21 <RodgerTheGreat> as you can see, I don't really wait for a pause
23:08:33 <oklopol> what do you mean?
23:08:47 <oklopol> you use both hands and take notes while drawing?
23:08:52 <IhopE> EhirD`: I'll post it in exactly one moment.
23:08:52 <EhirD`> or he omits notes
23:08:56 <RodgerTheGreat> I generally don't take notes
23:08:56 <EhirD`> IhopE: :D
23:09:02 <IhopE> What I have, I mean. Not the whole thing.
23:09:13 <oklopol> i'm pretty sure i saw a graph in there! :)
23:09:31 <RodgerTheGreat> because I find statistics extremely uninteresting, considering how many times I've done it in various classes over the years
23:10:12 <oklopol> statistics does have an ugly sound to it.
23:10:25 <oklopol> anyway, i'll sleep for a moment now, you all have fun ->
23:10:35 <RodgerTheGreat> I have oodles of fun in my CS classes
23:10:56 <AnMaster> <IhopE> Or Rodger Tokigun Helios EgoBot Gregor-Reddak-Ehird-Anmaster-Tritonio, which would be very weird. <-- huh?
23:11:08 <IhopE> AnMaster: don't you think that would be a very weird name?
23:11:09 <EhirD`> AnMaster: hello
23:11:22 <AnMaster> IhopE, stupid highlights
23:11:23 <AnMaster> hate them
23:11:35 <AnMaster> anyway yes
23:11:45 <AnMaster> IhopE, none of these are real names
23:11:46 <AnMaster> so what?
23:12:12 <IhopE> GregorR mentioned pretending everyone's nick was derived the same way as his.
23:12:34 <bartw> why is stdcall right to left with arguments ?
23:12:44 <oerjan> Gregor isn't a real name? :)
23:12:44 <EhirD`> bartw: because stdcall is evil
23:12:52 <oerjan> could have fooled me
23:12:54 <bartw> is it ?
23:13:12 <AnMaster> <IhopE> GregorR mentioned pretending everyone's nick was derived the same way as his. <-- and how is it?
23:13:22 <AnMaster> mine IS based on my initials (AN) yes
23:13:28 <IhopE> First name, last initial.
23:13:52 <oerjan> my name is obviously Oerja Nilsson. Sorry for fooling you all about my gender so long.
23:13:54 <oklopol> my real name is oklovonimol polokolmonopotol
23:14:08 <EhirD`> Ehir Dickinson
23:14:18 <AnMaster> oerjan, hm, sounds Scandinavian
23:14:25 * AnMaster is from Sweden
23:14:39 <oerjan> Norwegian here
23:14:42 <AnMaster> ah
23:14:50 <EhirD`> oerjan: YOU FAKED YOUR PHOTO?!12567862874623784234
23:14:51 <GregorR> oerjan: Gotta tell you, "Oerja" doesn't strike me as male or female :P
23:14:54 <AnMaster> oerjan, still don't know gender of name
23:15:03 <oerjan> EhirD`: no i'm just very ugly.
23:15:12 <bartw> RodgerTheGreat: nice drawings
23:15:25 <RodgerTheGreat> thanks
23:15:26 <AnMaster> oerjan, wait, "oe" O with / in?
23:15:35 <AnMaster> oerjan, same as Swedish örjan then?
23:15:37 <bartw> luckily im BartW
23:15:41 <AnMaster> then male
23:15:42 <oklopol> AnMaster: yeah
23:15:43 <oerjan> GregorR: well if it was norwegian it would be female. The only exception i recall is "Ola"
23:15:54 <oerjan> AnMaster: yep
23:16:04 <oerjan> (ending in -a that is)
23:16:53 -!- IhopE has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
23:17:27 <AnMaster> my name can be found in the source code of the brainfuck interpreter in bash I coded: http://rage.kuonet.org/~anmaster/bzr/index.py/get/bashfuck/head/bashfuck
23:17:32 <AnMaster> optimizing, using byte code
23:17:35 <AnMaster> yes I'm insane
23:17:49 <AnMaster> I'm also working on a modular irc bot in bash (http://envbot.org)
23:17:50 <GregorR> In bash? 8-D
23:17:53 <GregorR> That = awesome
23:18:15 <GregorR> I imagine you have a library of functions that turns bash into a bit more of a general-purpose language?
23:18:16 <AnMaster> GregorR, still, just compiling LostKing.b to byte code = about 10 minutes on my amd64
23:18:16 <EhirD`> yeah, he is insane
23:18:20 * GregorR has always enjoyed writing shell scripts :)
23:18:22 <EhirD`> i was about to say
23:18:27 <EhirD`> his lostkng.b performance is terrible
23:18:34 <AnMaster> EhirD`, yes indeed it is
23:18:44 <EhirD`> GregorR: and no, iirc
23:18:46 <EhirD`> he just uses bash
23:18:48 <AnMaster> if someone can make it faster, please branch it
23:19:45 <oerjan> "We're all mad here. I am mad. You're mad." "How do you know that I am mad?" asked Alice. "You must be," said the Cat, "or you wouldn't have come here."
23:20:04 <AnMaster> GregorR, I do have some stuff I reuse sometimes, stack functions, associative array emulation
23:20:13 <EhirD`> ah yes -- quoting alice in wonderland. The post-ironic hippy way to be cool on the internet.
23:20:14 <AnMaster> but for bashfuck I didn't reuse anything
23:20:22 <AnMaster> EhirD`, ahahaha
23:20:57 <AnMaster> I guess quoting Terry Pratchett doesn't work?
23:21:09 <EhirD`> no, that's the post-hippy ironic way
23:21:35 <AnMaster> EhirD`, eh? I got all Terry Pratchett books (except a few short stories that are out of print)
23:21:54 <AnMaster> EhirD`, and what is the post-hippy post-ironic way?
23:21:59 <oerjan> actually i am quoting Narbonic, which quoted Alice in Wonderland.
23:22:01 <EhirD`> killing yourself
23:22:05 <oerjan> sort of anyhow :)
23:22:09 <AnMaster> EhirD`, I see
23:22:21 <AnMaster> oerjan, "Narbonic"?
23:22:44 <oerjan> my favorite mad science webcomic so far
23:22:55 <AnMaster> link?
23:23:04 <AnMaster> (hm what is a "mad science webcomic"?)
23:23:05 <EhirD`> AnMaster: google gives it as #1 result
23:23:14 * AnMaster just reads user friendly
23:23:22 <oerjan> http://www.narbonic.com/
23:23:28 <AnMaster> for the last 5 years or so
23:23:35 <EhirD`> pff, user friendly
23:24:13 <AnMaster> EhirD`, what? I used to read that nethack one too, dudly or whatever the name was
23:24:53 <AnMaster> oerjan, there is no strip on the page?
23:24:54 <AnMaster> ??
23:25:00 <AnMaster> or do I have to enable java script
23:25:02 <AnMaster> I hope not
23:25:25 <EhirD`> no JS there
23:25:31 <EhirD`> sheesh, you could just view source
23:25:35 <EhirD`> and also stop being JS-paranoid
23:25:36 <oerjan> AnMaster: the webcomic is finished, read the archive
23:25:40 <AnMaster> <script language=javascript src=http://www.webcomicsnation.com/tooncast.php?series=narbonic_plus></script> <br>
23:25:42 <AnMaster> EhirD`, ?
23:25:51 <EhirD`> alright then
23:25:53 <AnMaster> noscript tells me there is java script
23:25:54 <AnMaster> :P
23:26:16 <EhirD`> disable noscript becaues it's a stupid, paranoid extension with no real practical value
23:26:30 <AnMaster> GregorR, btw envbot's performance is very good
23:26:41 <AnMaster> EhirD`, what? I use tor when I browse
23:26:44 <AnMaster> I AM paranoid
23:26:46 <oerjan> oh right, director's cut rerun. i haven't read that.
23:26:54 <EhirD`> :| hah, tor
23:27:02 <EhirD`> i guess you wear a tinfoil hat too
23:27:46 <oerjan> heh, today's rerun is pretty good
23:27:56 <AnMaster> <EhirD`> i guess you wear a tinfoil hat too <-- no?
23:34:24 <EhirD`> Not Invented Here strikes again!
23:34:29 <EhirD`> I have found myself writing a code editor.
23:34:54 <oerjan> AnMaster: does http://www.webcomicsnation.com/shaenongarrity/narbonic/series.php?view=archive&chapter=9763 work better? it's the first page of the archive.
23:37:23 <bsmntbombdood> whoa, AnMaster
23:37:44 <AnMaster> oerjan, yes it does
23:37:46 <AnMaster> bsmntbombdood, what?
23:37:52 <bsmntbombdood> nothing
23:38:10 <AnMaster> bsmntbombdood, yes I coded brainfuck interpreter in bash. Yes I'm mad. Do you want anything else? :P
23:38:29 <bsmntbombdood> writing a brainfuck interpreter in bash doesn't make you mad around here
23:38:36 <AnMaster> http://rage.kuonet.org/~anmaster/bzr/index.py/get/bashfuck/head/bashfuck and http://envbot.org is proof enought I'm mad
23:38:57 <AnMaster> bsmntbombdood, using bytecode and optimiztions in the interpreter AND coding it in bash IS mad
23:39:04 <bsmntbombdood> writing bash in brainfuck, that would make you mad
23:39:09 <EhirD`> bsmntbombdood: haha
23:39:18 <EhirD`> mad for doing the impossible
23:39:53 <oerjan> impossible is nothing
23:40:36 <AnMaster> bsmntbombdood, what about bash to C translator coded in bash?
23:40:48 <bsmntbombdood> possibly
23:44:39 <EhirD`> wow
23:44:40 <EhirD`> wxPython is nice
23:49:54 <RodgerTheGreat> mad science webcomics, eh? How about Phil Foglio's Girl Genius? (http://nonlogic.org/dump/images/1193870414-idee.png)
23:50:32 <oerjan> RodgerTheGreat: reading that too :)
23:51:32 <oerjan> among other defunct/ended ones: Casey and Andy, A Miracle of Science
23:53:13 <RodgerTheGreat> lmao. "..It heartens me to look ahead and see the bright future each and every one of you will create, using your disciplines to improve our world. Except for the computer-science majors. They're more likely to perpetrate evil."
←2007-10-30 2007-10-31 2007-11-01→ ↑2007 ↑all