00:02:21 -!- Sgeo has joined.
00:07:41 -!- TeruFSX has joined.
00:14:52 -!- jiella has quit (Quit: Leaving.).
00:18:07 -!- kwertii has joined.
00:18:21 <olsner> > (zipWith (/) `on` map (fromIntegral . ord)) "A[bbe\GSPehbZ\RS" "Hello World!" -- previous 10% bug, fwiw
00:18:23 <lambdabot> [0.9027777777777778,0.900990099009901,0.9074074074074074,0.9074074074074074...
00:45:07 <oerjan> olsner: what was this esolang again, i vaguely recall this 10% bug thing...
01:10:22 -!- monqy has quit (Quit: hello).
01:44:07 -!- trout has changed nick to const.
01:50:52 -!- madbr has joined.
01:52:50 -!- oerjan has quit (Quit: Ribbit).
01:55:52 -!- Jafet has quit (Quit: Leaving.).
02:19:40 -!- TeruFSX has quit (Ping timeout: 246 seconds).
02:33:20 -!- olsner has quit (Ping timeout: 246 seconds).
02:33:48 -!- olsner has joined.
02:37:52 <kmc> http://goatkcd.com/1115/sfw [nsfw]
03:06:35 -!- Jafet has joined.
03:14:55 -!- ogrom has joined.
03:16:14 -!- ogrom has quit (Client Quit).
03:38:22 <zzo38> What does 6502 do on each cycle of an instruction?
03:39:09 <madbr> usually a memory operation
03:39:50 <madbr> in some cases just an "internal operation" (all 2 cycle instructions that don't access memory are like this)
03:40:08 <madbr> such as nop (2 cycles)
03:40:33 <madbr> or lsr a (2 cycles)
03:40:55 <zzo38> But in instructions taking longer to execute, what memory access read/write done with each cycle? When does it read the next instruction and its operands?
03:41:09 <madbr> (a large majority of cycles do a memory op)
03:41:36 <madbr> I don't think it is pipelined
03:42:14 <madbr> so a cycle is something like
03:42:46 <madbr> [cycle 1] read instruction
03:43:17 <madbr> [cycle 2] no memory op but ALU is active
03:44:01 <zzo38> If there is no memory operations, what is on the address bus at that time?
03:44:44 -!- sivoais has quit (Ping timeout: 246 seconds).
03:44:46 <kmc> F L O A T I N G B U S
03:44:46 <madbr> probably the same address as last cycle, or 0
03:46:10 <madbr> fun fact: the original nmos 6502 was so slow that it actually only accessed memory half the cycles on the Apple II
03:46:24 <madbr> the other half was used by the video display :D
03:46:50 <kmc> i heard the original nmos 6502 would also do crazy shit if you gave it invalid instructions
03:47:23 <madbr> kmc: yeah that's what the docs say :D
03:47:24 <zzo38> I think there are unofficial instructions?
03:47:38 <kmc> i thought some of them were byproducts of the instruction decode logic
03:47:47 <madbr> zzo: the docs say that a lot are unstable
03:47:58 <madbr> plus they won't work on a 65816
03:48:06 <zzo38> Yes I know, I read that some are unstable, but they said some are stable.
03:48:38 <zzo38> But some are the same as other instructions and so are not so useful unless you are also using the instruction opcodes as data in the same program
03:48:44 -!- sivoais has joined.
03:49:18 <ion> Demo sceners have been using the “invalid” 6502 instructions a lot.
03:49:54 <madbr> supposedly they do weird shit like adding and anding stuff at the same time
03:50:13 <zzo38> Such things can occasionally be useful.
03:50:46 <ion> If you’re counting cycles, certainly.
03:51:31 <zzo38> I have added the stable unofficial instructions into Unofficial MagicKit (only available for targets which do not override those instructions with new ones)
03:53:04 <madbr> reading about the 6502 it does come off as totally underpowered
04:01:25 <zzo38> 6502 has decimal mode, but some 6502 based computers lack decimal mode
04:03:03 <madbr> who uses decimal mode?
04:03:13 <zzo38> Is the decimal mode useful for something other than decimal calculation?
04:03:42 <zzo38> I don't know who uses decimal mode.
04:03:52 <madbr> my guess is: banks
04:05:59 <zzo38> Some programs I wrote are for Famicom which lacks decimal mode, so I have never used it. If I program a computer which does have decimal mode I may sometimes used it.
04:06:25 <zzo38> x86 has some instructions for BCD arithmetic.
04:06:41 <zzo38> But I think they cannot be used in 64-bit mode.
04:07:04 <kmc> correct :/
04:07:34 <kmc> they are useful for things besides BCD
04:07:47 <kmc> AAM does AH <- AL / 10; AL <- AL % 10
04:07:56 <kmc> but you can actually change that 10 by changing the second byte of the instruction
04:07:58 <zzo38> Yes, AAM and AAD, you can change the base
04:09:47 <zzo38> So I suppose setting the base to 1 would be a way to move AL to AH and then set AL to zero, it might be slower but it might also be a smaller code
04:09:58 <zzo38> What happen if you set the base to zero?
04:11:00 <zzo38> Will GCC or LLVM make these instructions if it is not 64-bit mode?
04:12:24 <madbr> they probably don't run fast on modern processors
04:12:52 <zzo38> I know it may be slow, but might it sometimes result in a smaller code, if you select that option for some subroutines?
04:13:41 <madbr> like, you can't even express BCD operations in C/C++ afaik
04:13:54 <zzo38> In case you want to optimize some functions for size and some for speed
04:15:29 <madbr> how would you shrink a function by using BCD?
04:15:34 <zzo38> I know C has no commands for BCD operation, and LLVM also has no commands for BCD operation, but some things may sometime result in equivalent to such operation, or even other operation which the target computer may have
04:17:01 <zzo38> madbr: I don't know, but it might if the function is used for making BCD calculation. And anyways, the AAM and AAD instruction can be used for operations other than BCD arithmetic too.
04:18:05 <zzo38> They described above AAM does AH <- AL / 10; AL <- AL % 10 but it does not have to be 10 you can use a different number instead
04:18:33 -!- kwertii has quit (Quit: kwertii).
04:20:39 <zzo38> Such as if you just want to move AL to AH and then set AL to zero, or to move some of the bits of the numbers in certain way, it would probably be very slow to use division but may result in a smaller code, such as if used only for initialization, or if you want the code to fit in MBR
04:23:13 <madbr> still hare brained and no new instruction set should have those monstruosities :D
04:24:35 <madbr> like, wtf, 6 BCD instructions on x86
04:24:45 <madbr> which could have been something useful instead
04:25:55 <pikhq> Yeah, but in CISC design it almost makes sense
04:26:54 <zzo38> Well, I think AAM and AAD are useful instructions.
04:27:06 -!- Jafet has quit (Ping timeout: 245 seconds).
04:27:10 <madbr> they all have 1 byte opcodes too
04:28:09 <madbr> they take 10/18 cycles on the pentium
04:28:23 <kmc> bear in mind that x86 is evolved from a wee little calculator processor
04:28:51 <pikhq> Yeah. Its lineage goes back to a CPU with 4-bit address space for a desktop calculator.
04:28:53 -!- Jafet has joined.
04:29:06 <pikhq> Erm. Was it 4 bit address space?
04:29:12 <madbr> depressing but true
04:29:13 <pikhq> Might've just been 4 bit registers.
04:29:42 <pikhq> 12-bit address space.
04:29:48 <madbr> amazingly it's still better than the 6502
04:30:09 <madbr> which never got a 32bit version
04:30:39 <pikhq> It got a 16 bit version.
04:30:41 <zzo38> Yes they are too slow, but if they are not too slow it may sometimes be useful, and it can also be useful if you do not need it to be fast
04:30:50 <madbr> yeah, 65816, used on the snes
04:31:06 <pikhq> *Not* a 32 bit version.
04:31:33 <madbr> zzo: you could simply store a LUT somewhere
04:32:07 <madbr> and do the same operation in 1 cycle, pairable on the pentium
04:34:45 <kmc> it's all about the pentiums
04:36:18 <madbr> well, essentially on the pentium they decided which instructions would be fast, and which ones would be slow
04:36:29 <madbr> and the same selection applies to the later processors
04:37:58 <madbr> and essentially that's where they turned x86 into a bogo-risc
04:45:17 <shachaf> kmc: mosh works with the scroll wheel now?
04:45:59 <kmc> for what values of "works"?
04:46:15 <shachaf> I'm moshing to my irssi and scrolling the scroll wheel goes up and down in history.
04:47:04 <kmc> i am surprised
04:47:22 <shachaf> Hmm, this might be a fluke.
04:47:31 -!- Jafet has quit (Quit: Leaving.).
04:47:39 <kmc> i don't think we're setting alternate screen on the client
04:47:42 <kmc> https://github.com/keithw/mosh/issues/2 is still open
04:47:48 <kmc> you can ask in #mosh though
04:47:50 <shachaf> Yep, even if I detach from screen, scroll-wheel goes up and down in bash history.
04:48:08 <shachaf> Somehow I got into scroll-wheel-sends-up-and-down-arrows mode, or something.
04:49:12 <kmc> well that's useful
04:50:18 <kmc> in the neon sign, scrolling up and down, i am born again
04:50:20 <shachaf> kmc: Hah, irssi put me in this mode.
04:50:25 <kmc> irssi ate my balls
04:50:39 <shachaf> I previous sshed to irssi and exited with ~.
04:57:57 <madbr> the ARM has like 10 different multiply instructions
05:00:58 <zzo38> What kind of multiply instrucions?
05:01:10 <madbr> multiply, multiply accumulate, multiply subtract
05:01:20 <madbr> multiply to 64 bit
05:02:38 <madbr> weird "wide" multiply (32*16)
05:03:29 <madbr> multiply 16 bit into 64 bit accumulator (weird :o )
05:04:25 <madbr> double 16 bit multiply adding/subtracting the productions
05:05:06 <madbr> 32 bit mul keeping only the most significant 32 bits of the result
05:06:31 <madbr> dual 16bit multiply adding/subtracting the products then accumulating
05:07:29 <kmc> multiply with combining grass radical above
05:07:35 <madbr> same but accumulating 64bit
05:08:36 <madbr> multiply 32 bit into 64bit accumulator
05:09:00 <madbr> ...for the non SIMD multiplications :D
05:09:18 <madbr> the SIMD ones are even crazier :D
05:13:38 <madbr> good thing ARMs don't have bcd
05:17:15 <zzo38> Do you know any computers with a triple indirect jump with post increment instruction?
05:18:38 <kmc> well the RCA 1802 has weird indirect registers
05:18:40 <kmc> "Using the SEP instruction, you can select any of the 16 registers to be the program counter; using the SEX instruction, you can select any of the 16-bit registers to be the index register."
05:19:08 <kmc> but i don't know what the addressing modes are
05:19:16 <kmc> zzo38: do you want this address mode for any particular purpose?
05:20:05 <zzo38> I am just wondering if anything has something like that.
05:20:48 <zzo38> It allows you to change which register is the program counter? I have never seen anything like that before.
05:21:23 <kmc> as wikipedia describes, this was sometimes used for fast subroutine calls, even alternating coroutines
05:32:23 <madbr> can be translated as "this architecture will never be able to be pipelined"
05:35:27 <kmc> ARM lets you swap the contents of the instruction pointer and another register, right?
05:35:31 <kmc> that is similarly useful and less crazy
05:35:56 <madbr> yeah ARM has the PC as one of the GPRs
05:36:05 <madbr> which turned out to be a mistake
05:36:21 <madbr> now if you look at the ARM manual most instructions say
05:36:44 <madbr> "non of the operands of this instruction can be r15 (pc)"
05:37:02 <kmc> that's too bad
05:37:27 <madbr> it's ok when you're running at 10mhz and your pipeline is 2 cycles long
05:38:24 <madbr> once your cpu is doing 2 instructions at the same time then your PC is not your PC anymore
05:38:58 <madbr> not to mention crazy out of order CPUs (essentially all modern CPUs)
05:39:47 -!- sivoais has quit (Read error: Connection reset by peer).
05:40:25 <madbr> sgeo: it's possible!
05:40:34 -!- sivoais has joined.
05:40:39 <Sgeo> As in, I don't know what either of those mean.
05:41:00 <Sgeo> I know RISC is reduced ... something about few instructions
05:41:08 <Sgeo> Like a small number of opcodes or something
05:41:52 <kmc> a CPU has several stages to process an instruction
05:42:13 <kmc> fetch the instruction from memory, figure out what it means, fetch operand(s) from memory, do arithmetic or whatever, save result
05:42:18 <madbr> risc = lots of registers, high instruction set orthogonality
05:42:28 <kmc> each of these has a different piece of hardware
05:42:42 <kmc> it would suck if we only used one of those units at a time
05:42:50 <madbr> yeah but the number of stages varies a lot
05:42:59 <kmc> in a pipelined processor we are fetching one instruction while we decode the previous one, while we fetch for another, etc.
05:43:04 <kmc> yeah this is a simplistic explanation
05:43:06 <kmc> but that's the idea
05:43:52 <madbr> the ideal early RISC cpu runs 1 instruction per cycle
05:43:54 <kmc> another way to look at it is, if you tried to do all that stuff in one clock cycle, your max clock speed would be really low, because of the delay to propogate through all those logic gates
05:43:56 <Sgeo> What happens with jumps or conditionals?
05:44:10 <madbr> sgeo: depends on the length of the pipeline
05:44:13 <kmc> yeah, that's a trick
05:44:28 <kmc> this is why on MIPS processors, the instruction after a branch gets executed even if the branch is taken
05:44:35 <madbr> on longer pipelines and stuff like the x86 it tries to predict the result
05:44:46 <kmc> RISC processors tend to expose these implementation details, on the grounds that the compiler can deal with them
05:45:10 <Sgeo> Oh, hmm. I thought maybe the fetched thing that was after the jump just gets discarded
05:45:26 <madbr> sgeo: not on the MIPS
05:45:35 <kmc> yeah you can stall the pipeline like that
05:45:43 <madbr> it makes CPUs easier to design
05:45:54 <kmc> but then you're executing fewer than one instruction per clock
05:46:05 <kmc> if the compiler has nothing useful to put there, it can insert a NOP
05:46:08 <madbr> but there's not much point later on when your pipeline is 8 cycles and you have to do branch prediction anyways
05:46:09 <kmc> otherwise maybe it can do some useful work
05:46:33 <madbr> 1 cycle isn't much, you can pretty much always put something there
05:47:20 <kmc> Sgeo: another problem is data dependencies, what if a write and a read from the same register are in the ppipeline at the same time
05:47:48 <kmc> you can stall, or you can insert "bypass" paths which let it read the value that will be written, rather than the stale value that's in the register file
05:47:54 <kmc> which adds complexity
05:48:00 <kmc> MIT's 6.004 is a really nice intro to this stuff
05:48:03 <madbr> if your cpu is a well designed RISC you can do these all in 1 cycle
05:48:13 <kmc> you design a RISC processor in a logic gate level simulator
05:48:19 <kmc> and then you can optimize it for speed
05:48:32 <kmc> the labs and software are available online
05:48:33 <madbr> but once you're doing like 2 operations at the same time etc you have to introduce stalls
05:48:41 <madbr> or out of order execution
05:49:09 <kmc> i did the 2 stage pipeline with stalls on branches, which wasn't too bad
05:49:16 <kmc> but more than 2 stages gets hairy
05:50:32 <fizzie> TMS320C64x has two-instruction delay slots. Except it's one instruction if it's one of the instructions that are followed by an immediate word. Keeping track of that kind of thing manually is kind of a pain. (Though I suppose you're meant to mostly just write C and use the provided algo libs.)
05:50:45 <kmc> that's a DSP?
05:51:00 <kmc> VLIW is still popular for DSPs right?
05:51:02 * kmc does not know why
05:51:19 <madbr> kmc: they're probably easier to design
05:51:49 <madbr> of course that's a road to the intel itanium and we all know what happened to that one :D
05:51:54 <fizzie> I don't know how popular; the C64x used by the popular-in-phones OMAP platform (at least OMAP3 and I think 4 too) is a VLIW thing.
05:52:03 <kmc> it's amazing how far the inner workings of a CPU are from the virtual machine suggested by the instruction set
05:52:16 <kmc> when people talk about how C and assembly tell you "what the machine is really doing" i just laugh and laugh
05:52:39 <shachaf> They tell you what *a* machine is really doing.
05:52:44 <kmc> (of course with C people also forget that there's an optimizing compiler which can make liberal use of undefined behavior)
05:52:47 <shachaf> There's always another turtle somewhere.
05:53:02 <kmc> but they act like they've found the bottom turtle and it's special
05:53:37 <zzo38> We should make up the CPU where the instruction set corresponds closely to the inner working and work faster too.
05:53:38 <shachaf> The ISA is a pretty good turtle.
05:53:44 <madbr> well, it's the bottom turtle you can actually write for
05:53:52 <kmc> zzo38: that is the idea of RISC basically
05:53:54 <madbr> zzo: that's called a VLIW
05:54:19 <kmc> yeah i guess VLIW is that idea for superscalar
05:54:25 <madbr> zzo: the big problem with VLIW is that they bust the instruction cache
05:54:42 <madbr> you'd end up with an instruction word like
05:54:49 <pikhq> kmc: Doncha *love* it when people act like x86 asm is what the machine "really does"?
05:54:58 <kmc> shachaf: do you know about implementing a touch / proximity sensor with two digital I/O pins, a resistor, and a piece of wire?
05:55:18 <pikhq> Rather than just being the lowest abstraction Intel provides? *urgh*
05:55:22 -!- nortti has quit (Ping timeout: 268 seconds).
05:55:25 <kmc> well you set one pin as input and one as output
05:55:41 <kmc> connect the pins with a big resistor (≥ 1 MΩ)
05:55:48 <madbr> add r0, r1, r4 sub r3, r7, r8 add r9, r2, r14 shfnop mulnop ldr r5, r13
05:55:50 <zzo38> I have had ideas of CPU instruction sets based on what is hardware what I was thinking of.
05:56:01 <kmc> and also connect your wire or metal plate to the input pin
05:56:18 <madbr> essentially a bunch of ALUs, each one gets an operation on every cycle
05:56:28 <kmc> then you simply toggle the voltage at the output, and see how long it takes the input to match
05:56:43 <kmc> this is a measure of the capacitance on that pin, which will change if someone touches or gets near the wire / plate
05:56:54 <madbr> the other big problem with an architecture like that is that, what happens if you have a cache miss?
05:57:16 <madbr> you'd have to stall everything
05:58:05 <madbr> also you'd probably have to cover the chip in multiplexers
05:58:55 <kmc> the other other problem is that your compiler has to be crazy smart
05:59:08 <zzo38> Another idea I have, is first you need a open-specification FPGA (some people have partially reverse-engineered the AT40k FPGA, so we can use that), and have a compiler which takes LLVM codes with speed annotations (such as: this function runs in less than 1 million clock cycles if the third parameter is divisible by 5) and creates a hardware optimized for running this program.
05:59:13 <madbr> dunno how smart it would have to be but yeah
05:59:48 <madbr> would be workable if it could reorder operations over multiple loop iterations but afaik C pointers usually have some ways to defeat that
06:00:10 <zzo38> Does what I said would work at all?
06:00:35 <madbr> tho I've heard that GCC is even able to autovectorize loops so it might be workable after all
06:01:20 <zzo38> If the FPGA is capable of reprogramming itself at runtime, then you can have not only self-modifying software codes, but you can have self-modifying hardware codes as well.
06:01:34 <kmc> perhaps VLIW is popular for DSP because people are willing to hand-code these algorithms (and use them from libraries) rather than expecting to feed some 40 year old FORTRAN codes in and get good performance
06:01:54 <madbr> imho the problem is C/C++
06:02:10 <shachaf> kmc would surely agree that "C/C++" is a problem.
06:02:31 <kmc> using "code" as a non-uncountable noun is a sign that one has worked in academic computing
06:02:36 <zzo38> What problem is C/C++? It has some problems but I don't know what problem you mean.
06:02:38 <kmc> like "here is a code for fourier transform"
06:02:48 <kmc> "here is a collection of codes for manipulating splines"
06:03:21 <madbr> zzo: the general problem is that the user might throw weird pointers at your algo
06:03:26 <Sgeo> I thought "code" as a non-uncountable noun is a sign that you don't understand programming at all and want people to give you stuff to copy and paste
06:03:29 -!- nortti has joined.
06:03:33 <madbr> like multiple buffers that are really the same buffer
06:04:32 <zzo38> It is why you have to specify in your documentation, if it is allow to be the same buffer or not, and stuff like that
06:04:47 <kmc> the compiler doesn't know that
06:04:59 <kmc> well you can use the 'restrict' keyword in some cases
06:05:01 <madbr> zzo: that's why older C/C++ compilers have a "no aliasing" switch
06:05:10 <zzo38> I think they added the "restrict" keyword so that the compiler will know that?
06:05:21 <madbr> which means that you promise pretty promise that you're not going to do it
06:05:22 <zzo38> And I also think LLVM has corrected some things?
06:05:34 <zzo38> Does LLVM have all of these things better way?
06:05:42 <madbr> though recent compilers don't seem to have the switch so they might have found out some better way yeah
06:07:04 <madbr> if that is the case it reduces the VLIW's problems to "code size" and "how to prevent a stall when you have to fetch the data all the way from the RAM"
06:07:48 <nortti> stopping irssi with ^z accidentaly seems to result in nothing else than disconnection from everywhere
06:08:27 <Sgeo> My stomach hurts, don't know if it's hunger or nausea
06:09:24 <zzo38> My idea is to have multiple memory connected, one for program, one for data X, one for data Y, and any of them can be switched with each other, and then have the address bus for data X and Y to be their own registers, the data bus are also their own registers, use LFSR-based PC with one register affecting the LFSR taps, an instruction transfer register to register with condition....
06:09:43 <madbr> zzo: you don't need multiple memories when you have cache
06:10:52 <zzo38> Having the LFSR-based PC with a register affecting the LFSR taps is somewhat like having a multi-dimensional programming language, if done in the correct way needed to do this, I guess
06:11:18 <zzo38> O, and then also add multiplexer calculation like how the Muxcomp esolang does it
06:11:51 <zzo38> These are just some ideas I have to make a CPU; I don't know how it is really working.
06:12:31 <madbr> I'd try going for one that has the maximum number of ALUs
06:12:35 <zzo38> madbr: But when you have cache, don't you then also need to have stuff such as cache invalidation and checking if it is cache and so on, unless your instruction set is dealing directly with the cache
06:12:48 <madbr> and base everything else around keeping those ALUs full most of the time
06:13:41 <madbr> zzo: yeah but afaik that's not so bad
06:14:57 <zzo38> It also seems difficult to predict how many clock cycles a certain sequence of instructions will take if it automatically reorders them and put into cache and all that other stuff.
06:16:58 <madbr> considering how DRAM works it's a lot faster to have cache
06:17:30 <madbr> also it prevents the need of having multiple ram areas for program, data x etc...
06:17:47 <zzo38> OK, but I still want it that the cache only works with instructions that directly tells the cache what to do
06:18:33 <madbr> yeah but then the compiler has to guess what goes in cache
06:18:53 <madbr> and all the manual cache management will probably slow it down a lot
06:20:24 <madbr> the big benefit of cache is that essentially your inner CPU core doesn't have to deal with DRAM anymore
06:20:49 <madbr> it becomes just "load from cache, stall if I get a cache miss"
06:21:31 <kmc> right, for a long time the DRAM controller wasn't even on the processor
06:22:30 <zzo38> But you could require that instructions can only execute from cache, and these instructions modify other instructions in cache in order to affect the values you are dealing with, and have the external address/data bus to just be registers visible to the program stored in cache
06:23:46 <madbr> good luck writing a program for that
06:25:24 <zzo38> You could then also have multi-cores executing separate programs simultaneously, with some registers shared, and others which are not shared, and some which are partially shared.
06:26:01 <madbr> aka the Cell processor
06:30:56 <zzo38> Or have something like that checkboard design mentioned on esolang list of ideas, which has the checkerboard of processor and memory (so each processor accesses four memory cores and each memory is accessed by four processor cores)
06:31:17 <zzo38> I don't know how well it would work
06:31:43 <madbr> I'm not familiar with multicore operation
06:31:55 <zzo38> Neither am I, actually.
06:32:19 <madbr> except from the user point of view ("you have to mutex everything because nothing happens in the real order")
06:33:06 <zzo38> I wrote in esolang list of ideas, make a programming language which requires bus conflicts and race conditions in order to work.
06:33:29 <madbr> one nice idea I had is a dataflow processor
06:33:44 <madbr> like, instead of having "write x to register y"
06:33:57 <madbr> have each register take a new value each cycle
06:34:06 <madbr> and have one ALU per register
06:34:17 <zzo38> Yes, do like that.
06:35:29 <madbr> maybe with access to values produced 2 or 3 cycles ago
06:35:39 <madbr> or switching between two sets of registers
06:36:25 <zzo38> What would you think about my idea of making the program which includes the hardware description of the CPU optimized to execute this specific program?
06:36:42 <madbr> afaik that already exists
06:37:06 <zzo38> Is it possible to compile LLVM programs into such things?
06:39:25 <madbr> no, it's some crazy expensive design software
06:40:12 <madbr> afaik most people just get a fast ARM system on a chip and run the C++ on that instead :D
06:41:58 <madbr> it's probably not very different from writing a C++ program and optimising the few loops that run a lot in ASM
06:44:11 <nortti> http://jollatides.com/2012/10/01/jolla-handset-poll-give-jolla-your-feedback/
06:48:12 <madbr> the other weird thing is that the amount of gates and latency of components like adders can vary
06:49:23 <madbr> afaik modern processors use very low latency adders which means they're probably enormous
06:49:48 <zzo38> ARM has some complicated instructions, requires memory of differing data sizes, apparently you are not allowed to use some instructions unless you pay them, and OpenCores made a "Amber" processor based on ARM but they were sued and not allowed to make anything beyond ARMv2
06:50:51 <fizzie> Oooh: a CPU where you have to plug in a credit card to enable some parts of the instruction set. And a per-instruction charge. Careful with those loops, now!
06:51:20 <zzo38> I think this is stupid so I do not want to use ARM in a computer design.
06:51:23 <madbr> fizzie: that's ARM's revenue model
06:52:13 <madbr> from what I can tell they license the SIMD unit and stuff like that
06:52:52 <madbr> which is why some androids don't have them and you have to have a C++ version of like everything :D
06:53:40 <fizzie> Perhaps, but it doesn't quite go as far as getting money when the individual end users want to run something that takes advantage of tricky parts.
06:53:46 <madbr> multiple data sizes is ok, the really complicated one afaik is when you allow unaligned accesses
06:54:34 <madbr> supposedly there's a patent on that too
06:58:57 <madbr> how about a design that has 2 modes: RISC, and VLIW
06:59:16 <madbr> RISC is designed to run C++, have compact code (16bit opcodes)
06:59:40 <madbr> VLIW is for the few inner loops that run a lot and have to be optimised
07:01:03 <madbr> the vliw mode can probably even be specially simplified
07:01:47 <madbr> since it probably doesn't have to deal with, say, real branching
07:02:05 <madbr> it's going to mostly loop the same piece of code hundreads of time
07:02:18 -!- madbr has quit (Quit: Radiateur).
07:04:04 <fizzie> Blerp. They upgraded this workstation, and now XMonad keybindings for switching between monitors (mod-{w,e,r}) are in the wrong order, because screen 0 happens to be the right one, not the left one.
07:07:08 <fizzie> Man, these Intel model numbers, I've completely lost track of them. It used to be so simple.
07:07:20 <fizzie> Now this new workstation has an "E31230".
07:22:46 <zzo38> What hardware programming language would you program it by specifying what gates you use and what connection you use between them and what propagation delay?
07:31:09 -!- zzo38 has quit (Remote host closed the connection).
07:46:23 <Lumpio-> I wonder if he was trying to describe something like verilog
08:03:54 -!- atriq has joined.
08:10:22 <fizzie> I can't rotate this single screen when it's in a NVidia TwinView configuration?
08:15:40 <atriq> fizzie, my lack of knowledge of C is letting me down
08:15:53 <atriq> Does "typedef int8_t jbyte" name jbyte as a type synonym of int8_t?
08:16:27 <atriq> So, in Haskell, that'd be something like "type JByte = Int8"
08:17:33 <fizzie> If you take a regular declaration that makes 'foo', say, a pointer to a no-arg function returning int -- int (*foo)(void) -- then adding a typedef in front makes 'foo' a synonym for the type it would've normally made 'foo' an instance of.
08:18:28 <fizzie> "In a declaration whose storage-class specifier is typedef, each declarator defines an identifier to be a typedef name that denotes the type specified for the identifier in the way described in 6.7.6."
08:18:44 <fizzie> It's kind of a silly that 'typedef' is a "storage-class specifier".
08:19:37 <fizzie> ("The typedef specifier is called a ‘‘storage-class specifier’’ for syntactic convenience only.")
08:19:43 -!- Arc_Koen has joined.
08:23:02 <atriq> Well, my C textbook is new enough to tell me about typedef, and despite elliott's recommendations I have not burnt it yet.
08:23:05 <atriq> So, I'll read that
09:05:34 -!- pikhq_ has joined.
09:05:44 -!- pikhq has quit (Ping timeout: 255 seconds).
09:07:32 <Arc_Koen> so what's up? have you completed your fueue interpreter in haskell?
09:07:45 <kallisti> > (replicate 3 ) (replicate 2 [2, 2])
09:07:47 <lambdabot> [[[2,2],[2,2]],[[2,2],[2,2]],[[2,2],[2,2]]]
09:07:52 <atriq> Haven't been working on it
09:08:04 <atriq> I'm trying to port something fizzie and elliott made a while back to Haskell
09:13:48 <atriq> I'm having difficulties in that C is not Haskell
09:18:06 * kallisti has been working on a term rewriting grammar
09:18:10 <atriq> Mutable variables, for a start
09:18:43 <atriq> Actually, that's the only difference between C and Haskell I'm having trouble accounting ofr
09:18:53 <kallisti> pattern -> [replcaement | condition]
09:19:31 <atriq> Is there a way to search a github thing?
09:23:02 <fizzie> atriq: GitHub's own "advanced search" form at least at some point.
09:23:39 <fizzie> You need some kind of a "repo:foo/bar" specifier and then tell it to search from source code too.
09:24:32 <fizzie> https://github.com/search and the bits about "Code Search".
09:28:53 <kallisti> atriq: I actually have a private git server
09:28:58 <kallisti> I could set up a web interface
09:35:25 <Arc_Koen> but I forgot about nested loops
09:35:56 <Arc_Koen> how the hell can a brainfuck interpreter in thue account for nested loop?
09:36:21 -!- mig22 has joined.
09:36:28 <Arc_Koen> in order to "jump to the matching ]" I usually have a variable that count how deep in nested loops the ip is
09:37:28 <kallisti> Arc_Koen: I was thinking of a string rewriting grammar that uses a term rewriting system
09:37:33 <kallisti> but on a tree of weighted values
09:37:47 <kallisti> with conditions on the weights, and a pattern from the tree
09:38:17 <kallisti> and the resulting term and also an update of the current state of the weight.
09:39:22 <kallisti> condition | pattern -> replacement[state]
09:39:36 <kallisti> state can be ++, --, or a numeric expression of the input weights
09:40:13 <kallisti> replacement is a result of tokens from the input patterns capture symbols
09:40:31 <Arc_Koen> I'm not sure I know what you are talking about
09:40:37 <kallisti> condition is any numeric expression
09:41:21 <kallisti> a + b | "a -> b" -> ab [a + b]
09:41:48 <kallisti> transforms an -> into an addition of 2 weights
09:47:05 <Arc_Koen> what about http://esolangs.org/wiki/Definer
09:56:22 -!- ais523 has joined.
10:00:34 -!- Phantom_Hoover has joined.
10:00:37 -!- Phantom__Hoover has joined.
10:00:38 -!- Phantom__Hoover has quit (Client Quit).
10:04:16 -!- carado has joined.
10:04:43 -!- carado has quit (Client Quit).
10:04:57 -!- carado has joined.
10:08:44 -!- atriq has quit (Remote host closed the connection).
10:37:11 -!- jiella has joined.
10:47:05 <barts> has anyone here tried programming the Z80 or one of its derivatives?
10:59:02 <fizzie> And I am under the impression that others have, too.
10:59:27 <fizzie> http://zem.fi/rfk86/ <- mainly I just made that.
10:59:43 <HackEgo> http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.6799
11:00:11 <HackEgo> http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.19994
11:00:39 <fizzie> Well, I do know mooz did quite a lot for the calculator, but he's no longer here.
11:01:36 <barts> which one have you programmed?
11:08:18 -!- barts_ has joined.
11:08:33 -!- ais523_ has joined.
11:09:34 -!- ais523 has quit (Ping timeout: 240 seconds).
11:10:41 -!- ais523_ has changed nick to ais253.
11:10:43 -!- ais253 has changed nick to ais523.
11:11:36 -!- barts has quit (Ping timeout: 252 seconds).
11:11:50 <kallisti> http://en.wikipedia.org/wiki/Gumbo
11:16:04 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
11:34:40 -!- ais523 has quit (Remote host closed the connection).
11:35:23 -!- carado has quit (Quit: Leaving).
11:39:33 -!- ais523 has joined.
11:41:19 -!- carado has joined.
11:50:16 -!- Jafet has joined.
11:59:03 -!- TeruFSX has joined.
12:12:49 -!- ogrom has joined.
12:15:09 -!- Phantom_Hoover has joined.
12:15:48 -!- ais523 has quit (Remote host closed the connection).
12:17:04 -!- ais523 has joined.
12:19:55 <Arc_Koen> uh, the thue article doesn't say anything about comments
12:22:34 -!- ogrom has quit (Quit: begone).
12:26:01 <fizzie> I've seen #::=# as a kind of a line-comment indicator.
12:26:07 -!- TeruFSX has quit (Ping timeout: 240 seconds).
12:26:12 <fizzie> Presumably with the restriction that there won't be any #s ever.
12:26:19 <lambdabot> ais523: You have 1 new message. '/msg lambdabot @messages' to read it.
12:26:27 <ais523> it's one of those comments-inside-the-language-semantics thing
12:26:38 <ais523> like DO NOT put comment here in INTERCAL
12:27:15 <Arc_Koen> there's definitely a problem with input though
12:28:36 <Arc_Koen> basically if the input contains anything else than +-><[]., my interpreter will either not know of it (so it will halt because no rule can be applied) or will recognize it as injected code and then it can do about anything
12:29:42 <fizzie> It's a language for well-behaving users.
12:31:07 -!- ais523 has quit (Ping timeout: 246 seconds).
12:31:13 <Arc_Koen> I guess I could have an ip go through the brainfuck program before execution starts, and remove anything that's not a brainfuck instruction - but still, willingly injected code can trigger any rule
12:34:14 <Arc_Koen> also, my thue interpreter selects the rules to apply at random amongst the not-yet-tester-this-turn rules, but I guess the brainfuck interpreter in thue would be way faster if the thue interpreter tried rules in the order they are sorted, and brought the chosen rule on top of the rules list
12:35:17 <Arc_Koen> (for instance if the brainfuck interpreter is currently interpreting a '+', only the '+'related rules will be applicable so trying all the other rules is a waste of time
12:45:05 -!- nortti- has quit (Ping timeout: 256 seconds).
12:56:28 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
13:03:51 -!- boily has joined.
13:03:54 -!- Phantom_Hoover has joined.
13:04:13 -!- nortti- has joined.
13:12:38 -!- aloril_ has quit (Ping timeout: 244 seconds).
13:13:37 <barts_> what is the most esoteric language?
13:13:58 <HackEgo> Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: http://esolangs.org/wiki/Main_Page. (For the other kind of esoterica, try #esoteric on irc.dal.net.)
13:14:11 <barts_> i've already been welcomed, but thanks Arc_Koen
13:14:18 <barts_> why do you hold such an opinion?
13:14:24 <Arc_Koen> I don't think there is a "most" esoteric language, they are all esoteric in their own way
13:14:28 <barts_> assuming you are the person of this personal opinion
13:14:42 <Arc_Koen> eodermdrome uses graphs as a way to program
13:15:01 <barts_> that is very interesting
13:15:05 <barts_> does it process graphs?
13:15:18 <Arc_Koen> hrm, I don't know enough about it, actually
13:15:31 <barts_> i heard lisp could be implemented with a machine that does graph reduction.
13:15:46 <fizzie> It's a graph-rewriting language.
13:15:59 <Arc_Koen> have a look at http://esolangs.org/wiki/Eodermdrome
13:16:11 <Arc_Koen> (or hear what fizzie has to say, he knows much more than me)
13:16:22 <fizzie> There's a state graph, and rules for rewriting parts of it.
13:16:34 <fizzie> Well, the article is fine too.
13:17:43 <fizzie> It's really kind of like Thue except with (unlabeled) graphs.
13:18:28 <Arc_Koen> talking about thue... http://sprunge.us/HhXO
13:19:31 <Arc_Koen> it's 180 lines long already, I still have to do instructions > < . , and it's probably full of bugs because IT'S NOT HUMANLY READABLE
13:21:24 -!- epicmonkey has joined.
13:22:13 <barts_> oh i just read up on it
13:22:43 -!- carado has quit (Quit: Leaving).
13:24:03 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
13:24:04 <fizzie> I could possibly second the Eodermdrome opinion on esotericness, as ill-defined as that is.
13:24:31 <Arc_Koen> (I do hope you're talking about eodermdrome when saying "it's nice")
13:27:28 <barts_> or i might be talking about sending digital signals in analog carriers via amplitude modulation
13:27:37 <fizzie> It possibly loses some appreciability points from the fact that it's still lacking an interpreter, and there aren't that many programs written in it.
13:28:00 <fizzie> Compare to something like Befunge which is being used daily in mission-critical applications all over the globe.
13:28:05 <barts_> but does it have eclipse support
13:28:27 <fizzie> Perhaps someone should write a plugin.
13:28:54 <fizzie> fungot: What's your opinion on the productivity and popularity and efficientness and such of Befunge?
13:28:55 <fungot> fizzie: you just want to say " you can't make if a function is
13:29:15 <fizzie> fungot: I don't think I want to say *that*.
13:29:16 <fungot> fizzie: that's underload code in there, then
13:29:31 <barts_> fizzie: what's your opinion on the productivity and popularity and efficientness and such of peptides?
13:29:59 <fizzie> I think we should get rid of them.
13:30:04 -!- aloril_ has joined.
13:30:19 <fizzie> What have the peptides ever done for us?
13:30:23 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
13:30:25 -!- nortti- has quit (Ping timeout: 256 seconds).
13:36:14 <barts_> has it just reproduced
13:39:24 -!- jiella has quit (Quit: Leaving.).
13:49:49 -!- copumpkin has joined.
13:52:37 -!- carado has joined.
13:56:41 -!- mig22 has quit (Quit: mig22).
14:14:10 -!- Phantom_Hoover has quit (Ping timeout: 256 seconds).
14:16:28 -!- Phantom_Hoover has joined.
14:25:49 <ion> The Core http://edition.cnn.com/2012/10/01/tech/mantle-earth-drill-mission/index.html?hpt=butt
14:41:29 -!- nortti- has joined.
14:45:18 -!- Arc_Koen has quit (Quit: Arc_Koen).
14:51:07 -!- carado has quit (Remote host closed the connection).
15:10:50 -!- Phantom_Hoover has quit (Ping timeout: 256 seconds).
15:15:38 -!- epicmonkey has quit (Ping timeout: 246 seconds).
15:31:42 -!- jiella has joined.
15:38:38 -!- atriq has joined.
15:41:24 -!- kinoSi has quit (Read error: Connection reset by peer).
15:41:51 -!- kinoSi has joined.
15:45:03 <Sgeo> @tell Sgeo honk
15:45:17 <Sgeo> @tell lambdabot HONK
15:54:09 <Sgeo> honk HONK honk HONK :o)
15:55:14 <itidus21> ion: i like the fact that they're doing a $1 billion mission to "answer questions about the origins and evolution of life"
16:09:16 <atriq> itidus21, Homestuck fans have raised $2000000 for a video game that comes out in 2014.
16:09:23 <atriq> What do you make of that?
16:09:30 <lambdabot> Sgeo: You have 1 new message. '/msg lambdabot @messages' to read it.
16:09:53 -!- Phantom_Hoover has joined.
16:10:09 <barts_> You don't have any new massages.
16:17:35 * FireFly wonders if lambdabot checks if the edit distance is below some threshold or something
16:17:50 <FireFly> compared to the string 'messages', that is
16:18:16 <fizzie> FireFly: It allows up to two edits, but only if the parse is unambiguous.
16:18:39 <atriq> itidus21, I thought you liked Super Mario Bros?
16:19:05 <lambdabot> Local time for fizzie is Tue Oct 2 19:19:02 2012
16:19:11 <fizzie> Uh, that's not what I meant; what I meant was.
16:19:22 <lambdabot> Maybe you meant: dice ping time wiki
16:19:52 <itidus21> I think the game I came closest to liking was legend of zelda: link's awakening on gameboy
16:20:31 <fizzie> (The @pime result shows it's enough for there to be a unique command with the shortest edit distance, as long as that's <= 2.)
16:21:01 <atriq> Lost Levels or USA?
16:21:44 <fizzie> FireFly: Or I'm not entirely sure whether it's exactly edit distance or Hamming distance; and it's complicated by the fact that unique prefixes of commands are accepted too.
16:21:50 <itidus21> that was really something super mario usa
16:22:45 <fizzie> I suppose it's edit distance since it seems to allow deletions.
16:23:24 <lambdabot> Maybe you meant: messages messages?
16:23:39 <fizzie> Even though it has only one edit-distance-2 expansion (the one without ?).
16:23:46 <fizzie> Because of the no-typos-but-prefix handling.
16:23:58 <itidus21> i think it's not really the quality of the game itself, but the lies the game helps your mind momentarily tell itself
16:24:33 <itidus21> thats what i think i enjoy in fiction
16:24:53 <lambdabot> Maybe you meant: messages messages?
16:26:36 <itidus21> i guess that with your eyes, you can see yourself and you can see others
16:27:04 <itidus21> with your ears you can hear yourself and you can hear others.. etc etc.. but with your mind you can hear your thoughts but you can't hear any others
16:28:39 -!- FreeFull has joined.
16:28:51 <itidus21> so in a video game you see this sprite and you can say that sprite is me, everything else isn't
16:32:50 <itidus21> i guess you just have to be in the right mood, like with anything
16:33:17 -!- augur has quit (Remote host closed the connection).
16:34:09 <barts_> link's awakening was really fun
16:34:13 <barts_> i got stuck at some point
16:34:22 <barts_> and it took me years to figure out how to get past
16:34:33 <barts_> i h8 open plan games for this
16:34:58 <itidus21> like if you're sitting there thinking about video games as some philosophical metaphor like i am then you probably need a break from them
16:36:14 -!- atrapado has joined.
16:36:28 -!- Phantom_Hoover has quit (Ping timeout: 246 seconds).
16:45:26 -!- barts has joined.
16:46:32 -!- Jafet1 has joined.
16:46:33 -!- aaaaaa has joined.
16:48:19 -!- atrapado has quit (Disconnected by services).
16:48:27 -!- aaaaaa has changed nick to atrapado.
16:48:47 -!- barts_ has quit (Ping timeout: 246 seconds).
16:48:49 -!- Jafet has quit (Ping timeout: 246 seconds).
16:51:15 <FreeFull> barts: What point dod you get stuck at?
17:02:09 <atriq> There was a Scottish-Norwegian war?
17:04:17 <atriq> I'm tumblring on IRC
17:04:31 <olsner> if nothing else, I think they would've been at war during WW2
17:04:43 <atriq> No, there was a war called the Scottish-Norwegian war
17:04:48 <atriq> In the 13th century
17:05:29 <olsner> oh, it was *called* that? so it wasn't actually Scotland and Norway at war?
17:18:37 -!- Arc_Koen has joined.
17:18:51 -!- augur has joined.
17:19:42 -!- augur has quit (Read error: Connection reset by peer).
17:20:07 -!- augur has joined.
17:23:24 -!- Phantom_Hoover has joined.
17:40:43 <olsner> fungot: say something funny
17:40:44 <fungot> olsner: sicp 1ed has the pattern matcher would close over the value of the current
17:41:50 <fungot> Phantom_Hoover: and you can use almost anything as an excuse
17:41:58 <atriq> Hey, I'm still brb'ing
17:42:04 <atriq> Guess I'll brb some more
17:42:08 <fungot> Phantom_Hoover: many hellos!!! fnord head on fnord.
17:42:41 <olsner> fungot: say something fnarfful
17:42:42 <fungot> olsner: wife thought it might be possible to use 8-bit values in colourmap. :)
17:45:12 <fizzie> Yes, the whole idea is beyond bizarre.
17:45:23 <fizzie> 8-bit values, in colourmap, with fungot's reputation?
17:45:24 <fungot> fizzie: that's what she said... i know where jesus the monster truck?
17:46:19 <olsner> or was it actually fungot that the monster truck there?
17:46:20 <fungot> olsner: eval ( eq? programmer riastradh))
17:46:23 <fungot> Phantom_Hoover: does anyone know a short bf program for 10 million steps?
17:47:29 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher fungot homestuck ic irc* iwcs jargon lovecraft nethack pa qwantz sms speeches ss wp youtube
17:47:50 <olsner> "irc", was that from #perl?
17:48:54 -!- atriq has quit (Ping timeout: 240 seconds).
17:51:38 <fizzie> olsner: #esoteric, #scheme and a tiny bit from IRCnet's #douglasadams.
17:51:45 <fungot> Selected style: irc (IRC logs of freenode/#esoteric, freenode/#scheme and ircnet/#douglasadams)
17:52:01 <fizzie> Riastradh is/was a #scheme regular.
17:52:40 <fizzie> And eq? is/was (but most likely is) a Scheme predicate.
17:55:19 <olsner> not that I know anything about scheme, but yes
17:57:16 -!- atriq has joined.
17:58:30 <fizzie> !forth s" gforth" environment? [if] type [then]
17:58:38 <fizzie> (Just checking the version.)
17:59:47 <fizzie> gforth development isn't terribly breezy, 0.7.0 is the latest and it's from Nov 2008.
18:03:23 <nortti> it doesn't support 'char' thing but is otherwise nice
18:13:34 -!- nortti- has quit (Ping timeout: 240 seconds).
18:28:35 <itidus21> <fungot> Phantom_Hoover: does anyone know a short bf program for 10 million steps?
18:28:36 <fungot> itidus21: i think we have a shortage of paths but is much more interesting
18:30:36 -!- Taneb has joined.
18:30:45 -!- atriq has quit (Ping timeout: 256 seconds).
18:31:50 -!- Taneb has changed nick to atriq.
18:31:58 -!- Phantom_Hoover has quit (Ping timeout: 252 seconds).
18:34:26 <Arc_Koen> I'm sorry, did you say "a short bf program"? that sounded wrong
18:37:50 <fizzie> Short, but isn't likely to run for exactly ten million steps.
18:38:15 <fizzie> And fungot can't output the \0 character since that doesn't go through IRC.
18:38:16 <fungot> fizzie: i'm annoyed by both. technically it's not necessary in russian in that context?). i believe the internet works on cr/ lf is the most basic tasks
18:38:54 <fizzie> I think there are some reasonably short but "useful" (well...) programs inside that bot.
18:38:58 <fungot> echo reverb rev rot13 rev2 fib wc ul cho choo pow2 source help hw srmlebac uenlsbcmra scramble unscramble asc ord prefixes tmp test celebrate wiki chr ha rainbow rainbow2 welcome me
18:39:12 <fizzie> The echo/rev kind of things are pretty simple to do.
18:39:29 <fizzie> ^echo Do you hear an echo?
18:39:30 <fungot> Do you hear an echo? Do you hear an echo?
18:47:12 <FreeFull> ^srmlebac Hello? What is this?
18:49:13 <fizzie> They're all kind of related.
18:49:26 <fizzie> It's mostly about bouncing between the two ends of the string.
18:49:30 <fungot> >>,[>,]<[<]>[.>>]<[>>]<2[.<2]
18:50:02 <fungot> >>,[>,]<[<]>[.>>]<[>>]<2[.<2]
18:50:13 <fizzie> Oh, they're even that close.
18:50:30 <fizzie> Also these must be old, because it hasn't combined the >>s.
18:50:34 -!- ais523 has joined.
18:51:05 <fizzie> ^def scramble bf >>,[>,]<[<]>[.>>]<[>>]<<[.<<]
18:51:09 <fungot> >2,[>,]<[<]>[.>2]<[>2]<2[.<2]
18:51:30 <fizzie> There, it's a bit shorter.
18:51:50 <FreeFull> >> is exactly the same length as >2
18:51:57 <fizzie> Yes, well, I meant in memory.
18:52:09 <fizzie> The ^show output is just a textual dump.
18:53:39 <fizzie> In memory it's in two-cell pairs where one cell gives the command (<> or +- or [ or ] or , or .) and the other the argument (count for <> or +-, the jump destination for [ or ]), so >2 is two cells whereas >> is four.
18:54:17 -!- Phantom_Hoover has joined.
18:54:41 <fizzie> ^def tmp bf ------------------------------------------------------------------------------------------------------------------------------------------------------
18:55:25 <fizzie> From what I recall, ^show selects +/- (or </>) based on which would give the smaller number; internally it's always as-if the command were + or >.
18:55:39 <fizzie> (It has a wrapping tape.)
19:09:05 -!- carado has joined.
19:09:18 -!- oerjan has joined.
19:16:43 <atriq> I'm really proud of Fueue
19:19:52 <oerjan> smashing language, old chap
19:20:45 <atriq> I'm scarily not old
19:21:01 <atriq> Fermat's Last Theorem has been a theorem for longer than I've been a person
19:21:58 <Slereah> Fermat, that young whippernsapper?
19:22:04 <atriq> Since September 1994, yes.
19:22:39 <shachaf> It was a theorem before it was proved.
19:22:46 <shachaf> It was even *called* a theorem before it was proved.
19:22:56 <atriq> Both of those are true!
19:23:04 <oerjan> atriq is just trying to disguise the fact he's http://tvtropes.org/pmwiki/pmwiki.php/Main/ReallySevenHundredYearsOld
19:23:16 <atriq> I'm a page on TVTropes
19:23:39 -!- Sanqui has changed nick to Sanky.
19:24:11 <olsner> oerjan: oh, that esolang with the 10% bug was brainfuck
19:24:35 <oerjan> a little known fact about brainfuck
19:24:59 <olsner> it was first a bug in the interpreter that chopped off the first + (hello world starts with 10 of those, and uses the number 10 as a base to generate the characters)
19:25:28 <olsner> so I worked around that by adding another + and left the modified program as a trap for my future self
19:25:48 <olsner> when run in the corrected interpreter, that program gives a 10% bug in the other direction
19:30:17 <Arc_Koen> oerjan: I have two solutions to fix thue's input issue
19:30:45 <Arc_Koen> 1) input one character instead of one line. this way the programmer can make sure to treat characters in a way that doesn't allow code injection
19:31:41 <Arc_Koen> 2) allow the programmer to define an alphabet to use in the program, and a subset of that alphabet as the input alphabet
19:32:08 <olsner> oerjan: all brought back because Arc_Koen started doing the bf in thue thing, and I decided to figure out how my last ubuntu upgrade broke my apache config
19:33:47 <Arc_Koen> for 2), the alphabet can be something else than the usual ascii - to make it usable on a regular computer you need to "transcribe" your alphabet as ascii (if it's too big, use several chars to code one symbol), and the user's input is in ascii but with a transcription function that transforms it into your input alphabet
19:36:26 <olsner> oerjan: incidentally, the only broken part was that I forgot how to use the thing
19:38:22 <olsner> Arc_Koen: hmm, I guess :)
19:39:43 <olsner> fwiw, I didn't write that bf interpreter, but it is written in thue and I have no real idea how it works... thought it would be interesting to try and figure it out while debugging its breakage
19:40:04 -!- Phantom_Hoover has quit (Ping timeout: 260 seconds).
19:41:11 <oerjan> Arc_Koen: (1) is what Itflabtijtslwi does.
19:41:32 * oerjan realizes he did not have to think about how to spell that this time
19:44:54 <Arc_Koen> olsner: if you really want to debug a bf interpreter in thue I'd be glad to give you mine once it's over
19:45:04 <Arc_Koen> but it's kind of a boring thing to program
19:45:17 <Arc_Koen> the idea is *very* simple, but it takes a loooooot of substitution rules
19:47:10 <Arc_Koen> I think when I'm done I'll try to program in Definer, or another similar string-rewriting language that does allow for "variables"
19:48:17 <olsner> I think mod_rewrite uses PCRE
19:49:08 <oerjan> ais523: did thutubot have a bf implementation?
19:49:45 <Arc_Koen> for instance in the interpreter if I want to have some symbols travel through others, I say something like "if a symbol is enclosed in { } brackets, then it moves to the left", but I have to write the substition rules for all symbols {+}, {-}, {>}, etc., for all symbols they can meet 0{+}::={+}0, 1{+}::={+}1, 0{-}::={-}0, etc
19:49:59 <Arc_Koen> and to make things worse it's completely irreadable
19:50:15 <Arc_Koen> (espacially if one of the symbols is a : or a =)
19:51:38 <oerjan> it's like how i made the first loop in /// before i found the copying twice trick
19:51:46 <olsner> heh, avoid using : and = then :P
19:52:21 <Arc_Koen> olsner: well i'm kind of short in symbols and I don't want to use words too much
19:52:30 <oerjan> no wait, that was even more insane.
19:52:40 <olsner> an incredibly verbose interpreter would be a bit funny though
19:52:47 <Arc_Koen> I use = as the operator that checks if a cell is equal to 0
19:53:06 <olsner> (and debuggable, if it's constantly explaining exactly what it's doing)
19:53:26 <Arc_Koen> hmm, if you had said that sooner I might have made it completely full of words
19:54:01 <Arc_Koen> as in, even input would have had to be in the form increment decrement move left move right input output begin loop end loop
19:54:13 <Arc_Koen> but now I've written too much to want to restart anything
19:54:13 <oerjan> hm you could say the first /// loop was attempting to use a thue method in a language not suited for it.
19:54:31 <Arc_Koen> does /// use string-rewriting?
19:54:53 <oerjan> it's even simpler than thue.
19:54:56 <olsner> hmm, /// eats everything up until the third / after applying a rewrite rule?
20:02:23 <oerjan> basically /// is both string-rewriting and self-modifying code
20:03:54 <oerjan> with the latter the only way to do real flow control
20:04:57 <oerjan> and looping requires quine-like techniques
20:14:40 <Arc_Koen> erh, earlier today we told someone that was eodermdrome
20:14:50 <oerjan> THAT WAS EARLIER TODAY
20:15:19 -!- Phantom_Hoover has joined.
20:15:32 <oerjan> also, /// is already implemented.
20:16:07 <olsner> hmm, I might decide to implement /// soon
20:16:43 <oerjan> there might even be a more efficient implementation than the perl one. possibly by User:Nthern.
20:17:20 <olsner> more efficient than perl? wow!
20:17:47 <oerjan> the perl one keeps scanning the string from the beginning, whether or not there can be new matches there
20:18:00 -!- atriq has quit (Quit: Leaving).
20:18:38 <oerjan> for some substitutions that's gonna hurt.
20:19:29 <oerjan> it was just a quick hack to get a working implementations, after all.
20:20:02 <oerjan> it just _barely_ manages to run the BCT interpreter without hitting one of perl's internal limits.
20:20:40 <oerjan> (regexp recursion depth)
20:23:07 <oerjan> afaik Nthern is the only other person who has succeeded at programming in ///
20:23:14 <olsner> hmm, what is it that uses recursion in those regexps?
20:24:27 <oerjan> s!^/((?:[^/\\]|\\.)*)/((?:[^/\\]|\\.)*)/!!s is the one which tended to crash
20:25:38 <olsner> couldn't you make it [^/\\]+ to match longer chunks?
20:25:48 <oerjan> it is possible it doesn't use recursion in all perl versions, i think the ?: 's were an attempt to simplify it
20:26:15 <oerjan> olsner: except the BCT interpreter uses only / and \ characters :P
20:26:37 <olsner> aah, sounds appropriately evil
20:27:12 <oerjan> it seemed like the logical thing to aim for, after getting basic "readable" looping going
20:27:30 <itidus21> oerjan: so my brother drops a pair of shorts in the clothes washer and just leaves them there, i don't even know when... makes no reference to it... this is what i live with
20:27:39 <oerjan> that's after initial syntactic desugaring btw.
20:28:00 <olsner> after syntactic salting?
20:28:00 <oerjan> itidus21: HOW DESPICABLY EVIL
20:28:28 <fizzie> It's also possible to optimize some Perl regexps a whole lot with suitably placed (?>...)s. (It's a kind of a forced never-backtrack construct.)
20:28:35 * oerjan always checks the washing machine for forgotten clothes before using it.
20:29:12 <itidus21> oerjan: but they havent been washed... evidenced by their dryness
20:29:17 <oerjan> fizzie: i recall the perl version i used wasn't the newest one
20:29:33 <oerjan> itidus21: HOW DESPICABLY EVIL
20:30:24 <fizzie> It's possible (?>...) is reasonably new; it's quite far down in the manual, at least.
20:31:26 <fizzie> The *+ construct can be an easier way and I think it's earlier too.
20:31:41 <itidus21> oerjan: personally i don't even care.. i wash my stuff at laundromat lately.. but my mom comes along saying "can you turn on washing machine for me? running out of clean towels" because the knob is busted she can't actually turn on the machine herself
20:32:19 <itidus21> so i tell her about the shorts and she just carries them off into her room.. "ok ive emptied it"
20:32:33 <fizzie> oerjan: *+ and ++ and ?+ and {n}+ and so on are the "possessive" versions of the quantifiers.
20:32:55 <fizzie> oerjan: "Match as much as possible and never give anything back" is what they do.
20:32:57 <itidus21> so.. if i get depressed sometimes.. it's not baseless
20:33:07 <oerjan> oh. so it's not just * and + combined
20:33:45 <fizzie> /a++a/ e.g. can't ever match, because a++ gobbles all the a's.
20:34:54 <fizzie> Not that I know how well the regex engine can do without the hints in your original example, and whether the potential backtracking points matter. But it's a case where you know exactly what to match.
20:35:40 <oerjan> itidus21: hypocritically speaking, i'm pretty sure a healthy person wouldn't be depressed by such events.
20:36:37 <fizzie> "For instance, the typical "match a double-quoted string" problem can be most efficiently performed when written as: /"(?:[^"\\]++|\\.)*+"/ as we know that if the final quote does not match, backtracking will not help." (perlre example on them.)
20:36:40 <itidus21> oerjan: ain't noone healthy in this house
20:37:10 <oerjan> although perhaps it's a sign that we're at least a bit on the autistic spectrum
20:37:35 <oerjan> (disclaimer: DO NOT USE FOR MEDICAL ADVICE)
20:37:47 <olsner> regexps are awesome for writing gobbledygook like "(?:[^"\\]++|\\.)*+"
20:39:08 <oerjan> fizzie: that _does_ look eerily similar
20:41:10 <itidus21> oerjan: ironically for me facing my fears means doing someone elses laundry
20:43:09 -!- TeruFSX has joined.
20:48:09 <Arc_Koen> a fueue itnerpreter in thue would actually be shorter that a brainfuck one
20:48:31 <Arc_Koen> cause fueue has only one structure (that is, code and date are together)
20:50:06 <Arc_Koen> oerjan: your proof that fueue is turing complete, does it work if numbers are bounded?
20:51:18 <Arc_Koen> oh screw that I can do it with unbounded numbers *rolls his sleeves up*
20:53:23 <lambdabot> Ambiguous type variable `a' in the constraint:
20:53:44 <oerjan> fizzie: aww, changing * to *+ didn't help, at least with the perl version installed here (5.10.0)
20:55:45 <lambdabot> Ambiguous type variable `a' in the constraint:
20:56:17 <oerjan> Arc_Koen: my proof doesn't use number arithmetic at all, there's a lonely 1 used for a delaying trick
20:56:42 <Arc_Koen> you mean YOU DON'T NEED NUMBERS at ALL???
20:57:03 <oerjan> indeed, that 1 could probably be changed to something else :)
20:57:27 <ion> putStrLn "hello" `xor` putStrLn "world"
20:58:18 <oerjan> Arc_Koen: it's only using the functional parts of fueue in an essential way
20:58:26 <ion> arc_koen: class (Eq a, Num a) => Bits a
20:59:48 <oerjan> FreeFull: ghci uses the extended defaulting option, which defaults numeric types in more general circumstances
21:00:51 <oerjan> fizzie: btw http://oerjan.nvg.org/esoteric/slashes/longsubst.sss is a simple program triggering the bug
21:01:22 <oerjan> it _should_ print hello if working
21:01:48 <oerjan> oh and some newlines, i didn't bother removing them
21:01:52 <Arc_Koen> olsner: so i'm gonna make a verbose thue fueue interpreter
21:02:35 <oerjan> Arc_Koen: well you need numbers for output, but you can consider it TC even without if you consider final queue contents
21:02:36 <fizzie> oerjan: If I can manage to remember, I'll try some things out when I'm not typing via the phone.
21:03:46 <Arc_Koen> oerjan: would brainfuck be tc with cell contents being unbounded, but without the - instruction?
21:04:08 <Arc_Koen> I'm thinking it doesn't change anything
21:04:27 <Arc_Koen> like, you can have a cell you call "zero" which you increment instead of decrementing every other cell
21:05:07 <oerjan> Arc_Koen: as long as the tape still is unbounded, it might work
21:05:19 <Arc_Koen> hmm I don't think we need that
21:05:24 <Arc_Koen> for instance take 4-cell brainfuck
21:05:46 <Arc_Koen> don't use the fourth cell, except to emulate -
21:06:11 <Arc_Koen> (so if you're in the first cell, instead of - you write >+>+>+)
21:06:34 <oerjan> Arc_Koen: um you can never get information out of a cell if you cannot get it back to zero
21:06:45 <oerjan> other than that it is nonzero
21:07:27 <Arc_Koen> so how would it work if the tape was unbounded?
21:08:32 <oerjan> in that case there ought to be a way to move data further on the tape, to the still zero parts
21:09:43 <oerjan> so you would encode the cells of a brainfuck with - as sequences of 0's and nonzeros
21:10:21 -!- boily has quit (Quit: Poulet!).
21:10:51 <oerjan> well i'm reminded of Sceql
21:14:00 -!- monqy has joined.
21:14:01 <oerjan> anyway i'd imagine a memory layout like 0 ...arbitrary non-zero trash... 0 first bf cell 0 second bf cell 0 ... last bf cell 0 0 ...
21:14:33 <oerjan> hm make that 0 0 between the trash and first cell too
21:15:02 <oerjan> oh and a 0 0 somewhere around the current cell.
21:15:41 <olsner> hmm... I think apache does potentially evil things with leading slashes in uris
21:21:28 <olsner> "Use with extreme caution, as it may result in loop." :)
21:22:37 <olsner> (it could if there wasn't a limit on the number of matching rules and if the server didn't run out of memory so quickly)
21:23:53 <oerjan> ...arbitrary non-zero trash... 0 (0 (1 1*))* 0 (0 (1 1*))* 0 0 0...
21:25:21 <Arc_Koen> (the fueue interpreter might not be shorter than the brainfuck one because it has so much moving around)
21:26:02 <oerjan> wait i've not even finished browsing the logs yet...
21:26:26 <Arc_Koen> like, the 'fadd' function sends a 'check arithm' marker to see if it has correct arguments, then the marker comes back as 'ok arithm' or 'noop'
21:26:44 <Arc_Koen> if it's noop then fadd must move through the whole queue
21:27:26 <Arc_Koen> if it's ok arithm then it's a nightmare of adding two numbers, then the results still has to move through the whole queue
21:27:45 <Arc_Koen> if thue had WRAPPING that would be so easy
21:28:45 <Arc_Koen> oerjan: I'm not sure it's healthy browsing the logs... it's like every moment you're not on the chan you have to live twice (once out of the chan and once reading the log)
21:29:00 <Arc_Koen> you're gonna get old TWICE AS FAST
21:29:14 <Arc_Koen> of course an easy remedy would be to stay on the chan as often as possible :-)
21:30:04 -!- carado has quit (Quit: Leaving).
21:31:31 <fizzie> @tell Arc_Koen If you want things "easy", go Thutu or something. (Disclaimer: only lookes at Thutu briefly.)
21:31:34 <fizzie> I got tired of keeping that in the input buffer, waiting for the quit.
21:32:20 <Arc_Koen> AAA you just shifted the balance fo need sleep / got plenty things to do
21:32:20 <lambdabot> Arc_Koen: You have 2 new messages. '/msg lambdabot @messages' to read them.
21:34:23 <Arc_Koen> hum, you know what, thutu can wait
21:34:35 <lambdabot> oerjan said 1d 1h 43m 33s ago: did you mean to remove an a from the kipple truth-machine program? i don't know kipple so...
21:34:36 <lambdabot> fizzie said 3m 4s ago: If you want things "easy", go Thutu or something. (Disclaimer: only lookes at Thutu briefly.)
21:34:49 -!- Arc_Koen has quit (Quit: that's dr. turing to you, punk).
21:35:51 <Gregor> It's super-promising when you look up an obscure error on Google and the first result is “Pig Latin Reference Manual”
21:51:10 -!- TeruFSX_ has quit (Read error: Connection reset by peer).
21:51:55 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
21:53:00 <kmc> Keccak won the SHA-3 competition
21:54:15 <kmc> http://www.nist.gov/itl/csd/sha-100212.cfm
21:54:59 -!- kmc has set topic: I, for one, welcome our new hash function overlords | http://codu.org/logs/_esoteric/ | http://esolangs.org/wiki.
21:55:55 <fizzie> Keccak does sound like a proper name for an alien overlord.
21:56:40 <ion> Keccak sucks as a palindrome.
21:56:56 <kmc> it's pronounced "kashyyyk"
22:17:06 -!- TeruFSX has quit (Ping timeout: 245 seconds).
22:25:18 -!- atrapado has quit (Quit: Leaving).
22:25:23 <Gregor> It is astoundingly difficult to Keccak-hash something right now.
22:25:35 <Gregor> I'm looking for an implementation that I can just say “here's a file, what's its hash”
22:26:12 <Phantom_Hoover> i hope this is a homestuck joke and not something sincere
22:26:35 <kmc> http://guyism.com/wp-content/uploads/2012/07/best-resume-ever.jpeg
22:28:15 <ion> gregor: Add the future-snapshots repository and install sha3sum.
22:28:32 <ion> future-snapshots/20131001 should work nicely.
22:28:52 <Gregor> The implementation is publicly available, but it's all test suites, no tools.
22:33:20 <kmc> you should smoke a bowl of hash in honor of this occasion
22:42:19 -!- jiella has quit (Quit: Leaving.).
22:55:06 -!- TeruFSX has joined.
22:57:11 -!- Jafet1 has quit (Quit: Leaving.).
23:07:04 -!- FreeFull has quit (Quit: Zzzzzzzzzzzz).
23:09:19 <shachaf> Hmm, it's not a Merkle-Damgård hash.
23:18:35 -!- Jafet has joined.
23:20:20 <pikhq_> Gregor: http://keccak.noekeon.org/KeccakReferenceAndOptimized-3.2.zip
23:20:47 <Gregor> pikhq_: Try using that to get a hash of a file.
23:21:57 <pikhq_> Why would you make the test program something other than a read file and shove it into the hasher?
23:23:50 <pikhq_> Okay, I'm *sure* it's a perfectly reasonable hash algorithm, but the implementation was written by an incompetent.
23:24:21 <Gregor> They're Belgian *shrugs*
23:26:41 <pikhq_> http://keccak.noekeon.org/specs_summary.html Well, there's enough you could probably write it yourself.
23:29:17 <Gregor> All I was going to do was hash the topic.
23:29:23 <Gregor> The joke is long dead by now ;)
23:29:27 -!- TeruFSX has quit (Read error: Connection reset by peer).
23:35:27 -!- augur has quit (Remote host closed the connection).
23:37:55 <pikhq_> Actually, I'm impressed at how simple this hash algorithm can be.
23:46:32 <pikhq_> DCB6B8BD29813DA1A9B56667D751A6D444ECFC5B0F67D6EB85DEF9E
23:46:48 <pikhq_> That's SHA3-224 of the topic.
23:47:02 <Gregor> How 'bout just “I, for one, welcome our new hash function overlords”
23:47:28 <pikhq_> E581A6F9E364E179B336A2C6D6831D4B50CD7739C7E1565E3EBF2
23:47:47 -!- Gregor has set topic: I, for one, welcome our new hash function overlords | E581A6F9E364E179B336A2C6D6831D4B50CD7739C7E1565E3EBF2 | http://codu.org/logs/_esoteric/ | http://esolangs.org/wiki.
23:47:58 <shachaf> pikhq_: How are you computing it?
23:48:11 <shachaf> SHA3 looks much more complicated than SHA1 to me.
23:48:26 <pikhq_> shachaf: Grabbed "readable keccak" and shoved the string into it.
23:48:53 <pikhq_> http://www.mjos.fi/dist/readable_keccak.tgz
23:49:28 <pikhq_> A bit more if you want to make it useable as a general-purpose library, of course.
23:49:50 <pikhq_> But I doubt it'd go over 200 if you don't try optimizing it.
23:50:20 <shachaf> It still has a lookup table. :-(
23:53:24 <pikhq_> Ah. Part of why the other keccak implementations are complex is that they support all possible parameters of the algorithm...
23:53:38 <pikhq_> What I pasted their suffices for the SHA3 ones.