←2006-12-09 2006-12-10 2006-12-11→ ↑2006 ↑all
00:08:05 <pgimeno> this guy has abused a bit the concept of a 'one-liner': http://www.dustindiaz.com/basement/js/dom.js (beware the link crashes my Mozilla; it works fine in Firefox 1.5)
00:12:27 <pgimeno> btw, that's part of the source of http://www.dustindiaz.com/basement/tetris.html
00:12:47 <GregorR> 8-D
00:12:50 <GregorR> dHTML TETRIS!
00:12:56 <GregorR> That's better than http://www.codu.org/evilpong/
00:15:59 <pikhq> I prefer XML Tetris.
00:16:25 <GregorR> http://www.codu.org/rxml.php
00:21:39 <pgimeno> yay, rxml rox
00:23:19 <pgimeno> xml tetris?
00:23:57 <pgimeno> is that based in the turing-completeness (I think) of xslt?
00:25:14 <pikhq> Actually, it's nearly pure SVG.
00:25:15 <pikhq> Has a tiny bit of embedded Javascript.
00:25:33 <bsmntbombdood> crap crap
00:28:27 <pgimeno> oh
00:29:09 * bsmntbombdood borked his keyboard
00:30:45 <pgimeno> oh and btw there's a version with bgm: http://www.dustindiaz.com/basement/tetris-s.html
01:14:19 -!- wooby has quit.
01:16:52 -!- CakeProphet has joined.
01:29:51 <CakeProphet> Anyone recommend a good Lisp implementation... that's... easy to setup on Windows?
01:39:40 <bsmntbombdood> Sure.
01:39:50 <bsmntbombdood> Install a real OS, then use SBCL
01:40:03 <pikhq> Emacs.
01:40:22 <pikhq> Although realise that running Windows makes everything comparatively hard to setup.
01:40:46 <bsmntbombdood> I got a windows version of xemacs running in 30 seconds
01:41:41 <pikhq> I got a GNU/Linux version of Emacs running in 0 seconds.
01:41:49 <bsmntbombdood> yep
01:42:02 <bsmntbombdood> well...it takes like 2 seconds to start up
01:42:15 <pikhq> But it takes 0 seconds for me to install it. . .
01:42:19 <pikhq> Preinstalled. ;)
01:42:21 <bsmntbombdood> yeah
01:42:41 <bsmntbombdood> I can't believe an OS would ship without a decent text editor
02:11:29 -!- jix_ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
03:00:08 <lament> emacs is not a good lisp implementation.
03:01:33 <bsmntbombdood> It is a good emacs lisp implementation
03:01:52 <lament> i'm not even sure of that.
03:02:06 <pikhq> It is *the* Emacs Lisp implementation.
03:02:25 <lament> so?
03:24:37 * SimonRC goes to bed.
04:02:41 -!- GreaseMonkey has joined.
04:03:04 * pikhq takes a guess that GreaseMonkey likes Greasemonkey
04:05:59 * GreaseMonkey takes a guss that pikhq is correct
04:07:05 <bsmntbombdood> Connection error: Monkey too Greasy
04:07:19 <GreaseMonkey> yep <:D
04:10:35 * pikhq makes out with BFM
04:11:37 <bsmntbombdood> kinky
04:13:07 <pikhq> And incestous.
05:08:10 -!- GregorR-L has joined.
05:10:35 -!- calamari has quit (Remote closed the connection).
05:10:59 -!- calamari has joined.
05:11:08 <calamari> hi
05:11:29 <calamari> nonwrapping bf.. 5 - 12 = ?
05:12:03 <pikhq> 5-12=-7
05:12:22 <calamari> so one cell to store the sign ?
05:13:10 <pikhq> No, in nonwrapping BF, the cell is signed and either bound-checked or bignum.
05:13:36 <GregorR-L> Could be either *shrugs*
05:15:22 <calamari> I always assumed a nonwrapping program would work in a wrapping interp.. guess that isn't always the case
05:16:23 <pikhq> In a wrapping interp, 5-12=-7==248.
05:17:04 <calamari> 248 / 2 = 124 -7/2 = 3
05:17:09 <calamari> err -3
05:19:27 <pikhq> It's the whole "mod 255" thing that's mildly confusing. . .
05:21:30 <Sgeo> Any ideas on how to best mutilate Windows?
05:21:54 <calamari> Sgeo: I have some word documents you could open.. and some special multimedia files for your enjoyment
05:22:14 <Sgeo> Now... how to get them from Host to Guest :/
05:23:22 <calamari> GregorR: what assumptions does your c compiler make about cells?
05:23:29 <Sgeo> calamari, Win98 is running under VMware
05:23:36 <calamari> ahh
05:23:55 <pikhq> Sgeo: format C:
05:23:56 <calamari> here's something fun you can do
05:24:03 <Sgeo> pikhq, I tried that
05:24:06 <calamari> run debug
05:24:13 <Sgeo> pikhq, it wouldn't let me
05:24:14 <calamari> then enter this program:
05:24:19 <calamari> a
05:24:23 <calamari> cli
05:24:28 <calamari> jmp 101
05:24:30 <calamari> g
05:26:20 <calamari> Sgeo: how'd it go?
05:26:38 <Sgeo> I just got "^ Error"
05:26:51 <calamari> where
05:26:56 <calamari> on the g ?
05:26:59 <Sgeo> Yes
05:27:08 <calamari> sorry you need to push enter again after jmp 101
05:27:18 <Sgeo> So it's
05:27:20 <Sgeo> a
05:27:21 <Sgeo> cli
05:27:24 <Sgeo> jmp 101
05:27:26 <Sgeo> <enter>
05:27:26 <Sgeo> g
05:27:27 <Sgeo> ?
05:27:28 <calamari> yes
05:27:36 <calamari> but you're still okay
05:27:37 <Sgeo> Should I close and restart debug?
05:27:42 <calamari> you can just push enter
05:27:48 <calamari> then g <enter>
05:28:25 <Sgeo> The cursor just sort of... froze..
05:28:30 <calamari> yeah :)
05:28:44 <calamari> windows is probably gone
05:28:57 <calamari> (frozen)
05:29:05 <Sgeo> Something that left it in a pseudousable state would have been preferable..
05:29:08 <Sgeo> (more fun)
05:29:26 <calamari> I think it is cool how easy it is to screw up the multitasking in win98
05:29:43 <Sgeo> What does that debug thing do anyway?
05:30:05 <calamari> first it disables maskable interrupts
05:30:06 <pikhq> calamari: Win98 doesn't really multitask.
05:30:13 <calamari> then it enters a very tight loop
05:30:18 <pikhq> It just imitates it for the user.
05:30:18 <pikhq> :p
05:30:23 <calamari> pikhq: yeah it does.. p[reemptive too
05:30:44 <pikhq> Well, it isn't exactly good multitasking if one can preempt the preempting.
05:31:02 <Sgeo> Night allk
05:31:06 <calamari> pikhq: I didn't say it was good.. just saying it does do multitasking
05:31:24 <pikhq> I call that merely an imitation of multitasking. ;)
05:32:10 * Sgeo is confused
05:32:12 <Sgeo> Night all
05:32:23 <calamari> I call that an imitation of an argument :)
05:32:28 <calamari> cya sgeo
05:32:34 <pikhq> As do I. ;)
05:32:41 -!- Sgeo has quit (Remote closed the connection).
05:33:53 -!- GregorR-L has quit ("Leaving").
06:06:16 -!- calamari has quit ("Leaving").
06:11:23 -!- GreaseMonkey has quit ("Connection error 130 (Monkey too greasy)").
07:13:51 -!- pikhq has quit (Read error: 60 (Operation timed out)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:12:42 -!- tgwizard has joined.
10:19:18 -!- ivan` has joined.
12:41:49 -!- jix_ has joined.
14:19:12 -!- jix__ has joined.
14:35:28 -!- jix_ has quit (Read error: 110 (Connection timed out)).
14:55:11 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <-").
15:08:22 -!- Sgeo has joined.
15:52:02 -!- kipple_ has joined.
16:22:55 -!- oerjan has joined.
18:18:56 -!- CakeProphet has quit ("haaaaaaaaaa").
18:37:54 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
19:23:07 -!- jix_ has joined.
20:05:28 <Sgeo> Most fun way to fubar Win98?
20:16:45 -!- EgoBot has joined.
20:31:17 <SimonRC> Sgeo: F00F bug?
20:31:44 <Sgeo> No clue what that is
20:32:18 <oerjan> it makes your computer go up in smoke *F00F*
20:34:18 <oerjan> Would it be impolite of me to shorten the Deadfish interpreter?
20:35:58 <oerjan> Wait a minute...
20:36:51 <oerjan> It _really_ does not read any commands
20:39:51 <oerjan> OK if I am to believe the example then the interpreter is buggy rather than intentional
20:43:55 -!- GregorR has quit (Read error: 104 (Connection reset by peer)).
20:44:32 <SimonRC> http://216.239.59.104/search?q=cache:4DSsRj2iMo4J:www.x86.org/errata/dec97/f00fbug.htm+f00f+bug&hl=en&gl=uk&ct=clnk&cd=1
20:44:59 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:49:20 <oerjan> Gah. I can't believe I forgot what scanf does.
20:51:59 <bsmntbombdood> printf except backwards
20:52:47 <oerjan> But it doesn't discard the rest of the line, does it?
20:53:21 <bsmntbombdood> scanf(3)
20:53:42 <oerjan> I am already reading it.
20:58:02 -!- GregorR has joined.
21:01:26 <Razor-X> Meh. It's hard to forget C.
21:02:04 <bsmntbombdood> Easy to forget clib functions
21:02:25 <Razor-X> scanf?
21:02:38 <bsmntbombdood> ?
21:02:49 <oerjan> My brain confused it with sscanf I think.
21:02:58 <Razor-X> Aha.
21:03:13 <bsmntbombdood> woot C has continuations
21:03:15 <oerjan> So somehow I got the idea the program never read input.
21:03:36 <Razor-X> Continuations? call/cc style?
21:03:40 <bsmntbombdood> yeah
21:03:41 <oerjan> Since when?
21:03:48 <Razor-X> How?
21:03:48 <lament> since never
21:04:11 <lament> i assume he's talking about setjmp/longjmp?
21:04:21 <bsmntbombdood> setcontext(2)
21:04:54 <Razor-X> Switching between multiple threads of control within a process.
21:05:33 <bsmntbombdood> swapcontext(3)
21:05:34 <Razor-X> Oh. Hmm...
21:05:39 <lament> oh, huh, that does look like continuations
21:05:46 <Razor-X> Yeah, it does.
21:05:54 <bsmntbombdood> :)
21:05:58 <Razor-X> Who knew.
21:07:07 <bsmntbombdood> damn, right after I discover this, I have to do homework
21:07:52 <Razor-X> That's probably what all the Scheme interpreters use to implement call/cc.
21:08:32 <SimonRC> I think that Scheme terps actually use call/cc to implement call/cc.
21:08:41 <lament> Razor-X: except for the overwhelming majority that are written in Scheme
21:09:02 <Razor-X> Well... I'm thinking Gambit/Stalin/Chicken.
21:09:13 <SimonRC> You can add it to a graph-reduction-based interpreter without too much trouble, I suspect.
21:10:10 <SimonRC> Maybe the C-based ones have an explicit (spaghetti) stack rather than an implicit one, whereupon call/cc become easier.
21:10:27 <bsmntbombdood> hum, my linux box has swapcontext, but not my bsd box
21:11:22 <GregorR> Always read the CONFORMING TO section.
21:12:21 <bsmntbombdood> SUSv2, POSIX 1003.1-2001.
21:16:15 <bsmntbombdood> methough bsd was posix complient
21:16:33 <GregorR> I don't know what revision *shrugs*
22:18:08 -!- calamari has joined.
22:18:38 <calamari> hi
22:19:23 * calamari has an idea .. :)
22:19:47 * oerjan prepares to shoot calamari
22:19:51 * bsmntbombdood waits
22:20:06 <calamari> I want to see if I can convert labels and gotos into if's, while's, etc
22:20:44 <calamari> the idea would be to break down a complex program (using gotos, while, if, break, etc) into just gotos, then reconstruct it again
22:20:56 <calamari> this would be handy for break/continue removal
22:21:13 <bsmntbombdood> if,whiles are implemented with gotos
22:21:28 <calamari> bsmntbombdood: yes, I know
22:21:39 <SimonRC> calamari: It is possible, but you may need to introduce some temporary variables.
22:22:02 <calamari> SimonRC: yeah.. the hard part at least for my brain is building some kind of tree or such
22:22:17 <oerjan> well, you just need one variable, to save the next label
22:22:23 <calamari> then I can figure out where the loops are
22:22:24 <SimonRC> OTOH, BFBASIC manages to handle arbitrary gotos with just while loops.
22:22:26 -!- CakeProphet has joined.
22:22:39 <calamari> SimonRC: yeah it does.. but I cheated and used labels and gotos
22:22:57 <calamari> SimonRC: I'm trying to avoid that and hopefully produce more efficient code
22:23:23 <calamari> with the goal of making it easier to translate a language such as spaghetti or linguine into bf
22:23:30 <oerjan> and then a giant case statement in a while (1)
22:23:43 <calamari> oerjan: that's eseentially what I do with bfbasic
22:23:50 <oerjan> the case statement is then easily turned into nested if then else
22:24:47 <calamari> and it's kinda slow :)
22:25:11 <calamari> would be better to unravel the goto's, even if it means duplication of code blocks
22:25:13 <SimonRC> I think the tricky one is 10 FOO; 20 BAR; 30 MAYBE GOTO 10; 40 MAYBE GOTO 20;
22:26:34 * SimonRC spots that a "do{}while()" is just a backward jump and an "unless(){}" is just a forward one.
22:26:39 <SimonRC> hmm
22:27:52 <calamari> SimonRC: okay I've decomposed that tricky loop
22:28:28 <SimonRC> how?
22:28:31 <calamari> not sure how to write it in here tho.. let me try
22:28:39 <calamari> ABCDE
22:28:54 <calamari> B-C goes to A
22:28:57 -!- jix_ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:29:10 <calamari> D-E goes to B .. that's the original
22:29:29 <calamari> do you follow the notation for the original program?
22:30:06 <calamari> A,B,C,D,E are blocks of code
22:30:06 <oerjan> rather difficult to match 5 letters with 4 statements
22:30:17 <SimonRC> huh?
22:30:28 <calamari> like I said.. hard to write in irc
22:30:30 <calamari> hehe
22:30:39 <calamari> let me translate it into basic like you did
22:31:36 <oerjan> i think possibly you are dealing with the wire-crossing problem
22:32:02 <calamari> no I'm dealing with a text interface problem
22:32:13 <oerjan> as in, just if and while cannot build flowcharts with crossing wires without extra temporary variables
22:32:23 <calamari> who said anything about that
22:32:31 <calamari> I was just saying I was able to unravel it
22:32:57 <calamari> if anyone wants to say it is impossible then prepare to own up to it hehe
22:33:36 <calamari> let me draw a little diagram and post it
22:34:08 <SimonRC> I will boldly assert that it is impossible to translate my code into plain loops and ifs without either duplicating code or creating superfluous temporary variables.
22:34:20 <oerjan> actually that example does not really have wire-crossing
22:34:46 <calamari> SimonRC: right.. if you duplicate code
22:34:54 <calamari> that's what I intend to do
22:34:56 <SimonRC> oerjan: it does if you require that all the points are on the x-axis and all wires must only go through the upper half-plane
22:35:04 <calamari> if you duplicate part of the coee, it is easily unraveled
22:35:25 <oerjan> right, that makes sense
22:35:33 <calamari> that's what I was just drawing up
22:35:49 <calamari> guess I don't need to now hehe
22:35:58 -!- ihope has joined.
22:36:01 <ihope> 11.1265006 milligrams.
22:36:16 <bsmntbombdood> of crack
22:36:24 <oerjan> argh, a drive-by chemist!
22:36:35 <SimonRC> heh
22:37:08 * SimonRC goes for pizza, and then to bed, most likely.
22:37:28 <oerjan> i think it is possible to make code which cannot be unraveled simply with duplication
22:38:21 <calamari> that's easy.. a break statement
22:39:22 <calamari> hmm maybe that can be unraveled as well
22:39:27 <calamari> need to map these out
22:39:58 <calamari> anyhow, I think I'm on to something... translate into gotos, then recompose for the target language
22:40:19 <calamari> should be more efficient than the huge switch statement hack
22:44:23 <oerjan> this is essentially a finite state machine problem
22:44:57 <calamari> oerjan: cool
22:45:07 <oerjan> can every FSA be implemented with just while and case (getc()) statements?
22:45:25 <calamari> well, bf implements everything with just while
22:45:41 <oerjan> i am still talking about avoiding temporary variables
22:45:45 -!- kipple_ has quit (Read error: 131 (Connection reset by peer)).
22:45:45 <calamari> oic
22:45:59 <calamari> so if you had a bf with one cell
22:46:28 <ihope> Every FSA can be implemented using only goto.
22:46:33 <calamari> right
22:46:44 * oerjan bops ihope on the head
22:46:50 <calamari> if and goto
22:46:53 <oerjan> we are discussing _removing_ gotos
22:46:58 -!- kipple_ has joined.
22:47:00 <ihope> Oh.
22:47:44 <calamari> ihope: my idea is to decompose a program into goto's and labels then rebuild it for a target language
22:48:03 -!- kipple_ has quit (Client Quit).
22:48:18 <RodgerTheGreat> intriguing
22:48:41 <RodgerTheGreat> this looks like a job for an esoteric BASIC coder!
22:48:43 <calamari> the first step is to unravel weird goto loops into traditional structured code
22:48:47 <calamari> hehe
22:48:49 * RodgerTheGreat runs for his cape and cowl
22:51:52 <RodgerTheGreat> yeah, I can see how conditional jumps could become tricky to unravel.
22:52:18 <RodgerTheGreat> the tough part is seperating gotos that are branches from gotos that form loops
22:53:03 <oerjan> for one thing, while loops always have just two exits
22:53:20 <oerjan> graphically speaking
22:53:30 <RodgerTheGreat> some loops can be directly unfolded, but others are integral to the functioning of the program- the main loop, at least
22:53:37 <RodgerTheGreat> yeah
22:54:32 <calamari> blah I think I made a mistake in SimonRC's problem above
22:54:49 <calamari> the code duplication doesn't seem to be working for that one
22:54:57 <RodgerTheGreat> hm
22:55:41 <RodgerTheGreat> is the goal to create space-efficient code or speed-efficient code, or either?
22:56:09 <calamari> speed efficient
22:56:14 <RodgerTheGreat> ah
22:56:41 <calamari> ahh got it finally
22:57:13 <calamari> the problem was that I was trying to keep the d-while.. needed to convert it to a plain while
22:57:34 <oerjan> ok based on the limit to two exits for a while loop, here is a test case:
22:57:54 <oerjan> 4 statements, each of which can branch to any of the others
22:58:08 <calamari> cool :) this is helpful stuff
23:00:09 * calamari waits for the code
23:00:28 <oerjan> oh i thought it was obvious what i meant
23:00:35 <calamari> no
23:01:25 <oerjan> 10 MAYBE GOTO 30 OR 40 : 20 MAYBE GOTO 10 OR 40 : 30 MAYBE GOTO 10 OR 20 : 40 GOTO 10, 20 OR 30
23:01:48 <calamari> I don't understand statement 40
23:02:17 <oerjan> ok make that 40 MAYBE GOTO 20 OR 30 : 50 GOTO 10
23:02:24 <calamari> ok
23:02:51 <oerjan> oh and by the way the MAYBE is to mean that one option is not to jump at all
23:03:12 <calamari> ???
23:03:29 <RodgerTheGreat> couldn't each "maybe" be first broken into a pair of "jump or not" instructions?
23:03:43 <calamari> yeah
23:03:46 -!- tgwizard has quit (Remote closed the connection).
23:03:48 <calamari> if I understand
23:03:49 <oerjan> so for each statement, there are 3 possible statements to do next
23:04:01 <calamari> still unrollinging the first problem, it's long hehe
23:04:30 <oerjan> well i am sort of trying to be brief
23:05:17 <calamari> there done finally with the first one
23:05:28 <calamari> shall I write it in code?
23:05:49 <calamari> perhaps abbreviated..
23:06:44 <calamari> A B WHILE C { A B } WHILE D { B WHILE C { A B } }
23:06:54 <calamari> a and b are foo and bar
23:10:35 <RodgerTheGreat> hm. interesting
23:10:43 <calamari> oerjan: check that this is equiv to your code:
23:11:50 <calamari> 10 MAYBE 30 ELSE 15 : 15 MAYBE 40 ELSE 20 : 20 MAYBE 10 ELSE 25 : 25 MAYBE 40 ELSE 30 : 30 MAYBE 10 ELSE 35 : 35 MAYBE 20 ELSE 40 : 40 MAYBE 20 ELSE 45 : 45 MAYBE 30 ELSE 10
23:11:55 <oerjan> btw my code is just a flowchart in the form of the edges of a tetrahedron
23:13:23 <calamari> you can also remove the "else xxx" and add 50 goto 10
23:13:27 <calamari> (as you had)
23:13:49 * calamari draws it
23:14:58 <oerjan> looks fine to me
23:15:38 <oerjan> if that doesn't work then we need an example with real wire crossing
23:16:21 <calamari> if you can find a very simple one that'd be great
23:16:30 <calamari> this is rather long hehe
23:17:43 <oerjan> well the two simplest non-planar graphs are the complete graph on 5 points (i.e. 5 statements all connected) and the 3 + 3 bipartite graph (the famous 3 houses connected to 3 utilities puzzle)
23:18:33 <calamari> so you gave the first ?
23:18:58 <oerjan> no i just gave you 4 points, thought that might still be impossible
23:20:26 <oerjan> i have this feeling this has something to do with the fundamental group of the graphs
23:21:28 <calamari> I still haven't finished drawing the original problem yet hehe
23:22:05 <oerjan> oh, draw a square with one diagonal, and then a curved line between the other two points
23:22:30 <calamari> oic
23:22:44 <calamari> I'm drawing it as a flow chart
23:23:01 -!- Aardwolf has quit ("Ik zen der is mee weg").
23:23:24 <oerjan> i guess you need to duplicate the lines then
23:23:35 <calamari> yeah
23:23:49 <calamari> I can already see a huge mess brewing
23:25:23 <calamari> okay done drawing.. now the part that should be impossible
23:25:30 <oerjan> maybe try just 3 points first, i am not quite sure about that case
23:25:55 <calamari> there is no exit.. interesting :) that's okay I guess
23:26:24 <oerjan> well you can just add a couple if you want :)
23:26:40 <calamari> right.. 50 maybe 10
23:30:21 <ihope> I discovered the two great secrets to writing great fiction.
23:30:27 <ihope> But then I forgot one.
23:31:40 <oerjan> the other one is to have an unfallible memory :)
23:33:33 <ihope> A photographic memory?
23:33:45 <ihope> That'd help, yes.
23:35:06 <lament> i don't need photographic memory.
23:35:09 <lament> i have a camera.
23:35:47 <calamari> what about this much smaller problem: 10 MAYBE GOTO 50 : 20 MAYBE GOTO 50 : 30 FOO : 40 GOTO 10 : 50 BAR
23:36:10 <calamari> that's the break statement
23:37:02 <ihope> Take pictures of your novel and stick them in your ears?
23:37:14 <ihope> That'd probably work, yes.
23:38:50 <ihope> So assuming having a photographic memory is one secret to writing good fiction, the other just might be to describe the world the characters are in.
23:40:12 <calamari> oerjan: I can't remember.. were you disallowing temp variables for the solution?
23:40:24 <oerjan> yes
23:40:32 <calamari> if so, I don't see a way to solve my problem, and it's a subset of yours
23:40:37 <ihope> If you describe the world where it's not actually important that the world be described, the effect is that the world doesn't seem to exist only where it's important to the plot.
23:40:42 <calamari> mine translates to the following code
23:40:52 <calamari> while A { if B { C } }
23:41:16 <calamari> not seeing a way to turn that if into a while without a temp variable
23:41:39 <oerjan> eh, i have certainly not disallowed _if_s
23:41:42 <ihope> If one day somebody visits a store, and you didn't describe the store earlier, it seems like it spawned out of nowhere as soon as the person decided to visit it.
23:42:16 <calamari> oerjan: oh, I thought the point was to only use while loops
23:45:30 <calamari> although, I only need one variable to convert as many nested if's as I want into whiles
23:45:31 <oerjan> well it was you who stated the problem, i just disallowed temporary variables so we couldn't use that giant case statement you said was inefficient
23:45:38 <calamari> right
23:48:09 <oerjan> what kind of language is it you want to translate into by the way?
23:48:43 <calamari> well bf.. but I was hoping this could help for other langs too
23:49:09 <oerjan> ah, then you definitely want to disallow ifs
23:49:44 <calamari> well, like I say above, I can do them with constant memory in bf
23:49:49 <calamari> so I think it's fine
23:51:05 <oerjan> then you could do case statements as well
23:51:15 <calamari> yeah I know
23:51:58 <calamari> I think in the case of your problem, both methods would be about the same speed
23:52:38 <calamari> but in the typical cases, not using case statements in bf would be a win
23:53:46 <oerjan> one idea is to encode the label in binary and use a branching tree for the case statement
23:54:06 <calamari> yeah, we thought of that too :)
23:54:17 <calamari> but didn't implement it
23:54:34 <calamari> instead we decided to trade memory for speed
23:54:52 <calamari> (in the second version of bfbasic labels)
23:55:24 -!- lament has changed nick to Lament.
23:55:42 <calamari> of course one advantage of not using the case statement is I won't have a limit on the number of branch points
23:55:58 -!- Lament has changed nick to lament.
23:56:45 <RodgerTheGreat> hey, how many people have read about this thing before? http://www.retrothing.com/2006/12/the_tinkertoy_c.html
23:57:31 <oerjan> i have
23:58:13 <calamari> cool
23:58:22 <RodgerTheGreat> I found an article explaining how it worked a while back, but it never had any pictures of the device
←2006-12-09 2006-12-10 2006-12-11→ ↑2006 ↑all