←2007-08-09 2007-08-10 2007-08-11→ ↑2007 ↑all
00:18:02 -!- poiuy_qwert has quit (Read error: 110 (Connection timed out)).
00:30:08 <oerjan> :t properFraction
00:38:25 <lament> man, i like haskell, but it tries pretty hard to make me hate it
00:40:27 <bsmntbombdood> heh
00:43:09 <lament> i want to write my program, not implement basic math functions :(
00:44:46 <ihope> Haskell's making you implement basic math functions?
00:44:51 <oerjan> i think modding with doubles is a somewhat imprecise operation
00:49:46 <lament> it won't get any more precise from me implementing it
00:50:49 <ihope> You could import it from a C thing.
00:51:09 <ihope> And then eventually, somebody could extend GHC with it...
00:52:01 <lament> yes, exactly, like i said, i'd rather just write foo % bar like i would in Python.
00:54:44 * ihope nods
00:55:14 <ihope> ~exec sys.stdout([pi % e, pi - e])
00:55:15 <bsmnt_bot> NameError: name 'pi' is not defined
00:55:36 <ihope> Um...
00:57:58 <sp3tt> math.pi
00:58:20 <ihope> ~exec sys.stdout([math.pi % e, math.pi - e])
00:58:21 <bsmnt_bot> NameError: name 'e' is not defined
00:58:24 <sp3tt> ~exec sys.stdout([math.pi % math.exp(1), math.pi - math.exp(1))
00:58:25 <bsmnt_bot> SyntaxError: unexpected EOF while parsing
00:58:31 <sp3tt> ~exec sys.stdout([math.pi % math.exp(1), math.pi - math.exp(1])
00:58:40 <bsmnt_bot> SyntaxError: invalid syntax
00:59:57 <lament> ...
01:00:29 <lament> ~exec sys.stdout((math.pi % math.e, math.pi - math.e))
01:00:29 <bsmnt_bot> (0.42331082513074803, 0.42331082513074803)
01:01:06 <oklokok> lament: are you making fun of the world?
01:01:13 <oklokok> why did i say that?
01:01:31 <oklokok> gotta go -.>
01:02:13 <sp3tt> ~exec sys.stdout(math.exp(math.pi)-math.pi)
01:02:13 <bsmnt_bot> 19.9990999792
01:02:25 <sp3tt> aaaw, your floating point arithmetic is bugged
01:02:38 -!- pikhq has quit (Read error: 110 (Connection timed out)).
01:08:41 <oklopol> like if i'm face to face with someone, which face is mine?
01:08:49 <oklopol> the latter or the former?
01:10:07 <ihope> (|the latter> + |the former>)/sqrt(2)
01:10:27 <ihope> See? I told you WHICH quantum superposition it is.
01:11:17 <oklopol> can i... check the value?
01:11:38 <oklopol> or is it like uncheckalbbebvevr
01:11:44 <ihope> Sure.
01:12:00 <oklopol> i need a transform of some sort or?
01:12:04 <ihope> But it's different every time you say "face to face".
01:12:13 <oklopol> hmm... true
01:12:33 <sp3tt> the face is both yours and not yours at the same time
01:12:35 <ihope> Oh, actually, the + is a - if you're female.
01:12:38 <sp3tt> SCHRDINGER'S FACE
01:12:43 <ihope> sp3tt: exactly what I just said.
01:12:51 <ihope> Apart from the Schroedinger.
01:13:02 <sp3tt> but I can type it with the umlaut!
01:13:05 <oerjan> the word "face" and the word "phase" are originally the same, i think
01:14:28 <oerjan> the latter coming from the "face" of the moon
01:14:51 <oklopol> you just thought that up?
01:14:59 <ihope> Who what?
01:15:05 <oerjan> i vaguely recall it
01:15:25 <oklopol> i wish i vaguely recalled every bit of information that exists
01:15:30 <oklopol> like you do.
01:15:42 <ihope> I vaguely recall that P = NP.
01:15:51 <oklopol> ihope: your mum...
01:15:52 <ihope> I don't remember the details.
01:16:01 <sp3tt> I vaguely recall that the cat is dead.
01:16:19 <ihope> I vaguely recall that that proton is blue right now.
01:16:31 <sp3tt> No, it's ultraviolt
01:16:50 <ihope> That's not a color.
01:16:59 <oklopol> ultraviolent
01:17:07 <sp3tt> THE PROTON DECAPITATES YOU
01:17:07 <ihope> The only colors are red, green and blue.
01:17:17 <ihope> Unless you count antired, antigreen and antiblue.
01:17:25 <sp3tt> that's only one colorspace
01:17:26 <ihope> Those are the colors of antiprotons, among other things.
01:17:39 <oklopol> hmm... should i sleep in my armchair or my bed
01:18:01 <sp3tt> sleep is for the WEAK
01:18:29 <ihope> Sleep gives you special powers.
01:18:37 <oklopol> i can either sleep or stay awake doing nothing.
01:18:48 <ihope> oklopol: go for the special powers.
01:19:05 <oklopol> hmm... does sound intriguing
01:19:08 <sp3tt> eh, irc?
01:19:15 <sp3tt> I need food
01:19:17 <sp3tt> brb
01:19:29 <oklopol> i was, though, actually requesting where i should be doing my sleep
01:19:35 <ihope> Special powers like the ability to avoid sleepiness and the ability to not be bored.
01:19:43 <ihope> And the ability to shoot people ethically and legally.
01:19:50 <oklopol> sp3tt: irc is pretty much nothing
01:20:34 <ihope> Staying awake doing nothing, however, gives one the ability to utilize paper and computers.
01:20:35 <oklopol> boredom doesn't exist
01:20:50 <oklopol> really?
01:20:51 <oklopol> how?
01:21:08 <ihope> Apart from the fact that you have to do something while doing nothing in order to do that.
01:21:23 <ihope> Minor setback.
01:21:38 <oklopol> doing nothing = doing nothing productive
01:21:53 <oklopol> doing nothing i can "show for my day"
01:22:09 <ihope> Well, paper and computers can be non-productive.
01:22:14 <oklopol> really?
01:22:16 <oerjan> hm, my vague recollection is still a bit vague, the terms are apparently from latin and greek respectively, but had the same meaning so i _still_ think they were related
01:22:19 <oklopol> how exactly?
01:23:12 <oklopol> oerjan: where are there vague articles located that you've been memorizing your whole life, btw?
01:23:19 <oklopol> i might enjoy reading them
01:23:39 <oklopol> i shoud start writing vague articles
01:23:49 <oklopol> *should
01:24:27 <oklopol> unless there actually exist ones
01:24:30 <oklopol> i'd read them all.
01:27:48 <oklopol> i might endoy flying to istambul or something
01:27:54 <oklopol> i might get cold though
01:28:09 <oklopol> guess that would depend on how high i'd fly
01:28:21 <oklopol> now "sleep" ->
01:30:03 <oklopol> ihope: you forgot to tell me how to do something unproductive with the computer
01:30:06 <oklopol> (aside irc)
01:30:21 <ihope> Study... er, wait.
01:30:25 <ihope> Play games!
01:30:40 <oklopol> hmm
01:30:47 <ihope> Or study pointless things!
01:30:54 <ihope> Things that have been proven pointless!
01:31:00 <oklopol> anything i get better at is productive.
01:31:44 <ihope> Not if they don't produce!
01:31:53 <oklopol> hmm... well, okay, since that is actually quite exactly the definition i use, it's pretty easy coming up with non productive stuff
01:31:56 <ihope> Study something that mathematicians already know everything about!
01:32:10 <oklopol> improving my brain is productive.
01:32:32 <oklopol> since it's pretty much all that exists from my point of view.
01:34:19 <ihope> I guess you'll have to do something destructive, then.
01:34:41 <ihope> You can fail to revert vandalism on a wiki!
01:35:00 <oklopol> i could, in theory, just like throw dice all night... the only problem is i'd remember that and list it as the cool feat "throwing dice for 10 hours in a row"
01:37:43 <Sukoshi> Python fits my brain :)
01:37:52 <Sukoshi> And with that, I go to do me daily Japanese work.
01:39:42 <oklopol> and i go to sleep
01:39:46 <oklopol> reaaaally ->
01:44:52 * sp3tt goes to sleep
02:07:00 -!- meatmanek has left (?).
02:18:32 <ihope> Now, are there any optimizing Unlambda compilers/interpreters out there? >:-)
02:27:14 <oerjan> there is a guy in #haskell writing a compiler, i don't know how optimised it will be
02:28:40 <oerjan> also mandelson's interpreter is supposedly much faster than others, although i (vaguely :) ) recall it has some incompatibilities
02:30:09 <oerjan> *is = was, hard to say if it still is fastest when the unlambda homepage hasn't been updated in years
02:42:51 <ihope> Incompatibilities...
02:43:23 <oerjan> i again vaguely recall the d function didn't quite follow the spec, or something like that
02:43:58 <oerjan> possibly he memoized it, or something like that
02:44:34 <oerjan> anyway some program broke when i tested it (my interpreter? i don't recall)
02:59:15 -!- GregorR has quit (Remote closed the connection).
02:59:45 -!- oerjan has quit ("Good night").
03:00:18 -!- GregorR has joined.
03:12:27 -!- cherez has joined.
03:14:36 <GregorR> THE CHALLENGE: Create a joke with the punchline "Baroque Obama"
03:15:03 <Sukoshi> YOUR MOM is BAROQUE OBAMA.
03:18:05 <GregorR> 8-O
03:18:09 <GregorR> It's TRUE
03:31:10 -!- ihope has quit (Read error: 110 (Connection timed out)).
04:11:41 -!- puzzlet_ has joined.
04:11:41 -!- puzzlet has quit (Remote closed the connection).
04:26:02 -!- Sgeo has quit ("Ex-Chat").
04:38:19 -!- GreaseMonkey has joined.
05:54:18 -!- poiuy_qwert has joined.
05:57:19 -!- jix has quit (Nick collision from services.).
05:57:33 -!- jix has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:03:37 -!- olsner has joined.
08:09:50 -!- cherez has quit ("Leaving.").
08:46:29 -!- poiuy_qwert has quit.
10:22:32 -!- jix has quit ("CommandQ").
10:26:04 <GreaseMonkey> night all
10:26:52 -!- GreaseMonkey has quit ("Remember kids, be careful with explosives, they might be interesting!").
10:28:27 -!- asiekierka has joined.
10:28:33 <asiekierka> My friend did something for me!
10:28:39 <asiekierka> a BF loader that fits in a bootsector!
10:28:57 <asiekierka> interperter is NASM 155 bytes (binary compiled)
10:29:09 <asiekierka> whole thing 194 bytes
10:29:31 <asiekierka> 510 - 194 = approx. space for BF code :)
10:29:39 <asiekierka> cool?
10:29:50 <Sukoshi> AWESOME!
10:30:09 <Sukoshi> I don't know enough about bootcodes, but I wanna read the ASM :)
10:30:34 <asiekierka> ok
10:30:36 <asiekierka> wait
10:30:48 <asiekierka> stdin - keyboard
10:30:55 <asiekierka> BF code is compiled in the binary :D
10:31:15 <Sukoshi> :)
10:31:28 <asiekierka> my friend did it
10:31:29 <asiekierka> not me
10:31:30 <asiekierka> but wait
10:31:36 <asiekierka> i'll try to compile it and test 1st
10:33:07 -!- Darktemplar has joined.
10:33:22 <asiekierka> it's my polish friend
10:33:22 <asiekierka> he did it
10:33:25 <asiekierka> CONGRATS!
10:33:35 <Darktemplar> heh
10:34:11 <asiekierka> Waiting for JumpF**k, keyboard BF code typing and RAW BF store (to make max size up to 1,4MB)
10:34:20 <asiekierka> i'd like to first see the first two
10:34:25 <asiekierka> then a option to add the third :)
10:35:00 <asiekierka> okay
10:35:03 <asiekierka> i'll put the code
10:36:10 <Darktemplar> if I make a BF-CommandLineInterface that's gonna be dead :)
10:36:24 <asiekierka> why?
10:36:57 <Darktemplar> I don't think I'd fit it in bootloader still
10:37:05 <Darktemplar> perhaps I can fit the CLI, but FS support...
10:37:11 <asiekierka> it's unneeded
10:37:17 <asiekierka> you'll make FS support (RAW)
10:37:17 <Darktemplar> okay..
10:37:22 <Sukoshi> Heya.
10:37:23 <asiekierka> then you will put rest of code in RAW
10:37:27 <Sukoshi> Awesome stuffs my friend.
10:37:32 <asiekierka> AND the BF codefiles in raw
10:37:38 <Darktemplar> sure...
10:37:43 <asiekierka> ok
10:37:50 <asiekierka> sending the code with ,[.,] and binaries
10:37:52 <asiekierka> but first testing
10:38:07 <Darktemplar> I haven't tested it with multiple loops
10:38:19 <Darktemplar> but frequent stack operating around'em should do
10:38:26 <asiekierka> i'll test
10:38:48 <Darktemplar> <let me make the CLI then>
10:39:06 <asiekierka> okay
10:39:13 <asiekierka> then try and do JumpF**k ok?
10:39:31 <asiekierka> if you want
10:40:57 <Sukoshi> You can do what Forth does, blocks for the FS.
10:42:08 <Darktemplar> you mean like filename:SECTOR3-6?
10:42:38 <Sukoshi> Each block is a fixed size.
10:43:11 <Sukoshi> So block 21 is just data at address (21 * block-size) + block-offset.
10:44:16 <asiekierka> But look, we want to sometimes store multiple files - oh wait, this can be done with SysLinux+MemDisk+GZip combo :)
10:44:41 <Darktemplar> you mean RAW is no fun <cries>?
10:44:51 <Darktemplar> multiple files in RAW is perfectly OK
10:45:36 <Sukoshi> Well, I guess.
10:45:52 <Darktemplar> 512 bytes per block
10:46:03 <asiekierka> oh
10:46:11 <Darktemplar> LBA->CHS is about 25-30 bytes
10:46:24 <asiekierka> we need also like a file:
10:46:41 <Darktemplar> blah
10:46:47 <asiekierka> that stores filename you want (8.0 :D) and amount of blocks it takes
10:46:58 <asiekierka> or 5.0 for that matter
10:46:59 <Darktemplar> it is easier for me to parse hex than dec
10:47:04 <asiekierka> so use hex
10:50:19 -!- ehird` has joined.
10:50:31 <asiekierka> hi!
10:50:41 <asiekierka> My friend did a BF reader in a bootsector!
10:50:49 <asiekierka> with 300-400 bytes left for code
10:50:51 <asiekierka> he is here
10:50:53 <asiekierka> Darktemplar.
10:51:19 <ehird`> ummm so what
10:51:26 <ehird`> of course you can fit BF into a bootsector
10:51:29 <ehird`> BF is friggin tiny
10:51:40 <asiekierka> but he will add many stuff to it
10:51:45 <ehird`> then it isn't BF any more
10:51:48 <asiekierka> and it's smaller than AmigaOS interperter
10:51:54 <asiekierka> he will add not stuff to language
10:51:54 <Darktemplar> many stuff
10:51:59 <Darktemplar> like a CLI
10:52:01 <Darktemplar> :D
10:52:03 <asiekierka> (except JumpF**k of course :D)
10:52:12 <asiekierka> and a command right?
10:52:15 <asiekierka> to read from files
10:52:23 <asiekierka> @(filename.txt) i mean
10:52:23 <Darktemplar> but kinda debug-like one
10:52:48 <ehird`> why is jumpfuck "of course"?
10:52:53 <ehird`> i wrote jumpfuck mainly for compiler writers
10:52:59 <asiekierka> ... oh. But i wi---
10:53:03 <asiekierka> YOU WROTE IT?
10:53:16 <ehird`> this jump fuck? http://esolangs.org/wiki/JumpFuck
10:53:18 <ehird`> if so, yes
10:53:21 <asiekierka> yes
10:53:45 <asiekierka> i wanted to add just the commands
10:53:48 <asiekierka> the 2 jump commands
10:53:49 <Darktemplar> adding jumpfuck shouldn't be hard..
10:53:59 <asiekierka> and one my command (if you implement RAW, it shouldn't be hard)
10:54:06 <Darktemplar> another segment register, like FS... yet limiting that stuff to run on 286+
10:54:24 <ehird`> how do people suggest i make this TC? http://pastie.caboo.se/86457 i was thinking maybe a "computed ld/st" which takes its address from a register as well
10:54:40 <ehird`> but i'm not sure which opcodes i'd remove to do it
10:55:11 <asiekierka> and my command... @, Read (actual cell) char from (cell after actual) block to (cell before actual)
10:55:52 <Darktemplar> ehird, ur making a binary EL?
10:55:58 <asiekierka> or it may use @(200|3) that will read 200th char from 3rd block (512 bytes/block right?) and save it to actual cell :)
10:56:03 <asiekierka> it's better for me
10:56:12 <ehird`> Darktemplar: binary what?
10:56:18 <Darktemplar> esoteric language
10:56:22 <ehird`> Darktemplar: yes. that's a spec for a computer architechture
10:56:35 <ehird`> but it isn't really meant to be mainly esoteric
10:56:36 <asiekierka> but look, ehird, you'll have first JumpF**k implementation :D
10:56:37 <ehird`> more an experiment
10:56:41 <ehird`> asiekierka: true :)
10:57:04 <ehird`> i'm just trying to get an assembly language with the smallest instructions i can while still being relatively easy to use
10:57:10 <asiekierka> If you'll make the new architecture, try and port Darktemplar's bootloader to it
10:57:24 <Darktemplar> ehird->make it objective-enforcing :D
10:57:44 <Darktemplar> something like a weird minimized Java
10:57:50 <ehird`> no way
10:57:56 <Darktemplar> why <cries>
10:58:03 <asiekierka> and ehird`: Do you have any command ideas?
10:58:04 <ehird`> this is meant to be machine code that could feasably be put on a machine
10:58:13 <ehird`> except for a really simple computer where size of code is everythign :)
10:58:18 <ehird`> asiekierka: nope
10:58:18 <asiekierka> since we have 3 more commands to BF, making it total of 11 commands
10:58:20 <asiekierka> too bad
10:58:27 <ehird`> maybe BF machine's IO commands?
10:58:30 <ehird`> then you could do graphics :p
10:58:56 <Darktemplar> cool
10:59:07 <Darktemplar> 1111 -> couldn't you make it SwitchToWeirdMode :?
10:59:19 <ehird`> Darktemplar: you need nop :)
10:59:26 <ehird`> what is weird mode anyway
10:59:43 <Darktemplar> theory...
10:59:46 <Darktemplar> or a joke
11:00:09 <asiekierka> you could (but not need to) make a command like S(125) that will set current cell to 125
11:00:17 <asiekierka> will save up to 20 lines!
11:00:23 <asiekierka> i recommend it
11:00:36 <asiekierka> or make it Add Number
11:00:41 <Darktemplar> like ! - read from port no. current cell and save it in n+1 cell
11:00:42 <asiekierka> so it adds 125 to current cell
11:00:52 <Darktemplar> or direct memory access :D
11:00:58 <asiekierka> OH! You may add it
11:01:13 <Darktemplar> yeah. Let's come up with another EL
11:01:31 <asiekierka> it will be called "EsoOoS"
11:01:35 <Darktemplar> like ADD = CreateCommand("Add.Command","+",NOTPRIVILENGED);
11:01:40 <asiekierka> nope
11:01:46 -!- sekhmet has quit (heinlein.freenode.net irc.freenode.net).
11:01:48 <asiekierka> i'll make list of added commands
11:01:54 <Darktemplar> but that would be kinda freaky
11:01:56 <Darktemplar> ok
11:02:05 <Darktemplar> but asie, decide which cell size to use
11:02:06 -!- sekhmet has joined.
11:02:12 <Darktemplar> it's no problem for me to switch to words
11:02:26 <ehird`> gwar, why are there no decent binary editors
11:02:36 <Darktemplar> because you can't sell them
11:02:43 <ehird`> :p
11:03:15 <ehird`> hmm found one
11:03:19 <Darktemplar> OK. Got to go. Some work awaits..
11:03:20 <Darktemplar> bye
11:03:21 -!- Darktemplar has left (?).
11:06:40 <ehird`> hehe, tiny infinite loop:
11:06:45 <ehird`> "à."
11:06:49 <ehird`> without quotes
11:06:55 <asiekierka> why?
11:06:59 <asiekierka> what does
11:07:01 <ehird`> of course that's just the machine code i need headers
11:07:11 <ehird`> asiekierka: that is "111000000000"
11:07:25 <ehird`> look at the spec i posted to see why that loops
11:08:08 <asiekierka> i see
11:08:16 <ehird`> 1110 CCCCCCC Jump to C.
11:08:31 <ehird`> and at position 00000000, we have "111000000000"
11:08:40 <ehird`> which jumps to 00000000...
11:09:21 <ehird`> in reality, the shortest infinite loop will be a bit longer
11:09:33 <ehird`> you have to specify how long the code is (so the machine knows where the data section starts)
11:09:38 <ehird`> and that takes 32 bits
11:09:43 <ehird`> i might reduce it to 16.
11:10:56 <asiekierka> i may send you the code
11:11:04 <asiekierka> to Darktemplar's interpreter
11:11:08 <asiekierka> if you want
11:12:12 <ehird`> so the shortest infinite loop is that code i posted
11:12:17 <ehird`> but the shortest infinite loop wrapped in a binary
11:12:32 <ehird`> is "...à."
11:12:56 <ehird`> aka "00000000000000000000000000001100111000000000"
11:13:24 <ehird`> aah, damnit my instruction set has no "halt"
11:13:53 <ehird`> somebody tell me what insutrctions they don't think would get much use in http://pastie.caboo.se/86457 :p
11:15:15 <asiekierka> 1111 :D
11:16:15 <ehird`> have you EVER coded low-level asm?
11:16:21 <ehird`> do you seriously think NOP is useless?
11:17:32 <asiekierka> no
11:17:38 <asiekierka> and maybe
11:17:48 <ehird`> http://en.wikipedia.org/wiki/NOP
11:17:56 <ehird`> there are quite a few examples of good use there
11:22:25 <ehird`> I guess for NOP you could do
11:22:35 <ehird`> AD A B
11:22:37 <ehird`> err
11:22:44 <ehird`> wait you couldn't do that
11:22:46 <ehird`> MV A A then
11:22:58 <ehird`> so 1111 is halt...
11:24:35 <ehird`> ok here's the newest spec: http://pastie.caboo.se/86570
11:24:46 <ehird`> if someone comes up with a nice way to make it TC :)
11:31:41 <asiekierka> ehird`: Could you help me?
11:31:46 <asiekierka> the Darktemplar code fails
11:31:48 <asiekierka> oh wait
11:37:17 <asiekierka> I'll go on and learn ASM later
11:40:10 <ehird`> how much chuck would a chuck wood wood if a chuck wood could wood chuck?
11:43:39 <oklokok> mrning
11:45:58 <ehird`> morning
11:48:51 <ehird`> got any ideas for how i can make http://pastie.caboo.se/86570 turing complete? :)
11:51:24 <oklokok> wait
11:52:56 <oklokok> make 1st bit of each memory slot be a swith that expands that memory slot to be as bit as the whole memory
11:53:02 <oklokok> and... there.
11:53:15 <oklokok> you have to have some infinity there
11:54:31 <asiekierka> how to make a newline in low-level ASM (i'm learning it)
11:54:34 <asiekierka> without a OS
11:54:40 <asiekierka> i.e. booted from a bootsecotr
11:54:43 <asiekierka> bootsector*
11:55:31 <asiekierka> is it 13 and 10?
11:55:31 <asiekierka> or 10?
11:55:33 <asiekierka> or what?
11:56:23 <asiekierka> ehird`!
11:56:27 <asiekierka> oklokok!
11:56:28 <asiekierka> do you know?
11:57:07 <oklokok> hmm
11:57:32 <oklokok> 0D0A in windows, 0A in unix, 0D in mac iirc
11:57:34 <oklokok> i have no idea.
11:57:46 <asiekierka> ???? in BIOS
11:57:54 <oklokok> i have no idea.
11:57:55 <oklokok> :P
11:59:21 <asiekierka> i think 0D0A
11:59:23 <asiekierka> but not sure
12:00:26 <oklokok> you can put that to be sure
12:00:49 <asiekierka> not now
12:01:07 <asiekierka> wait
12:01:13 <asiekierka> i'll probably be back in 10-15 mins
12:01:25 <ehird`> iback
12:01:29 <ehird`> i'm back
12:01:34 <ehird`> anyway
12:01:36 <ehird`> all i really need
12:01:41 <ehird`> is some way to access memory relative to some other location
12:01:48 <ehird`> right now you can only specify an absolute
12:02:05 <ehird`> however i need to keep the instruction set at its current size
12:02:19 <asiekierka> gotta go
12:02:31 -!- asiekierka has quit.
12:03:15 <oklokok> just make a relative jump
12:03:22 <oklokok> that'd make it tc as well
12:03:38 <oklokok> i just like nestable memory slots better :
12:03:40 <oklokok> :P
12:05:32 <ehird`> how would a relative jump make it tc
12:05:38 <ehird`> you still can't access infinite memory
12:05:58 <oklokok> i mean
12:06:05 <oklokok> a relative jump in memory
12:06:14 <oklokok> so that memory slot 0000 moves
12:06:17 <oklokok> back and forth
12:06:26 <oklokok> tc via trivial isomorphism to bf
12:06:47 <ehird`> oh
12:06:54 <ehird`> well it's not really typical then
12:07:00 <ehird`> right now it looks quite a lot like some other simple machine codes
12:07:05 <ehird`> that would make it.. less so
12:07:23 <oklokok> you can also do like 0000-7FFF always program spesific, and 8000-ffff move if relative jump used
12:07:42 <oklokok> and 8000-FFFF would have "infinite" memory for each program
12:07:50 <oklokok> or smth
12:08:17 <oklokok> millions of ways to do ittidy
12:08:25 <ehird`> i mean
12:08:32 <ehird`> i want it something like most machine codes
12:08:36 <ehird`> they don't use weird hacks like that
12:08:42 <ehird`> they're just... tc in a normal way
12:09:05 <oklokok> okay, then you will have to leave out the "every memory slot is n bits and every address is m bits" attitude.
12:09:32 <oklokok> it will then *look* more like asm in instruction descriptions, but it will inherently be less asm
12:09:48 <oklokok> have you checked an "asm" for a highlevel language?
12:09:57 <oklokok> like python bytecode or jvm
12:09:57 <ehird`> inherently less asm = :(
12:10:02 <ehird`> and yes
12:10:10 <ehird`> besides
12:10:16 <ehird`> i need that attitude
12:10:24 <ehird`> otherwise code can't be portable across amount of memory
12:10:26 <oklokok> i haven't looked at jvm tbh, but that isn't actually that high-level of course
12:10:30 <oklokok> huh
12:10:33 <oklokok> whut
12:10:38 <oklokok> yeah
12:10:42 <oklokok> so... my idea.
12:10:47 <oklokok> mem jump
12:10:53 <oklokok> hmm
12:11:05 <oklokok> you could have a way to jump to next "page"
12:11:09 <oklokok> and back again
12:11:15 <ehird`> but i have never seen machine code with "mem jump"
12:11:16 <ehird`> :)
12:11:17 <oklokok> that'd make it tc as well, but it'd be cleaner
12:11:23 <ehird`> how DOES most machine code do it anyway?
12:11:31 <ehird`> to handle calculated memory positions?
12:11:32 <oklokok> do... what?
12:11:35 <ehird`> instead of just immediate values?
12:11:43 <oklokok> it's called addition
12:11:53 <ehird`> sure
12:11:57 <ehird`> do they have a computed store or something
12:11:58 <ehird`> like
12:12:23 <ehird`> cld r1 r2 - "access the memory whose position is in r1 and store it in r2"
12:12:42 <ehird`> as well as ld r1 addr - "access the memory at addr and store it in r1"?
12:12:48 <ehird`> or something like that?
12:13:41 <oklokok> usually asm has something like thta
12:13:43 <oklokok> *hathtat
12:13:56 <ehird`> i see, that makes sense
12:14:02 <oklokok> you have that too
12:14:05 <ehird`> no i do not
12:14:10 <ehird`> I have ld, but not cld
12:14:19 <ehird`> cld would make it turing complete
12:14:27 <ehird`> but i can't add any instructions
12:14:30 <ehird`> i've reached my limit
12:14:32 <oklokok> then i have misunderstood you... wait a bit
12:14:38 <ehird`> so i need to remove 2 instructions that won't be used much
12:14:40 <ehird`> pick two? :)
12:15:34 <oklokok> nop can be hacked in using the others... same goes for many of the calculations, but it might be ugly if you'd just have a random subset of the logicals
12:15:53 <oklokok> (ehird`) cld r1 r2 - "access the memory whose position is in r1 and store it in r2"
12:15:57 <oklokok> why does this make it tc?
12:16:04 <oklokok> and how is that different from ld?
12:16:38 <oklokok> "access the memory whose position is in r1" != "access the memory at addr" ?
12:18:32 <ehird`> brb
12:19:07 <ehird`> and
12:19:10 <ehird`> it makes it turing complete because
12:19:13 <ehird`> r1 is a register
12:19:33 <ehird`> Ah, wait, I'm going to tweak the code a bit
12:19:59 <oklokok> are registers infinite?
12:20:03 <oklokok> bignumzz
12:20:55 <ehird`> ok:
12:20:56 <ehird`> http://pastie.caboo.se/86579
12:20:57 <oklokok> i'm sorry, but i don't see the tucrity.
12:21:13 <ehird`> everything but the first two AAAAAAAAs are register ids
12:21:26 <oklokok> that pastie hates me a lot
12:21:37 <ehird`> now, if i had a version of the first two instructions which instead of the immediate AAAAAAAA took a register AAA, you could do computed memory access
12:21:45 <ehird`> only problem is, i'm out of instructions...
12:21:55 <ehird`> so what two instructions can i get rid of without too much effect?
12:24:28 <oklokok> whell, s/xor and or not/nand nor ;)
12:24:57 <ehird`> i don't want to get rid of not
12:25:07 <ehird`> or xor
12:25:12 <ehird`> or or, or and
12:25:20 <ehird`> those are pretty much essential for non-hellish programming
12:27:50 <oklokok> memory management, arithmetic, binary logic, conditional jump, unconditional jump, halt... you pretty much need those if you don't want to do anything far-fetched
12:28:04 <ehird`> exactly
12:28:09 <ehird`> but i need two mor memory management instructions
12:28:34 <oklokok> hmm, can you please try to explain how those are different from the ones you have now?
12:29:02 <ehird`> honestly i have no idea how you are having trouble with it
12:29:04 <ehird`> http://pastie.caboo.se/86579
12:29:10 <ehird`> 0000 AAAAAAAA BBB and 0001 AAAAAAAA BBB
12:29:19 <ehird`> AAAAAAAA is an immediate value. in the binary file
12:29:21 <ehird`> HOWEVER
12:29:34 <ehird`> EVERY other single argument for EVERY instruction apart from those two AAAAAAAAs, is a register ID
12:29:39 <oklokok> ah well, you can just replace those
12:29:46 <ehird`> SO
12:29:47 <ehird`> I need
12:29:52 <ehird`> a computed st/load
12:30:00 <ehird`> with AAA BBB arguments, which take the address from the register
12:30:01 <ehird`> you see?
12:30:17 <ehird`> HOWEVER i can't just replace those two
12:30:18 <oklokok> yes yes
12:30:25 <ehird`> as they supply the >only way to get values from memory<
12:30:33 <oklokok> really?
12:30:34 <ehird`> since, of course, you have to get something into the registers in the first place
12:30:36 <ehird`> before you can add to them
12:30:38 <ehird`> to use them as addresses
12:30:41 <ehird`> think about it
12:30:49 <ehird`> if everything is indirect to register values, and every register starts at zero
12:30:52 <ehird`> how do you get a value into a register?
12:31:07 <ehird`> so, i need those normal ST/LD
12:31:09 <oklokok> ah ture, but i'd prefer a way to set a value to a register over those .P
12:31:10 <oklokok> :P
12:31:12 <ehird`> but i also, for turing completeness, need a computed ST/LD
12:31:19 <ehird`> so, i need to replace two instructions
12:31:47 <oklokok> but i can tell you that will not make it tc
12:32:43 <ehird`> it >will<
12:32:54 <ehird`> well, maybe not completely TC
12:33:01 <ehird`> because of the size of the values
12:33:03 <ehird`> BUT
12:33:12 <ehird`> "turing complete" for all practical purposes
12:33:21 <oklokok> oh, if that's all you want, then it already is tc
12:33:24 <ehird`> as in you can write real useful programs in it
12:33:25 <ehird`> and no
12:33:34 <oklokok> except for that stuff you haven't gotten in yet
12:33:37 <ehird`> because accessing relative memory positions and other pointer arithmetic is pretty much mandatory
12:34:02 <ehird`> Hmm - what is the bitshifts in most programming languages? Arithmetic shift or logic shift
12:34:14 <oklokok> i do know that, but as i said, you can just replace those first two with cld and ld and have a way to set a register to a valua
12:34:16 <oklokok> *value
12:34:27 <oklokok> what do you mean?
12:34:35 <ehird`> what do you mean what do i mean
12:34:49 <oklokok> arithmetic shift == takes sign into account
12:34:49 <oklokok> ?
12:35:12 <ehird`> http://en.wikipedia.org/wiki/Logical_shift
12:35:18 <ehird`> http://en.wikipedia.org/wiki/Arithmetic_shift
12:35:18 <oklokok> you usually have two shifts in an asm, since asms are rarely typed
12:35:19 <oklokok> hmm
12:35:23 <oklokok> i'll check those out...
12:35:28 <ehird`> ok, well which one should i implement ;)
12:35:54 <ehird`> aha
12:35:59 <ehird`> i don't actually need bit shifts!
12:36:06 <oklokok> why?
12:36:10 <ehird`> >> N == / (2 ** N)
12:36:20 <ehird`> << N == * (2 ** N)
12:36:36 <oklokok> ...orly
12:36:40 <ehird`> yarly
12:36:45 <ehird`> and i have the irb session logs to prove it!
12:37:33 <oklokok> that is kinda given
12:37:56 <oklokok> that is a way to get a round the need for two different shifts, yes.
12:38:12 <oklokok> if you have multiplication always be signed
12:38:28 <oklokok> usually, you also have two multiplication instructions & division instructions
12:38:35 <oklokok> for signed / unsigned
12:38:53 <ehird`> everything is unsigned in this
12:38:55 <oklokok> so you may want to have everything just unsigned and let ppl get around that on their own
12:38:57 <oklokok> yes
12:39:08 <ehird`> hmm
12:39:14 <oklokok> that was my way to say you should naturally have logical shifts
12:39:16 <ehird`> i don't have an exponential oprator though
12:39:22 <oklokok> ...orly
12:39:29 <ehird`> so the 2 ** N bit might be... annoying to do
12:39:46 <oklokok> that really isn't the easiest way to use one of those operators to emulate another...
12:40:10 <ehird`> i guess though that people would just work out 2 ** N beforehand
12:41:52 <oklokok> >> and << are effectively quick 2**n div/mul... so it's pretty obvious they aren't exactly *needed*
12:42:12 <oklokok> *quick div/mul by 2**n
12:43:18 <ehird`> ok i've got a new spec
12:43:24 <ehird`> i'll just put it up now
12:43:59 <ehird`> http://pastie.caboo.se/86585
12:44:12 <ehird`> waitaminute
12:44:18 <ehird`> the first integer doesn't have to be 32-bit...
12:44:21 <ehird`> addresses only go up to 8 bits
12:44:35 <ehird`> wait... that means code will have to be hideously small
12:45:06 <ehird`> :s 255 bits max
12:45:09 <ehird`> err, wait, no
12:45:25 <ehird`> ~65536 bits max :p
12:45:29 <ehird`> that's rather less worrying, hehe
12:47:11 <ehird`> http://pastie.caboo.se/86585 there we go
12:47:26 <ehird`> a turing complete, slightly usable machine architechture
12:47:37 <ehird`> with tiny, tiny, tiny instruction size
12:48:05 <ehird`> now i'll design an asm spec for it!
12:49:02 <oklokok> speccidy spaccidy
12:50:32 <ehird`> of course it doesn't have IO...
12:50:37 <ehird`> what do you think i should do to rectify that?
12:50:42 <ehird`> replace two more instructions? :S
12:51:02 <oklokok> you could do the INT instrcution
12:51:05 <oklokok> *instrcution
12:51:07 <oklokok> *instruction
12:51:16 <ehird`> interrupts are evul
12:51:36 <oklokok> well yes, but they're nice if you want small instruction size
12:51:46 <oklokok> though... might be a bit cheatish
12:52:31 <ehird`> yes
12:52:38 <ehird`> i think i'll find two more instructions i can remove
12:52:54 <ehird`> and add in and out, both taking AAA BBB
12:53:09 <oklokok> well, arithmetic is used a lot more than binary stuff, and the jump/memory stuff has to be there for it to be an actual programming language
12:53:15 <ehird`> A is the register which contains the port, B is the register which contains what to send
12:53:21 <ehird`> and i'll define some standard ports
12:53:25 <ehird`> and
12:53:26 <oklokok> so... i'd say NAND! :P
12:53:28 <ehird`> in will take
12:53:33 <ehird`> AAA BBB
12:53:36 <ehird`> actually
12:53:38 <ehird`> in will just take AAA
12:53:47 <ehird`> A contains the port, A gets replaced with the read value
12:53:56 <ehird`> And, um, I don't have NAND.
12:54:02 <ehird`> read the spec :)
12:54:38 <oklokok> or you could just have 4 ports and have the first bit indicate whether it's an output or an input port
12:54:42 <oklokok> hmm... might be a bit ugly
12:54:44 <oklokok> ah
12:54:54 <oklokok> sorry, you're using the register value as the port of course
12:55:02 <ehird`> yeah that's just a sneaky way to add another instructiosn :p
12:55:06 <oklokok> so you'd still have like a million ports
12:55:12 <ehird`> no
12:55:14 <ehird`> values are 8 bits
12:55:17 <ehird`> 256 ports :)
12:55:25 <oklokok> ehird`: i meant i'd say "do the nand"
12:55:29 <oklokok> do the do the nand
12:55:35 <ehird`> whut
12:55:42 <oklokok> i mean
12:55:49 <oklokok> s/xor and or not/nand
12:55:55 <ehird`> that makes no sense
12:55:57 <ehird`> do you mean
12:55:59 <ehird`> get rid of not and and
12:56:03 <ehird`> and replace them with nand?
12:56:06 <oklokok> yes
12:56:10 <ehird`> then not is nand a a?
12:56:12 <oklokok> and also remove or and xor
12:56:16 <ehird`> no
12:56:19 <ehird`> i don't like those
12:56:24 <ehird`> this is meant to be relatively easy
12:56:31 <ehird`> removing all those logic operations just makes it a turing tarpit
12:56:38 <oklokok> yeah... but you don't need binary stuff for most things
12:56:48 <ehird`> its meant to be a turing tarpit in internals, but externally it should be just about normal :)
12:58:13 <ehird`> but, glargh
12:58:16 <ehird`> there appears to be nothing i can remove
12:58:24 <ehird`> 16 instructions are not enough :(
12:58:50 <oklokok> you can remove the first two and add a "set"
12:58:59 <ehird`> ?
12:58:59 <oklokok> and you have one spot open
12:59:03 <ehird`> i don't get it
12:59:12 <oklokok> set REG VALVALUE
12:59:26 <ehird`> no
12:59:29 <ehird`> VALUE = bad
12:59:32 <ehird`> ADDRESS = good
13:00:21 <oklokok> if you can set register values, you can do stuff like incrementation without having a memory cell that has the number "1" in it...
13:00:38 <oklokok> now you'd have to have a memory slot where you have the number "1" to be able to increment
13:00:52 <ehird`> yeah
13:00:53 <ehird`> that's simpler
13:00:57 <ehird`> so i like my way
13:01:11 <oklokok> so... "set" would make the first two unnecessary, make a lot of calculation easier and also make it more pure
13:01:28 <oklokok> because now you have really duplicate instructions
13:02:05 <oklokok> the first two and the ones where memory location is looked up from a register are pretty much the same, the first ones are just the unpure version of the latter
13:02:36 <oklokok> (purity == the nice INSTRUCTION AAA BBB pattern)
13:02:37 <ehird`> okay i guess
13:02:45 <oklokok> (then SET would be the only exception)
13:03:06 <oklokok> i'm feeling foodneedish
13:03:21 <ehird`> hmm
13:03:23 <ehird`> i don't like your idea
13:03:28 <oklokok> oh
13:03:28 <ehird`> because it makes setting memory locations harder
13:03:29 <oklokok> why ?
13:03:32 <oklokok> oh
13:03:35 <ehird`> you need a SET and then a STORE
13:03:39 <ehird`> well
13:03:41 <ehird`> you need:
13:03:43 <ehird`> SET, CSTORE
13:03:45 <ehird`> instead of just
13:03:46 <ehird`> STORE
13:04:21 <oklokok> haha
13:04:28 <ehird`> what :(
13:04:43 <oklokok> then why not make another set of arithmetic instrcutions as well that take memory slots as params?
13:05:01 <ehird`> well because i'm keeping it at 16 instructions :p
13:05:02 <oklokok> so you don't have to LOAD ADD STORE, but just ADD
13:05:13 <oklokok> i'm just saying my way is superior!
13:05:17 <oklokok> super ber
13:05:18 <ehird`> okay, fine
13:05:23 <oklokok> :P
13:05:43 <oklokok> i'm really gonna go eat now
13:05:47 <oklokok> hf with your asm
13:06:00 <oklokok> i wish i was doing something... doing stuff is so much fun :<
13:06:04 <oklokok> but i ain't
13:06:09 <ehird`> okay:
13:06:13 <oklokok> because i'm reading swedish vicabulary.
13:06:14 <ehird`> http://pastie.caboo.se/86585
13:06:16 <oklokok> *vocabulary
13:06:19 <ehird`> i need to free up one more instruction
13:07:17 <oklokok> hmm
13:07:46 <oklokok> usually you *have* a condition for a jump and any 1100 AAA AAA CCC equals 1101 CCC
13:07:51 <oklokok> if you see what i mean
13:08:21 <oklokok> (two reasons to remove 1101 that way)
13:08:27 <oklokok> s/way/was
13:08:27 <ehird`> ok
13:08:37 <oklokok> also 1111 == nop?
13:08:47 <oklokok> or is that like implicit?
13:08:59 <ehird`> 1111 is where i'm going to put the last added instruction
13:09:02 <ehird`> so "jump" is normally just asm sugar?
13:09:22 <oklokok> hmm... x86 has like 15 jumps...
13:09:35 <ehird`> i'm just thinking that, jumps are really really common
13:09:42 <ehird`> and, if it has to compare something every time..
13:10:04 -!- olsner has quit.
13:10:52 <oklokok> true
13:11:03 <oklokok> if you don't wanna do any preprocessing for the code that is
13:11:10 <oklokok> (trivial optimization...)
13:11:43 <oklokok> (err... not really)
13:12:08 <ehird`> well yeah it is trivial
13:12:18 <ehird`> but
13:12:19 <ehird`> it's fake
13:12:24 <ehird`> since it'll use another instruction internally
13:13:40 <oklokok> hmm...
13:14:41 <oklokok> you could make a halt address.
13:14:44 <oklokok> 11111111
13:15:03 <oklokok> SET 000 11111111 JUMP 000
13:15:26 <ehird`> yeah but, that's quite a lot of work to halt
13:15:28 <oklokok> that'd be like fast-forwarding to the end of the code
13:15:30 <ehird`> and halting is very common
13:15:44 <ehird`> anywa
13:15:49 <ehird`> it's feasable that some code would be that long
13:15:53 <ehird`> though. admittedly. not likely :)
13:15:59 <ehird`> but...
13:16:03 <ehird`> yeah. i'll get rid of halt
13:16:08 <ehird`> but wait
13:16:15 <ehird`> what if 11111111 was in the data section
13:16:21 <ehird`> then you'd jump into data
13:16:27 <ehird`> and, feasably, you might want to execute some data
13:16:39 <ehird`> yeah i don't think specializing jump is good
13:16:43 <ehird`> i'll just get rid of unconditional jump
13:16:44 <oklokok> well, you'd basically have one less space for code/data...
13:16:49 <oklokok> what
13:16:53 <oklokok> yeah
13:16:57 <oklokok> (i misread you)
13:17:46 <oklokok> 00000000-11111111 ~ 00000000-11111110, so that'd really not be that big a sacrifice... the problem with removing halt is really the fact you may want to use it as a convenience for debugging
13:18:09 <oklokok> that'd make it quite verbose
13:18:33 <ehird`> yeah
13:18:38 <ehird`> i'll just get rid of unconditional jump
13:18:42 <ehird`> anyway i've almost finished the new spec
13:18:47 <ehird`> hmm
13:18:51 <ehird`> should i combine input and output?
13:18:57 <ehird`> READ 000 = input
13:18:59 <ehird`> WRITE 000 = output
13:19:01 <oklokok> that's the 3rd way i suggested
13:19:04 <ehird`> yeah
13:19:06 <ehird`> no i mean
13:19:07 <ehird`> the port
13:19:09 <oklokok> hmm
13:19:13 <ehird`> like, one port for "terminal"
13:20:25 <oklokok> you could have IO AAA BBB PPP, where AAA would be input register, BBB output and PPP port... millions of ways to cincumvent having to have both IN and OUT
13:20:35 <oklokok> (i guess that was a note-to-self more like)
13:20:48 <ehird`> i want both in and out
13:20:51 <ehird`> you do not understand
13:20:55 <ehird`> i am talking about port numbers
13:20:57 <oklokok> aaaaand now i realize what you said.
13:20:58 <oklokok> yes
13:21:21 <oklokok> takes me a while sometimes, no matter how simple a thing people say to me
13:21:22 <oklokok> hmm
13:21:39 <oklokok> that sounds like a good way
13:22:21 <oklokok> can't really come up with a good reason though
13:28:22 <ehird`> back
13:28:24 <ehird`> yes
13:28:44 <ehird`> ok
13:28:48 <ehird`> so if i have terminal as 0
13:28:49 <ehird`> what should port 1 be
13:31:23 <ehird`> :/
13:32:35 <oklokok> you wanna include those in the spec?
13:32:43 <oklokok> well i guess you wanna assign a few
13:32:47 <oklokok> hmm
13:33:02 <oklokok> you could have stderr next
13:33:15 <oklokok> or have it be port 11111111
13:33:27 <oklokok> then you could have a nop port
13:33:35 <oklokok> nops are great
13:33:38 <oklokok> nopol <3
13:33:47 <oklokok> why.am.i.not.eating ->
13:49:35 <oklopol> decided not to eat today, bought 5 liters of juice
13:57:24 <ehird`> I have
13:57:26 <ehird`> 0 - terminal
13:57:32 <ehird`> 1 - ?
13:58:02 <oklopol> that's pretty... impressive :P
13:58:42 <ehird`> what should 1 be :p
13:59:47 <oklokok> you can have a sound port and a kinda raw pixel feed port or something
13:59:48 <oklokok> eh
13:59:52 <oklokok> i mean, graphic output
14:00:04 <ehird`> maybe
14:00:08 <ehird`> but.. something more useful..?
14:00:14 <oklokok> then, some kinda nethack.
14:00:20 <ehird`> nah
14:00:24 <ehird`> that'd be implementation defined ports
14:00:34 <ehird`> i want to define 3-5 ports and then have the rest implementation defined
14:00:42 <ehird`> then you could implement a web browser or something in it :D
14:00:57 <oklokok> heh, that'd be fun
14:02:15 <ehird`> sooooooooooo
14:02:19 <ehird`> what should port 1 be
14:05:26 <ehird`> :(
14:11:46 <oklokok> stdio, stderr are the only ones i can think of
14:12:01 <ehird`> nonononono
14:12:04 <oklokok> since you obviously don't want anything that esoteric and my ideas tend to be like that
14:12:05 <ehird`> i don't mean like keybaord input/output
14:12:06 <oklokok> hmm
14:12:07 <oklokok> oh
14:12:10 <ehird`> i mean ANY kind of IO
14:12:19 <ehird`> just, any sort of communication at all
14:12:23 <oklokok> stdio == keyboard?
14:12:32 <ehird`> stdio mostly == terminal
14:12:43 -!- RedDak has joined.
14:12:50 <oklokok> well, i was just thinking like standard io
14:13:30 <oklokok> you can have stuff like mouse and keyboard of course, but i don't know at what point it should be implementation defined
14:14:14 <ehird`> you are thinking too limited definition of IO
14:14:33 <oklokok> i realize that.
14:14:36 <ehird`> absolutely ANY operation that could be said to have some sort of link to "input" and "output" 8-bit values, that isn't covered by the instruction set
14:15:00 <oklokok> ah, true... you could have like additional instrcutions taht way
14:15:10 <oklokok> (i can't type that word for some reason)
14:16:21 <ehird`> kind of...
14:16:29 <ehird`> but... e.g. a computer speaker could be IO
14:16:39 <ehird`> and the value could be some sort of pitch/amplitude combination
14:16:42 <ehird`> you know, the little beeping speaker
14:16:58 <oklokok> i already said that
14:17:07 <oklokok> you said that's not very necessary
14:17:08 <oklokok> :|
14:18:10 <ehird`> no you didn't say that :|
14:18:25 <oklokok> (oklokok) you can have a sound port
14:18:29 <oklokok> i guess i didn't
14:18:38 <oklokok> but i tried to
14:18:42 <ehird`> sound port != computer speaker
14:18:55 <oklokok> sound port = general term
14:19:09 <oklokok> *more general term
14:20:53 <ehird`> yeah, but..
14:21:10 <oklokok> anyway, yeah you can have one be a sound port
14:21:13 <ehird`> yes
14:21:17 <ehird`> ok, what about 2
14:21:22 <ehird`> just 2, and then i'll leave the rest undefined
14:21:39 <oklokok> and possible two separate ports for *raw* and *pitch+length* output
14:21:43 <oklokok> *possibly
14:22:25 <oklokok> making sounds is hell in like every goddamn platform
14:22:28 <oklokok> no matter what you use
14:22:31 <oklokok> i hate it
14:23:25 <ehird`> yeah; how do you do it in ruby?
14:23:28 <ehird`> computer speaker
14:23:36 <oklokok> eh
14:23:46 <oklokok> i have a feeling you know more ruby than me
14:24:00 <oklokok> since i vaguely recall you teaching me the basics of ruby
14:24:18 <ehird`> it was a question to everyone :P
14:24:53 <oklokok> ...eh... mine was too!
14:26:41 <ehird`> when i say computer speaker
14:26:43 <ehird`> i mean internal speaker
14:26:48 <oklokok> i do know
14:27:00 <oklokok> pc beeper is what i've thought it's called
14:27:09 <oklokok> ut...
14:27:10 <oklokok> *bit
14:27:12 <oklokok> *but
14:27:25 <oklokok> i guess that's just for pc.
14:27:30 <oklokok> *might* be
14:28:08 <ehird`> :)
14:28:13 <ehird`> maybe
14:30:00 <oklokok> the internal speaker is kinda boring
14:31:02 <ehird`> you have clearly never played old games
14:31:11 <ehird`> i've heard complex polyphonic tunes composed with internal speakers
14:31:53 <oklokok> it can't be strictly polyphonic...
14:31:54 <ehird`> with enough tricks you can get some nice lo-fi tunes
14:31:56 <ehird`> and, no
14:32:01 <ehird`> but if you alternate between two very short notes
14:32:05 <ehird`> you can get the illusion
14:32:08 <ehird`> of polyphony
14:32:21 <oklokok> yeah, okay you've convinced me
14:32:36 <oklokok> wonder if you could do that with python's beep...
14:32:45 <ehird`> no
14:33:20 <ehird`> also
14:33:21 <oklokok> you van't?
14:33:22 <oklokok> *cant
14:33:25 <ehird`> if i add something that controls the screen too
14:33:26 <oklokok> *can't
14:33:38 <ehird`> you could create a 99 bottles of beer program with colour graphics and sound :)
14:33:41 <ehird`> like an old dos app!
14:34:05 <oklokok> i'll make one that synthesizes a guy saying the lyrics.
14:34:19 <ehird`> with an internal speaker?!
14:34:22 <ehird`> that'd be impressive
14:34:46 <oklokok> depends on how strictly the movement of the cone is defined
14:34:52 <oklokok> i assume it's *very*
14:35:31 <oklokok> so... you could make a program to convert wav -> beeper
14:36:16 <ehird`> maybe
14:36:20 <ehird`> are you on windows?
14:36:28 <oklokok> yes, now
14:37:10 <ehird`> do you have ruby installed
14:37:13 <ehird`> or python
14:37:21 <oklokok> yes
14:37:23 <oklokok> python
14:37:25 <ehird`> which
14:37:28 <oklokok> version
14:37:37 <oklokok> 2.2, 2.4 and 2.5
14:38:32 <oklokok> 2.4 doesn't open iirc
14:38:40 <oklokok> and 2.5 i have to do some tricks to get open
14:45:55 <ehird`> ok
14:45:58 <ehird`> right:
14:46:08 <ehird`> import win32api
14:46:54 <ehird`> did that work?
14:47:07 <oklokok> huh?
14:47:19 <oklokok> i do know how to make the pc beeper sing in python
14:47:22 <ehird`> oh
14:47:42 <oklokok> http://vjn.fi/s/beepiano.py
14:48:03 <ehird`> wow, a three letter domain name
14:48:04 <ehird`> impressive
14:48:08 <ehird`> not many of those around
14:48:09 <oklokok> i made that a million years ago
14:48:20 <oklokok> there's a website with a link to each of them
14:48:31 <oklokok> that's not exactly my page
14:48:40 <oklokok> it's our group's... vjn's page
14:48:49 <ehird`> ah
14:49:27 <oklokok> the domain was easy to get, we were just lazy enough to get a web hotel system so it costed like hell
14:49:41 <oklokok> but it's fun wasting money
14:51:06 <ehird`> web hotel?
14:51:13 <oklokok> well okay it's my page in that most of the content is made by me
14:51:17 <oklokok> (about hald)
14:51:18 <oklokok> *half
14:51:55 <oklokok> web hotel == a public service for a server to maintain that
14:52:05 <ehird`> ah
14:52:08 <ehird`> by the way
14:52:22 <ehird`> some of the best pc speaker music is in old lucasarts graphical adventure games
14:52:27 <ehird`> start them with the pc speaker command line option
14:53:06 <oklokok> i don't feel like dl'ing any games now, you can record some for me and upload
14:53:07 <oklokok> :)
14:53:27 <ehird`> :p ok
15:00:05 <oklokok> are you actually gonna do that btw, because waiting for you to upload it is actually now my excuse for doing nothing at all
15:00:14 <oklokok> well, i'm actually picking at my toes
15:00:20 <oklokok> they seem to be... rotten
15:00:28 <oklokok> i'm gonna go... do some cleaning now ->
15:01:40 <ehird`> i am going to do it
15:01:52 <ehird`> i'm just finding my copy of the game
15:04:21 -!- RedDak has quit ("I'm quitting... Bye all").
15:06:16 <ehird`> found it
15:06:18 <ehird`> ok, starting it
15:07:24 <ehird`> recording
15:12:14 <oklokok> i can hardly wait
15:13:50 <ehird`> oh no
15:13:51 <ehird`> i hit record
15:13:55 <ehird`> but it's recorded at insanely low volume
15:14:04 <ehird`> ah there
15:14:09 <ehird`> it can be amplified without much qualityloss
15:14:16 <oklokok> if it's square, you can easily amplify
15:14:17 <oklokok> yeah
15:14:26 <oklokok> it's prolly sine... but same thing
15:15:06 <ehird`> hmm not a good recording
15:15:27 <ehird`> i'll find a recording elsewhere
15:15:52 <oklokok> i don't really care about the quality that much
15:17:00 <ehird`> yeah but it skips parts
15:17:03 <ehird`> audacity is stupid
15:17:56 <oklokok> what?
15:18:09 <oklokok> audacity is stupid how?
15:18:39 <ehird`> it skips parts when recording
15:18:42 <ehird`> for no apparent reason
15:18:51 <oklokok> weird
15:19:00 <ehird`> (case in point of how quiet this recording is: i can amplify 36db and it doesn't even go to halfway full amplitude)
15:19:44 <ehird`> i think this might be ok
15:19:50 <ehird`> but be warned that the real thing sounds far more like music
15:19:52 <ehird`> and less like random bleeps
15:20:01 <ehird`> stupid skipping
15:20:28 <ehird`> k, making an mp3
15:20:38 <ehird`> note that there's periods of silence in between the three tunes
15:20:43 <ehird`> because i had to, you know, play the game up to that point
15:20:46 <ehird`> not too long though
15:20:58 <oklokok> ah okay
15:21:23 <ehird`> k uploading
15:23:43 <ehird`> http://rapidshare.com/files/48135293/monkeyisland.mp3.html
15:23:49 <ehird`> too lazy to upload it to a real host
15:27:05 <oklokok> i think that sounds great :)
15:27:15 <oklokok> but i don't think that's anything near what it should sound
15:28:47 <ehird`> yeah it skips in random places
15:29:13 <ehird`> so, that's an example of pc speaker polyphony
15:29:23 <oklokok> hmm.. either it skips all the time or i don't think many people would enjoy listening to that
15:29:30 <ehird`> it does skip all the time
15:29:42 <ehird`> seriously; download the game (monkey island 2) and run "monkey2 i" sometime
15:29:47 <ehird`> it sounds nothing like tha trecording :p
15:30:18 <ehird`> now i need to work out a consistant way to pack computer speaker values
15:30:19 <ehird`> an api
15:30:20 <oklokok> mahh
15:30:53 <ehird`> bear in mind that "2000, 100" in the windows library only produces a very short beep
15:30:56 <ehird`> we need to store... big values.
15:31:43 <oklokok> hmm
15:31:52 <ehird`> within 256
15:31:55 <ehird`> i guess, maybe
15:31:58 <ehird`> the register value could be a memory address
15:32:05 <ehird`> and then like 5 places after that is the values
15:32:47 <ehird`> whoa, a program that plays wavs to the pc speaker
15:32:48 <ehird`> crazy
15:33:34 <ehird`> no worky in xp :(
15:33:48 * ehird` gets updated one
15:34:07 <oklokok> huh
15:34:11 <oklokok> ah
15:34:25 <oklokok> yeah, it's prolly pretty easy to do, i just don't know the basics of the beeper
15:36:23 <ehird`> this driver isn't xp-confirmed-compatible :s
15:36:33 * ehird` is hopefully not suiciderating computer
15:37:53 <ehird`> how do you suggest we lay out the argument?
15:39:19 <ehird`> i think a 16-bit integer for both tone+amp will be enough
15:39:23 <ehird`> so, four slots of memory
15:39:28 <ehird`> so should the value be the first slot of memory's address?
15:40:14 <ehird`> ?
15:41:26 <oklokok> hmm
15:41:46 <oklokok> like 256 for duration and 256 for pitch
15:43:02 <oklokok> if you actually make tones (implicit 440*(2**(n/12)) conversion before output), composing will be easier and 256 will be enough
15:43:18 <oklokok> but ppl might find that a bit hmm... what's the word
15:43:45 <oklokok> restricting.
15:43:50 <oklokok> that was hard
15:44:01 <ehird`> yes
15:44:02 <ehird`> restricting
15:44:15 <ehird`> two 16-bit unsigned integers is just 4 slots of memory anyway
15:44:32 <ehird`> and goes beyond what most computer speakers can produce as far as tone goes, and into insane lengths of tones as length goes
15:45:11 <oklokok> 16 bits will be enough if you do frequency pitch
15:45:32 <oklokok> also, i was supposed to leave an hour ago
15:46:05 <ehird`> its not frequency pitch
15:46:11 <ehird`> its SOME-WEIRD-NUMBER length
15:46:17 <oklokok> ?
15:46:43 <oklokok> i'm not talking about length
15:46:46 <oklokok> but pitch
15:48:06 <ehird`> ok
15:48:38 <ehird`> speaking of pc speakers, and i posted the monkey island 2 theme earlier, here's the monkey island 1 theme tune played live: http://www.youtube.com/watch?v=mYZXNVHVfhc it's awesome
15:48:45 <oklokok> it's really never useful having tone output by frequency
15:48:53 <ehird`> it melds tons of different parts
15:49:03 <ehird`> oklokok: i'm going based on win32's Beep function
15:49:17 <oklokok> i do know
15:54:24 <oklokok> http://www.youtube.com/watch?v=WjvD3C_nvBk&mode=related&search= <<< original version?
15:55:00 <oklokok> you have to do some serious hacking if that's actually done with a monophonic output
15:56:47 <oklokok> i know everything can be done with a monophonic output since that's all computers have, but still
15:57:11 <oklokok> you'd have to change note like 100 times a second
15:57:18 <oklokok> and still i think it'd sound wrong
15:57:26 <oklokok> so you'd have to add up the sines
15:57:39 <oklokok> and efficiently just emulate a raw output using the beeper
15:57:50 <oklokok> which is like 100 times harder than just making the output
16:05:21 <ehird`> wait
16:05:23 <ehird`> i'll check
16:05:32 <ehird`> and no
16:05:34 <ehird`> that is not the original
16:05:39 <ehird`> i showed you monkey island 2
16:05:50 <ehird`> http://www.youtube.com/watch?v=6lTz2nkPNXA
16:06:09 <ehird`> that's the adlib version, so, not the best
16:06:17 <ehird`> my recording starts with the monkeys dancing
16:06:26 <ehird`> but anyway, my recording skipped every 2 seconds
16:06:29 <ehird`> so of course it sounded nothing like that
16:08:11 <ehird`> however mine also includes largo's theme
16:08:18 <ehird`> and omits the Scabb Island theme
16:08:34 <ehird`> and also has the chapter change theme
16:11:11 <ehird`> i seem to remember this scene was the best-composed for the pc speaker: http://www.youtube.com/watch?v=wbTTyacCO5c
16:11:22 <ehird`> there's no recordings of it on the speaker though and i'm not playing half way through the game to get there
16:15:13 -!- Svenstaro has joined.
16:15:24 <oklokok> i'll be going now, cul! ->
16:15:30 <ehird`> bye
16:17:28 -!- sebbu has joined.
16:39:32 -!- jix has joined.
17:23:28 -!- lament has set topic: Esoteric programming language discussion | FORUM AND WIKI: esolangs.org | CHANNEL LOGS: http://ircbrowse.com/cdates.html?channel=esoteric | NOTE TO EHIRD DO NOT REMOVE: \instructionset.
17:29:30 -!- jix has quit (Nick collision from services.).
17:29:44 -!- jix has joined.
17:42:01 -!- lament has quit ("Lost terminal").
17:42:57 -!- cherez has joined.
18:05:10 -!- lament has joined.
18:18:28 <ehird`> 3.14
18:21:35 <lament> 3.1489797239479878971073891723816378969086359782649786301276382935496123897
18:22:03 <oklokok> :D
18:22:10 <puzzlet_> seems rational
18:25:02 <lament> ehird`: you'll have to remove that note from the topic when you don't need it, nobody else is gonna do it
18:25:09 <ehird`> i know
18:25:13 <ehird`> i still need it right now :p
18:25:27 * ehird` is forgetful
19:10:41 -!- poiuy_qwert has joined.
19:33:04 -!- ihope_ has joined.
19:33:16 -!- ihope_ has changed nick to ihope.
19:33:28 -!- olsner has joined.
19:39:08 -!- ihope has quit (Nick collision from services.).
19:39:30 -!- ihope has joined.
19:39:34 -!- ihope_ has joined.
19:45:11 <ihope> I hear the sound of either "All I Know" or an ice cream truck playing Popeye.
19:47:30 <ehird`> i see
19:47:38 <ehird`> ihope: i made that instruction set TC, i think
19:48:57 <ehird`> http://pastie.caboo.se/86663
19:49:07 <ehird`> i need to define some standard ports though
19:49:16 <ehird`> i think i'll define Terminal and PC speaker and leave the rest implementation-defined
19:49:27 <oklokok> i really don't like you calling it tc :\
19:49:36 <ehird`> oklokok: please read http://pastie.caboo.se/86663
19:49:39 <ehird`> it >is< turing complete
19:49:39 <oklokok> oh
19:49:45 <oklokok> you changed it?
19:49:49 <ehird`> yes
19:49:52 <ehird`> the current spec should be TC
19:49:57 <oklokok> then sorry
19:49:58 <oklokok> i'll read
19:50:02 <ehird`> if you don't believe me... then i guess i'll write brainfuck rewriting rules for it
19:50:35 <oklokok> hmm...
19:50:59 <ihope_> ehird`: oh, and couldn't you use MemoServ or something for your notes-to-self?
19:51:05 <oklokok> so you can make a list of 1000000000 entries in it?
19:51:09 <ehird`> possibly, ihope_
19:51:20 <ehird`> oklokok: if you had more than 8-bit addresses, yes
19:51:26 <oklokok> eh
19:51:45 <ehird`> (In this aspect, even C isn't turing complete. Pointers have maximum values.)
19:51:47 <oklokok> you think that's directly extendable to infinite size registers?
19:52:08 <ehird`> (And yes, I know C isn't TC. I think if mine is on the same computational level of C, nobody will ever need anything more :))
19:52:11 <oklokok> ehird`: this is a common discussion, this one about C, but no, pointers do not have to be finite size.
19:52:18 <oklokok> in C
19:52:20 <ehird`> C isn't TC, anyway
19:52:27 <oklokok> it is if pointers are infinite.
19:52:35 <oklokok> the size of a pointer is not defined
19:52:38 <ehird`> they are
19:52:39 <oklokok> it can be bignum
19:52:44 <ehird`> no it can't
19:52:48 <ihope_> Why not?
19:52:50 <ehird`> or at least, it can't in C89#
19:53:24 <oklokok> ehird`: then i've been lied to, i haven't read the spec of c, since i don't like the lang that much anymore
19:53:24 <ihope_> Does that spec explicitly state that there must be a biggest pointer?
19:53:40 <oklokok> s/to/at
19:53:47 <oklokok> s/at/to
19:53:51 <ehird`> ihope_: iirc, it defines pointers pretty precisely
19:53:54 <oklokok> (doing some nop there)
19:54:06 <oklokok> eh
19:54:22 <oklokok> defining precisely != defining a maximum size
19:55:06 <oklokok> anyway, that isn't tc then, and you *did not* change it :\
19:55:09 <oklokok> or did you?
19:55:12 <oklokok> i can't find it
19:55:14 <ehird`> http://pastie.caboo.se/86663
19:55:34 <ehird`> it may be non-TC, but if so it's only because it has the same restriction as C89
19:55:44 <ehird`> and, frankly, i'm not bothered. nobody stops using C because it isn't TC.
19:56:02 <oklokok> can you quote me the part making C pointers finite?
19:56:10 <oklokok> in the spec
19:56:55 <ehird`> you have to pay to get the spec
19:57:00 <ehird`> do you have it?
19:57:04 <oklokok> because iirc someone on this channel said nothing there says it
19:57:29 <oklokok> i do not have it, i'd've checked that like 4 times if i had it :P
19:57:29 <olsner> oklokok: C types are guaranteed to have a size in bytes defined at compile-time
19:58:40 <olsner> and bytes are afaik defined to be 8-bit quantities...
19:58:47 <oklokok> i doubt that
19:58:49 <oklokok> latter one
19:58:54 <oklokok> eh
19:59:22 <oklokok> i mean, i think they have a size defined in chunks, but those need not necessarily be bytes
19:59:33 <oklokok> just whatever is used for memory slots
20:00:10 <oklokok> anyway, i haven't read the spec, someone here just said something about something and i *vaguely recall*, so...
20:00:53 <ehird`> defined size at compile-time == you can't have an infinite size
20:00:59 <ehird`> == c is not turing complete
20:01:46 <olsner> well, PC:s aren't turing complete either due to the finite size of memory
20:02:11 <oklokok> pc's aren't, C could still be
20:02:48 <oklokok> defined size in bytes, yes, but if the byte is a bignum, it's tc.
20:02:55 <oklokok> *if bytes can be bignum
20:06:42 <ehird`> but they can't
20:06:53 <ehird`> sizeof(X) must return a value that makes sense
20:06:58 <ehird`> and it must be >right<
20:06:59 <ehird`> so no -1
20:07:05 <ehird`> sizeof(void *)...
20:07:11 <ehird`> MUST be < infinity
20:07:15 <ehird`> thus, C is not turing complete
20:07:23 <olsner> ehird`: sizeof(char) could be sizeof(pointer-to-bignum)
20:07:38 <ehird`> olsner: Sure.. So what?
20:07:47 <ehird`> It'd be the same size as a pointer to a bignum.
20:08:27 <olsner> I mean, sizeof(void *) would be composed of bignums in such a way as to have constant size (but use hidden extra data to enable unbounded values)
20:08:55 <olsner> thus, sizeof's would be bounded, but the values contained unbounded
20:09:17 <ehird`> So given a turing-complete C implementation, sizeof(void *) == ?
20:09:34 <olsner> could be just 1, since a byte is a bignum
20:10:27 <ehird`> what
20:10:29 <ehird`> that makes no sense
20:10:39 <ehird`> if its a bignum then its size is not 1
20:10:53 <ehird`> also bytes are defined to be 8 bits
20:10:57 <ehird`> so a byte cannot be a bignum
20:11:50 <ihope_> ehird`: the spec defines a byte as 8 bits, and that sizeof() returns a number of bytes?
20:12:05 <ehird`> pretty much yes
20:12:25 <olsner> there is contention as to whether that byte size actually is mandated by the standard ;-)
20:12:31 -!- Darktemplar has joined.
20:12:57 -!- Darktemplar has left (?).
20:13:43 <ehird`> still
20:13:48 <ehird`> sizeof() must return a number of bytes
20:13:53 <ehird`> and sizeof(void *) is no exception
20:13:57 <ehird`> thus pointer addresses are limited
20:14:01 <ehird`> thus C is not turing complete
20:16:58 <ehird`> so C is only as powerful as my machine spec there
20:17:00 -!- jix has quit (Read error: 104 (Connection reset by peer)).
20:17:05 <ehird`> so you can't complain about my machine not being tc! :p
20:17:43 -!- jix has joined.
20:20:41 <ihope_> olsner: there's contention as to... wha?
20:21:28 <olsner> whether the size of a byte is defined by the C standard to be exactly 8 bits
20:22:06 <ihope_> ...how does it manage to not be clear on that?
20:23:10 <olsner> it probably is clear on that... you just have to read that part of the standard ;-)
20:24:08 <ehird`> so, have we all agreed that yelling at my machine for not being "really" tc is pointless :)
20:26:25 <olsner> I think the discussion did have the potential to bring forth a deeper understanding of C's turing in/completeness
20:26:37 <ihope_> ehird`: do you still need that thing in the topic?
20:26:45 -!- ehird` has set topic: Esoteric programming language discussion | FORUM AND WIKI: esolangs.org | CHANNEL LOGS: http://ircbrowse.com/cdates.html?channel=esoteric.
20:26:48 <ehird`> no :)
20:27:29 <ehird`> ok, now the machine arch needs a name
20:27:34 <ehird`> then i'll write some simple programs and an implementation
20:28:15 <ihope_> YAEL or YAEP?
20:28:22 <ehird`> ?
20:28:38 <ihope_> Yet Another Esoteric Language/Platform?
20:28:51 <ehird`> it isn't really that esoteric, though, is it?
20:28:54 <ehird`> well, would you call it esoteric?
20:28:59 <ehird`> it's just a minimal machine language is it not?
20:29:08 <ihope_> I dunno.
20:29:14 <ihope_> YAML or YAMP, then?
20:29:17 <ehird`> well, what would make it esoteric?
20:29:25 <ehird`> yaml is a data format :)
20:30:36 <ihope_> If it's not made with usability and ease of implementation in mind, it's esoteric :-)
20:30:39 <olsner> MiniMaL (MINImal MAchine Language) :P
20:30:53 <ihope_> What does MiniMAX stand for?
20:31:02 <ehird`> it is designed with usability in mind :)
20:31:04 <olsner> but anything above 1 instruction isn't really minimal anymore
20:31:18 <ehird`> the whole point was to be tiny, but usable if you know some sort of asm
20:31:32 <ehird`> and i can't see how it would be hard to implement
20:31:41 <ihope_> Well, why did you want it to be tiny?
20:32:02 <ehird`> because yesterday RodgerTheGreat was talking about a turing-complete network protocol
20:32:09 <ehird`> and i remarked that the packet format would have to be incredibly small
20:32:20 <ehird`> and that you could probably get away with 4-bit opcodes
20:32:23 <ehird`> giving you 16 commands
20:32:26 <ehird`> thus...
20:32:27 <ihope_> Sounds esoteric to me.
20:32:30 <ehird`> i took that idea with me
20:32:36 <ehird`> and made a tiny machine language that was still usable
20:32:43 <ehird`> it doesn't look really esoteric to me but maybe it does to you?
20:33:03 <ihope_> I guess tininess is... um...
20:33:08 <ihope_> A useful thing to strive for.
20:33:18 <ehird`> not really =p
20:33:20 <ihope_> Thus making it not an esoteric feature.
20:33:36 <ehird`> its tinyness really has no use
20:33:37 <SimonRC> Nooooooooo!
20:33:55 <ehird`> i just wondered how small i could make an architechture while still having it relatively easy-to-use
20:34:07 <olsner> plus, tininess isn't essential for esotericism
20:34:14 <ihope_> Sounds esoteric again, then.
20:34:24 <SimonRC> not only did they close the wormhole that was keeping the Ori's ships out, but in destroying the Ori they removed most of the Ancients' motivation to help them!
20:34:30 <SimonRC> (SG-1)
20:34:36 <SimonRC> *Oris'
20:34:38 <ehird`> ihope_: Okay
20:34:43 <SimonRC> * whatever
20:34:46 <ehird`> i might call it MiniMaL
20:34:50 <ehird`> I might call it Yael (no acronym)
20:34:56 <ihope_> Though are you sure MiniMAX or BCT doesn't sort of win?
20:35:04 <ehird`> MiniMAX means what?
20:35:05 <ehird`> BCT means what?
20:35:32 <ihope_> Bitwise Cyclic Tag.
20:35:35 <ehird`> ah, esoteric things
20:35:37 <poiuy_qwert> SimonRC stargate is good
20:35:43 <ehird`> bitwise cyclic tag -- easy to use? are you KIDDING?
20:35:45 <ihope_> Mini Mov-Add-Xchg.
20:35:57 <ihope_> I dunno. You might need to spend some time learning it, but after that...
20:36:01 <ehird`> yeah exactly
20:36:02 <olsner> so, by winning the fight they lost their allies?
20:36:14 <ehird`> whereas here if you know something about low-level programming you can pick it up immediatly
20:37:39 <ihope_> Mm...
20:37:50 <ehird`> MiniMAX is hardly easy to use
20:38:05 <SimonRC> don't forget the various SJM architectures
20:38:32 <SimonRC> one uses CPP and a library of macros to make it quite usable
20:38:59 <SimonRC> plus, SJMs always have the right O()
20:39:10 <ehird`> name time: MiniMaL or Yael?
20:39:17 <ihope_> I like Yael.
20:39:27 <ihope_> It's... likable.
20:39:35 <ehird`> :P
20:39:36 <ehird`> ok then
20:39:37 <ehird`> Yael it is
20:39:39 * ehird` puts it on the wiki
20:39:50 <SimonRC> (SJM = subtract and jump if negative)
20:40:04 <SimonRC> Yet Another Esoteric Language?
20:40:05 <ihope_> Like a circle of grass ten feet across with forest all around.
20:40:12 <ihope_> SimonRC: originally, I think.
20:40:40 <ihope_> I suggested YAEL, standing for that; he pondered Yael, supposedly not standing for anything at all.
20:40:40 <olsner> SimonRC: "the right O()"?
20:40:56 <ihope_> I was going to suggest "subtract and branch unless positive".
20:41:25 <SimonRC> An O(n) aalgorithm on normal architectures is O(n) in an SJM architecture, unlike (e.g.) Brainfuck
20:41:32 <ihope_> Is subtract-and-branch-unless-positive nicely isomorphic to subtract-and-jump-if-negative?
20:41:47 <ehird`> it can be Yet Another Esoteric Language if you think it should stand for that
20:41:51 <ehird`> but Yael is its official name :)
20:42:30 <SimonRC> where is the spec?
20:44:02 <ehird`> it's on pastie, but i'm adding a bit to it and putting it on the wiki now
20:44:10 <ihope_> http://pastie.caboo.se/86663
20:46:39 <ehird`> ok: http://esolangs.org/wiki/Yael
20:46:41 <ehird`> spec version 1
20:47:17 <ehird`> an infinite loop is remarkably short :) "1100000000000"
20:47:26 <ehird`> it would be shorter if i still had an unconditional jump
20:47:26 <ihope_> +[]
20:47:36 <ehird`> ihope_: and that in binary? :)
20:47:36 <ihope_> ```sii``sii
20:47:51 <ehird`> if i had an unconditional jump it would be "<jmp>000"
20:47:55 <ihope_> Both of them could be expressed as 0, but that would be a weird coding.
20:47:57 <ehird`> assuming jump is 1111, "1111000"
20:48:27 <ehird`> and "1111000" in a file is pretty much the shortest you're gonna get unless you have a language called Infinity Loop :P
20:48:30 <ehird`> *Infinite
20:49:37 * ehird` is writing hello world in it
20:53:59 <ehird`> spec updated with infinite loop and change to get-memory command
20:55:53 <ehird`> wow, without mnemonics this hurts my brain :)
20:57:03 <ihope_> Spec updated?
20:57:11 <olsner> an interesting challenge would be to make the program speak "Hello world" through the speaker :P
20:57:14 <ehird`> the basic principle is "x = 0; while (x < 14) out(0, end_of_code + x); halt();Hello, world!"
20:57:19 <ehird`> ihope_: the wiki page
20:57:28 <ehird`> but in practice its a lot harder.
20:57:41 <olsner> 256 bytes of data + code makes that really really hard unfortunately
20:57:46 <ihope_> Oh.
20:58:08 <ehird`> no
20:58:11 <ehird`> not 256 bytes of data + code
20:58:21 <ehird`> 256 bytes is the POINTER size
20:58:30 <ehird`> read the spec
20:58:48 <olsner> oh, so the code size is unlimited, but only the first 256 bytes are read/writable?
20:58:51 <ehird`> with that definition, code+data max size is 65536
20:58:55 <ehird`> no...
20:58:58 <ehird`> think about it
20:59:03 <ehird`> oh, wait, yeah
20:59:06 <ehird`> 256 bytes of code
20:59:12 <ehird`> but that >should< be enough to code hello world
20:59:16 <ehird`> if it isn't i'll update the spec
20:59:23 <ehird`> the instructions are small enough
20:59:34 <oklokok> (ihope_) I dunno. You might need to spend some time learning it, but after that... <<< i rather doubt a human could learn to write *anything* in bct
20:59:44 <olsner> I'm talking text-to-speech (or a simple vocal model) hello world
20:59:59 <ehird`> oh
21:00:00 <ehird`> yes
21:00:08 <ehird`> computer speaker is hard to make speak in the first place, haha :p
21:01:29 <olsner> but the spec doesn't say that the instruction pointer is limited to 0..255, so I guess you can get quite far with frivolous code generation ;-) i.e. generate an N-megbyte program that explicitly loads immmediate data into registers and never jumps
21:01:37 <ihope_> oklokok: {{x1|b=b|i=i}}
21:01:45 <ihope_> Something in BCT.
21:03:01 <oklokok> hmm... bct consists entirely of 1's and 0's, so i have a feeling that's some sort of abstraction i don't get?
21:03:16 <ihope_> oklokok: Wiki Cyclic Tag syntax.
21:03:42 <oklokok> well it wasn't exactly "something in bct" then
21:03:49 <oklokok> but i don't know wiki cyclic tag
21:03:55 <oklokok> i know it exists though
21:04:09 <ihope_> In BCT, program 11 starting with string 11
21:04:16 <ihope_> (Actually, program 1111.)
21:05:14 <ehird`> http://pastie.caboo.se/86687 this is the theory of the hello world program
21:05:21 <ehird`> i just have to work out the value of halt/mainloop_start :)
21:05:24 <ehird`> which can be done in a few seconds
21:07:09 <ihope_> Hmm.
21:09:06 <oklokok> i somehow have a feeling http://esolangs.org/wiki/Wiki_Cyclic_Tag somehow assumes i know what mediawiki software is
21:09:57 <ihope_> MediaWiki is the software behind Esolang, Wikipedia, and Wikia, among other things.
21:10:10 <ehird`> I FINISHED HELLO WORLD
21:10:13 <ehird`> WOOOOOOOOOOOOO
21:10:31 <oklokok> first of all i have no idea how there could be multiple lines
21:10:35 <oklokok> and wtf is an interpreter there
21:10:49 <oklokok> ihope_: i know that, of course
21:11:10 <ihope_> A program seems to go on only one line.
21:11:11 <oklokok> i mean i know it's the base of those
21:11:52 <ihope_> And the interpreter thing at the beginning is sort of like a shebang line.
21:11:55 <oklokok> okay... then i understand, assuming all d, a and b are used simultaneously for each of the data bits in one cycle
21:12:04 <oklokok> meaning what exactly?
21:12:12 <ihope_> d is 0, a is 10, b is 11.
21:12:17 <ihope_> o is 0, i is 1.
21:12:26 <ihope_> Oh, shebang line?
21:12:59 <oklokok> a shebang tells how to interpret what follows
21:13:00 <ihope_> Like how Python files occasionally begin with #!/usr/bin/env python, to denote that /usr/bin/env python is the interpreter.
21:13:00 <oklokok> right?
21:13:05 <ihope_> Yeah, pretty much.
21:13:05 <oklokok> yeah
21:13:13 <oklokok> so what exactly does it do there?
21:13:51 <oklokok> [edit] Semantics
21:13:51 <oklokok> The d, a, and b commands have been described above. The commands repeat in the order they are given forever. There is one special restriction: there must be at least 2 commands (a 1-command program may be simulated by giving the command twice), and the program must maintain at least 2 bits of data in the data queue at all times, or undefined behaviour will result.
21:13:56 <oklokok> i completely skipped that.
21:13:57 <ehird`> http://esolangs.org/wiki/Yael
21:14:01 <ehird`> see Hello world under programs
21:14:06 <ihope_> Well, if you put, say, x1 there, it denotes that Template:x1 is the interpreter.
21:14:09 <ehird`> the "without comments" one is, of course, the most interesting :D
21:14:11 <oklokok> how in the name of fuck can i always skip the important part.
21:14:23 <ehird`> it looks like line noise doesn't it :)
21:14:29 <ehird`> but i think it's nicely compact, for a machine language hello world
21:14:35 <ehird`> VERY compact, indeed
21:14:57 <oklokok> ihope_: i have no idea what that means
21:15:10 <oklokok> like... it checks the hd for an interpreter with that name?
21:15:24 <oklokok> and... then uses that?
21:15:33 <ihope_> It's template transclusion.
21:16:19 <ihope_> {{foo|blah|bleh|blih}} gets replaced with Template:foo with parameters blah, bleh and blih.
21:16:34 <ehird`> hey, anyone know an editor that will accept a binary 0/1 string and write it as binary to a file?
21:16:40 <ehird`> or will i have to write it myself :p
21:16:52 <ihope_> Any hex editor? :-P
21:17:21 <ehird`> some don't seem to do it properly :p
21:17:29 <ihope_> Oh?
21:17:29 <oklokok> ihope_: in bct i do not know what parameters are, exactly.
21:17:38 <oklokok> so... i have no idea how foo can have params
21:17:57 <ihope_> oklokok: the parameters the "interpreter" takes are the program and the data string.
21:18:13 <ehird`> xvi32 only does hexadecimal literals
21:18:15 <ehird`> no binary entry
21:18:32 <oklokok> ihope_: i still do not know what it means there
21:18:33 <ihope_> I guess writing one yourself... might not be hard.
21:18:38 <oklokok> you just put a random string there?
21:18:41 <ehird`> yes but i am lazy
21:18:56 <ihope_> oklokok: {{name of the template|program|data string}}
21:19:27 <oklokok> ihope_: template?
21:19:49 <ihope_> MediaWiki, when given that, passes program and data string to Template:name of the template and displays the result.
21:20:00 <oklokok> what
21:20:18 <ihope_> I probably should have used more hyphens or something :-P
21:20:18 <oklokok> i see no connection between that and the language described
21:20:35 <ihope_> The language at the "Wiki Cyclic Tag" wiki page?
21:21:45 <ihope_> The example given: {{x1|d=a=b|i=o=i=i}}
21:21:56 <oklokok> ah
21:22:00 <oklokok> now i see how that works
21:22:22 <ehird`> ok well
21:22:35 <ehird`> someone http://esolangs.org/wiki/Yael#Hello_world
21:22:40 <ehird`> put that binary code into a file
21:22:51 <ehird`> then put Hello, world! in ascii form - those exact characters - after it
21:22:51 <oklokok> the interpreter can be any interpreter that is of mediawiki syntax... and there is a mediawiki syntax program that works as an interpreter for wiki cyclic tag there
21:22:54 <ehird`> and upload it somewhere =P
21:23:00 <oklokok> and the interpreter name has to be the name of that
21:23:02 <oklokok> right?
21:23:22 <ihope_> oklokok: yeah, pretty much, I think.
21:23:38 <oklokok> okay, in theory, that might be nice to tell in the wiki.
21:23:50 <ihope_> ehird`: I'll see what I can do.
21:23:51 <oklokok> well.. i guess you can assume ppl know what mediawiki is
21:23:55 <ehird`> ihope_: thanks :P
21:24:13 <ihope_> oklokok: ...well, I don't really see what you just said.
21:25:36 <oklokok> i'm just saying the page assumes people understand what mediawiki does
21:25:42 <ihope_> Oh, indeed, it doesn't quite say that that example interpreter should be placed in a wiki page of the appropriate name.
21:25:45 <oklokok> i assumed mediawiki *is* the interpreter.
21:25:52 <oklokok> naturally
21:26:15 <oklokok> wiki page?
21:26:30 <oklokok> i don't still know the connection between actual wiki pages and that :P
21:26:56 <oklokok> why does everything assume the reader isn't an idiot.
21:26:57 <ihope_> The code in "MediaWiki Interpreter" is to be placed into a wiki page of the appropriate name.
21:27:23 <oklokok> has someone actually used that?
21:27:32 <ihope_> I think I have once.
21:28:05 <ihope_> Hmm, there happens to be some in the sandbox: http://esolangs.org/wiki/Esolang:Sandbox
21:28:09 <ehird`> got it:
21:28:14 <ehird`> "\000\034\004\000\020\0000\020\223!V\207\030\333\233\027\204L\002Hello, world!"
21:28:26 <ihope_> Aww.
21:28:51 <ehird`> does the mediawiki installation allow arbitary uploads?
21:28:55 <ehird`> like, can i upload a .bin
21:29:02 <ihope_> I think so.
21:29:05 <ehird`> or a .yae
21:29:07 <ehird`> or a .yal
21:29:08 <ehird`> or a .yel
21:29:11 <ihope_> Er, installation, did you say?
21:29:18 <ehird`> ?
21:29:26 <ihope_> Oh, try it: http://esolangs.org/wiki/Special:Upload
21:29:45 <oklokok> ihope_: what do i do with those if i wanna run them?
21:30:18 <ihope_> oklokok: just stick one in a wiki page.
21:30:28 <ihope_> It'll display as the "next step".
21:31:17 <oklokok> i never actually tried "sticking stuff" on a wiki page... but i see how that'd work
21:31:34 <oklokok> so... you can't actually make the server run a program?
21:32:01 <ihope_> Not the whole way through. Only one step at a time.
21:32:16 <ehird`> okay, wow, this hello world is the smallest ever
21:32:27 <ihope_> Hello, world!
21:32:31 <ihope_> Written in CAT.
21:32:33 <ehird`> heh
21:32:36 <oklokok> or... slashes!
21:32:38 <ehird`> i mean, metaphorically
21:32:44 <oklokok> also, "h" in hq9
21:32:50 <ehird`> it looks so tiny, in text editors
21:32:51 <ehird`> and everything
21:32:52 <ehird`> so compact.
21:32:57 <ihope_> And by CAT, I mean something else.
21:33:02 <ihope_> oklokok: that's /// :-)
21:33:19 <oklokok> ihope_: i'm not the only one who uses the remanized version of the name :P
21:33:23 <oklokok> but yeah
21:33:25 <oklokok> you're right
21:33:35 <ehird`> ok, yael file extension = ?
21:33:57 <oklokok> ehird`: implementation defined io stuff?
21:34:00 <ehird`> 3 letters! :)
21:34:01 <ehird`> oklokok: no
21:34:02 <ehird`> i mean
21:34:06 <ehird`> file extension, as in
21:34:08 <ehird`> "binary.yael"
21:34:10 <ehird`> except, 3 letters
21:34:15 <oklokok> ah okay
21:34:25 <ehird`> ymc?
21:34:27 <ehird`> yael machine code
21:34:35 <ihope_> .yæl
21:34:37 <ihope_> :-P
21:34:40 <ehird`> heh
21:34:45 <ehird`> a.ymc
21:34:45 <oklokok> that's nicer than leaving out one of the letters
21:34:50 <ehird`> it's fun to stay at the a dot ymc
21:34:54 <oklokok> ihope's was the best idea though
21:35:02 <oklokok> [edit] Semantics
21:35:02 <oklokok> The d, a, and b commands have been described above. The commands repeat in the order they are given forever. There is one special restriction: there must be at least 2 commands (a 1-command program may be simulated by giving the command twice), and the program must maintain at least 2 bits of data in the data queue at all times, or undefined behaviour will result.
21:35:05 <oklokok> ...
21:35:11 <oklokok> that was not my intention
21:35:29 <ehird`> ok, ymc
21:37:16 <ehird`> ".ymc" is not a recommended image file format.
21:37:17 <ehird`> Retrieved from "http://esolangs.org/wiki/Special:Upload"
21:37:19 <ehird`> GRRR
21:37:35 <ehird`> nonlogic dump it goes
21:38:50 <ehird`> http://esolangs.org/wiki/Yael Now with hello world binary!
21:39:49 <ehird`> absolutely tiny. seriously.
21:40:21 <ehird`> somebody should write 99 bottles :p
21:40:25 <ehird`> my hello world already has a loop
21:40:31 <ehird`> and shows how to print strings
21:40:34 <ehird`> so it shouldn't be too hard
21:40:36 <ehird`> just tedious
21:41:22 * ehird` just realised that Yael has 8 registers, not 4
21:41:23 <ehird`> that's cool
21:41:26 * ehird` updated spec
21:41:58 <poiuy_qwert> it would probably be smaller if you null ended the string and just looped till null instead of having a counter
21:42:15 <ehird`> yeah i should probably do that...
21:42:44 <ehird`> alternatively someone else should modify my version to do that because i can't bear to write any more right now because that hello world made me tear out my hair :
21:42:45 <ehird`> *:p
21:43:08 <ehird`> UH OH PROBLEM.
21:43:16 <ehird`> my hello world won't work
21:43:20 <ehird`> it jumps to a bit, not a byte
21:43:32 <ehird`> so all jumps really need some padding to one byte :S
21:43:34 <ehird`> ugly, i guess
21:43:43 <ehird`> but, otherwise you'd run out of addresses to jump to fast
21:44:37 <ehird`> left a note on the hello world section
21:46:06 <poiuy_qwert> i dont understand what you mean, could you explain please?
21:46:20 <ehird`> # Set halt = halting instruction
21:46:20 <ehird`> 0000 100 10011001
21:46:20 <ehird`> # Set mainloop_start = start of main loop
21:46:20 <ehird`> 0000 101 01011010
21:46:33 <ehird`> those addresses are relative to the start of the program in >bits<
21:46:38 <ehird`> whereas, jumping uses bytes
21:46:46 <ehird`> so, i need to pad out the bits right before where i want to jump so they start on a byte
21:46:54 <ehird`> and update those addresses to reference the byte positions instead
21:47:14 <poiuy_qwert> ah i see
21:47:28 <ehird`> ah maybe i could make jump relative, but still in bits
21:47:42 <ehird`> and have bjmp/fjmp - backwards and forward jump
21:48:10 <ehird`> i can't think of what i would replace though
21:50:31 <poiuy_qwert> also, you used a list on the wiki which says "1. stdout and stdin", but in the hello world you set port to 00000000, not 00000001
21:50:46 <poiuy_qwert> im assuming the code is correct not the list?
21:52:51 <poiuy_qwert> and some commands dont use a multiple of 8 bits?
21:55:02 <poiuy_qwert> nvm i see
21:56:45 <ehird`> code, yes
21:56:51 <ehird`> and commands are variable sized
21:57:50 <ehird`> fixed the list in question
21:57:58 <ehird`> ok how about a challenge
21:58:10 <ehird`> first person to write some code to play a tune in yael wins a prize
21:58:20 <ehird`> but not just hardcoding loads of values into memory
21:58:21 <ehird`> do some tricks
21:58:22 <ehird`> or something
21:58:24 <ehird`> yeah.
21:58:38 <ehird`> like, if you're going for a slide from one note to another, do it algorithmically
21:58:49 <ehird`> don't just store all the notes in memory.
22:06:38 <ehird`> :D
22:06:45 <ehird`> i take it nobody thinks thats a good idea
22:06:45 <ehird`> :p
22:08:26 <SimonRC> :-S
22:09:35 <ehird`> it might be pretty
22:09:38 <ehird`> hard mightn't it
22:11:13 <ihope_> Hmm...
22:11:34 <ihope_> Lemme look at the spec.
22:12:12 <ehird`> note that the jumping and memory access and everything is based on BYTES, not bits
22:12:17 <ehird`> so you might have to pad some stuff out with 0s
22:12:32 <ihope_> What's the length given in units of?
22:12:42 <ihope_> And how do you control the starting time?
22:15:10 <ehird`> ?
22:15:16 <ehird`> oh
22:15:19 <ehird`> welllllll
22:15:24 <ehird`> i guess ... i dunno
22:15:31 <ehird`> win32's Beep function? :P
22:15:41 <ehird`> yeah, that sounds like a good benchmkar
22:15:43 <ehird`> *benchmark
22:15:46 <ehird`> win32's Beep function.
22:24:42 -!- olsner has quit (Read error: 104 (Connection reset by peer)).
22:25:19 -!- olsner has joined.
22:28:00 <ehird`> if you can make a little algorithmic tune i'll be impressed :)
22:28:08 <ehird`> i'll make a little asm spec for it, later
22:28:10 <ehird`> to make it easier
22:28:34 <oklokok> algorithmic tune?
22:28:42 <ehird`> like, a regular computer speaker tune
22:28:45 <ehird`> but, if, you say
22:28:52 <ehird`> slided up from note A to B three times
22:29:01 <ehird`> then you'd code the sliding up and the three times algorithmically
22:29:09 <ehird`> instead of just hardcoding the sliding notes 3 times
22:29:36 <ihope_> Have some number of voices, each playing at a certain rate.
22:29:51 <ehird`> you can't do that, internal speakers are monophonic
22:30:02 <ihope_> Blah.
22:30:03 <ehird`> but, yes, that kind of thing
22:30:05 <ehird`> well
22:30:09 <ehird`> you can do polyphony with it
22:30:17 <ehird`> play extremely short sounds from each one after another
22:30:20 <ehird`> (use 1 as the length)
22:30:21 <ihope_> Monophonic?
22:30:26 <ehird`> yes
22:30:44 <ehird`> but if you get the length of the sound that you play before switching to the next one right
22:30:48 <ehird`> then you can create the illusion of polyphony
22:30:50 <ihope_> Just what's that mean?
22:31:00 <ehird`> monophonic?
22:31:04 <ihope_> Yes.
22:31:05 <ehird`> you can only produce one sound at a time
22:31:10 <ehird`> you can't play "dah" and "duh" at the same time
22:31:14 <ihope_> Okay.
22:31:16 <ehird`> but you can play "dah" and then "duh"
22:31:21 <ihope_> Have some number of voices, each playing at a certain rate.
22:31:29 <ehird`> so if you want more than one voice, you have to quickly play short sounds from each in succession
22:31:37 <ihope_> When a voice is told to play, it looks at the last note played by each other voice, and then plays the lowest note that isn't one of those.
22:31:57 <ehird`> is this a roundabout way of sliding up?
22:32:10 <ehird`> i was thinking more of going in a loop and incrementing a variable then playing that variable as the tone :)
22:32:10 <ihope_> I don't think so.
22:32:19 <ihope_> More of an entire music generation thing.
22:32:28 <ehird`> oh
22:32:32 <ehird`> well if you can code that in Yael
22:32:34 <ehird`> i'm impressed.
22:32:36 <ihope_> Mm, doing that would produce a simple tune :-)
22:32:44 <ehird`> ok :)
22:32:47 <ehird`> write it now :p
22:32:53 <ihope_> Yours, I mean.
22:32:58 <ehird`> ah
22:32:59 <ehird`> yes
22:33:00 <ehird`> :P
22:33:05 <ehird`> i was meaning as a >segment<
22:33:06 <ehird`> of a song.
22:33:11 <ihope_> Ah.
22:33:15 <ehird`> like, if at one point you want to slide up and down three times
22:33:17 <ehird`> don't hardcode it all
22:33:21 <ehird`> do it algorithmically
22:33:50 <ehird`> ah! i know the perfect song to do
22:33:59 <ehird`> slide from lowest note to highest note, and from highest note to lowest note
22:34:01 <ehird`> at the same time
22:34:04 <ehird`> emulating polyphony
22:34:14 <ehird`> repeat 3 or so times.
22:34:23 <ehird`> if someone does that, i'll give them a medal :p
22:34:29 <ehird`> shouldn't be too hard
22:35:02 <ehird`> in fact
22:35:05 <ehird`> nevermind repeating 3 times
22:35:06 <ehird`> loop forever
22:35:14 <ehird`> then you'll have an oscillating music program :)
22:35:48 <oklokok> that's like insanely easy
22:35:54 <ehird`> so do it :)
22:36:10 <oklokok> hmm... i'll make an interpreter for that first unless you do that
22:36:16 <ehird`> i'll write an interpreter
22:36:19 <ehird`> but anyway --
22:36:32 <ehird`> remember you don't just want
22:36:36 <ehird`> (HI length 1) (LO length 1)
22:36:39 <ehird`> since length 1 is far too short
22:36:47 <ehird`> you want (HI length 1) (LO length 1) (HI length 1) (LO length 1)
22:36:48 <ehird`> or similar
22:36:53 <ehird`> to keep polyphony but have longer notes
22:37:29 <ehird`> actually i can't be bothered to write an interpreter right now
22:37:30 <ehird`> you do it :p
22:37:33 <ehird`> i'll write a c one later
22:37:36 <ehird`> but i don't have a c compiler on this machine
22:40:11 <ehird`> actually
22:40:13 <ehird`> don't write any programs yet
22:40:17 <ehird`> i want to change the jumping mechanism
22:40:22 <ehird`> i need to lose one instruction
22:40:28 <ehird`> which should i use?
22:40:32 <ehird`> *lose
22:41:21 <oklokok> i'm not doing anything yet, really, but perhaps later
22:43:30 <ehird`> which instruction should i lose?
22:44:12 <oklokok> input and output can be hacked together
22:44:31 <ehird`> not nicely though
22:44:32 <oklokok> and xor and or can emulate each other
22:44:47 <oklokok> i don't think you can remove anything nicely
22:44:49 <ehird`> how does xor emulate or?
22:45:22 <oklokok> 2 of them can emulate the third
22:45:59 <ehird`> how does xor emulate or?
22:46:11 <ehird`> i mean, if i have (A xor B) and not (A or B), what is (A or B)?
22:46:44 <ehird`> hmm
22:46:57 <ehird`> (A xor (B and true))?
22:49:20 <SimonRC> um, no
22:49:48 <SimonRC> xor cannot "fold" things together, I think
22:50:18 <SimonRC> actually, viewed as a SAT problem, xor does not distinguish inputs and outputs!
22:55:10 <ehird`> (A xor (B and true)) is (A or B)
22:56:15 <ehird`> er, wait no
22:56:37 <ehird`> there is surely a way to emulate or with xor
22:56:44 <SimonRC> I know
22:56:50 <SimonRC> now proove it!
22:56:57 <ehird`> =p
22:57:20 <SimonRC> you can invert three signals with 2 not gates though
22:57:31 <SimonRC> I forget how, but the circuit is rather complicated
23:05:55 <ehird`> nobody has written a tune i see :p
23:06:02 <ehird`> what was that about "insanely simple"
23:06:05 <ehird`> hmm
23:06:13 * ehird` continues wondering what instruction to ditch
23:09:41 <ihope_> 1011?
23:10:02 <ihope_> Maybe 1010 while you're at it.
23:10:12 <ehird`> division and multiplication are useful :(
23:10:24 <ihope_> Isn't... what you want to add useful?
23:10:31 <ehird`> otherwise you can't have a short factorial! everyone knows how important factorials to be :P
23:10:39 <ehird`> and yes... but only slightly...
23:10:43 <ehird`> i mean... you can still do everything now
23:10:47 <ehird`> but i'm making it more elegant
23:10:50 <ihope_> Division helps with factorials?
23:10:56 <ehird`> no, multiplication
23:11:06 <ihope_> Then get rid of only division?
23:11:10 <ehird`> jmp ABSOLUTE_BYTES -> bjmp RELATIVE_BITS and fjmp RELATIVE_BITS
23:11:15 <ehird`> and no i like division :(
23:28:25 <ihope_> Division is weird!
23:29:23 -!- olsner has quit (Read error: 104 (Connection reset by peer)).
23:32:57 -!- oerjan has joined.
23:34:13 <ehird`> :p
23:34:24 <ehird`> for some reason i think i want to try learning base 57
23:34:30 <ihope_> Base 57?
23:34:38 <ihope_> That's silly. Learn base 59 instead.
23:35:14 <ehird`> why. base 57 is cooler
23:35:19 <ihope_> No it isn't.
23:35:21 <ihope_> Base 59 is prime.
23:35:38 <ihope_> Or you could go base 67, which is also prime.
23:35:56 <ihope_> Or 61, or any of the many other prime numbers...
23:36:36 <ehird`> base 43
23:36:45 <ehird`> no - base 31
23:37:53 <ehird`> 3.4c25oe856s6...
23:37:55 <ehird`> not pretty enough
23:38:40 <SimonRC> 36 is good
23:38:56 <ihope_> No, 36 is bad bad bad!
23:38:57 <SimonRC> very composite, yet typable
23:39:06 <ihope_> It's composite composite composite!
23:39:13 <ehird`> i hate base 36
23:39:17 <ehird`> base 43 might be nice
23:39:17 <ihope_> Unless you want a composite number, of course.
23:39:19 <SimonRC> digits -> 0123456789abcefghijklmnopqrstuvwxyz
23:39:27 <SimonRC> or base 62:
23:39:33 <ihope_> I think base 31 is nice.
23:39:38 <SimonRC> digits -> 0123456789abcefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
23:39:52 <SimonRC> mixed-base, like HP money?
23:39:56 <ihope_> Base 61 lets you use every alphanumeric character except "D".
23:40:00 <ehird`> what does pi look like in base 43
23:40:01 <SimonRC> ?
23:40:09 <SimonRC> ehird`: ask dc
23:40:15 <ehird`> i don't have dc, this is the windows box
23:41:02 <ehird`> you ask dc for me :p
23:41:51 <SimonRC> not installed
23:42:34 <ihope_> Hmm.
23:42:43 <ihope_> I'll run up and run it.
23:44:12 <ihope> What's the syntax?
23:44:43 <ehird`> for calculating pi in base 43?
23:44:50 <ihope> Yeah.
23:44:51 <ehird`> probably P<[";d']43 knowing dc
23:44:59 -!- ihope__ has joined.
23:45:28 <SimonRC> ihope__: um, "run up"
23:45:29 -!- cherez has quit ("Leaving.").
23:45:47 <SimonRC> you don't have ssh on that box
23:45:47 <ihope> SimonRC: yes?
23:45:50 <SimonRC> ?
23:45:55 <ihope> I probably do.
23:46:01 <ihope> But I don't know its IP address.
23:46:33 <ehird`> gawd all i want is pi_43 :p
23:48:14 <ehird`> =p
23:49:02 <SimonRC> ihope: ah, you need DNS then... :-)
23:50:10 <ihope> "The symbol & (called an ampersand) is sometimes placed in front of a number to show that it is a hexadecimal number." http://www.cleavebooks.co.uk/scol/calnumba.htm
23:50:28 <ehird`> that's very interesting and all, but-
23:50:34 <ehird`> :p
23:50:34 <ihope> Cool, a convention I've never heard of rather than the one that seems ubiquitous.
23:50:49 <ihope> Heck, you do it :-P
23:50:52 <ehird`> i can't
23:50:52 <ehird`> :(
23:51:06 <ihope> P<[";d"]43 gives a large number of error messages.
23:51:16 <ehird`> it was a joke-
23:51:20 <ihope> Oh.
23:53:07 <ehird`> just - someone put it in the topic - pi in base 43 - if they calculate it :p i'll see it tomorrow
23:53:13 <ihope> Oi.
23:53:20 <ihope> MemoServ?
23:53:24 <ehird`> k
23:53:42 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
←2007-08-09 2007-08-10 2007-08-11→ ↑2007 ↑all