00:18:02 -!- poiuy_qwert has quit (Read error: 110 (Connection timed out)).
00:38:25 <lament> man, i like haskell, but it tries pretty hard to make me hate it
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:55:14 <ihope> ~exec sys.stdout([pi % e, pi - e])
00:55:15 <bsmnt_bot> NameError: name 'pi' is not defined
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])
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:02:13 <sp3tt> ~exec sys.stdout(math.exp(math.pi)-math.pi)
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:10:07 <ihope> (|the latter> + |the former>)/sqrt(2)
01:10:27 <ihope> See? I told you WHICH quantum superposition it is.
01:11:38 <oklopol> or is it like uncheckalbbebvevr
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: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: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:15:25 <oklopol> i wish i vaguely recalled every bit of information that exists
01:15:42 <ihope> I vaguely recall that P = NP.
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: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: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:21:08 <ihope> Apart from the fact that you have to do something while doing nothing in order to do that.
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: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: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:24:27 <oklopol> unless there actually exist ones
01:27:48 <oklopol> i might endoy flying to istambul or something
01:28:09 <oklopol> guess that would depend on how high i'd fly
01:30:03 <oklopol> ihope: you forgot to tell me how to do something unproductive with the computer
01:30:21 <ihope> Study... er, wait.
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:52 <Sukoshi> And with that, I go to do me daily Japanese work.
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: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:52 -!- GreaseMonkey has quit ("Remember kids, be careful with explosives, they might be interesting!").
10:28:27 -!- asiekierka has joined.
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:31 <asiekierka> 510 - 194 = approx. space for BF code :)
10:30:09 <Sukoshi> I don't know enough about bootcodes, but I wanna read the ASM :)
10:33:07 -!- Darktemplar has joined.
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:36:10 <Darktemplar> if I make a BF-CommandLineInterface that's gonna be dead :)
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:50 <asiekierka> sending the code with ,[.,] and binaries
10:38:19 <Darktemplar> but frequent stack operating around'em should do
10:40:57 <Sukoshi> You can do what Forth does, blocks for the FS.
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:46:47 <asiekierka> that stores filename you want (8.0 :D) and amount of blocks it takes
10:50:19 -!- ehird` has joined.
10:50:41 <asiekierka> My friend did a BF reader in a bootsector!
10:51:26 <ehird`> of course you can fit BF into a bootsector
10:51:45 <ehird`> then it isn't BF any more
10:51:48 <asiekierka> and it's smaller than AmigaOS interperter
10:52:48 <ehird`> why is jumpfuck "of course"?
10:52:53 <ehird`> i wrote jumpfuck mainly for compiler writers
10:53:16 <ehird`> this jump fuck? http://esolangs.org/wiki/JumpFuck
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: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:12 <ehird`> Darktemplar: binary what?
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: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: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 <asiekierka> since we have 3 more commands to BF, making it total of 11 commands
10:58:27 <ehird`> maybe BF machine's IO commands?
10:58:30 <ehird`> then you could do graphics :p
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
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:41 <Darktemplar> like ! - read from port no. current cell and save it in n+1 cell
11:01:35 <Darktemplar> like ADD = CreateCommand("Add.Command","+",NOTPRIVILENGED);
11:01:46 -!- sekhmet has quit (heinlein.freenode.net irc.freenode.net).
11:02:06 -!- sekhmet has joined.
11:02:26 <ehird`> gwar, why are there no decent binary editors
11:03:21 -!- Darktemplar has left (?).
11:06:40 <ehird`> hehe, tiny infinite loop:
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: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: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: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:16:15 <ehird`> have you EVER coded low-level asm?
11:16:21 <ehird`> do you seriously think NOP is useless?
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:44 <ehird`> wait you couldn't do that
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:40:10 <ehird`> how much chuck would a chuck wood wood if a chuck wood could wood chuck?
11:48:51 <ehird`> got any ideas for how i can make http://pastie.caboo.se/86570 turing complete? :)
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: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:57:32 <oklokok> 0D0A in windows, 0A in unix, 0D in mac iirc
12:00:26 <oklokok> you can put that to be sure
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:31 -!- asiekierka has quit.
12:03:38 <oklokok> i just like nestable memory slots better :
12:05:32 <ehird`> how would a relative jump make it tc
12:05:38 <ehird`> you still can't access infinite memory
12:06:14 <oklokok> so that memory slot 0000 moves
12:06:26 <oklokok> tc via trivial isomorphism to bf
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:08:17 <oklokok> millions of ways to do ittidy
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: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:11:05 <oklokok> you could have a way to jump to next "page"
12:11:15 <ehird`> but i have never seen machine code with "mem jump"
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:35 <ehird`> instead of just immediate values?
12:11:57 <ehird`> do they have a computed store or something
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:56 <ehird`> i see, that makes sense
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: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: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: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:19:10 <ehird`> it makes it turing complete because
12:19:33 <ehird`> Ah, wait, I'm going to tweak the code a bit
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: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: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: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:30:00 <ehird`> with AAA BBB arguments, which take the address from the register
12:30:17 <ehird`> HOWEVER i can't just replace those two
12:30:25 <ehird`> as they supply the >only way to get values from memory<
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: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: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:54 <ehird`> well, maybe not completely TC
12:33:01 <ehird`> because of the size of the values
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: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:35 <ehird`> what do you mean what do i mean
12:34:49 <oklokok> arithmetic shift == takes sign into account
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:28 <ehird`> ok, well which one should i implement ;)
12:35:59 <ehird`> i don't actually need bit shifts!
12:36:45 <ehird`> and i have the irb session logs to prove it!
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: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: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: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: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: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: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: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: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: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: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: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: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:25 <oklokok> ehird`: i meant i'd say "do the nand"
12:55:59 <ehird`> get rid of not and and
12:56:03 <ehird`> and replace them with nand?
12:56:12 <oklokok> and also remove or and xor
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: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 <oklokok> and you have one spot open
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: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:45 <oklokok> (then SET would be the only exception)
13:03:23 <ehird`> i don't like your idea
13:03:28 <ehird`> because it makes setting memory locations harder
13:03:35 <ehird`> you need a SET and then a STORE
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:43 <oklokok> i'm really gonna go eat now
13:06:00 <oklokok> i wish i was doing something... doing stuff is so much fun :<
13:06:13 <oklokok> because i'm reading swedish vicabulary.
13:06:14 <ehird`> http://pastie.caboo.se/86585
13:06:19 <ehird`> i need to free up one more instruction
13:07:46 <oklokok> usually you *have* a condition for a jump and any 1100 AAA AAA CCC equals 1101 CCC
13:08:21 <oklokok> (two reasons to remove 1101 that way)
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:11:03 <oklokok> if you don't wanna do any preprocessing for the code that is
13:12:08 <ehird`> well yeah it is trivial
13:12:24 <ehird`> since it'll use another instruction internally
13:14:41 <oklokok> you could make a halt address.
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:49 <ehird`> it's feasable that some code would be that long
13:15:53 <ehird`> though. admittedly. not likely :)
13:16:03 <ehird`> yeah. i'll get rid of halt
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: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:38 <ehird`> i'll just get rid of unconditional jump
13:18:42 <ehird`> anyway i've almost finished the new spec
13:18:51 <ehird`> should i combine input and output?
13:19:01 <oklokok> that's the 3rd way i suggested
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:55 <ehird`> i am talking about port numbers
13:20:57 <oklokok> aaaaand now i realize what you said.
13:21:21 <oklokok> takes me a while sometimes, no matter how simple a thing people say to me
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:48 <ehird`> so if i have terminal as 0
13:32:35 <oklokok> you wanna include those in the spec?
13:32:43 <oklokok> well i guess you wanna assign a few
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:49:35 <oklopol> decided not to eat today, bought 5 liters of juice
13:58:02 <oklopol> that's pretty... impressive :P
13:59:47 <oklokok> you can have a sound port and a kinda raw pixel feed port or something
14:00:08 <ehird`> but.. something more useful..?
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:11:46 <oklokok> stdio, stderr are the only ones i can think of
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:19 <ehird`> just, any sort of communication at all
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: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: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:17:07 <oklokok> you said that's not very necessary
14:18:10 <ehird`> no you didn't say that :|
14:18:25 <oklokok> (oklokok) you can have a sound port
14:18:42 <ehird`> sound port != computer speaker
14:21:10 <oklokok> anyway, yeah you can have one be a sound port
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:22:25 <oklokok> making sounds is hell in like every goddamn platform
14:23:25 <ehird`> yeah; how do you do it in ruby?
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:26:41 <ehird`> when i say computer speaker
14:26:43 <ehird`> i mean internal speaker
14:27:00 <oklokok> pc beeper is what i've thought it's called
14:27:25 <oklokok> i guess that's just for pc.
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:32:01 <ehird`> but if you alternate between two very short notes
14:32:05 <ehird`> you can get the illusion
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:33:25 <ehird`> if i add something that controls the screen too
14:33:38 <ehird`> you could create a 99 bottles of beer program with colour graphics and sound :)
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:46 <oklokok> depends on how strictly the movement of the cone is defined
14:35:31 <oklokok> so... you could make a program to convert wav -> beeper
14:37:10 <ehird`> do you have ruby installed
14:38:40 <oklokok> and 2.5 i have to do some tricks to get open
14:47:19 <oklokok> i do know how to make the pc beeper sing in python
14:47:42 <oklokok> http://vjn.fi/s/beepiano.py
14:48:03 <ehird`> wow, a three letter domain name
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: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:13 <oklokok> well okay it's my page in that most of the content is made by me
14:51:55 <oklokok> web hotel == a public service for a server to maintain that
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
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:28 <oklokok> i'm gonna go... do some cleaning now ->
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:13:55 <ehird`> but it's recorded at insanely low volume
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: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:18:39 <ehird`> it skips parts when recording
15:18:42 <ehird`> for no apparent reason
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: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: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: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: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: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: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: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:43 <oklokok> i'm not talking about length
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: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: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: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:21:35 <lament> 3.1489797239479878971073891723816378969086359782649786301276382935496123897
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:13 <ehird`> i still need it right now :p
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: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:52 <ehird`> the current spec should be TC
19:50:02 <ehird`> if you don't believe me... then i guess i'll write brainfuck rewriting rules for it
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:20 <ehird`> oklokok: if you had more than 8-bit addresses, yes
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:27 <oklokok> it is if pointers are infinite.
19:52:35 <oklokok> the size of a pointer is not defined
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:51 <ehird`> ihope_: iirc, it defines pointers pretty precisely
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: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:55 <ehird`> you have to pay to get the spec
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: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:06:53 <ehird`> sizeof(X) must return a value that makes sense
20:06:58 <ehird`> and it must be >right<
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: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: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: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: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: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: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: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:20 <ihope_> Thus making it not an esoteric feature.
20:33:36 <ehird`> its tinyness really has no use
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: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:43 <ehird`> bitwise cyclic tag -- easy to use? are you KIDDING?
20:35:57 <ihope_> I dunno. You might need to spend some time learning it, but after that...
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: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: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: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: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:36 <ehird`> ihope_: and that in binary? :)
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: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: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: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:58:11 <ehird`> not 256 bytes of data + code
20:58:21 <ehird`> 256 bytes is the POINTER size
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: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
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: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: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: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: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:12 <ihope_> d is 0, a is 10, b is 11.
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:13 <oklokok> so what exactly does it do there?
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: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: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:17:21 <ehird`> some don't seem to do it properly :p
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: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:56 <ihope_> oklokok: {{name of the template|program|data string}}
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: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: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: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: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: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:28:05 <ihope_> Hmm, there happens to be some in the sandbox: http://esolangs.org/wiki/Esolang:Sandbox
21:28:14 <ehird`> "\000\034\004\000\020\0000\020\223!V\207\030\333\233\027\204L\002Hello, world!"
21:28:51 <ehird`> does the mediawiki installation allow arbitary uploads?
21:28:55 <ehird`> like, can i upload a .bin
21:29:11 <ihope_> Er, installation, did you say?
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:38 <ehird`> i mean, metaphorically
21:32:50 <ehird`> it looks so tiny, in text editors
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:35 <ehird`> ok, yael file extension = ?
21:33:57 <oklokok> ehird`: implementation defined io stuff?
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> 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:37:16 <ehird`> ".ymc" is not a recommended image file format.
21:37:17 <ehird`> Retrieved from "http://esolangs.org/wiki/Special:Upload"
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:41:22 * ehird` just realised that Yael has 8 registers, not 4
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: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: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`> # Set mainloop_start = start of main loop
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: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: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: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:45 <ehird`> i take it nobody thinks thats a good idea
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:31 <ehird`> win32's Beep function? :P
22:15:41 <ehird`> yeah, that sounds like a good benchmkar
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:42 <ehird`> like, a regular computer speaker tune
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:03 <ehird`> but, yes, that kind of thing
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: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: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: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:19 <ihope_> More of an entire music generation thing.
22:32:32 <ehird`> well if you can code that in Yael
22:32:36 <ihope_> Mm, doing that would produce a simple tune :-)
22:33:05 <ehird`> i was meaning as a >segment<
22:33:15 <ehird`> like, if at one point you want to slide up and down three times
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:23 <ehird`> if someone does that, i'll give them a medal :p
22:35:05 <ehird`> nevermind repeating 3 times
22:35:14 <ehird`> then you'll have an oscillating music program :)
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: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: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: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: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: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: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: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:37 <ehird`> there is surely a way to emulate or with xor
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:13 * ehird` continues wondering what instruction to ditch
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: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:29:23 -!- olsner has quit (Read error: 104 (Connection reset by peer)).
23:32:57 -!- oerjan has joined.
23:34:24 <ehird`> for some reason i think i want to try learning base 57
23:34:38 <ihope_> That's silly. Learn base 59 instead.
23:35:14 <ehird`> why. base 57 is cooler
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: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:17 <ihope_> Unless you want a composite number, of course.
23:39:19 <SimonRC> digits -> 0123456789abcefghijklmnopqrstuvwxyz
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:15 <ehird`> i don't have dc, this is the windows box
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:51 <ehird`> probably P<[";d']43 knowing dc
23:44:59 -!- ihope__ has joined.
23:45:29 -!- cherez has quit ("Leaving.").
23:45:47 <SimonRC> you don't have ssh on that box
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: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 <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:51:06 <ihope> P<[";d"]43 gives a large number of error messages.
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:42 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).