2012-02-25.txt:23:21:05: <Ngevd> I'm thinking of calling this "Fueue"
2012-02-25.txt:23:48:24: <Ngevd> Fueue spec on wiki
2012-02-26.txt:11:12:26: <Ngevd> Programming in Fueue is haaaard
2012-02-26.txt:11:39:39: <monqy> taneb do fueue programs ever terminate
2012-02-28.txt:20:07:38: <Taneb> Writing programs in Fueue is hard...
2012-02-28.txt:20:10:34: <Taneb> I've written most of a Truth-machine in Fueue
2012-03-03.txt:08:42:12: <Taneb> I think Fueue is Turing-complete
2012-03-25.txt:20:37:44: <Taneb> Also, Fueue, which needs more love
2012-03-25.txt:20:48:49: <Taneb> Hey, does Fueue count as concatenative?
2012-03-25.txt:20:49:39: <elliott> Taneb: considering a fueue program as a function from a queue to a queue, does (p ++ q)(queue) represent q(p(queue))?
2012-06-29.txt:15:34:29: <Taneb> Nandypants, Numberwang, MIBBLLII, Fueue, Brook, Constatinople, Luigi, Real Fast Nora's Hair Salon 3: Shear Disaster Download
2012-08-27.txt:17:17:19: <Arc_Koen> hmm I'm trying to write an ocaml interpreter for Fueue http://esolangs.org/wiki/Fueue
2012-08-27.txt:17:23:34: <Arc_Koen> are you implying I got fooled by the "Fueue is a http://esolangs.org/wiki/Queue-based http://esolangs.org/wiki/Esoteric_programming_language" at the beginning of the wiki page?
2012-08-28.txt:20:22:04: <atriq> Did that guy who was implementing Fueue in OCaml get anywhere?
2012-08-28.txt:20:26:41: <atriq> You now know more about Fueue than the language's creator
2012-08-28.txt:20:40:44: <Arc_Koen> Taneb: when I'm finished do you have some example Fueue programs to test it on?
2012-08-28.txt:20:42:41: <oerjan> a few fueue programs
2012-08-28.txt:20:43:16: <Arc_Koen> "a fueueue programs"
2012-08-28.txt:21:01:03: <Arc_Koen> Taneb: "Hello world" in Fueue is as simple as "72 101 108 108 111 32 (etc.)"
2012-08-28.txt:21:07:05: <Arc_Koen> Taneb: since we're lacking example programs, I could write my first 99 bottles of beer in fueue!
2012-08-28.txt:21:09:54: <Arc_Koen> isn't Fueue missing an if statement or something?
2012-08-28.txt:21:29:08: <oerjan> i'm just trying to write a nontrivial loop in fueue
2012-08-28.txt:22:05:28: <oerjan> *fueue
2012-08-28.txt:22:09:22: * Arc_Koen 's starting to hate fueue
2012-08-28.txt:22:11:53: <Arc_Koen> so i'll go back to implementing an interpreter and i'll let you master fueue :)
2012-08-28.txt:22:29:04: <Arc_Koen> (that's kind of the big issue with fueue but you're the one we're gonna blame)
2012-08-28.txt:22:40:28: <Arc_Koen> on a totally unrelated matter, i'm kind of disappointed by how fast and easy it is to describe a new language like fueue, as opposed to how long and boring it is to implement that description
2012-08-28.txt:22:42:27: <Arc_Koen> maybe I should make a program that writes a C program that interprets fueue
2012-08-28.txt:22:49:07: <FreeFull> Arc_Koen: You should write a fueue interpreter in fueue
2012-08-28.txt:23:20:48: <Arc_Koen> (also I lied, I haven't done the string fueue program -> queue conversion yet but that should be easy)
2012-08-29.txt:12:06:32: <Arc_Koen> empty fueue: input a character, then segmentation fault
2012-08-29.txt:12:07:58: * oerjan suddenly realizes efficient fueue probably needs garbage collection of some kind
2012-08-29.txt:13:10:24: <fizzie> All Fueue problems seem so sad.
2012-08-29.txt:13:14:07: <oerjan> hm fueue has no EOF detection
2012-08-29.txt:13:36:46: <fizzie> oerjan: If the "read character" Fueue 'operation' returns -1 for EOF, then the empty-program cat will in fact print an infinite amount of -1's after the actual contents.
2012-08-29.txt:13:36:50: <Arc_Koen> anyway, let'ss write a "string fueue program to queue" function now so that the interpreter can be truly useful
2012-08-29.txt:13:37:42: <fizzie> The fflush might be nice for all those Fueue programs that print a prompt like "> " and then wait for input.
2012-08-29.txt:13:42:14: <fizzie> A Fueue cat that properly halts on EOF (assuming EOF = read -1) sounds like a nice little exercise for you folks, too.
2012-08-29.txt:13:42:15: <oerjan> atriq: WHAT DO YOU WANT TO HAPPEN IN FUEUE WHEN EOF IS READ
2012-08-29.txt:13:48:55: <oerjan> hm how in the world would one handle keeping a fueue program doing nothing for one round, and then managing to handle a character read afterwards...
2012-08-29.txt:13:59:49: <Arc_Koen> atriq: I'd actually be relieved if you could prove fueue was not turing-complete, then add a few functions that would make it both turing complete and usable
2012-08-29.txt:14:13:09: <atriq> ):[):] is a Fueue infinite loop, I believe
2012-08-29.txt:14:14:52: <Arc_Koen> "doing nothing is doing something" could be Fueue's slogan
2012-08-29.txt:14:17:09: <atriq> I think Underload was the main inspiration for Fueue
2012-08-29.txt:15:05:27: <Arc_Koen> oerjan: I think it's all working now, do you have some interesting fueue program for me to test?
2012-08-29.txt:16:02:30: <Arc_Koen> I don't know the fueue specifications about that :)
2012-08-29.txt:19:19:31: <oerjan> atriq: I FIND YOU INSUFFICIENTLY IMPRESSED BY MY LATEST FUEUE PROGRAM
2012-08-29.txt:21:26:12: <atriq> For a Fueue interpreter
2012-08-29.txt:21:27:19: <atriq> Its type is Kleisli (MaybeT (StateT Integer IO)) (Sequence FueueItem) (Sequence FueueItem)
2012-08-29.txt:21:58:09: <oerjan> hm it seems hard in fueue to move information conditionally leftward
2012-08-29.txt:22:10:10: <atriq> @unmtl MaybeT (StateT Int IO) (Seq FueueItem)
2012-08-29.txt:22:10:10: <lambdabot> Int -> IO (Maybe (Seq FueueItem), Int)
2012-08-29.txt:22:23:20: <atriq> @unmtl StateT Int (MaybeT IO) (Seq) (FueueItem)
2012-08-29.txt:22:23:27: <atriq> @unmtl StateT Int (MaybeT IO) (Seq FueueItem)
2012-08-29.txt:22:23:27: <lambdabot> Int -> IO (Maybe (Seq FueueItem, Int))
2012-08-29.txt:22:25:17: <oerjan> all this @unmtl is just fueuetile
2012-08-29.txt:22:47:05: <atriq> In this implementation of Fueue, it pushes 0
2012-08-29.txt:22:47:25: <atriq> (this is not part of the specification of Fueue)
2012-08-29.txt:23:12:01: <Arc_Koen> atriq: In this implementation of Fueue, it pushes 0
2012-08-29.txt:23:13:48: <Arc_Koen> I already have all the pain not mistyping fueue
2012-08-30.txt:01:32:52: <Arc_Koen> ./ofueue ")$2[)$--------2~)~~[)[)~(~[~[$~H~]~)%+~91-):]~1+:])]]~[$~H~])%+-91)[65][65]"
2012-08-30.txt:01:32:52: <Arc_Koen> Fatal error: exception Fueue.Unknown_operand(104)
2012-08-30.txt:01:39:45: <Arc_Koen> ./ofueue "72 101 108 108 10 H"got passed it hehe
2012-08-30.txt:01:53:51: <Arc_Koen> ./ofueue "72 101 108 108 10 H"
2012-08-30.txt:01:59:04: <Arc_Koen> Fatal error: exception Fueue.Unknown_operand(104)
2012-08-30.txt:02:04:44: <Arc_Koen> ./ofueue "+-*/%:~!$(<)H"
2012-08-30.txt:02:04:44: <Arc_Koen> ./ofueue "+-*/%:~"))[[H]]"(<)H"
2012-08-30.txt:02:05:03: <Arc_Koen> funny I thought no fueue function had to be escaped
2012-08-30.txt:02:07:33: <Arc_Koen> ok, so the program "sequence of all fueue functions" works
2012-08-30.txt:02:08:20: <Arc_Koen> ./ofueue ')$2[)$--------2~)~~[)[)~(~[~[$~H~]~)%+~91-):]~1+:])]]'
2012-08-30.txt:02:14:10: <Arc_Koen> ./ofueue ')$2[)$--------2~)~~[)[)~(~[~[$~H~]~)%+~91-):]~1+:])]]~[$~H~])%+-91)[65][65]'
2012-08-30.txt:02:28:42: <Arc_Koen> I'll try replacing it with Queue.length fueue or whatever
2012-08-30.txt:02:30:47: <Arc_Koen> ./ofueue ')$2[)$--------2~)~~[)[)~(~[~[$~H~]~)%+~91-):]~1+:])]]~[$~H~])%+-91)[65][65]'
2012-08-30.txt:02:31:44: <Arc_Koen> and then this will be THE FIRST FUEUE INTERPRETER
2012-08-30.txt:03:07:31: <Arc_Koen> when trying it on the empty fueue program though, it looks like there is nothing to trigger the end of "waiting for an input"
2012-08-30.txt:03:10:22: <Arc_Koen> echo 'ABCD' | ./ofueue ' '   prints ABCD then Fatal error: exception End_of_file
2012-08-30.txt:03:16:40: <Arc_Koen> along with a few fueue programs
2012-08-30.txt:03:25:12: <Arc_Koen> except for that fength bug which I "corrected" by replacing fength by Queue.length fueue when it was used
2012-08-30.txt:11:37:57: <Arc_Koen> for Fueue
2012-08-30.txt:11:38:05: <Arc_Koen> no, a Fueue interpreter written in ocaml
2012-08-30.txt:13:00:48: <Arc_Koen> hum apparently my fueue interpreter discards blocks instead of sending them back to the end
2012-08-30.txt:13:03:25: <fizzie> Arc_Koen: Regarding debugging prints and whatever, you could consider adding a trace/single-step kind of mode that'd print the fueue contents (or maybe say up to K first and last items) at each step; it might even be useful for all the Fueue developers, in addition to making debugging easier.
2012-08-30.txt:13:11:36: <Arc_Koen> atriq: are empty blocks allowed in fueue programs? I may have asked that already
2012-08-30.txt:13:30:01: <Arc_Koen> echo "ABCD" | ./ofueue ' '       prints ABCD then raise an End_of_file error
2012-08-30.txt:13:30:43: <Arc_Koen> ./ofueue ' '   without the pipe waits for me to make an input, prints it, and then things become weird
2012-08-30.txt:14:32:31: <atriq> Okay, for my Fueue interpreter
2012-08-30.txt:14:50:08: <Arc_Koen> if you have a corner of the web dedicated to fueue I would be glad to have the interpreter there, so that we can get rid of the "unimplemented" on the wiki
2012-08-30.txt:14:51:26: <atriq> Gregor, can Arc_Koen put his interpreters for Fueue in the Esoteric File Archive?
2012-08-30.txt:14:54:35: <Arc_Koen> atriq: so in Ftack, everything is like Fueue except we're using a stack instead; if the first value is a function which cannot be executed immediately, or if it's a block, it is sent back to the top of the stack
2012-08-30.txt:15:36:09: <Arc_Koen> ohhhhhh you're talking about fueue?
2012-08-30.txt:20:35:38: <Arc_Koen> atriq: why are the fueue functions characters rather than words like "dup", "pop", etc.?
2012-08-30.txt:20:50:51: <oerjan> i think compiling underload minus S (but including (...)S) into fueue should be doable
2012-08-30.txt:21:00:39: <Arc_Koen> here are the fueue.c and fueue.ml implementations: http://zzo38computer.cjb.net/esoteric/Arc_Koen/
2012-08-30.txt:21:18:10: <Arc_Koen> it works exactly like fueue, except with a stack; if the top element isn't either a number or a function with appropriate values directly behind it, it is sent back to the top of the stack.
2012-08-30.txt:21:21:50: <Arc_Koen> ironically I'm guessing some small programs that were hard to write in fueue would be easy to write
2012-08-30.txt:21:28:55: <oerjan> :: is another infinite loop for both fueue and ftack :)
2012-08-31.txt:12:16:19: <Arc_Koen> wait, did Oerjan just prove Fueue was turing-complete while I was sleeping?
2012-08-31.txt:18:00:51: <atriq> Fueue
2012-08-31.txt:18:02:35: <fizzie> I just got a "Segmentation fault (core dumped)" when I tried to feed it to that fueue.c.
2012-08-31.txt:20:55:29: <oerjan> no, now we're talking about fueue
2012-08-31.txt:20:59:43: <fizzie> Perfueuetions. Fuemutations. Permueues.
2012-08-31.txt:22:02:43: <Arc_Koen> fizzie: if you have any idea why infinite loops end up in a segmentation fault with fueue.c, please let me know
2012-08-31.txt:22:35:18: <fizzie> FWIW, gcc -O2 makes your fueue.c not segfault in the oerjogram, for me.
2012-08-31.txt:22:37:02: <fizzie> What sort of infinite recursion you have there, anyway? I didn't notice anything else than processFueue, with a self-call all the way in the end.
2012-08-31.txt:22:37:28: <Arc_Koen> well processFueue is recursive and oerjan's program is an infinite loop
2012-08-31.txt:22:37:41: <Arc_Koen> so processFueue won't stop calling itself until the program ends, which never happens
2012-08-31.txt:22:40:34: <Arc_Koen> it's used by the fueue function '('
2012-08-31.txt:22:42:29: <fizzie> All that is in the stack (i.e. locals of processFueue) is the 'Queue' structure itself.
2012-08-31.txt:23:11:34: <Arc_Koen> oerjan: I tried your program with fueue.c; as it didn't work I tried it with fueue.ml; as it didn't work I tried it with fueue.c using --print
2012-08-31.txt:23:35:38: <Arc_Koen> fizzie: even with copyQueue fixed and processFueue a while loop, I still get a segfault on oerjan's thuemorse program
2012-09-01.txt:00:30:55: <Arc_Koen> btw, ./fueuec thuemorse still ends up on a segfault, even with catching empty queues
2012-09-01.txt:00:54:20: <Arc_Koen> oerjan: funny bug...        ./fueuec '--65' works as it should, but ./fueuec --print '--65' reveals it doesn't    -- 65      65 0      A 0     (waits for input)
2012-09-01.txt:01:39:06: <Arc_Koen> so hum, you have proven fueue was turing-complete?
2012-09-01.txt:01:46:29: <oerjan> two consecutive underload functions aren't translated to two consecutive fueue subprograms.  you need to use the AB translation to concatenate underload programs.
2012-09-01.txt:01:47:54: <oerjan> the ! translation also would gobble up the [], in a very literal fashion since it happens precisely at the spot where i use a fueue ! to remove the popped element
2012-09-01.txt:02:09:10: <oerjan> no, they always match.  (A) is more or less similar to fueue (A
2012-09-01.txt:02:09:25: <oerjan> fueue [A]
2012-09-01.txt:02:10:53: <oerjan> except that fueue [A] does nothing, while underload [A] moves itself from the running program to the stack
2012-09-01.txt:02:14:22: <Arc_Koen> zzo38: I think I corrected all bugs and memory leaks from fueue.c so i'd be thankful if you could replace it http://sprunge.us/iEAW
2012-09-01.txt:09:29:10: <atriq> I ought to upload my Fueue interpreter somewhere
2012-09-01.txt:12:24:50: <Arc_Koen> @tell oerjan ./fueuec '~!~)): [[48 [)):] [~!~)):] ~~) !][49 [~!~)):] [)):] )~]]'      11010011001011010010110011010011001011001...  '110' seems a weird start for the thue morse sequence...
2012-09-01.txt:17:33:33: <atriq> A bit slow, but I think that's a problem with Fueue
2012-09-01.txt:18:52:51: <lambdabot> Arc_Koen said 6h 28m 1s ago: ./fueuec '~!~)): [[48 [)):] [~!~)):] ~~) !][49 [~!~)):] [)):] )~]]' 11010011001011010010110011010011001011001... '110' seems a weird start for the thue morse sequence...
2012-09-01.txt:19:39:34: <oerjan> @tell atriq <atriq> A bit slow, but I think that's a problem with Fueue <-- I think programs like my thue-morse program could be sped up a lot if you kept track of long subsequences of non-triggering elements (e.g. blocks)
2012-09-01.txt:19:40:05: <fizzie> Arc_Koen: Not related, but was your latest fueue.c around? 
2012-09-01.txt:19:49:53: <fizzie> The fueue.c code seems to be mostly valid C++, except for four instances of relying on the implicit conversion of void* to Token*.
2012-09-01.txt:20:03:54: <lambdabot> oerjan said 24m 20s ago: <atriq> A bit slow, but I think that's a problem with Fueue <-- I think programs like my thue-morse program could be sped up a lot if you kept track of long subsequences of
2012-09-01.txt:21:10:53: <atriq> Right, to make my Fueue implementation more speedy
2012-09-01.txt:21:11:07: <atriq> I have added another constructor to the FueueItem datatype
2012-09-01.txt:21:11:22: <atriq> FCache :: Seq FueueItem -> FueueItem
2012-09-01.txt:21:12:00: <atriq> It's just FCache (Seq FueueItem)
2012-09-03.txt:02:09:47: <oerjan> for example for fueue underload was a very good fit, since it had very similar pieces even if they worked bizarrely differently
2012-09-04.txt:00:48:56: <oerjan> elliott: well Fueue has been up, several interpreters and programs were written, include a TC proof (by guess who)
2012-09-04.txt:00:50:22: <Arc_Koen> I wake up one morning, check the fueue page, and it includes a section saying that it is turing complete... I come here, ask people what happened, and apparently the only sign was oerjan saying "another day, another TC proof" before going to sleep
2012-09-04.txt:00:51:25: <oerjan> i am pretty sure i mumbled something about underload (minus S) possibly being convertible to fueue before that
2012-09-04.txt:00:52:13: <Arc_Koen> also i found a truth machine in fueue on the truth machine's page, was that you?
2012-09-04.txt:12:10:56: <Arc_Koen> atriq: so I haven't seen your haskell fueue interpreter
2012-09-06.txt:12:30:50: <atriq> My Fueue interpreter has devolved into a mess of varying levels of indentation
2012-09-10.txt:20:30:13: <atriq> Fueue and Real Fast Nora's Hair Salon 3: Shear Disaster Download are my two favourite esolangs I have created
2012-09-11.txt:15:41:07: <lambdabot> when I look at the instruction set I feel like it's basically Fueue, except the program and the data queue are separated. what am I missing?
2012-09-11.txt:15:41:07: <lambdabot> Arc_Koen said 16h 32m 1s ago: oh and I noticed the truth-machine fueue program from the truth-machine wiki page doesn't work. it first tries to print "-48", then (assuming the interpreter hasn't
2012-09-11.txt:15:42:12: <atriq> And also, I never tested the truth-machine in Fueue
2012-09-11.txt:15:44:26: <Arc_Koen> I think a truth-machine is quite hard to implement in fueue, because of the "one complete no-op rotation" you have to have in order to get input, and then this input alone is supposed to de-no-op the queue
2012-09-11.txt:15:46:54: <Arc_Koen> also I was wondering: where does the "F" in fueue come from ?
2012-09-11.txt:18:35:45: <oerjan> <Arc_Koen> I think a truth-machine is quite hard to implement in fueue, because of the "one complete no-op rotation" you have to have in order to get input, and then this input alone is supposed to de-no-op the queue
2012-09-11.txt:19:47:10: <oerjan> trying to get fueue input working
2012-09-11.txt:20:14:50: <Arc_Koen> hmmm does fueue accept empty blocks?
2012-09-11.txt:20:49:47: <Arc_Koen> zzo38: could you replace fueue.c with http://sprunge.us/EIBh please? modifications include fixing a memory leak, using union types, and fixing an issue with empty blocks
2012-09-15.txt:19:29:31: <atriq> Can I submit Fueue to the 2006 essies?
2012-09-24.txt:19:50:45: <atriq> Fueue?
2012-09-24.txt:19:51:24: <atriq> Fueue has queues which can contain queues
2012-09-24.txt:19:51:29: <olsner> tried to google fueue and found https://en.wikipedia.org/wiki/Women_in_piracy
2012-09-24.txt:19:54:04: <olsner> argh :( I thought I was looking it up on the eso wiki and failed to find the fueue article, turns out that was wikipedia
2012-09-27.txt:20:38:51: <Arc_Koen> atriq: I've been thinking, it seems rather logic to me that Fueue programs should end when they try to input but reach EOF
2012-09-27.txt:20:40:32: <Arc_Koen> input in Fueue is a mean to "save" the program from an infinite no-op loop; if there is no input available, then it means there's nothing left to save the program from this no-op loop
2012-09-27.txt:20:41:27: <atriq> And write Fueue programs to handle it
2012-09-27.txt:20:42:35: <oerjan> btw i have no idea how to handle Fueue input that is a negative number :)
2012-09-27.txt:20:46:41: <atriq> Fueue is a ridiculous language.
2012-09-27.txt:21:15:51: <Arc_Koen> oerjan: do you think Fueue would be TC, using its input system as input, if EOF halted execution?
2012-10-02.txt:09:07:32: <Arc_Koen> so what's up? have you completed your fueue interpreter in haskell?
2012-10-02.txt:19:16:43: <atriq> I'm really proud of Fueue
2012-10-02.txt:20:48:09: <Arc_Koen> a fueue itnerpreter in thue would actually be shorter that a brainfuck one
2012-10-02.txt:20:48:31: <Arc_Koen> cause fueue has only one structure (that is, code and date are together)
2012-10-02.txt:20:50:06: <Arc_Koen> oerjan: your proof that fueue is turing complete, does it work if numbers are bounded?
2012-10-02.txt:20:58:18: <oerjan> Arc_Koen: it's only using the functional parts of fueue in an essential way
2012-10-02.txt:21:01:52: <Arc_Koen> olsner: so i'm gonna make a verbose thue fueue interpreter
2012-10-02.txt:21:25:21: <Arc_Koen> (the fueue interpreter might not be shorter than the brainfuck one because it has so much moving around)
2012-10-07.txt:08:03:09: <atriq> You know, I'm actually really surprised that Fueue is Turing-Complete
2012-10-15.txt:18:12:29: <atriq> (look at Fueue and Eodermdrone and Malbolge)
2012-11-13.txt:14:20:36: <atriq> Fueue is a ridiculous language
2012-11-13.txt:16:32:24: <atriq> Arc_Koen, in your implementations of Fueue, what was the divide by zero behaviour?
2012-11-13.txt:16:34:39: <Arc_Koen> ~/desktop/ocaml stephan$ gcc -o fueue fueue.c
2012-11-13.txt:16:34:39: <Arc_Koen> ~/desktop/ocaml stephan$ ./fueue '/ 5 0'
2012-11-13.txt:16:35:23: <Arc_Koen> ~/desktop/ocaml stephan$ ocamlc -o fueue fueue.ml
2012-11-13.txt:16:35:23: <Arc_Koen> ~/desktop/ocaml stephan$ ./fueue '/ 5 0'
2012-11-13.txt:16:37:57: <Arc_Koen> ./fueuec '/ 129 2 ~ H'
2012-11-14.txt:09:45:12: <atriq> Testing my Fueue interpreter:
2012-11-16.txt:19:39:01: <Arc_Koen> atriq: how's your fueue interpreter going?
2012-11-16.txt:21:18:03: <atriq> Okay, the Fueue program that should print the alphabet is instead printing out ^A, \-91
2012-11-16.txt:21:23:08: <atriq> Could you do "fueueinterpwhatever > file", and send me the file?
2012-11-16.txt:21:24:22: <Arc_Koen> or can I do ./fueuec --print ')$2[)$--------2~)~~[)[)~(~[~[$~H~]~)%+~91-):]~1+:])]]~[$~H~])%+-91)[65][65]' > file   and then still halt at any time with ^C or ^D ?
2012-11-16.txt:22:33:53: <Arc_Koen> now to write a fueue interpreter in fueue
2012-11-24.txt:20:54:55: <atriq> More or less awkward than Fueue?
2012-12-07.txt:22:52:23: * oerjan swats Gregor for ignoring Fueue -----###
2012-12-07.txt:22:53:04: <Taneb> Although the interesting bits of Fueue were unintentional
2012-12-18.txt:22:09:58: <Taneb> Just finished off my Fueue interpreter
2012-12-27.txt:22:43:50: <Taneb> elliott, Fueue is almost interesting
2012-12-27.txt:22:53:52: <oerjan> Taneb: Fueue almost certainly can do all of Underload other than S, it's just that i left out ~ * and a because they seemed like they would be comparably painful.  adding just ~ would give a path via turing machines instead of minsky.
2012-12-27.txt:23:18:17: <Taneb> By the way I finished my Fueue interpreter
2013-01-07.txt:20:22:51: <Taneb> c00kiemon5ter, check out Fueue. It's queue-based and ridiculous
2013-01-07.txt:20:58:24: <GreyKnight> Fueue?
2013-01-09.txt:19:07:23: <Taneb> Fueue is implemented in three languages
2013-01-17.txt:17:01:34: <Taneb> Futuerjan: I saw your edits on the Fueue article
2013-01-17.txt:23:52:32: <oerjan> @tell Taneb <Taneb> Futuerjan: I saw your edits on the Fueue article <-- HOW CAN YOU DO THAT WITHOUT A GUI?
2013-01-19.txt:18:31:02: <oerjan> Taneb: my underload to fueue conversion worked on all the programs i tested :) (after upping the C interpreter's buffer size to 10000.)
2013-01-21.txt:10:06:24: <oerjan> `pastelogs fueue.*
2013-01-21.txt:10:06:39: <oerjan> `pastelogs fueue.*eof
2013-01-21.txt:10:06:53: <fizzie> Fueueof.
2013-01-21.txt:10:07:35: <fizzie> Hey, the "fueueof" made it to the output. Funky.
2013-01-21.txt:10:11:40: <oerjan> it seems http://codu.org/logs/_esoteric/2012-08-29.txt has the fueue eof discussion
2013-01-21.txt:10:16:48: <oerjan> so the fueue eof situation is a mess.  the C interpreter returns some negative number (usually -1 but not portably), the ocaml interpreter just throws an uncatched exception, and Taneb has not linked to his own interpreter so i don't know what it does.
2013-01-26.txt:15:25:06: <Taneb> mroman, try writing a brainfuck interpreter in Fueue
2013-01-26.txt:15:31:53: <mroman> fueue
2013-01-26.txt:15:33:08: <Taneb> Because that doesn't exist and I use to make that mistake every time, and I created Fueue
2013-01-26.txt:15:33:14: <ais523> http://esolangs.org/wiki/Fueue
2013-01-26.txt:15:35:58: <Taneb> (it's actually hypothetically possible to write a BF interpreter in Fueue)
2013-01-30.txt:03:29:35: <oerjan> no use fueue, look how simple it is to print a number in decimal!
2013-01-30.txt:20:08:25: <oerjan> ooh i left a literal n in the fueue program
2013-01-30.txt:20:33:47: <oerjan> Taneb: um isn't fueue supposed to allow return as whitespace?
2013-01-30.txt:20:33:54: <oerjan> `pastelogs fueue
2013-01-30.txt:20:34:44: <oerjan> `pastelogs fueue