←2007-12-28 2007-12-29 2007-12-30→ ↑2007 ↑all
00:00:03 <ehird`> exactly
00:00:13 <oklofok> although 1. why the fuck would you and 2. if you have any interest in speed, you do cmpl Function
00:00:13 <ehird`> maybe gradually over time you should tone it down a bit :-)
00:00:22 <oklofok> hehe :D
00:00:35 <ehird`> by the way, does oklotalk have to look like those mindmashers?
00:00:37 <oklofok> i think it'll be much less grandioso once i actually start implementing it...
00:00:44 <ehird`> show me some clean understandable more-than-one-char-var-names oklotalk :P
00:00:46 <oklofok> actually, it can look quite nice
00:01:23 <ehird`> example please :P
00:01:55 <oklofok> i can show you the somewhat public thingie, if you promise not to publish it / say it's not speccy enough, it's just like the haskell factorial website, but with oklotalk, and with explanations
00:02:15 <oklofok> a lot of explanations, but no full formal spec.
00:02:31 <oklofok> that's what always happens when i start writing something.
00:03:38 <ehird`> i won't publish it :-)
00:03:53 <Slereah> Well, I can input a file on the first tape.
00:03:55 <ehird`> by the way, my implementation is called C-oklotalk :P
00:03:59 <ehird`> imaginative i know
00:03:59 <Slereah> Onto that BF interpreter.
00:04:02 <faxathisia> I want to see this website
00:04:05 <faxathisia> oklofok
00:04:19 <oklofok> the haskell one?
00:04:22 <oklofok> it's great
00:04:25 <faxathisia> no the one with oklotalk
00:04:27 <oklofok> but i can't find it
00:04:36 <oklofok> oh... goddammit
00:04:43 <oklofok> :)
00:04:50 <ehird`> you are popular oklofok :-)
00:04:57 <ehird`> why don't you just trust little old #esoteric :P
00:05:40 <oklofok> there is not website for the oklotalk one, which is why it's just semi-public
00:05:48 <oklofok> i've basically jsut sent it to a few ppl
00:05:50 <oklofok> *just
00:05:55 <oklofok> guess i'll upload it....
00:06:07 <oklofok> but i warn ya, it's *not* that interesting
00:07:25 <ehird`> i find oklotalk extremely interesting
00:07:28 <oklofok> lol, this isn't ready for publishing...
00:07:32 <ehird`> i'm going to implement all my programs in it okay :p
00:07:40 <ehird`> like, my continuation-based webframework
00:07:43 <ehird`> and stuff
00:07:58 <oklofok> basically some scribble i made for the heck of it, and to get some thoughts sorted
00:08:00 <oklofok> http://www.vjn.fi/pb/p551122163.txt
00:08:01 <oklofok> but there it is
00:08:08 <ehird`> it's Oklotalk then
00:08:10 <ehird`> not OkloTalk
00:08:11 <ehird`> or oklotalk
00:08:16 <oklofok> Oklotalk, definitely.
00:08:28 <oklofok> to differentiate between my nick
00:08:40 <oklofok> because, it's a somewhat different origin
00:08:53 <oklofok> very slight somewhat, and i'm not getting into that
00:09:05 <oklofok> wonder what i pasted there....
00:09:28 <ehird`> ' Because everything is everything in oklotalk,'
00:09:33 <oklofok> hehe
00:09:36 <ehird`> what's factorial+5
00:09:42 <oklofok> umm
00:09:48 <oklofok> that's (factorial (+ 5))
00:09:51 <oklofok> in lisp notation
00:09:57 <ehird`> i mean, the function factorial, + 5
00:10:06 <oklofok> Factorial + 5 then
00:10:06 * ehird` renames C-oklotalk to C-Oklotalk
00:10:13 <ehird`> Factorial + 5 = ?
00:10:13 <oklofok> wait
00:10:47 <oklofok> that would mean, factorial gets as args the list [#: + 5]... depends on the pattern matches what happens then
00:11:00 <oklofok> most likely they will all fail, and it'll return void
00:11:12 <oklofok> or None
00:11:25 <oklofok> #z to be spesific.
00:11:57 <ehird`> no
00:12:03 <ehird`> functions are first-class in oklotalk right
00:12:06 <oklofok> "guess function" is a bit stupid for a term
00:12:13 <oklofok> sure they are
00:12:17 <oklofok> well
00:12:26 <oklofok> there's just lambdas, but no difference
00:12:38 <ehird`> hmmmm question
00:12:49 <ehird`> please pick something other than + for concat
00:13:00 <ehird`> (x+y)+z = x+(y+z), and x+y = y+x
00:13:04 <ehird`> none of these apply to concatentation
00:13:05 <ehird`> err
00:13:07 <ehird`> the first does
00:13:08 <ehird`> but not the second
00:13:13 <oklofok> oh, the "return" function's explanation has a flaw, which a friend of mine noticed, but anyway, the "return" call is just for show, and it's actually identity there
00:13:17 <ehird`> and, + should be flippable, so.
00:13:36 <oklofok> nope, you can actually specify these rules separately for different types.
00:14:30 <oklofok> and theoretically, by using explicit typing, let the interpreter know it can optimize with the knowledge (x+y)+z == x+(y+z)
00:15:00 <ehird`> yes but x+y is y+z, and this does not apply to concatentation
00:15:04 <ehird`> thus + is a bad name for it
00:15:12 <oklofok> nope
00:15:46 <oklofok> also, x+y for numbers produces a numerical value... does this mean it can't be used for other types unless that too produces a numerical value?
00:15:58 <oklofok> what exactly is the use of having those identities always hold?
00:17:12 <ehird`> operator input and return types should not be constant
00:17:16 <ehird`> but properties of application should be
00:17:24 <oklofok> why?
00:17:28 <ehird`> (Overtalk, an Oklotalk successor? oh fuck no)
00:17:32 <oklofok> :))
00:17:41 <ehird`> oklofok: it means you can reason about programs better
00:17:47 <ehird`> and is simply cleaner
00:18:07 <oklofok> nah, oklotalk is too dynamic for that to be true
00:18:18 <oklofok> and too conciseness-oriented
00:18:26 <ehird`> still
00:18:27 <ehird`> it's nicer
00:18:35 <oklofok> what could i use then?
00:18:40 <ehird`> (also, Oklotalk should not be actor-based. actor model == function model)
00:18:44 <ehird`> (for the mostpart.)
00:18:52 <ehird`> (see: why scheme was created, to test that hypothesis)
00:18:59 <ehird`> oklofok: depends what you have unused
00:19:03 <ehird`> ..
00:19:03 <oklofok> nothing, really
00:19:03 <ehird`> ~
00:19:08 <ehird`> .. would work well
00:19:13 <oklofok> that's for ranges
00:19:25 <oklofok> although i'd use ¨ if it was more standard.
00:19:43 <oklofok> errr why should it not be actor based?
00:19:59 <ehird`> because mostly actors are equiv. to functions
00:20:03 <oklofok> and?
00:20:09 <ehird`> well, it makes it pointless :)
00:20:23 <ehird`> by the way, is 3 spaces the standard Oklotalk indentation width? i like that, it's crazy :P
00:20:26 <oklofok> well, everything is equivalent to everything.
00:20:55 <oklofok> err i actually use 3 there :)
00:20:57 <oklofok> errrrr
00:20:58 <oklofok> i mean, 4
00:22:39 <ehird`> do you? damn
00:22:42 <ehird`> 3 would be cool
00:23:00 <oklofok> hmmmm, there's some obsolete strictness information there...
00:23:31 <ehird`> can you make oklotalk standard 3-spaces? pleeeez? :P
00:23:39 <oklofok> it says ´(...) != (...) when it comes to strictness, but that would make no sense, since ´ and ` never do but okenity changes
00:23:45 <oklofok> yeah, i can :P
00:23:59 <ehird`> :D
00:25:11 <oklofok> {|...} i think is the dynamically scoped lazily evaluated list... hard to keep up, really ;)
00:25:43 <oklofok> i change the scope types quite often, since there's always something wrong with them...
00:25:47 <ehird`> does oklotalk allow multiple return values?
00:25:54 <ehird`> i'm pondering the best way to implement return values
00:25:54 <oklofok> you can return a list
00:26:04 <ehird`> by the way a while ago you posted a parsing spec, where's that?
00:26:18 <oklofok> F={1 2} returns 1 and 2
00:26:28 <oklofok> ummm, that's actually somewhat lost.
00:26:41 <oklofok> if you recall the date, i can find it though.
00:26:56 <oklofok> ooooh
00:27:26 <oklofok> http://www.vjn.fi/mb/?p=oklotalkspec operators are wrong, and i'm not sure about the rest either.
00:27:45 <ehird`> what is that interface written in? xD
00:28:05 <oklofok> "Nesting basically means making a list of tokens one single token with information about how it was nested." wait, what :)
00:28:09 <ehird`> Comments can be handled in a separate phase before the actual parsing (even before tokenizing) by just replacing every comment with a space (' '). nuh uh what about strings :-)
00:28:30 <oklofok> wtf have i been smoking.
00:29:01 <oklofok> heh, i actually realized that later myself
00:29:14 <ehird`> ¤
00:29:14 <ehird`> ¨ I CAN'T TYPE THESE :P
00:29:19 <oklofok> the one online isn't the newest, just almost
00:29:23 <oklofok> heh, perhaps :)
00:29:29 <ehird`> nor ´
00:29:37 <oklofok> ´ is kinda crucial :)
00:29:53 <ehird`> i might make an emacs mode that lets me type that stuff :P
00:30:01 <ehird`> oklotalk-mode.el!
00:30:03 <oklofok> each time you need to use a function as first-class, you need ´
00:30:15 <ehird`> hahahah imagine trying to syntax highlight
00:30:17 <oklofok> well, just when you actually create a lambda on the fly
00:30:21 <oklofok> :D
00:30:26 <ehird`> hmm, i guess what i could do is write a program in oklotalk which hooks into the parser
00:30:33 -!- puzzlet has quit (Remote closed the connection).
00:30:34 <ehird`> and returns an s-expression parse tree
00:30:35 -!- puzzlet_ has joined.
00:30:40 <oklofok> hehe
00:30:42 <ehird`> so that i can simply call it and use emacs lisp's parser
00:30:48 <oklofok> now, can you let me code for a while? :P
00:30:58 <ehird`> invalid syntax ofc would be a problem but i would just make it highlight them as 'error' regions or something :P
00:31:04 -!- helios_24c3 has quit ("Leaving").
00:31:11 <oklofok> invalid syntax, what's that?
00:31:43 <oklofok> i've been considering an ide that actually runs the code in the background to check for errors...
00:31:58 -!- jix has quit ("CommandQ").
00:32:11 <oklofok> oklotalk is definitely not user-oriented
00:32:28 <oklofok> which is kinda lame since it's not really efficient either :)
00:33:09 <oklofok> i'm mainly going for as much theoretical freedoms as possible, conciseness, and as much madness i can fit in.
00:33:19 <oklofok> now, i need to get back to graphica
00:33:21 <ehird`> oklofok: invalid syntax will exist in oklotalk as much as you try and make that not happen
00:33:23 <ehird`> it just will exist
00:33:34 <oklofok> really?
00:33:35 <ehird`> also, what if i wrote a program to delete the hd
00:33:36 <ehird`> :P
00:33:53 <ehird`> oklofok: and yeah, because 'everything makes sense' can not be true without making your language useless
00:33:56 <oklofok> safety is actually easy to do in oklotalk
00:34:26 <oklofok> everything doesn't make sense semantically, but every string will definately a correct oklotalk program
00:34:27 <oklofok> *definitely be a
00:35:09 <ehird`> DSA:P{}AWO)(_)(U)(~*(HE(AJHWEC }}LÅ’Í”ÒÎ{:!@"E:OP$U)($)($)(@£_$(_+
00:35:15 <ehird`> that's valid syntax?
00:35:18 <oklofok> sure
00:35:23 <oklofok> i can parse that for ya
00:35:28 <ehird`> well, there'll be something that's invalid
00:35:48 <ehird`> oklofok: actually, the nested braces implicitness, please remove that... it means it's impossible to do matching-brace-highlighting
00:35:55 <ehird`> also, typos could cause weird semantic errors
00:36:13 <oklofok> sorry, i wont remove that, one of my favorites ;)
00:36:35 <oklofok> also, what would incorrect parens do without it!
00:36:42 <ehird`> cause an error
00:36:51 <ehird`> also, what if i forget to type a brace and it ends up thinking it's in the wrong place?
00:37:00 <ehird`> and what about matching brace highlighting in all good editors? srsly :<
00:37:10 <oklofok> heh, sorry, i ruin my language as i please :)
00:37:38 <ehird`> answer my questions! :P
00:38:08 <oklofok> well, i don't really care about those :)
00:38:17 <oklofok> not my prob
00:39:19 <oklofok> anyhow, just do code~[\"("´'")"|"{"´'"}"|"["´'"]"]
00:39:36 <oklofok> and you'll know whether it has the correct digits
00:40:17 <oklofok> or something close to that, i don't remember which operator does string matching :P
00:40:47 <ehird`> at least make it runtime-disableable :P
00:40:53 <ehird`> by the way, oklotalk file ext is .ot right?
00:41:01 <oklofok> prolly
00:41:17 <ehird`> i'll make a strict.ot which disables some of the crazier things :-)
00:42:19 <oklofok> the parser is (supposedly...) fully accessible at runtime, and somewhat parametrizable, you can just include a parser at the beginning of your program and start coding "on top of" that
00:42:57 <oklofok> there are multiple syntaxes for oklotalk, mainly differentiating on tokenization
00:43:01 <ehird`> would you reccomend a strict.ot for use or is it anti-Oklotalkian? :-)
00:43:45 <oklofok> if strict is an oklotalk program parsing your code as you write it, i'd say definitely oklotalkian
00:43:57 <ehird`> no
00:44:05 <oklofok> it is an emacs mode?
00:44:12 <ehird`> strict.ot is a file that you include in your oklotalk programs, like perl's "use strict"
00:44:16 <oklofok> ah
00:44:19 <ehird`> it does things like disabling implicit parens
00:44:27 <ehird`> just to make the language a bit saner
00:44:44 <oklofok> sure, the built-ins should provide such parser modes anyway.
00:46:04 <ehird`> but actually using it, is that oklotalkian or do real oklotalkers just deal :P
00:46:43 <oklofok> real oklotalking uses the K philosophy, it's originally designed to be write-only.
00:47:03 <oklofok> the parenthesis thing is partly because of conciseness
00:47:40 -!- cherez has joined.
00:47:59 -!- cherez has left (?).
00:49:21 <ehird`> so real oklotalking = no strict.ot :P
00:49:49 <oklofok> i'd say so
00:50:07 <oklofok> the paren precedence doesn't *always* make things look bad
00:50:27 <oklofok> especially if you add some more complex whitespace enhanced parsing
00:50:49 <oklofok> like out 4 + somfunc(otherfunc(soidf(oier(value
00:51:15 <ehird`> it makes auto-indentation basically impossible
00:51:52 <oklofok> perhaps, but say what you will, it stays, and i gotta code graphica now :P
00:53:58 <ehird`> oklofok: aww come on :P
00:54:01 <ehird`> how about
00:54:06 <ehird`> making the implicitness optional
00:54:10 <ehird`> and turned off by default, but stil lthere
00:54:47 <ehird`> by the way, using pattern matching in oklotalk, how do i match on multiple params?
00:55:16 <oklofok> F={A B -> A*B}; 4 f 2 -> 8
00:55:52 <ehird`> A = { 0 n -> n+1; m 0 -> '(m-1 1) m n -> '(m-1 '(m n-1)) }
00:55:54 <ehird`> correct?
00:56:21 <oklofok> you can spesifically match for a certain arity with F={#1 A B -> A+B;#2 A B -> A*B}; f 2 3 -> 5; 2 f 3 -> 6
00:56:24 <oklofok> hmm
00:56:37 <oklofok> ackermann?
00:56:43 <ehird`> Yes.
00:56:46 <ehird`> Using the definition:
00:56:46 <ehird`> A(0, n) = n + 1
00:56:46 <ehird`> A(m+1, 0) = A(m, 1)
00:56:46 <ehird`> A(m+1, n+1) = A(m, A(m+1, n))
00:56:48 <oklofok> you need a ; there
00:56:55 <ehird`> apart from that
00:57:04 <oklofok> then, almost :)
00:57:09 <oklofok> you need to have vars uppercase
00:57:19 <ehird`> why
00:57:23 <oklofok> and m-1 1 needs a comma or something.
00:57:42 <oklofok> because lowercase variables are considered funcokens and are used as operators :)
00:57:49 <ehird`> youch
00:57:50 <ehird`> ok :P
00:57:52 <ehird`> A = { 0 N -> N+1; M 0 -> '(M-1, 1); M N -> '(M-1 '(M, N-1)) }
00:57:54 <oklofok> m-1 == (m (- 1))
00:58:05 <oklofok> M-1 == (- M 1)
00:58:26 <ehird`> how do i mutate a variable in OT?
00:58:31 <oklofok> that's a bit weird, and oklotalk will definitely need a bit special ide anyway...
00:58:48 <oklofok> well, = is the only thing you can actually change a var with
00:58:55 <oklofok> i mean, the contents of a variable
00:59:11 <oklofok> everything else is sent to the object like [oper params]
00:59:16 <oklofok> in a list like that
00:59:19 <ehird`> also, emacs can handle oklotalk, mostly
00:59:26 <ehird`> since it can do turing-complete things for language modes
00:59:36 <ehird`> oklofok: how do i do IO?
00:59:42 <oklofok> out and in
00:59:43 <ehird`> specifically, there is a concept of ports or streams right?
00:59:50 <ehird`> and printing to them is generic?
00:59:58 <ehird`> so a socket has the same interface, etc?
01:00:02 <ehird`> as a file, or stdout
01:00:13 <oklofok> yes, although there is not *byte* in oklotalk, really, well, there is, but you don't see it.
01:00:18 <oklofok> *is no
01:00:30 <oklofok> i mean, any stream will have to handle any object.
01:00:43 <ehird`> uh
01:00:46 <ehird`> that's barely possible
01:00:47 <oklofok> so... no, there isn't a stream in the sense you mean, proly.
01:00:49 <oklofok> *prolly
01:00:52 <oklofok> :)
01:00:54 <ehird`> can you wrap that around a low-level byte based interface? :P
01:01:03 <ehird`> we need to interact with the real world with our programs here
01:01:10 <oklofok> hehe, outn will call str() for the object prolly
01:01:19 <ehird`> well, byte OR character
01:01:23 <ehird`> oklofok: it is unicode, right?
01:01:30 <ehird`> strings are unicode, files are read as unicode, etc
01:01:35 <ehird`> with of course bytes and bytestrings
01:01:36 <oklofok> i haven't actually thought about that, but i think it is.
01:02:34 <ehird`> yaaaay
01:02:43 <ehird`> what about loading files
01:03:16 <ehird`> also, i have the tentatively-named ehirdtalk to implement too :P
01:03:55 <oklofok> :D
01:03:56 <ehird`> fact<-{<3->1=>*$-1} is factorial, iirc
01:04:03 <ehird`> more clearly:
01:04:03 <oklofok> you can add the sanity i lack :)
01:04:11 <oklofok> ah, i recall that
01:04:26 <oklofok> stream / code flow oriented
01:04:35 <ehird`> fact <- { ((_ < 3) -> 1) => (_ * ($ (_ - 1))) }
01:04:37 <oklofok> at least those were the things you explained back when i first saw that
01:04:43 <ehird`> and naw, not really
01:04:50 <ehird`> but the evaluation is weird
01:04:51 <oklofok> just a guess
01:05:03 <ehird`> hmm that should be:
01:05:12 <ehird`> fact<-{<3=>1->*$-1}
01:05:13 <ehird`> i think
01:05:20 <ehird`> well the pattern matching is crazy
01:05:38 <ehird`> as you can see, since -> or => or whatever 'if' is matches on a tuple on the left side
01:05:47 <ehird`> but it doesn't do it by matching on the tuple (which would mean it'd already be evaluated)
01:05:52 <ehird`> it matches on the call to the tuple constructor
01:06:03 <oklofok> that fact is wrong
01:06:08 <oklofok> errr
01:06:11 <oklofok> or am i wrong...
01:06:18 <ehird`> err, you are right
01:06:23 <oklofok> you have <3 in both
01:06:26 <ehird`> fact<-{<2->1=>*$-1} is factorial, iirc
01:06:34 <oklofok> hmm
01:06:53 <oklofok> what implies the implicit _ after => there?
01:07:00 <ehird`> the * binary operator
01:07:10 <oklofok> ah, not everything can be any-ary
01:07:25 <oklofok> should've known
01:07:25 <ehird`> any left-out dangling params are _
01:07:32 <oklofok> i know
01:07:55 <ehird`> i forgot how i did param names :(
01:09:44 <oklofok> hmm
01:10:00 <ehird`> an actually clear ehirdtalk program:
01:10:02 <ehird`> fib <- { 0 -> 0 => 1 -> 1 => > 1 -> $(-1) + $(-2) }
01:10:03 <ehird`> err
01:10:11 <ehird`> with newlines
01:10:12 <ehird`> fib <- {
01:10:15 <ehird`> 0 -> 0 =>
01:10:20 <ehird`> 1 -> 1 =>
01:10:27 <ehird`> > 1 -> $(-1) + $(-2)
01:10:29 <ehird`> }
01:10:42 <oklofok> hmmmm
01:10:46 <oklofok> i don't buy that
01:10:54 <oklofok> - can't be unary?
01:11:11 <ehird`> _ is unary negation
01:11:14 <oklofok> ah
01:11:20 <ehird`> or you could just do 0-
01:11:22 <oklofok> then i do buy that
01:11:37 <oklofok> yeah
01:11:55 <ehird`> though i am going to remove some of that stuff
01:12:00 <ehird`> because fact<-{*1..} should work
01:12:21 <ehird`> maybe ?
01:12:35 <ehird`> fact<-{?<2->1=>?*$?-1}
01:12:43 <oklofok> you could do like K
01:12:48 <ehird`> what does k do
01:13:13 <oklofok> \ is a primitive that does map when preprended to an oper
01:13:17 <oklofok> / does reduce
01:13:20 <oklofok> io think
01:13:22 <oklofok> *i think
01:13:28 <oklofok> it's 3 years since i looked at taht
01:14:13 <ehird`> ooh i know
01:14:15 <ehird`> {} matches on tuples
01:16:47 <ehird`> oklofok: gimme a call/cc in oklotalk
01:18:00 <ehird`> that is: (call/cc f) is (f k), where k is a function with a saved call stack from the point of call/cc, which on call with an argument restores the call stack and returns its argument as the return value of call/cc
01:18:09 <ehird`> also, k is callable multiple times
01:18:16 <oklofok> hmm... @@ may be the current continuation... i recall i had to make a new one because ' was clearly unoverloadable
01:19:52 <ehird`> oklofok: would cps-transformation of oklotalk be possible
01:19:54 <oklofok> you can do `'@#vars to get the current namespace, but without a state list, you can't make a goto without the explicit current continuation @@
01:20:25 <oklofok> i'm going to make it possible if it's no yet
01:20:28 <oklofok> *it's not yet
01:20:36 <oklofok> everything must be possible
01:20:59 <Slereah> I think I have a BF interpreter now.
01:21:08 <oklofok> cool
01:21:12 <ehird`> oklofok: just make the call-stack accessable
01:21:14 <oklofok> in what language?
01:21:18 <Slereah> But writing the + and - function in full is awfully boring.
01:21:22 <Slereah> Turing machine.
01:21:36 <ehird`> specifically, you can access the current call stack, replace the current callstack, and unwind with a return value to a certain point
01:21:42 <ehird`> then, you can implement continuations in about 3 lines
01:21:59 <ehird`> so basically add a global callstack object that you can assign to, and give it an 'unwind' operator
01:21:59 <faxathisia> bf interpreter in what Slereah?
01:22:05 <faxathisia> ooh sorry
01:22:07 <faxathisia> I didn't notice
01:22:17 <faxathisia> cool :D
01:22:24 <faxathisia> What does it look like"?
01:22:41 <oklofok> ehird`: yeah, if you can access the exact point where you are at the code
01:22:48 <oklofok> the code pointer to be exact
01:22:59 <Slereah> So far, http://paste-it.net/5460/raw/
01:23:05 <ehird`> dont need to do that oklofok
01:23:17 <oklofok> i don't?
01:23:18 <oklofok> why
01:23:21 <Slereah> The + isn't complete, there's no - yet, and it's not wrapping so far.
01:23:34 <Slereah> It also isn't in ASCII, but well.
01:23:58 <Slereah> (It's also on a Turing machine with 3 tapes, because I don't want to do a 1 tape version now)
01:24:34 <oklofok> ah, indeed, the call stack would hold the points of return anyway :)
01:24:35 <oklofok> silly me
01:31:31 <ehird`> so, any callcc oklofok ? :)
01:31:45 <oklofok> right, f@@
01:32:08 <oklofok> (f current_continuation)
01:32:13 <oklofok> (call/cc f)
01:32:41 <ehird`> what's the implicit paramater name in oklotalk
01:32:43 <oklofok> you call-with-current-continuation by calling with the current continuatino
01:32:49 <oklofok> ?
01:32:51 <oklofok> _
01:33:02 <ehird`> call/cc = {_@@}
01:33:13 <oklofok> almost
01:33:14 <ehird`> feel free to give a more concise definition :P
01:33:33 <oklofok> CallCC = {`_ @@}
01:33:39 <oklofok> oh
01:33:51 <oklofok> actually, that will use the continuation in CallCC :)
01:33:57 <oklofok> i need to ponder about this a bit.
01:33:58 <ehird`> hehe
01:34:25 <oklofok> oh, actually doesn't matter, i think
01:34:33 <ehird`> oklofok: oklotalk booleans
01:34:35 <ehird`> what are they
01:34:38 <oklofok> since callcc will return what was returned anyway
01:34:45 <oklofok> you usually use the atoms #t and #f
01:35:16 <ehird`> hey, schemeish
01:35:17 <ehird`> i like it
01:35:28 <oklofok> errr actually §t and §f... it seems i've added another set of atoms for typing and then mixed them up :o
01:35:59 <oklofok> #<...> should be reserved for stuff you don't actually need to see, but you *can*
01:36:00 <ehird`> ffffffff do i really have to type that char
01:36:06 <oklofok> :)
01:36:09 <ehird`> what about \
01:36:11 <ehird`> \t \f
01:36:19 <oklofok> i've never seen a keyboard without it.
01:36:25 <oklofok> in one press
01:36:28 <ehird`> i've only seen one keyboard with it
01:37:18 <ehird`> so oklofok what is the simplest way just to print a number to the screen then a newline
01:37:30 <oklofok> heh, well, dunno, need to think about the charset later
01:37:44 <oklofok> there are lots of chars not everyone can type in use.å
01:37:50 <ehird`> eh?
01:37:51 -!- GregorR has quit (Remote closed the connection).
01:37:53 <ehird`> just tell me the ismplest way :P
01:38:03 <oklofok> ...simplest way?
01:38:33 <ehird`> just the oklotalkian way to print a number then a newline
01:38:45 <oklofok> outn5
01:38:47 <oklofok> err
01:38:48 <oklofok> outn 5
01:40:38 <ehird`> my repl prompt will be awesome
01:40:54 <ehird`> it will have both nesting depth and line count
01:41:17 <ehird`> oklofok: does 'x = y' return y?
01:41:31 <oklofok> no.
01:41:34 <oklofok> it's not that simple
01:41:50 <oklofok> actually...
01:42:15 <oklofok> yeah, works exactly as in c
01:42:49 <ehird`> is there a standard way to pretty-print, e.g. a continuation?
01:43:02 <ehird`> currently i'm just planning on doing either #[a continuation] or (a continuation)
01:44:18 <oklofok> fact={{_<2}->1;_*'$_-1}; Fact!5=1; fact 6 -> 6
01:45:16 <oklofok> a function can be either a rule or a hashmap, you can assing any value to it, and it will be considered a new pattern match, with the greatest precedence.
01:46:44 <ehird`> oklofok: are there to-end-of-line comments?
01:46:49 <oklofok> no.
01:46:56 <oklofok> not currently, at least
01:46:59 <ehird`> pretty pleez :( it'd make my repl display nicer
01:47:03 <oklofok> -- will do that, prolly.
01:47:12 <ehird`> aww
01:47:17 <ehird`> why not ;;
01:47:17 <oklofok> <--...--> and --...
01:47:26 <oklofok> nah
01:48:00 <ehird`> -- could be ambigiouuuuusssss
01:48:02 <ehird`> and ;; is scheme
01:48:02 <ehird`> y
01:48:26 <oklofok> " -- " to be exact.
01:48:55 <oklofok> anyway, oklotalk is not meant to be comment-friendly.
01:52:17 <ehird`> hijacking your pastebin: http://www.vjn.fi/pb/p615162456.txt
01:52:20 <ehird`> continuations!
01:53:38 <oklofok> hmm
01:54:14 <ehird`> where's your fact-tutorial again?
01:54:23 <oklofok> up there
01:54:46 <oklofok> http://www.vjn.fi/pb/p551122163.txt
01:54:59 <ehird`> hmm make test Test
01:55:38 <ehird`> hmm,
01:55:42 <ehird`> a function object
01:55:45 <ehird`> i.e. {.....}
01:55:48 <ehird`> what do i know about it?
01:55:52 <oklofok> that's no problem if test has no initial value... although you don't wanna get into the details of that ;)
01:55:53 <ehird`> i.e. what info can i get about the function
01:56:00 <oklofok> hmm
01:56:03 <oklofok> what do you mean?
01:56:14 <ehird`> can i get arity?
01:56:16 <ehird`> a name?
01:56:17 <ehird`> etc
01:56:27 <ehird`> some way to say something more useful than [a function]
01:56:32 <oklofok> name cannot be accessed, for functions don't have names
01:56:52 <oklofok> it could have no name, or a million names
01:57:12 <oklofok> arity can be accessed, although i'm not sure how.
01:57:19 <oklofok> btw. the test function doesn't work as you wan
01:57:21 <oklofok> *want
01:57:26 <oklofok> it basically doesn't do anything...
01:57:31 <oklofok> oh, wait
01:57:44 <oklofok> ah
01:57:52 <ehird`> x = y returns y :-)
01:58:04 <oklofok> just use TehContinuation <- instead of =
01:58:18 <oklofok> <- is for setting a new value without making the var local
01:59:14 <oklofok> correct otherwise
01:59:35 <ehird`> ok
02:00:47 <ehird`> so how should i pretty print a function, oklofok?
02:00:58 <ehird`> [N-arity function] ?
02:01:13 <ehird`> i must be able to give more info than that
02:03:09 <oklofok> str F may provide the actual code of an uncompiled function
02:03:16 <oklofok> although i haven't specified what it does.
02:03:29 <ehird`> can't it just prettyprint the parse tree?
02:03:34 <ehird`> i guess that might lead to ugliness
02:03:37 <oklofok> sure
02:03:53 <oklofok> i don't wanna speficy that now
02:04:02 <oklofok> since i haven't thought about it
02:04:50 <ehird`> is [...] used for anything
02:05:05 <ehird`> or can i safely prettyprint [helpful info]
02:05:13 <oklofok> [] is for lists that are evaluated lazily, but that don't have their own scope.
02:05:40 <oklofok> [] is for lists, that is.
02:05:54 <oklofok> () is for lists too, as is , and juxtaposition.
02:06:19 <oklofok> also {} can be a list, although you need to apply it
02:06:25 <oklofok> ...since it's a lambda
02:06:48 <ehird`> give me some unused braces!
02:06:58 <oklofok> :D
02:07:11 <oklofok> <|...|>
02:07:14 <oklofok> xD
02:07:15 <oklofok> dunno
02:07:33 <oklofok> also, what exactly are you doing?
02:08:20 <ehird`> well, when you use a REPL
02:08:25 <ehird`> it has to show a result somehow
02:08:26 <ehird`> so.
02:08:34 <ehird`> like python does <object at blah>
02:08:49 <oklofok> indeed, just wondering whether you're making a repl or just playing you are one.
02:09:48 <ehird`> i will make one when c-oklotalk is written
02:10:05 <ehird`> so really i just need some unused pairable markngs :P
02:10:32 <oklofok> <> are just used as normal operators...
02:10:44 <oklofok> but i don't see how that's better
02:12:15 <ehird`> i guess i can do <-- -->
02:12:32 <oklofok> true
02:12:57 * ehird` wonders what untaken symbol to use for last-thing-evaluted
02:15:05 <Slereah> Well, there it is me think : http://paste-it.net/5461/raw/
02:15:15 <Slereah> To use with this thing here : http://paste-it.net/5462/raw/
02:15:46 <Slereah> And possibly this chart handy, since I can't do good ASCII on it : http://paste-it.net/5463/raw/
02:15:55 <ehird`> oklofok: http://www.vjn.fi/pb/p422433545.txt
02:15:58 <ehird`> pretty nice looking imo
02:17:03 <oklofok> :o
02:17:12 <oklofok> nice work, i see no syntactic errors
02:17:25 <oklofok> i mean, nothing that would behave incorrectly :P
02:17:30 <oklofok> except for ht fib
02:17:31 <oklofok> *the
02:17:32 <Slereah> I'll try the 99 bottle program to see if it works, after some conversion.
02:17:38 <oklofok> N-1, N-1
02:18:13 <oklofok> Slereah: working bf interpreter in a turing machine? that's quite awesome
02:18:14 <ehird`> what's wrong with the fib oklofok
02:18:21 <oklofok> can i see the newest one?
02:19:02 <oklofok> ehird`: it's wrong
02:19:08 <ehird`> oh yes
02:19:09 <ehird`> :P
02:19:11 <oklofok> :P
02:19:12 <Slereah> Well, I'm not sure on the working part yet.
02:19:25 <Slereah> I only tried little programs so far.
02:19:26 <ehird`> oklofok: so does that look like a session with a respectable oklotalk system to you? :P
02:19:31 <ehird`> (don't say implementation. Say system!)
02:19:36 <oklofok> ehird`: looks great
02:19:50 <Slereah> I thought the loops would be harder to do than that, though.
02:19:54 <ehird`> oklofok: my prompt is crazy :D
02:20:09 <ehird`> #1 why would you want to know your current input number
02:20:16 <ehird`> #2 can't you tell the nesting by indent?
02:20:42 <oklofok> i think the returning the info as a <----> is a fun idea, perhaps i should make <----> a first class annotation or something!
02:21:40 <ehird`> haha
02:21:56 <ehird`> it should parse the english inside
02:22:53 <oklofok> heh, i was thinking it'd behave as an empty list except would produce it's contents when str()'d
02:23:09 <ehird`> no, it should produce <-- contents -->
02:23:10 <ehird`> :D
02:23:13 <ehird`> self-evaluyating
02:24:38 <ehird`> back tomorrow
02:24:46 -!- ehird` has quit.
02:27:30 <Slereah> Hm.
02:27:54 <Slereah> Either there's an error or it takes forever!
02:28:10 <oklofok> hmm, is your code infinite?
02:28:46 <Slereah> I just entered some random big BF program.
02:29:13 <Slereah> Which would at best display random chars, since it's not the same code, or plain old errors, but I wasn't expecting nothing to happen.
02:32:06 <Slereah> Bood thing I can just display the tape!
02:32:09 <Slereah> G
02:33:36 <Slereah> Although it is painfully long to watch.
02:36:51 -!- Slereah- has joined.
02:38:43 <Slereah-> >:|
02:42:35 <Slereah-> What program would be a good way to test a BF interpreter?
02:42:35 <Slereah-> I already did text display and cat.
02:43:03 <oklofok> lost kingdom
02:43:13 <oklofok> there's a digit root by keymaker
02:43:18 <oklofok> you can google it
02:43:30 <Slereah-> I know of Lost Kingdom.
02:43:48 <Slereah-> But since so far it's not in ASCII, I'm not tickling that one.
02:44:43 <Slereah-> I made some local version of hello world with some loops in it. Seems to work.
02:50:21 <Slereah-> "Random byte generator" is awfully slow and gives me a whole lot of empty chars.
02:50:41 <Slereah-> Damn.
02:50:49 -!- GregorR has joined.
02:52:56 <Sgeo> Hi GregorR
02:53:36 <Slereah-> I guess I'll have to write a program to write the + function for ASCII!
02:53:38 * Sgeo might write the first lines of a PSOX interpreter tonight
02:53:48 <Slereah-> 'cause I'm not writing the 256 lines for it.
02:54:33 <GregorR> Sgeo: /*
02:54:44 <oklofok> :D
02:54:45 -!- Slereah has quit (Read error: 110 (Connection timed out)).
02:54:46 <GregorR> Oh, lines
02:54:53 <GregorR> /*
02:54:59 <GregorR> * A PSOX interpreter
02:55:07 <Sgeo> hehe
02:55:20 <Sgeo> Incidentally, that doesn't work
02:59:25 <Sgeo> *silence*
03:00:00 <faxathisia> sorry for breaking the silence
03:03:17 <Sgeo> No one's going to guess/already knows why I said that it wouldn't work
03:03:40 * faxathisia assumes you're writing in python but doesn't feel the need to mention this
03:04:08 <Sgeo> faxathisia, but you DID mention it >.>.. incidentally, that is the reason
03:05:49 <Slereah-> I can't seem to copypasta the \000 char.
03:05:56 <ihope> Suddenly, I want to write a program along the lines of the Lego drag-and-drop programming stuff, except with a functional "programming language" instead of imperative.
03:06:11 -!- User333 has joined.
03:06:23 <User333> Hi everyone~
03:06:28 <ihope> Ello.
03:06:31 <Sgeo> Hi User333
03:06:34 <Slereah-> Hello.
03:06:38 <User333> I found this place through "searchIRC"
03:06:41 <User333> what's it about?
03:06:59 <ihope> Programming languages that are intentionally weird somehow, more or less.
03:07:10 <User333> why the "esoteric" tag/
03:07:24 <ihope> Do you know the meaning of "esoteric"?
03:07:35 <User333> yes
03:08:10 <ihope> There's not much I can say, then, really.
03:08:46 <User333> oh..well im not a programmer, i thought all of it was within the same language
03:09:27 <ihope> If you consider yourself a nerd at all, try it :-)
03:09:54 <pikhq> mv: cannot stat `./../include/d/4.1.3/object.d': No such file or directory
03:09:56 <User333> oh i see, i was looking for esotericism
03:10:10 <faxathisia> this is it
03:10:19 <pikhq> Esoteric languages, ahoy.
03:10:21 <User333> no, esotericism is mysticism
03:10:43 <ihope> Indeed, esoteric programming and esotericism aren't the same thing.
03:10:51 * pikhq suspects that searchIRC needs to include the word "programming" with that.
03:11:42 <User333> so you are the guys who worship movies like "I, Robot" instead of LOTR
03:12:04 <User333> hehe just playing
03:12:15 <faxathisia> I like TRON more
03:12:38 <User333> have you guys found this? http://nerogame.org/
03:13:13 <ihope> Hmm, looks interesting.
03:13:17 <User333> its supposedly an advanced "evolution" game where you can shape your own robot teams "unique intelligence"
03:13:42 <User333> i had a hard time with it, since im not a programmer lol... all my robots learned was to run around a wall
03:15:11 <User333> so wait a second... isnt esoteric programming very closely related to hacking?
03:15:30 <ihope> I don't think so.
03:15:32 <pikhq> Define 'hacking'.
03:15:59 <User333> "finding ways around barriers" or "finding new ways to infiltrate"
03:16:19 <faxathisia> I don't think that's a good definition of hacking..
03:16:40 <pikhq> I'm going to beg to differ with any definition that involves breaking into computers, myself.
03:16:42 <ihope> In that case, esoteric programming can be hacking.
03:16:58 <ihope> But I'd say it's quite separate from breaking into computers.
03:17:04 <pikhq> Hacking, (v): "Being creatively clever (especially in terms of programming)"
03:17:16 <ihope> More like trying to overcome "limitations" in the programming language.
03:17:22 <pikhq> ex: "I'm hacking together a D build environment."
03:17:41 <User333> how many of you have OCD?
03:17:48 <pikhq> Not I.
03:17:55 <User333> are you sure?
03:17:58 <User333> :)
03:18:11 <Sgeo> Any OCD that I may have is completely unrelated to computer use >.>
03:18:18 <Slereah-> Oh bloody hell.
03:18:32 <User333> im just asking because you seem compulsive about correct grammar
03:18:33 <pikhq> Quite certain, yes.
03:18:37 <Slereah-> The BF interpreter is too long to input in the Python interface.
03:18:45 <Slereah-> I'll just have to use the dreaded files!
03:18:46 <faxathisia> lol
03:18:53 <faxathisia> how is there a limit?
03:19:02 <Slereah-> I'm not sure.
03:19:16 <pikhq> That much comes as a result of doing a lot of programming; computers are compulsive about correct grammar.
03:19:18 <Sgeo> Any OCD that I might have is almost certainly unrelated to grammar..
03:19:21 <Slereah-> But whatever is the case, it's annoying to enter. I'll just input it as a file.
03:19:51 <faxathisia> (It's also just a bit distressing how badly media vandalised the word hacking an created associated problems)
03:20:05 <pikhq> I suspect that most computers, parsing "foo := 'abc'", would not accept "flimble" as a foo token. . .
03:20:17 <User333> you should meet my friends, they think hacking is memory editing
03:20:32 <pikhq> That's amusingly horrid.
03:23:02 <Slereah-> Oh bloody hell.
03:23:12 <User333> so..have any of you hacked server sided aspects of games?
03:23:49 * pikhq suspects that User333 is remarkably confused about what we do.
03:24:03 <pikhq> Quick, bring out the discussion of the merits of SKI combinator calculus!
03:24:19 <Sgeo> No PSOX?
03:24:27 <pikhq> Sgeo: Alright, PSOX works.
03:24:29 -!- Slereah has joined.
03:24:37 <Sgeo> wb Slereah
03:24:37 <faxathisia> every 'bit string' of SK terms is well typed?
03:24:39 <Slereah> Fuck ASCII. I'll stick with my interpreter.
03:24:51 <pikhq> Although you need to implement a SK namespace. :p
03:24:54 * Sgeo should start writing the PSOX code now
03:25:03 <faxathisia> wait a min I want trees not bit strings..
03:25:23 <pikhq> Mmm. Turing-complete with a small amount of symbols. . .
03:25:57 * faxathisia strives for turing-incompletness :S
03:26:04 <pikhq> That's trivial.
03:26:12 <faxathisia> but!
03:26:16 * Slereah is totally Turing complete
03:26:17 <pikhq> Just be sure to have your only method of storing data be a single stack.
03:26:24 <faxathisia> also capable of doing large amounts of interesting calculations
03:26:36 <faxathisia> I guess I really mean, everything termiantes and that kind of things
03:26:45 <pikhq> Unless you're so friggin' insane that you implement two stacks in a single stack.
03:26:46 <faxathisia> the langauges are rare
03:26:50 <pikhq> In which case, I salute you.
03:29:45 <User333> so wait...wheres the money behind finding if something is turing-powerful
03:30:09 <Slereah> Well, that got Turing an article for a start!
03:30:42 <ihope> Sorry; all the money behind proving Turing-completeness went to ais523. :-P
03:30:49 <User333> lol
03:30:56 <Slereah> Damn him and his 2,3 machine money!
03:32:19 <User333> you guys should look into Korean programming, most confusing stuff ever...
03:32:57 <Slereah> I've seen Malbolge this afternoon. I doubt that it will even approach that level!
03:33:10 -!- User333 has quit ("Leaving").
03:33:12 <pikhq> *Nothing* is as evil as Malbolge.
03:33:58 <Slereah> Since I barely know what a register is, I'm pretty screwed!
03:34:53 <Slereah> Hm.
03:35:01 <Slereah> I'll write a ROT13 program!
03:35:17 <pikhq> Malbolge makes grown men cry. Including men who write code using a hex editor and nothing else.
03:35:18 <faxathisia> "proof by implementing brainfuck in the typesystem"
03:36:01 <pikhq> Slereah, if you can write a ROT13 program, you are officially the best Malbolge coder in the world. Bar none.
03:36:20 <Slereah> Not in Malbolge.
03:36:26 <Slereah> I need to test my BF interpreter.
03:36:36 <pikhq> Oh.
03:36:44 <pikhq> Much saner.
03:37:19 <Slereah> I am somewhat sad that people didn't chose to comment their ROT13 BF programs. I can't just change the ouchy parts.
03:38:47 * Sgeo really should be doing stuff like taking care of cats right now :/
03:38:50 <Slereah> A Turing machine isn't an efficient BF implementer. You can't just increment the symbols like that.
03:39:49 <oklofok> Slereah: please try to keep the surprises more subtle, i almost had a heart attack.
03:40:08 <Slereah> Heh.
03:40:25 <Slereah> I'll stop bitching about it.
03:41:20 <oklofok> nah, just trying to be funny
03:41:26 <oklofok> "funny"
03:42:10 <Slereah> Then again, 5 AM isn't the best of time to program in BF.
03:42:11 -!- Slereah- has quit (Read error: 110 (Connection timed out)).
03:42:22 <Slereah> It can wait another day.
03:42:30 <oklofok> indeed, and 5:46 isn't the best time to be coding.
03:43:03 <Sgeo> Anyone want to write a Malbolge program that takes advantage of PSOX features?
03:43:17 <Slereah> Is that a threat?
03:43:37 <Slereah> "Do what I say, or you'll code in Malbolge with PSOX features!"
03:43:43 <pikhq> I don't want to write a Malbolge program.
03:43:50 <Sgeo> lol Slereah
03:45:01 -!- ihope has quit ("CGI:IRC").
03:45:44 <Slereah> I want to see a computer with a Malbolge CPU. And spikes on it.
03:45:54 <Slereah> The computer, not the CPU.
03:46:08 <Slereah> With the skulls of the foolish on top
04:05:02 <Slereah> http://paste-it.net/5472/raw/
04:05:15 <Slereah> Here it is commented. Does it seem okay to you?
04:17:22 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
04:17:46 <oklofok> ret2[$:UPUPRI:com;1:ERLEUPUPLE:ret]]
04:17:50 <oklofok> great stuff
04:17:58 <oklofok> although all i get out of it is cheap laughs :)
04:18:12 <oklofok> as always with this kind of line noise
04:18:27 <oklofok> oh, comments
04:18:59 <Slereah> I don't know. I find it somehow easy to read and write.
04:18:59 <oklofok> i guess those might be readable, but the font is too small for my eyes
04:19:16 <oklofok> prolly, once you have *any* idea what *anything* there means.
04:19:58 <Slereah> Well, it's mostly the notation of Turing, but with 2 characters per instruction. Easier on the interpreter.
04:21:28 <Slereah> LE is left, RI is right, UP is up (tape above), DW is down (tape below), ER is erase, Px is print x (on the tape), DI is display (on the screen), CH is the choice instruction (prints the keyboard input on the tape), LF and TB are just fancy "print new line" and "print tab".
04:22:57 <Slereah> The state itself (for instance, 1[#:P@RI:com;cr:LE:1]) is to be read as : "In the state 1, if the current cell is #, print @ and go right and to state com, if the current cell is any other character, go left and to state 1".
04:23:17 <Slereah> (cr is for "remaining characters", roughly)
04:26:51 <Slereah> If you want line noise, I have the 4 characters version!
04:27:05 <Slereah> Although it can't input, or output for that matter.
04:27:13 <Slereah> But you can watch the tape as it goes.
04:31:23 <oklofok> cool, graphica seems to work now :o
04:31:57 <Slereah> Graphica?
04:32:41 <oklofok> my graph specifying system
04:32:44 <oklofok> http://www.vjn.fi/pb/p241624426.txt
04:32:55 <oklofok> the first one is how the code will look like before parsing
04:33:03 <oklofok> the second is what i parsed it as, manually
04:33:12 <oklofok> then, there's the graph in ascii form
04:33:18 <oklofok> it's
04:33:19 <faxathisia> ooh :D
04:33:21 <oklofok> node:
04:33:34 <oklofok> node_it's connected_to, another_node, etc
04:34:00 <oklofok> just bidirectional edges implemented atm
04:34:19 <oklofok> not sure whether unidirectional ones will work with the same evaluator
04:34:40 <oklofok> but it's quite nice after i get the parser working, since it produces a normal python dict
04:34:48 <Slereah> Lisp-related language?
04:35:06 <oklofok> not really
04:35:14 <Slereah> I see a whole lot of parenthesis!
04:35:23 <oklofok> well, the second one is, since i parse into lisp-like syntax
04:35:31 <oklofok> the second one is python code
04:35:36 <oklofok> i did parsing manually, you see
04:35:46 <Slereah> I barely know what parsing means.
04:35:50 <oklofok> ah
04:35:51 <oklofok> sorry
04:35:56 <Slereah> No matter.
04:36:02 <oklofok> like, if you have 3*31+5*7
04:36:09 <oklofok> it's very hard to evaluate
04:36:23 <oklofok> so, you can parse it into (+ (* 3 31) (* 5 7))
04:36:29 <oklofok> which will be trivial to evaluate.
04:36:36 <oklofok> if there's list support
04:36:51 <oklofok> also, 3 31 * 5 7 * +, and you just need a list
04:37:06 <Slereah> Heh.
04:37:10 <faxathisia> you got a blob of text and you can turn that into structured data, where the data is in the shape of the meaning'
04:37:12 <faxathisia> of the code
04:37:21 <oklofok> (and a stack..)
04:37:29 <Slereah> Reminds me of that lambda calculus thingy I tried to implement.
04:38:41 <Slereah> Unfortunately, I'm not very good at that parsing of nested parenthesis.
04:38:43 <oklofok> http://projecteuler.net/index.php?section=problems&id=68
04:38:58 <oklofok> that's the one my code describes
04:39:13 * faxathisia thinks that parsing is terribly hard unless you have logic programming or a combinator parser :S
04:40:13 * Slereah does all his programming on Python
04:40:26 <oklofok> faxathisia: wanna stretch your brain a bit and tell me if you can see how the code of mine relates to that gon ring
04:40:34 <oklofok> also Slereah
04:40:44 <oklofok> Slereah: python AND turing machines
04:40:52 <Slereah> Well, yes.
04:40:58 <Slereah> But a Turing machine on Python!
04:41:02 <oklofok> heh
04:41:13 <faxathisia> oklofok; Well I'd want to know why there is no <-> before Ring68 n-1 m
04:41:25 <Slereah> I tried to do it on C originally, but it was too much of a pain in the ass to have an infinite tape.
04:41:28 <oklofok> ah
04:41:34 <oklofok> the <-> applies to that too
04:41:45 <oklofok> it's just not necessary, since it's indented
04:41:49 <faxathisia> ahh ok
04:41:52 <oklofok> it assumes <-> is meant for that too
04:42:10 <oklofok> parsing isn't fully specced yet... which is why i had to parse manually
04:42:36 <oklofok> i was actually quite surprised the trees+tagging thing worked so well :o
04:43:00 <oklofok> it's a very intuitive way to produce graphs
04:43:04 <oklofok> i think..
04:43:22 <faxathisia> mm I think it's wrong :p
04:43:32 <oklofok> oh, where?
04:43:34 <faxathisia> maybe this should be Ring68 0 m :: #Mid m <-> #Outer n
04:43:42 <faxathisia> or am I confused?
04:43:45 <oklofok> it chmm
04:44:00 <oklofok> err
04:44:01 <oklofok> hehe
04:44:11 <oklofok> :: T means tag this as T
04:44:34 <oklofok> so... the nodes produced are always tagged as #mid + their id
04:45:08 <oklofok> and, they are connected to a node called #outer their_id, plus the next node in the middle ring.
04:45:40 <oklofok> the recursion only goes through the middle ones, the outer ones are created without recursive calls
04:46:16 <oklofok> ah
04:46:26 <oklofok> sorry, i now realize what you said :)
04:46:34 <oklofok> nope, it's correct as is
04:46:48 <oklofok> you see, once the last node in the middle ring is tagged as m
04:47:00 <oklofok> the evaluator realizes it's the same as the first one
04:47:14 <oklofok> and the first one alrady has the connection to the outer node
04:49:28 <oklofok> faxathisia: did you get it now? :D
04:49:29 <faxathisia> ahh I understand
04:49:31 <faxathisia> this is very cool
04:49:33 <faxathisia> I just evaluated ti http://rafb.net/p/jRexrI17.txt
04:50:32 <oklofok> in fact, it's so cool i'm pretty sure it's been invented multiple times before me.
04:51:19 <oklofok> but, until oerjan joins and tells me he vaguely recalls seeing it somewhere, i'm going to enjoy it
04:51:57 <faxathisia> hehe
04:54:56 <oklofok> i need the parser, could try making an n-dimensional grid or something
04:55:40 <oklofok> unfortunately, the parsing isn't as trivial as it seems, i tend to add lots and lots of hard-to-implement details in everything :\
04:55:50 <faxathisia> can't you use haskell as the parser?
04:56:06 <faxathisia> like just define some functions and then it parses oh wait :: you couldn't use
04:56:18 <oklofok> it's not haskell syntax
04:56:32 <Slereah> Hm. Using only single-chars state names, the bitchanger interpreter is under 4 lines on the Machine.
04:56:36 <faxathisia> if it's close enough I always recommend abusing some existing parser :p
04:56:47 <oklofok> hehe
04:56:55 <oklofok> nah, i make my parsers raw
04:57:02 <oklofok> like a MAN.
04:58:33 <oklofok> i've made a few parsing libs, and i have about 3 parametrizable evaluators for basic prefix+infix expressions, one allowing regexes for everything
04:58:51 <oklofok> and still, i always try to do everything with a few splits and cuts :)
04:59:16 <faxathisia> woah
04:59:30 <faxathisia> what sort fo parsing libs
05:03:27 <bsmntbombdood> "it doesn't take most people very long to notice that I am not in fact crazy"
05:03:31 <bsmntbombdood> lol, esr is funnt
05:03:34 <bsmntbombdood> *funny
05:05:09 <oklofok> faxathisia: not good ones, and none parse very generically
05:05:29 <faxathisia> I like the mixfix stuff in Agda2
05:05:39 <oklofok> misfix?
05:06:04 <faxathisia> I can write if_then_else_ :: Bool -> a -> a -- or something
05:06:07 <faxathisia> then define it like
05:06:16 <faxathisia> if cond then do else other = ...
05:06:27 <faxathisia> and use it like that from then on
05:06:37 <oklofok> oh
05:06:41 <oklofok> interesting
05:07:04 <oklofok> i wouldn't wanna parse that :)
05:08:37 <faxathisia> http://cvs.coverproject.org/marcin/cgi/viewcvs/Agda2/examples/Introduction/Operators.agda?rev=HEAD&content-type=text/vnd.viewcvs-markup
05:10:05 * faxathisia will probably steal their parser if I want a langauge that looks like that
05:24:38 <Slereah> Oh bloody hell.
05:27:37 <Slereah> My interpreter confuses between UP followed by ":" with "P:"
05:31:16 <Slereah> Either I get a great idea, make some temporary fix or weasel my way out by changing "UP" to something without P's.
05:31:17 <Slereah> Hm.
05:36:49 <Slereah> Temprary fix here I come.
05:43:42 -!- calamari has left (?).
05:45:18 <Slereah> http://paste-it.net/5473/raw/
06:10:39 <oklofok> http://www.vjn.fi/pb/p554531552.txt
06:11:14 <oklofok> lol, 1.5 hours of thinking whether i should make the parser, then 40 minutes of making it :D
06:11:28 <oklofok> not that it's ready yet, it just parses that program.
06:12:26 <oklofok> but the rest is just 1. making an infix expression parser 2. making a lisp(ish) evaluator 3. making it support recursion, didn't put it in since i don't need it there
06:13:01 <oklofok> Slereah: what does tha tdo?
06:13:03 <oklofok> that do
06:13:38 <Slereah> Well, I changed it when I noticed that it needed one instruction less, but it's a Bitchanger compiler.
06:13:59 <oklofok> cool
06:14:33 <Slereah> Although I have no way to check for much accuracy, because my attempts at making an OR gate with it havebeen futile so far.
06:14:35 <oklofok> hmm, sun rises soon, i think it's time for some sleeps ->
06:14:43 <Slereah> I know the feeling.
06:14:48 <Slereah> I should go too.
06:33:54 -!- oerjan has joined.
06:42:09 <pikhq> Hello, oerjan.
06:42:32 * pikhq can now act on behalf of 3 second-class players and 2 first-class players in Agora. Insane.
06:44:15 <pikhq> Agora's Child, The Association of Federated Organizations, The WALRUS, myself, and Steve Wallace.
06:55:30 <oerjan> well, you are not the first person to go through a period of Agora overachievement :)
06:55:53 <oerjan> just don't suddenly disappear and bring the game to a near crash like some of the former ones :)
06:56:24 <oerjan> (this is a vague recall (TM) btw)
07:00:51 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
07:01:23 -!- bsmntbombdood has joined.
07:01:59 <pikhq> It's not overachievment until I take the office of rulekeepor.
07:02:05 <pikhq> :p
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:44:11 <GregorR> Heh, I set up Trac and Mercurial (with commit) on a server where I have no SSH, that doesn't have Python installed >: )
09:30:08 -!- oerjan has quit ("leaving").
10:59:07 -!- helios_24c3 has joined.
11:40:10 -!- Hiato has joined.
11:47:41 <Hiato> hello again, everyone :)
11:57:27 -!- helios_24c3 has quit ("Leaving").
12:00:55 -!- RedDak has joined.
12:08:24 -!- RedDak has quit (Remote closed the connection).
13:06:33 -!- Hiato has left (?).
13:35:38 -!- helios_24c3 has joined.
13:36:14 -!- jix has joined.
13:41:56 -!- jix has quit ("CommandQ").
14:11:45 -!- ihope has joined.
14:12:04 <ihope> pikhq: whose side are you on, then? :-P
14:47:20 * Slereah needs a catchy name for his language.
14:47:33 <Slereah> Donald Knuth was right, it is the hardest part!
14:49:46 <ihope> What's an important feature of the language?
14:50:36 <Slereah> Turing completeness?
14:50:50 <Slereah> The isomorphism to the Turing machine is the identity function!
14:51:12 <ihope> Call it Yet Another Turing Language or YALT, then.
14:51:22 <ihope> Acronyms that don't quite match up with what they stand for are always fun.
14:51:43 <Slereah> Heh.
14:52:27 <ihope> "ISO" stands for "International Organization for Standardization", after all. :-P
14:52:57 <Slereah> Yes, but the ISO is greek IIRC.
14:53:30 <oklofok> iso means big
14:54:00 <ihope> A cross between "isos", "IOS" and "OIN".
14:57:53 <Slereah> What's a good function to tell Python to wait n milliseconds?
15:00:00 <ihope> sleep(n/1000), possibly.
15:00:06 <ihope> In the time module.
15:07:30 <Slereah> http://paste-it.net/5480/raw/
15:07:34 <Slereah> Success!
15:07:42 -!- puzzlet_ has quit (Remote closed the connection).
15:07:47 -!- puzzlet has joined.
15:40:36 -!- oerjan has joined.
15:41:13 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
15:43:12 -!- puzzlet has joined.
15:45:04 * oerjan vaguely recalls "ISO" was a compromise between English and French. the French got the acronym, the English the expansion.
15:45:54 <Slereah> If it was French, it would start with an O.
15:45:55 <oerjan> or was that SI? perhaps both.
15:46:12 <Slereah> Organisation des standards internationaux, or Organisation internationale des standards.
15:53:47 <oerjan> ah, "ISO is not, however, an acronym or initialism for the organization's full name in either official language. Rather, the organization adopted ISO based on the Greek word .... (isos), which means equal."
15:55:26 <oerjan> er, are you sure you used my line literally?
15:55:39 * oerjan throws an axe after Mr. Wong
15:56:51 <Slereah> Axes!
15:56:55 <Slereah> My one weakness!
15:56:58 <Slereah> How did you know!
16:23:50 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
16:25:45 -!- puzzlet has joined.
16:57:00 -!- Hiato has joined.
17:05:30 -!- wooby has joined.
17:09:58 -!- helios_24c3 has quit ("Leaving").
17:12:44 <Slereah> Hello.
17:12:56 <Hiato> Hi Slereah
17:27:13 -!- Hiato has left (?).
17:28:53 -!- helios_24c3 has joined.
17:35:24 -!- Hiato has joined.
17:36:10 <Hiato> Ok all, the links are now fixed and the news typo was fixed, so everything is working now at http://full0.8tt.org
17:36:39 <Hiato> so you can get the interpreter and view the source (the links for which were both broken before)
17:43:57 * pikhq returneth
17:44:13 <Slereah> Welcometh backth.
17:44:21 <Hiato> Ditto-eth
17:45:00 <Hiato> Pikhq, I fixed up all the links on the site, you can now get the interpreter and the source (they were broken beofre)
17:59:53 -!- wooby has quit.
18:06:44 * pikhq nods
18:06:44 <pikhq> I'll have to set up a Pascal compiler sometime; currently waking up, and soon going to try getting Plof working.
18:19:38 <Hiato> sure
18:20:00 <Hiato> well, you can download the .exe and use wine or whatever
18:20:49 -!- helios_24c3 has quit ("Leaving").
18:21:49 * Slereah tries to make an actually good parser for the Love Machine 9000
18:21:56 <Slereah> Or whatever its name may be.
18:22:02 <pikhq> More of a pain than just compiling a Pascal compiler.
18:23:01 <Slereah> The P instruction is bugging me.
18:24:19 * pikhq tosses Slereah YACC
18:24:54 <pikhq> Unless you're insane like Gregor, and code your parsers by hand, you'll like YACC.
18:25:08 <Slereah> YACC?
18:25:18 <pikhq> Yet Another Compiler Compiler
18:25:39 <pikhq> You give YACC some input vaguely like Backus Naur Form, and it outputs a parser to parse that syntax.
18:25:53 <pikhq> Combine with lex to get the tokenization right, and voila.
18:26:10 <pikhq> You may already have them installed: look for GNU Bison and GNU Flex on your system.
18:26:19 <Slereah> But that might mean having to rewrite most of the Love Machine 9000! :O
18:26:36 <Slereah> GNU? I don't have Linux on little man
18:27:08 <pikhq> What *do* you have?
18:27:13 <Slereah> Windows XP.
18:27:30 <Slereah> I once tried to install some Kubuntu, boy, did I regret it!
18:27:33 <pikhq> Here's some rope, a chair, and instructions on tying a noose.
18:27:39 <Hiato> :D
18:27:49 <Hiato> I mean err.. amm
18:27:54 <Hiato> shame (?)
18:28:11 <pikhq> If you want to use that system sanely, at the *very* least, get Cygwin.
18:28:24 <Slereah> What doth that be?
18:28:33 <pikhq> Cygnus' GNU for Windows.
18:28:48 <pikhq> It's a port of most of GNU to Windows.
18:29:15 <pikhq> And makes Windows POSIX-compliant. That, in itself, is an astounding feat.
18:30:35 <Slereah> Will it be possible to use the function sys.stdin.read on python and it works?
18:30:52 <pikhq> Oh, you're coding in Python, not C?
18:31:05 <pikhq> Well, I'm sure Python has a YACC-alike out there. . .
18:31:11 <Slereah> Didn't you get that from my long line of Python related questions?
18:31:17 <pikhq> Didn't see them.
18:31:28 * pikhq shoves C down Slereah's throat first
18:31:39 <Slereah> I tried writing the Love Machine in C.
18:31:53 <Slereah> But making an infinite tape in C is bothersome.
18:32:02 <pikhq> Not really. . .
18:32:29 <Slereah> Maybe for you people with an actual knowledge of code!
18:32:33 <pikhq> Just make a doubly-linked list; when you reach the end of the list, just add a new node.
18:32:43 <pikhq> Trivial.
18:33:30 <oerjan> i recall someone here used a parsing library for Python
18:33:43 <oerjan> it was more the combinator kind
18:34:02 <pikhq> I could ask a minor-Python-diety friend of mine when he wakes up.
18:34:25 <Hiato> Ok, here's a little taste of my next esolang: {/(<<)[^<]:>:>^>>>v<|v->{<^^<v|^-<{<<<}~}\{(>>)[^<]:=:}}
18:34:25 <Hiato> I have _no_ idea what that does, but it is syntactically correct. Comments?
18:34:39 <Slereah> A Python deity? Can he touch my code to make it perfect?
18:34:46 <pikhq> He may.
18:34:54 <pikhq> Hiato: I love the syntax. Truly.
18:35:02 <Hiato> I'm glad
18:35:06 <Hiato> I like it too ;)
18:35:16 <Slereah> It has a lot of smiley faces.
18:35:33 <Hiato> oh, huh well that just happened to be that way
18:35:49 <pikhq> oerjan: Hiato seems intent on pleasing the people here who want non-Brainfuck-based Esolangs.
18:35:57 <pikhq> His are brilliantly creative. ;)
18:36:12 <Hiato> thanks :)
18:41:01 <Hiato> In case anyone's interested, the language has 13 symbols and 6 commands
18:43:25 <pikhq> Fairly sparse. Good so far.
18:43:32 <pikhq> Slereah: PLY.
18:43:35 -!- cherez has joined.
18:47:26 <Slereah> Wut?
18:48:37 <pikhq> That's the Python YACC-like thing.
18:48:50 <pikhq> And I'm *still* going to recommend you learn UNIX and C. ;)
18:49:08 <Slereah> I have my share of C, don't worry.
18:49:24 <pikhq> Then why did you think implementing a *tape* in C was so hard?
18:49:31 <Slereah> That's the language we have to use in the sort-of CS class I have.
18:49:47 <Slereah> Well, it's the infinite part I was worried!
18:49:55 <pikhq> Just make it automatically resizing.
18:49:58 <pikhq> Simple.
18:50:17 <Slereah> I can just do .append on the snake, but I saw some worrying malloc and such in C.
18:50:27 <pikhq> Like I said before: dual linked list, when you reach NULL on it, malloc a new list node. Simple.
18:50:46 <Slereah> There's two words I can't recognise in that statement.
18:50:49 <Slereah> Please parse it.
18:51:05 <pikhq> Do you not know what a linked list is?
18:51:20 <Slereah> My major is in physics, not computer science.
18:51:39 <pikhq> A linked list is kinda computer science 101.
18:52:01 <Slereah> Describe it. Maybe I've heard of it, but don't know the translation!
18:52:18 <pikhq> A linked list has any number of nodes.
18:52:28 <Slereah> "Node" is the second mystery word.
18:52:32 <pikhq> Each node has a pointer to another node, and a pointer to the data.
18:52:46 <pikhq> A dual linked list has a pointer to the previous and the next node.
18:52:52 <pikhq> http://en.wikipedia.org/wiki/Linked_list
19:02:05 <Slereah> Hm.
19:02:16 <Slereah> PLY is in a .tar.gz
19:02:43 <Slereah> Ah, Winrar can do it.
19:05:09 <pikhq> Don't complain about Tarballs. It's a decent format for us Unix-types.
19:07:27 <Slereah> Never fear. I'll have to install the damn Linux eventually.
19:34:47 <Hiato> Ok, first programme done:
19:34:47 <Hiato> {{>>}~~~~~~~~~~{{-<~}<<}/{{(<){{[<<]}}}}:>:~{>>{<<}}~{<<{>>~<<}>>}~{<<{>>}}\{>>v}~{^}~~~~~{<}~{<{~}v>}~}
19:34:47 <Hiato> It outputs "T" using the 10th number of the Fibonacci sequence - 4 (which is then 84). I could have done the boring 84 additions, but recursion and conditions are way more fun :)
19:35:06 <Hiato> *- 5
19:37:15 <pikhq> :-O
19:37:43 <pikhq> I'm going to guess that {} contains a loop?
19:37:59 <Hiato> nope, sorry ;) the / and \ do
19:38:54 <pikhq> Ah.
19:39:26 <Hiato> the stuff immediately after the / is the condition stuff ending at :>: meaning greater than
19:40:55 -!- puzzlet has quit (Remote closed the connection).
19:41:08 -!- puzzlet has joined.
19:41:22 <Hiato> {{>>}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{v<<{~}}}
19:41:26 <Hiato> would work identically
19:41:34 <Hiato> except it's just 84 additions
19:43:35 <pikhq> Hmm.
19:44:42 <Hiato> is that a no? Should I modify the language, anything you hate, replace a symbol etc...
19:47:04 <pikhq> Nothing I hate.
19:47:15 <pikhq> I'm just curious what everything does. :p
19:51:28 -!- jix has joined.
19:56:08 -!- sebbu2 has joined.
20:00:12 -!- ihope has quit ("CGI:IRC (Session timeout)").
20:13:09 -!- sebbu has quit (Read error: 110 (Connection timed out)).
20:22:23 -!- Sgeo has joined.
20:22:58 * Sgeo will start writing code for PSOX today!
20:23:05 <Hiato> Sure, no prob :) I just wanted feedback
20:23:33 <Hiato> yes please Sgeo so that I can include (?) PSOX in my new esolang, check above for examples
20:24:00 <Sgeo> "above"? I just got here >.>
20:24:11 <Hiato> lol, sorry, I meant above in the log
20:24:16 <Hiato> or I can paste again
20:24:16 <Sgeo> oh
20:24:18 <Hiato> if you like
20:24:26 * Sgeo opens log
20:25:30 <Hiato> 11:34:47
20:25:55 <Hiato> actually it starts at 10:34:25
20:26:00 <Hiato> brb
20:26:06 <Sgeo> PSOX doesn't need to be included in the specs of the esolang or anything. It's mostly language neutral
20:26:08 <Sgeo> hb
20:27:05 <Sgeo> Is it ok if types in PSOX 1.0 are regex-based?
20:27:13 * Sgeo pokes pikhq and oklofok and random other people
20:27:17 <pikhq> Possible.
20:27:52 <Sgeo> Also, there's quite a bit of overhead with the VARG(LNUM) and VARG(LBYTES) types
20:28:09 <Sgeo> Suppose a function is expecting a VAR(LNUM)
20:28:24 <Sgeo> and you want to add 3 bytes together: 0x01, 0x02 and 0x03
20:28:39 <Sgeo> This would be the input to the function
20:29:06 <Sgeo> 0x01 0x01 0x01 0x00 0x01 0x01 0x02 0x00 0x01 0x01 0x03 0x00
20:29:18 <Sgeo> No, it's
20:29:22 <Sgeo> 0x01 0x01 0x01 0x00 0x01 0x01 0x02 0x00 0x01 0x01 0x03 0x00 0x00
20:29:41 <Sgeo> Want the explanation?
20:30:55 <Sgeo> 0x01(varg indicator) 0x01(lnum indicator) 0x01(data) 0x00(li) 0x01(vi) 0x01(li) 0x02(d) 0x00(li) 0x01(vi) 0x01(li) 0x03(d) 0x00(li) 0x00(vi)
20:31:19 <Sgeo> Does this need to be fixed somehow? How can this be fixed?
20:32:15 <Sgeo> pikhq, thoughts?
20:32:39 <pikhq> I have none ATM.
20:32:53 * Sgeo wants to finalize the spec soon
20:35:11 <Sgeo> As in, if I don't get ideas very soon, it's staying that way >.>
20:37:46 <pikhq> Finalise it. Implement it. If problems show up when coding using it, then fix them. ;)
20:39:19 * Sgeo makes the first commit in a while
20:39:23 <Sgeo> Just moving a parenthesis
20:47:29 <Hiato> back, if you missed me :P
20:50:14 <Slereah> Well, I think my code works now
20:52:50 <Slereah> And the brainfuck sorting program works, yay!
20:53:06 <Hiato> :)
20:53:31 <Slereah> Thank you dbc.
20:53:41 <pikhq> w00ts.
20:53:55 <Sgeo> dbc?
20:54:16 <Slereah> dbc sent me a PM of a BF program that works regardless of encoding.
20:55:35 <Sgeo> Incidentally, due to the way that PSOX works, it will mean EOF=0
20:55:46 <Sgeo> well, that's simplifiying
20:56:00 -!- jix has quit (Read error: 113 (No route to host)).
20:57:25 <Hiato> cool, Sgeo, I don't suppose that you will write PSOX in anything bu Python (My python is equivalent in skill to sand), perhaps C/C++/Ruby/C#/Lua etc (or am I holding my breath for something that will never come) Perhaps a .dll or .lib even?
20:57:28 <pikhq> dbc is a diety of Brainfuck coders.
20:57:52 <pikhq> Among other things, he wrote a Brainfuck interpreter in Brainfuck.
20:57:58 <Hiato> wow
20:58:00 <Slereah> Heh.
20:58:04 <Hiato> now that's impressive
20:58:06 <Sgeo> You only really need to know Python if you want to write an implementation for a domain..
20:58:15 <pikhq> And Python is not hard to pick up.
20:58:20 <Hiato> meh, ok
20:58:20 <Slereah> My hat off for dbc.
20:58:29 <Sgeo> pikhq, when PSOX comes out, will he write a BF-in-BF interpreter for PSOX?
20:58:29 <Hiato> Mine too :P
20:58:31 <faxathisia> What does "equivalent in skill to sand" mean?
20:58:51 <pikhq> :p
20:58:53 <Slereah> It means that his skills in Python are equivalent to ground up quartz.
20:58:54 <Hiato> well, it means that a handful of sand could write better code in Python than me
20:58:59 <Hiato> lol, also tru
20:59:04 <faxathisia> ahh I like this expression
20:59:04 <Hiato> *true
20:59:09 <Hiato> :)
20:59:25 <Slereah> You don't need skills to write in python silly man
20:59:30 <Sgeo> Hiato, of course, if you want, you could implement PSOX in those other languages >.>
20:59:35 <Slereah> You think of something, and bal, you write it!
20:59:53 <Hiato> Really? Is it as simple as Ruby (9.times do hrmm....)
21:00:07 <Hiato> Thanks for the honour, Sgeo :P
21:00:11 <Slereah> I don't know
21:00:24 <pikhq> Ruby is fugly.
21:00:45 <Hiato> well, it's easy and that makes up for it to me ;)
21:00:49 <Slereah> Heh. Reminds me. A friend wrote an early version of the Love Machine 9000 on Ruby
21:01:09 <Hiato> what is this Love Machine 9000 of yours?
21:01:20 * pikhq shall go back to Plof
21:01:41 <pikhq> Where everything is an object, defined in terms of Plof. ;p
21:01:59 <Hiato> :) I want
21:02:02 * pikhq wonders if he should do a Function.opCastTo(). :p
21:02:22 <Hiato> lol
21:02:28 -!- ihope has joined.
21:02:29 <Slereah> The Love Machine 9000 is what I call this language I have yet to find a name for.
21:02:57 <Slereah> It's pretty much a fancy version of the original Turing machine notation.
21:03:01 <Hiato> Aha, I see, any pre-pre-docs or something? I'd like to see what you have come up with
21:03:13 <Slereah> Well, the interpreter already exists.
21:03:19 <Hiato> awesome :)
21:03:23 <Slereah> I just have a hard time finding a snazzy name.
21:03:30 <Hiato> *cough* link *cough*
21:03:42 <Hiato> I like Love Machine 9000 :P
21:04:03 <Slereah> http://paste-it.net/5482/raw/
21:04:21 <Slereah> If you want to see the basic syntax, just type "help".
21:04:44 <Hiato> cool, is this Python or what
21:04:51 <Slereah> A whole lot of it.
21:05:07 * faxathisia is impressed
21:05:12 <Hiato> aha, where can I grab an interpreter (I'm unfortuantely on a windows box)
21:05:13 <faxathisia> (never saw python that looks like this..)
21:05:17 -!- RedDak has joined.
21:05:19 <Hiato> (ditto)
21:05:28 <Hiato> (actually, never saw python)
21:05:32 <Slereah> http://paste-it.net/5483/raw/
21:05:38 <Slereah> Here's the BF interpreter.
21:05:46 <Hiato> wicked
21:05:50 <faxathisia> how did you write that? :D
21:05:57 <Slereah> Just replace the c:/e.txt at the end by the textfle you want.
21:06:02 <Slereah> Write what?
21:06:07 <faxathisia> BF interpreter
21:06:31 <Slereah> Here's a somehow commented version of it : http://paste-it.net/5472/raw/
21:08:35 <Hiato> wow, that is seriously impressive. Awesome job and wicked language (from what I can tell)
21:08:45 <Slereah> Thanks.
21:09:00 <Slereah> The [ ] were much easier than I thought they would be.
21:09:23 <Slereah> It's the + and - that are the big problem
21:09:50 <Slereah> I made a bitchanger interpreter. It looks much nicer.
21:09:51 * Sgeo implements major version checking
21:10:52 * Sgeo forgot that it's "elif" not "else if"
21:11:09 <Hiato> same in Full 0, it only takes this much code to do the [ and ]:
21:11:10 <Hiato> @{5}[($a0$a1=?[)([($a4$a5>0)({4}[35])]{1}[a6])]@{5}[($a0$a1=?])([(a6>0)({3}[a6][35])]{6}[($a4$a5>0)({2}[a6]
21:11:10 <Hiato> @{5}[(a6>0)({3}[a1]{3}[(0>a1)({1}[(a1)(999)]{1}[a0])]@{5}[($a0$a1=?])({2}[a6])]@{5}[($a0$a1=?[)({3}[a6])]
21:11:10 <Hiato> @{2}[!-21])]{3}[37])]{3}[35])]@{5}[($a0$a1>-1)({4}[35])]
21:11:10 <Hiato> but his much for just + and -:
21:11:10 <Hiato> @[a1]@{5}[(a1>999)({1}[(a1)(0)][a0])]@{5}[(a5>999)({1}[(a5)(0)][a4]{4}
21:11:11 <Hiato> [(a4>?z)({1}[(a4)(a2)]{6}[(a5)(a3)])])]@{5}[(a3>a5)([(a4=a2)({1}[(a5)(999)]{6}
21:11:13 <Hiato> [(a4)(?z)])])]@{5}[(a5/>0)({1}[(a5)(999)]{1}[a4])]@{5}[($a4$a5>255)({1}
21:11:15 <Hiato> [($a4$a5)(0)])]@{5}[(0>$a4$a5)({1}[($a4$a5)(255)])]
21:11:19 <Hiato> sorry for spam :(
21:12:14 <Slereah> I tried to make an actual ASCII version of the BF interpreter, but the Love Machine 9000 doesn't seem to be able to understand that much strange characters.
21:12:31 <Slereah> I also can't copypasta the NUL char.
21:12:58 <Hiato> yeah, is there no way to say #0 or literal 0
21:13:27 <Slereah> I also don't want to have the NUL char on the machine.
21:13:46 <Hiato> ah, yes
21:13:58 <Slereah> If I want to look at the tape and there's nothing printed for NUL, it will be hard to read
21:14:03 -!- helios_24c3 has joined.
21:14:40 <Slereah> (If you want to look at the tapes, just replace nd by d10 for instance, or d and any number)
21:14:57 <Sgeo> Checking minor ver not implemented yet
21:14:59 <Sgeo> woohoo!
21:15:39 <Hiato> true, the problem with tape like systems..
21:16:53 <Slereah> Best I can do is print "NUL" on the cell for the NUL char.
21:16:53 <oerjan> hah, just beat me to it :)
21:17:00 <oerjan> argh
21:17:54 <Sgeo> Well, I seem to have the concept behind opening a subprocess down..
21:18:35 <Hiato> lol : This programmer does not support empty programs as quine
21:18:35 <Hiato> awesome
21:18:41 <Hiato> :)
21:19:13 <Slereah> Plus, it prevents the program to crash if I type enter by mistake.
21:19:30 <Hiato> true. But that is still awesome :D
21:20:19 <Sgeo> IS http://trac2.assembla.com/psox/browser/trunk/impl/PSOX.py fugly?
21:20:55 <Hiato> Slereah, there is a problem with your BF interpreter
21:20:59 <Slereah> If you find a #print "butts" somewhere, it's just a marker I use.
21:21:03 <Slereah> What is it?
21:21:28 <Hiato> +++++++[>+++++++<-]>.
21:21:29 <Hiato> this should produce a 1 but I get an "M"
21:21:44 <Slereah> That's because it's not in an ASCII encoding.
21:21:54 <Hiato> ?
21:21:58 <Slereah> Here's the chart : http://paste-it.net/5463/raw/
21:22:18 <Hiato> Aha
21:22:18 <Slereah> As I said, I couldn't make a +/- in ASCII.
21:22:20 <Hiato> that helps
21:22:35 <Hiato> sorry, I must have missed that
21:22:40 <Slereah> Here's the local hello world :
21:22:40 <Slereah> >++++++[<+++++++>-]<++.>>+++++[<+++>-]<.+++++++..+++.<<++++[>+++++<-]>-.>++++++++.--------.+++.------.----
21:22:40 <Slereah> ----.<++++++.
21:22:54 <Slereah> Oops
21:22:55 <Slereah> >++++++[<+++++++>-]<++.>>+++++[<+++>-]<.+++++++..+++.<<++++[>+++++<-]>-.>++++++++.--------.+++.------.--------.<++++++.
21:22:57 <Slereah> There.
21:23:51 <Slereah> I think I will do an ASCII version, but with the 1 through 8, 11 through 31 abd 126 through 255 as something else.
21:24:12 <Hiato> cool, no prob
21:24:15 <Slereah> Maybe those musical notes I was thinking about.
21:24:20 <Hiato> lol :)
21:24:25 <Hiato> there is another problem though
21:24:33 <Slereah> http://paste-it.net/5480/raw/
21:24:38 <Hiato> I can't runt the interpreter more than once in a row
21:24:39 <Sgeo> anyone going to comment?
21:25:02 <Hiato> SyntaxError: invalid syntax if I try
21:25:27 <Hiato> I have to close IDLE a run it again
21:25:35 <Slereah> Well, the BF interpreter halts when it reaches an empty char.
21:25:38 <Hiato> if I need to run the prog more than once
21:25:53 <Slereah> Sgeo : I can't read much of it.
21:26:13 <Hiato> I see, but it returns me to the main prompt ie Help works fine and Instructions etc
21:26:21 <Hiato> but I can't run the BF interpreter again
21:26:31 <Hiato> woops
21:26:32 <Hiato> wait
21:26:37 <Hiato> that's the python help
21:26:42 <Hiato> tralalalalaallalalala
21:26:45 <Slereah> Heh.
21:27:08 <Hiato> Forget I said any of that
21:27:21 <Slereah> If you want some moar obfuscation, there's a minimalist version of the love machine 9000.
21:27:41 <Hiato> wicked (the harder to read, the better it looks :P )
21:27:46 <Sgeo> Slereah, hm?
21:27:58 <Slereah> http://paste-it.net/5459/raw/
21:28:12 <Slereah> Although it cannot stop at all.
21:28:37 <Hiato> oh well
21:28:43 <Hiato> lets see this puupy
21:29:51 <Slereah> The syntax is roughly : http://farm3.static.flickr.com/2384/2144871414_67e1245e41_o.jpg
21:30:25 <Hiato> aha
21:30:47 <Hiato> well this was probably supposed to happen, but
21:30:48 <Hiato> Traceback (most recent call last): File "C:\Love Machine 9000.py", line 332, in <module> sys.exit("Initial m-state " + fstate + " does not exist") SystemExit: Initial m-state q0 does not exist
21:31:15 <Hiato> PS: What you are doing Slereah is beyond me at his time of night
21:32:47 <Slereah> Maybe you didn't type the program as one line.
21:33:03 <Hiato> probably the problem
21:33:16 <Slereah> (Haven't found a way to strip the new lines so far, so everything is in one line)
21:33:25 <Hiato> Ok, I see
21:34:59 <Slereah> If you have some algorithm to solve the halting problem, I might be able to use it to halt the 4 symbols program!
21:35:20 <Slereah> Otherwise, it just runs forever.
21:35:27 <Hiato> :) lol
21:35:41 <Sgeo> Slereah, you mean stripping newlines in python?
21:35:43 <Hiato> well, why don't you just register at a fortune teller website :P
21:35:46 <Slereah> Yes.
21:35:59 <Sgeo> somestring = somestring.replace("\n", "")
21:36:22 <Slereah> Let's see!
21:37:00 <Slereah> It works, thankies.
21:37:05 <Sgeo> yw
21:37:29 <Slereah> (Just put prog=prog.replace("\n", "") on line 167 of the love machine)
21:38:32 <Hiato> roger
21:38:38 <Slereah> It will be easier to type those damn programs
21:39:44 <Hiato> Hrmm, I still get n error though: Traceback (most recent call last): File "C:\Love Machine 9000.py", line 205, in <module> sys.exit("Direction required") SystemExit: Direction required
21:39:58 <Hiato> with the minimal version of the love machine 9000
21:40:12 <Slereah> That's because you must add a left or right instruction.
21:40:15 <Slereah> < or >.
21:40:21 <Hiato> woops
21:40:22 <Hiato> ok
21:40:39 <Hiato> hah
21:41:07 <Slereah> I could just make a version with a "do not move" instruction, but where's the fun in that!
21:41:37 <Hiato> True
21:41:56 <Hiato> Compicated is fun (as is the case with my new Esolang)
21:42:22 <Slereah> I could even make a retarded version.
21:42:29 * Sgeo doesn't want PSOX to be too complciated :/
21:42:38 <Sgeo> ALthough the current specs mean a LOT of overhead
21:43:01 <Slereah> Switch the *+<> symbols to numbers, convert it to base ten, and make a version with just a long line of "+" to reach that number.
21:43:03 <Hiato> Lol, no thanks. Sgeo, Hiato also doesn't want PSOX to be com[plicated
21:43:27 <Hiato> starting to sound like Malbolge a bit there (don't scare me ;) )
21:43:35 * Sgeo doesn't know how to make the specs less scary
21:43:59 <Hiato> (add pictures of rabbits and such :P )
21:44:01 <Slereah> Well, I mostly use the version that you saw before, the one with less scary syntax.
21:44:07 <Sgeo> Did I mention the huge overhead of sending 3 bytes to add together to a function expecting VARG(LNUM)?
21:44:12 <Hiato> yes, and I am thankful for that too
21:44:36 <Sgeo> 0x01 0x01 0x01 0x00 0x01 0x01 0x02 0x00 0x01 0x01 0x03 0x00 0x00
21:44:50 <Hiato> yip
21:44:55 <Slereah> If you want some classic program for the love machine : http://paste-it.net/5484/raw/
21:44:59 <Hiato> unfortunately ;) No sleep for the wicked
21:45:24 <Hiato> cool, lets see what this baby does
21:45:26 <Sgeo> There are 3 bytes of data in that line. The rest is overhead :/
21:45:33 <Sgeo> Hiato, scary?
21:45:52 <Hiato> oh yeah, you bet
21:45:57 <Sgeo> :(
21:45:57 <Hiato> (no sarcasm)
21:46:22 <Sgeo> I'm probably going to freeze that into the specs though :(
21:46:38 <Slereah> Oh bloody hell. Something happened to it between the versions of the LM.
21:46:43 <Hiato> Slereah, that's awesome ! Except for the fact that it goes 99, 68, 67
21:46:46 <Slereah> It goes from 98 to 68.
21:46:47 <Hiato> but hety
21:46:50 <Hiato> its beer
21:46:54 <Hiato> its alowed
21:46:56 <Hiato> :P
21:47:00 <Slereah> Goes down smoothly!
21:47:00 <Hiato> *hey
21:47:06 <Slereah> I think I know what went wrong.
21:47:08 <Hiato> :)
21:47:27 <Hiato> Good idea Sgeo, shame though
21:47:29 <Slereah> I had to disallow the syntax character::newstate for conveniance reason
21:47:51 <Sgeo> Thing is, BF should be able to process that format smoothly..
21:47:53 <Hiato> ahh (no idea where that is in the programme) but well spotted
21:47:53 <Slereah> So I made a big replace "::" by ":DN:"
21:48:13 <Slereah> Probably nicked something.
21:48:26 <Hiato> Sgeo : that is scary still
21:48:29 <Slereah> Good thing I have a commented version somewhere.
21:48:31 <ihope> Sgeo: of course, 10 bytes of overhead is quite often not significant.
21:48:48 <Hiato> Slereah : Only you know what's going on deep within the bowls of this beast :P
21:49:13 <Sgeo> vs. 3 bytes of data, it's not significant?
21:49:36 <Slereah> Hell, I'm not even sure!
21:49:40 <Hiato> (I'm no expert here, but sounds like a lot to me)
21:49:46 <ihope> If you only send this once, nobody will notice.
21:49:46 <Hiato> lol
21:49:54 <Hiato> (so we hope)
21:49:57 <Slereah> But well, since it's a Turing machine, I can just visualize the tape!
21:50:04 <ihope> If you send it a million times, that becomes 10 megabytes of overhead for 3 megabytes of data, which probably is significant.
21:50:08 <Slereah> See what happens.
21:50:12 <Hiato> true, and a useful feeature too :)
21:50:23 <Hiato> Agreed
21:50:27 <Slereah> Although it takes an awfully long time for that program.
21:50:36 <Sgeo> Maybe it will be fixed in PSOX 1.1
21:50:50 <Hiato> well, good luck then Slereah, god speed ;)
21:51:10 <Slereah> Take one down, and pass it around!
21:51:14 <ihope> What is this overhead, anyway? An initial handshake?
21:51:19 * Slereah goes back to the counter
21:51:20 <Hiato> Well, I don't real;why mind that much Sgeo. But as iHope pointed out, it can become alot
21:51:23 <Slereah> 99!
21:51:25 <Hiato> *really
21:51:30 <Sgeo> It's the VARG(LNUM) format
21:51:33 * Slereah goes back to the end of the tape
21:51:40 <Sgeo> Indicator bytes to show when the data ends
21:51:42 <Hiato> (lol)
21:52:22 <Hiato> once again, I'm no expert but can't you demarcate a data stream?
21:52:47 <Sgeo> 0x01(vi) 0x01(li) 0x01(d) 0x00(li) 0x01(vi) 0x01(li) 0x02(d) 0x00(li) 0x01(vi) 0x01(li) 0x03(d) 0x00(li) 0x00(vi)
21:53:01 <ihope> What's that SADOL-like number format where a number is the length of the number followed by its digits?
21:53:13 <Sgeo> Where vi is VARG indicator bytes, li is LNUM indicator bytes, and d is data
21:53:25 <Sgeo> ihope, I doubt that BF could process that easily..
21:53:26 <Hiato> oh, well I understand it now
21:53:42 <Hiato> Agreed, Sgeo (if's aer a pain)
21:53:43 <ihope> Oh.
21:53:44 <Hiato> *are
21:54:16 <Sgeo> So, is that craptastic, or acceptable?
21:54:23 <Slereah> State 16a is the troublemaker!
21:54:38 <ihope> Acceptable as long as you provide a lower-overhead alternative, I'd say.
21:54:59 <Sgeo> lower-overhead but less powerful :/
21:55:10 <Slereah> There was a double ; in state 16a.
21:55:11 <Sgeo> adding only two bytes at a time, for instance
21:55:15 <Slereah> Cancer of the semicolon.
21:55:15 <Hiato> Yes, make them suffer for using hard languages
21:55:17 <Hiato> :P
21:55:30 <Hiato> But, no, if it is absolutely necissary, I truly think it's acceptable
21:55:47 <Sgeo> Incidentally, there is overhead before being allowed to accept input
21:55:49 <Hiato> Well found Slereah, and look, were still in 07 :P
21:56:20 <Sgeo> For instance, in BF, where a "," would normally go, you'd put "[-].+..+++++++++.,,,"
21:56:32 <Hiato> meh, oh well Sgeo, it'll have to do (and anyways, its your library thing, not ours and I don't mind that much)
21:57:12 <Hiato> actually though, on second thought, it seems to me to be a rather nice challenge
21:57:16 <Hiato> now that I think of it
21:57:17 <Sgeo> Is that craptastic?
21:57:24 <Sgeo> tbh, I can see no alternative..
21:57:29 <ihope> Depends on how many times you have to execute it and whether there's an alternative.
21:57:49 <Sgeo> No alternative, although you can request multiple bytes, or a line at a time
21:58:01 <Hiato> well, I think that the real problem will be TCP communication where allot of data is sent and then the overhead accumulates
21:58:08 <Hiato> but it doesn't truly mtter
21:58:18 <Hiato> I consider this a gift to the Eso community
21:58:23 <Sgeo> ty Hiato
21:58:27 <Hiato> to be able to acces the web from malbolge :P
21:58:41 <Hiato> np
21:59:56 <Sgeo> Reading in a line: "[-].+.-.++++++++++.,,[>,]"
22:00:06 <Sgeo> (Assuming there are no 0x00 in that line)
22:00:09 <Hiato> yeah, that's not bad at all
22:00:18 <Hiato> (ah, catch 22)
22:00:44 <Sgeo> If you want it to work even if there's a 0x00, you need to check for 0x0A at the end
22:00:58 <Hiato> I see, so there are means and ways
22:01:10 <Hiato> therefore now worries, be happy man ;)
22:01:58 <Sgeo> Also, that code overwrites the EOF indicator, so you won't know if that's the last line, or if the 0x0A really was present..
22:02:31 <Hiato> hrmm
22:04:07 <Sgeo> Incidentally http://trac2.assembla.com/psox/browser/trunk/spec/psox.txt#L155 is the relevent part of the spec
22:05:50 <Hiato> wow, that is allot of hard work done there. Well done on that. :)
22:06:30 <faxathisia> I really like this r"((?:\x01" + some_type_regex + r")*?\x00)"
22:07:46 <Sgeo> ty Hiato
22:08:23 <Hiato> ps: it is also well thought out, so don't be too worried about my inexperienced opinion on handshakes and overheads ;)
22:09:15 <Sgeo> Handshake is 7 bytes by the client, 2 by the server
22:09:26 <Sgeo> erm, 3 by the server
22:09:39 <Hiato> sounds find to me
22:09:42 <Hiato> :)
22:10:45 <Slereah> Hm. I think that by using never referenced states, I could make comments for the love machine.
22:11:08 <Hiato> That would be both nice, and helpful :)
22:11:10 * Sgeo is almost done writing the handshake-processing code
22:11:17 <Hiato> (wicked)
22:11:20 <Slereah> Something like comments[a:"comments":a]
22:11:42 <Hiato> yes, that would be very useful (and the beer is a prime example :P )
22:11:55 <Slereah> Well, actually, it could be much shorter.
22:12:11 <Slereah> For that program, I used a one state-one instruction kind of thing.
22:12:18 <Hiato> the easier for commenting, the better
22:12:20 <Slereah> Each letter printing takes one state.
22:12:26 <Hiato> oh, I see
22:12:38 <Slereah> But I could just use PbRIPoRIPtRI....
22:13:25 <Hiato> I won't doubt you on that (its now way too late to concentrate on that) ;)
22:13:33 <Sgeo> Hey, once PSOX is done, will anyone be writing domains and implentations for domains for it?
22:13:38 <Sgeo> implementations
22:13:53 <Hiato> I can give it a bash
22:13:56 <Hiato> (literllay)
22:14:04 <Hiato> *literally
22:14:32 * Sgeo would like to see an IRC domain, which would mean Brainfuck IRC bots!
22:14:37 * oerjan wonders if "literally" means what Hiato thinks it means
22:15:16 <Hiato> lol, woops
22:15:48 <Hiato> I told you, too late :P
22:16:05 <Hiato> lol, that's actually really funny :) :)
22:16:30 * Sgeo won't write the domain himself though, at least not until PSOX 1.0 is released..
22:16:54 <Sgeo> PSOX 1.0 will provide File I/O and HTTP access, and that's it, unless others write domains..
22:17:01 <Hiato> Yeah, BF chatbots w00t :)
22:17:06 <Slereah> The comment idea works oka.
22:17:18 <Hiato> good to hear Slereah :)
22:17:31 <Hiato> Cool, well I/o and HTTP is more than enough for an initial realease
22:17:39 <Hiato> without a doubt
22:22:43 <Hiato> alright, well its late again here. Cheers all
22:23:06 <Hiato> and once more, anything Full 0 related, let me know hiato1@gmail.com (this time all the links are valid and working)
22:23:14 <Hiato> http://www.full0.8tt.org
22:23:23 -!- Hiato has quit ("Leaving.").
22:28:09 * Sgeo adds the concept of PRIs
22:29:25 <Sgeo> domain longnames are PRIs
22:29:30 <Sgeo> What else would be a PRI?
22:29:42 <Sgeo> Anyone paying any attention?
22:32:09 <Sgeo> A PSOX Resource Identifier. Can either be a valid URI, or a string registered on http://esolangs.org/wiki/PSOX/PRI
22:34:27 <Sgeo> Comments on http://trac2.assembla.com/psox/changeset?old_path=trunk%2Fspec%2Fpsox.txt&old=15&new_path=trunk%2Fspec%2Fpsox.txt&new=16 ?
22:37:29 <Sgeo> pikhq, oklofok oerjan ihope GregorR faxathisia anyone?
22:37:42 <faxathisia> I don't know howto comment on that
22:38:44 <faxathisia> do you mean PESOIX's?
22:38:53 <faxathisia> What's that stand for
22:39:05 <pikhq> PSOX is his own project.
22:39:18 <pikhq> Meant to fulfill the role of PESOIX.
22:39:19 <Sgeo> PESOIX is PSOX's "spiritual ancestor"
22:39:25 <faxathisia> ah alright
22:39:35 <pikhq> I support the PRI, myself.
22:40:15 <pikhq> If you're sufficiently insane, you could even provide a way to get new domains via a PRI.
22:40:47 <Sgeo> You mean implementations?
22:41:08 <Sgeo> Sounds like something of a security risk..
22:41:48 <Slereah> Here's the commented version. Somehow.
22:41:49 <Slereah> http://paste-it.net/5486/raw/
22:42:43 <Slereah> Half of this program is made to handle less than 10% of the display.
22:42:55 <Sgeo> Incidentally, PSOX File I/O takes place in a sandbox unless "-s fullfileio" is specified
22:48:56 -!- ehird` has joined.
22:48:59 <Sgeo> Hi ehird`
22:49:06 <Slereah> Hello sir.
22:49:16 <Sgeo> Updates to psox.txt : http://trac2.assembla.com/psox/changeset?old_path=trunk%2Fspec%2Fpsox.txt&old=15&new_path=trunk%2Fspec%2Fpsox.txt&new=16
22:50:16 <ehird`> fsfsfdfdfs
22:50:18 <ehird`> oklofok! distract me from annoyance with oklotalk talk
22:50:36 <Sgeo> Hm
22:50:48 <Sgeo> I might end up preventing a PSOX 1.10 from existing..
22:50:50 <Slereah> :O
22:50:55 <Slereah> IT IS LIKE LOOK
22:51:10 <Sgeo> I mean, 1.9 and 1.11 but no 1.10 allowed :/
22:51:22 <Sgeo> Or I'll just fix the issue before 1.10
22:51:26 <oklofok> ehird`: i can grant some graphica talk later
22:51:27 * Sgeo opts for that route
22:51:34 <oklofok> once i make the parser complete
22:51:35 <ehird`> oklofok: graphica=
22:51:50 <Sgeo> ehird`, why don't you like PSOX?
22:51:58 <oklofok> the graph defining language i made yesterday
22:52:16 <ehird`> Sgeo: you bikeshed with it
22:52:22 <Sgeo> bikeshed?
22:52:56 <Slereah> Arthur.
22:52:56 <oklofok> i do agree, although i do that myself all the time
22:52:58 <Slereah> Bikeshed.
22:53:01 <Slereah> Jackson.
22:53:04 <oklofok> not that i knwo what bikeshedding is.
22:53:06 <ehird`> ,@define bikeshed
22:53:09 <oklofok> *know
22:53:10 <ehird`> wait, it isn't here
22:53:11 <ehird`> fsdfsdfsdfdsf
22:53:21 * Sgeo reads wiki
22:53:42 <Sgeo> You mean asking for trivial opinions?
22:53:45 <Sgeo> erm, opinions with trivial impact?
22:53:46 <ehird`> no
22:54:18 <ehird`> http://www.bikeshed.com/
22:55:56 <Slereah> "Parkinson shows how you can go in to the board of directors and
22:55:57 <Slereah> get approval for building a multi-million or even billion dollar
22:55:57 <Slereah> atomic power plant, but if you want to build a bike shed you will
22:55:57 <Slereah> be tangled up in endless discussions.
22:56:07 <Slereah> People. I need to build an atomic power plant.
22:56:34 <ehird`> Slereah: you shall need a bikeshed
22:56:46 <Slereah> No need ehird`.
22:56:55 <Slereah> Nuclear powered cars.
22:57:07 <ehird`> nuclear powered bikes
22:57:08 <Slereah> How awesome would that be!
22:57:14 <ehird`> duh
22:57:27 <oerjan> Wadler's law may also be relevant
22:59:34 <Sgeo> I don't like the color of bikeshed.com. It should be changed. Why didn't the maker of that page ask for input? (j/k j/k j/k)
23:00:05 <oerjan> "In any language design, the total time spent discussing a feature in this list is proportional to two raised to the power of its position. 0. Semantics 1. Syntax 2. Lexical syntax 3. Lexical syntax of comments
23:00:13 <ehird`> say oklofok
23:00:24 <ehird`> what would you say to an implementation of oklotalk in scheme
23:00:26 <ehird`> it'd be less horrific than doing it in C
23:00:47 <ehird`> hehe
23:01:32 <faxathisia> apart from MLs are there are languages specifically designed for writing other languages in?
23:03:04 <Slereah> ML?
23:03:15 <Slereah> Oh, meta language.
23:03:18 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
23:03:20 <ehird`> faxathisia: lisp
23:03:22 -!- puzzlet has joined.
23:03:29 * Sgeo keeps working on the handshake code
23:03:47 * Slereah shakes the hand of the world.
23:03:48 <Sgeo> Hi puzzlet. If you care about PSOX, did you see http://trac2.assembla.com/psox/changeset?old_path=trunk%2Fspec%2Fpsox.txt&old=15&new_path=trunk%2Fspec%2Fpsox.txt&new=16
23:03:49 <Slereah> Hello world!
23:04:26 <Slereah> Will this handshake language include high fives?
23:04:31 <Sgeo> hehe
23:05:03 <Slereah> Maybe the high-five command terminates the program or something.
23:05:20 <Sgeo> 0x00 0x02 0x00 n 0x0A is terminate program
23:05:34 <Slereah> 0x^5
23:05:35 <Sgeo> with error code n
23:12:44 <Sgeo> sgeo@ubuntu:~/dev/psox/trunk/impl$ python PSOX.py bf test.b
23:12:44 <Sgeo> Client's reported minimum version: 9
23:12:44 <Sgeo> Client's reported maximum version: 0
23:12:46 <ihope> What does 0x00 0x02 0x00 n something-else do?
23:13:06 <Sgeo> ihope, fails to be proper PSOX
23:13:19 <Sgeo> IllegalPSOXError
23:13:37 <Sgeo> the 0x0A is at the end of all functions to make sure the client's interpreter sends it properly
23:13:40 <ihope> I take it there's a good reason the terminate command isn't just 0x00 0x02 0x00 n.
23:13:45 <ihope> Ah.
23:14:13 <Sgeo> Thing is, PSOX doesn't send a 0x0A to make sure it gets received properly :/
23:14:48 * Sgeo isn't sure if that's much of an issue, but GregorR brought up the possibility that interpreters only send when they hit 0x0A
23:15:17 <GregorR> If you just write printf(), it'll work that way.
23:15:26 <GregorR> And lots and lots of interpreters do that.
23:15:40 <GregorR> Therefore, requiring a newline = more portable.
23:15:56 -!- RedDak has quit (Remote closed the connection).
23:15:58 <Sgeo> But they don't read line-by-line, they read character-by-character?
23:18:17 -!- helios_24c3 has quit (No route to host).
23:18:55 -!- oerjan has quit ("Good night").
23:20:08 <ehird`> Sgeo: you are really unix-naive aren't you
23:20:30 <ehird`> the console hangs on until <enter>
23:20:47 <ehird`> eh, unrelated
23:20:47 <ehird`> but, yeah
23:33:37 * Slereah will now try to implement some m-functions on the love machine 9000, since the parser is now working correctly
23:33:47 <oklofok> http://www.vjn.fi/pb/p412226441.txt
23:33:49 <oklofok> 2d grid
23:34:11 <oklofok> output of the graphica interpreter
23:34:40 <faxathisia> an interpreter now? :D
23:34:42 <faxathisia> in what
23:35:04 <oklofok> well, "interpreter"
23:35:16 <oklofok> it's in a sense a language.
23:35:23 <oklofok> since it may well be tc already
23:35:53 <oklofok> i have no idea how to actually draw a graph so that it makes no sense, it's quite hard to algorithmically determine whether the edges overlap *too much*
23:36:48 <oklofok> anyone wanna pitch a more complex graph so that i need to continue my parser :P
23:36:53 <oklofok> everything i come up with can already easily be represented :<
23:36:56 <faxathisia> what language is the interpreter in ?
23:37:08 <oklofok> python
23:37:14 <faxathisia> can I try it? :D
23:38:11 <oklofok> you need to inject the program in the actual code... i'll make it read the prog from a file first, i don't like people touching my code. :)
23:42:54 <oklofok> lol
23:43:18 <oklofok> not as easy a conversion as i though, since my parser can't handle the parsing of the actual expressions yet :D
23:43:50 <oklofok> so, okay, you need to put the code in the variable ptrns, it's clearly marked, and the exp needs the initial node
23:44:00 <oklofok> which you will have to parse manually... i think
23:45:37 <oklofok> faxathisia: http://www.vjn.fi/pb/p334611515.txt
23:46:02 <oklofok> i can help you with the syntax, and the variables ring and grid hold the two example progs i've made
23:47:13 <oklofok> i'll make the parser complete tonight, after that it'll handle lisp and math style computation with numbers, and possibly a few other primitive datatypes, in case that doesn't take long.
23:47:26 <oklofok> doesn't take long to make
23:49:47 <oklofok> heh, guess i should stop waiting for you to respond and actually begin writing the parser ;)
23:51:05 <Sgeo> oklofok, begin writing the parser
23:51:30 <oklofok> i'll promise to start before you start writing psox ;)
23:51:38 <oklofok> unless you already did.
23:51:48 <Sgeo> I started the PSOX.py interpreter already
23:51:49 <oklofok> gotta get some coke first
23:51:50 <oklofok> ->
23:51:50 <Sgeo> =P
23:51:56 <oklofok> oh, darn :P
23:52:05 <oklofok> well, i did write the part that's in the link yesterday
23:52:08 <Sgeo> So far, it can recognize the handshake
23:52:15 <oklofok> it does some parsing already
23:52:20 <oklofok> ------>
23:52:35 <Sgeo> Although it violates PSOX spec in that it exits if the program isn't PSOX or is an unsupported version..
23:52:50 <Sgeo> PSOX spec says it keeps going and gives info *shrugs*
23:52:56 <Sgeo> I'm violating my own spec :/
23:53:30 <Sgeo> And there's already a known bug that won't affect anything in the near future: It vomits on receiving a claim that it's e.g. PSOX 1.10
23:53:34 <Sgeo> Or 10.x
23:54:24 <Sgeo> Incidentally, handshake implies that clients have a version a.b-c not just simple a.b
23:55:36 <Sgeo> Anyone going to respond?
23:55:59 <oklofok> <------
23:56:06 <oklofok> can't, parsing time ->
23:59:36 -!- ehird`_ has joined.
←2007-12-28 2007-12-29 2007-12-30→ ↑2007 ↑all