00:07:54 -!- Sorella has joined.
00:10:43 -!- Sellyme has quit (Excess Flood).
00:12:45 -!- Sellyme has joined.
00:37:39 -!- Patashu[Zzz] has changed nick to Patashu.
00:39:19 -!- zzo38 has joined.
00:41:31 -!- conehead has quit (Quit: Computer has gone to sleep).
00:42:36 -!- conehead has joined.
00:42:36 -!- conehead has quit (Client Quit).
00:55:24 -!- Sgeo has joined.
00:59:39 <Sgeo> Maybe telling a charity telemarketer that I feel like I have too much money is not a good idea...
00:59:44 <Sgeo> Was asked for $365
01:00:36 <kmc> did you pony up
01:00:49 <Sgeo> I made no promises
01:02:52 -!- tertu has quit (Disconnected by services).
01:02:52 -!- ter2 has joined.
01:04:17 <pikhq> Sgeo: Do what I do, and purchase a $1000 monitor.
01:04:44 <Sgeo> I have no place to put it
01:07:10 <kmc> do what I did, and purchase a $1000 monitor and two $250 monitors
01:07:37 <kmc> seriously though, Sgeo, do you know of http://www.givewell.org/
01:07:39 <pikhq> I'm pretty sure I don't have cause for another monitor. This thing is huge.
01:08:27 <Sgeo> I've donated to them a few times. I did mention that to the telemarketer, who was all 'we have 4 stars on Charity Navigator'
01:08:34 <Sgeo> (They do. It's UNICEF)
01:09:03 <pikhq> Have you considered... having less money?
01:10:50 <kmc> Sgeo: if you find a way for donating large amounts of money to produce more than a slight and transient easing of guilt, let me know
01:11:05 <kmc> I think I probably need to do one thing to be objectively helpful, and another thing to feel good about myself
01:12:14 <Sgeo> Donating large amounts of money on a regular basis automatically? I plan on trying... well, not sufficiently large amounts, but something like that
01:12:38 <Sgeo> Although I'm sure there would be some guilt with any amount <100%
01:21:38 -!- ter2 has quit (Ping timeout: 240 seconds).
01:24:28 <kmc> https://gist.github.com/kmcallister/9986166 speeding up an ASCII whitespace scan by a factor of 5 using SSE 4.2
01:24:31 -!- TodPunk has joined.
01:27:46 <pikhq> How does it compare against http://git.musl-libc.org/cgit/musl/tree/src/string/memchr.c ?
01:27:57 <kmc> don't know
01:28:11 <kmc> that only looks for a single byte though
01:28:14 <kmc> this can do a set of up to 16
01:28:51 <kmc> this is pretty gnarly code
01:35:05 <pikhq> Ah, so it's more like strspn.
01:35:31 <Sgeo> kmc: apparently I forgot that Rust has macros :/
01:35:38 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
01:35:58 <Sgeo> http://www.reddit.com/r/rust/comments/224gc0/rust_010_released/cgjpkwh?context=1
01:37:00 <kmc> 420 smoke macros every day
01:38:14 <Sgeo> RUST IS NOT A GAME WHERE NAKED MEN MURDER EACH OTHER WITH HATCHETS
01:41:17 <Bike> there is a video game entitled "rust" in which player avatars are naked and murder each other with hatchets
01:45:52 <lexande> maybe the name of the game is case-sensitive
01:46:42 <Bike> http://playrust.com/wp-content/uploads/2013/12/RustLogo-Normal-Transparent.png it's usually stylized "RUST" though
01:46:59 <Bike> wow i don't know why it looks like that
01:50:24 -!- Slereah_ has quit (Ping timeout: 268 seconds).
02:14:47 <kmc> https://github.com/mozilla/rust/issues/12723
02:19:18 -!- nisstyre has quit (Quit: WeeChat 0.4.3).
02:26:30 <Bike> not bad, metajack
02:27:03 -!- madbr has joined.
02:28:20 <zzo38> What kind of question?
02:28:22 <madbr> how efficient is llvm's alias analysis?
02:28:31 <madbr> zzo38 : a hard one
02:28:40 <Bike> efficient as in how well does it work, or efficient as in how fast does the analysis itself run
02:28:44 <madbr> actually I'm not expecting an answer
02:29:56 <madbr> mostly up to what kind of inner loops can it figure out that none of the writes alias any of the reads
02:31:07 <madbr> essentially trying to figure if my architecture concept is never gonna work :D
02:32:09 <madbr> mostly interested in the kind of number crunching loops you get in video games
02:32:40 <madbr> video rendering, sound rendering, physics simulations, floating point stuff
02:33:09 <zzo38> So would you then have instructions dedicated to video, audio, and physics?
02:33:29 <madbr> don't care about the kind of code that's all function calls, hashes, graph parsing, linked lists... that kind of code is generally impossible to accelerate anyways
02:34:15 <madbr> zzo: just an architecture that can run ~8 instances of a loop at the same time
02:34:35 <zzo38> Yes, you should need some parallel instructions.
02:34:36 <madbr> without multithreading
02:35:10 <madbr> right, it's similar to autovectorization but a little more general
02:35:27 <madbr> essentially it adds possibility for feedback loops
02:36:06 <Bike> wait, feedback? how?
02:36:23 <zzo38> In esolang wiki, there is a article called "Checkout" it describes a code for parallel looping, and some other things
02:36:23 <madbr> each slice runs 1~2~etc slices after the previous one
02:36:25 <kmc> oh jeez, "jmp 3" and "jmp 3f" are not the same instruction at all
02:36:27 <kmc> jumping to 0x0000000000000003 considered harmful
02:37:08 <madbr> so if the longest feedback loop takes 1 cycle to propagate (ie some kind of accumulator), then slice 2 runs 1 instruction later than slice 1
02:38:25 <madbr> if you're doing something like a filter and it takes, say, 10 cycles due to having a couple multiplies in the loop, then slice 2 runs 10 cycles later, slice 3 runs 20 cycles later, slice 4 runs 30 cycles later etc
02:39:55 <madbr> it's probably mostly for math heavy DSP kind of code since you can still only do 1 memory read per cycle across all slices
02:40:29 <madbr> except for really simple cases like an SSE-style aligned block of values
02:41:38 <madbr> so essentially you need 7 math ops to do for every 1 memory read
02:42:04 <madbr> if you make it dual-issue then you need 15 math ops for every 1 memory read :D
02:43:20 <zzo38> You should then use a "load program" instruction, to load the program into internal memory, and then other instruction set up each execution unit, and then you can make it slice like that to don't interfere with memory access.
02:44:21 <madbr> but then you have to operate on really small data loads
02:44:34 <madbr> like, cache-size data loads
02:44:48 <madbr> kinda like the ps3's cell processor actually
02:45:09 <zzo38> What is the cache size?
02:45:58 <madbr> it depends on how the chip is made
02:46:13 <madbr> but it's definitively under 1 meg
02:46:34 <madbr> probably in the 32k~256k range
02:47:13 <madbr> essentially it becomes a cell processor like on the ps3
02:49:39 <madbr> which kinda became moot when they figured out how to turn x86 into 8 cores (which is a pretty scary concept tbh)
02:52:32 <madbr> anyhow, if llvm can figure out that none of the memory reads can alias any of the writes inside a loop, you can autovectorize anything that has predictable flow
02:53:58 <madbr> if it doesn't have something like "half the operations are memory operations" or "feedback loop is as long as the loop itself so the loop is essentially 100% serial", you can probably come out ahead in terms of speed
02:57:29 <madbr> kindof an anti-pentium2
02:58:59 <madbr> which seems to be based around the idea that most programs are horrible unoptimizable crudge made out of jumps and memory accesses
02:59:51 <Bike> http://www.beepboopbitcoin.com/ Finally.
03:00:07 <madbr> (the fastest cpus are still ultimately based on that design which I guess says something about software... or maybe about how people benchmark them)
03:05:38 -!- ter2 has joined.
03:07:53 <Bike> is it like controversial that most programs are made of jumps and memory accesses?
03:08:34 -!- fcrawl has quit (Ping timeout: 240 seconds).
03:08:49 <madbr> no but it's essentially the unoptimizable part of programs
03:09:04 <madbr> since it has lots of stuff like short dependencies
03:09:22 <zzo38> Some things in the program could be manually optimized though
03:09:55 <kmc> scanned 100 MB of data for ASCII space characters in about 8 ms
03:09:59 <kmc> 12 GB/s ain't bad
03:10:06 <kmc> it's within a factor of 2 of the theoretical max memory bandwidth
03:26:29 <^v> 47 is one of my favorite numbers now
03:26:46 <copumpkin> I agree. It's a pretty good number
03:28:00 <^v> it (47*x)%256 can be anywhere from 0-255
03:28:19 <Bike> what causes that, 256 and 47 being coprime probably?
03:29:10 <copumpkin> aren't all odd numbers coprime to 256?
03:29:11 <^v> i recently found this out by making a text to Barely converter
03:29:30 <^v> copumpkin, yes actually, fuck
03:46:25 -!- ter2 has quit (Ping timeout: 240 seconds).
03:52:00 -!- ter2 has joined.
04:07:39 -!- ter2 has quit (Ping timeout: 252 seconds).
04:13:04 -!- ter2 has joined.
04:14:45 -!- nisstyre has joined.
04:14:50 -!- nisstyre has quit (Changing host).
04:14:50 -!- nisstyre has joined.
04:22:49 -!- Sorella has quit (Quit: It is tiem!).
04:25:46 -!- conehead has joined.
04:27:18 <^v> i made hello world in barely
04:27:19 <^v> xoooooooooooooohjjjjjjjjjjjjjjjhhhxooooooooxooooooxjjjxjjjjjjjjjjjjjjjjjjjjjjjjxjjjjjjjjhxooooooooooooxooohjjjjhhhxjjjxxjjjjjjjxjjjjjjjhhjhhhhoooooxhoooooooooooooooooooooohjhhhoooooooooooo~
04:30:08 <^v> and holy shit i made it smaller
04:30:09 <^v> xjhhhhxooooooooxooooooxjjjxhhoohhhhxjjjjjjjjhxooooooooooooxjhhhhxjjjxxjjjjjjjxjjjhhhhhhxjjjjjjjjjjjjjjhhhh~
04:30:58 <kmc> it looks like a cat is walking on your keyboard
04:31:46 <^v> i am the kind of asshole who makes hello worlds in languages that dont have them yet
04:31:50 <^v> and doesnt post them to the wiki
04:32:23 <^v> what i have so far: fishstacks and barely
04:32:26 <^v> need to make more
04:32:29 <^v> just to piss people off
04:32:49 <zzo38> I would want the instruction set, where, implicit vectorization/out-of-order/pipelining/caching/etc is not allowed.
04:33:40 <^v> and mind you, these are all pregenerated tables which i can use to convert text to that lang instantly
04:33:54 <^v> which i am not giving to you, because i am an asshole
04:35:57 <madbr> zzo38 : I'm not sure sure that's possible
04:36:10 <madbr> zzo38 : though you can make it really hard :D
04:37:04 <^v> a compiler that disagrees with you if you do something too complicated
04:38:29 <zzo38> madbr: What do you mean by that?
04:38:52 <madbr> without self modifying code you can simply cache the code
04:38:59 <madbr> and cache the data
04:39:48 <madbr> the running core cannot figure out that it got hella cached
04:40:02 <madbr> or even out-of-ordered
04:40:04 <zzo38> I mean, that cache is only accessed by instructions which explicitly access the cache in the certain way.
04:40:44 <zzo38> And then, the instructions in cache are VLIW which is different from instructions from external memory, is another possibility.
04:41:29 <madbr> explicit cache I think doesn't gain anything AFAIK
04:42:40 <^v> because i dont feel like being an asshole today, here is the conversion table: https://gist.github.com/infinikiller64/9987604
04:42:53 <zzo38> It gains not complicating the execution with not knowing the cache and having to just guess instead, making also the speed confusing...
04:42:53 <^v> warning: your browser will probably crash
04:43:42 <zzo38> ^v: Then put "view-source:" at front, or download using curl, and then the browser might not crash as much.
04:43:54 <^v> https://gist.githubusercontent.com/infinikiller64/9987604/raw/07db8ab7a7e64a58e4f2fb3bb957296b5a54f2cf/gistfile1.lua
04:44:14 <zzo38> OK, that one better
04:44:55 <^v> 256^2 values
04:46:42 <madbr> zzo38 : it simplifies the design I guess yeah
04:46:45 <zzo38> madbr: I think simplicity of the implementation is better than simplicity of the interface, and simplicity is better than completeness, robustness, correctness, sanity, etc.
04:47:13 <madbr> but to get the kind of RISC speed there's more or less no way around a data and instruction cache
04:47:21 <zzo38> Yes, I always want to simplify the design.
04:47:26 <madbr> otherwise your speed is going to be on the order of the 386
04:47:39 <zzo38> I did not say to eliminate the cache entirely, but to make it explicit-only.
04:47:44 <madbr> unless you use pseudo-static ram or some other similar exotic part
04:48:23 <madbr> zzo38 : then you're still going to need 2 RAM banks probably
04:48:37 <madbr> one for data, one for instructions
04:49:46 <madbr> the problem is that DRAM has pages :(
04:49:59 <zzo38> There would still be an internal cache, which is also used for microcodes, so in instruction cache it would be VLIW codes
04:50:55 <madbr> opening a new page and reading a value is something like 3 times slower than reading a value from an already open page
04:51:05 <madbr> more if you're using more recent DRAM
04:52:10 <madbr> pages are something like 512bytes/1k/2k/4k/8k etc depending on DRAM generation/size
04:52:27 <zzo38> It could use 8-bits external memory interface, and 128-bits for internal memory interface for cache, so you can deal with arrays of whatever bit size of data, you loaded, and is also for use with VLIW, which has longer instructions than the external one.
04:53:06 <madbr> I'm not sure you can guzzle picture data from RAM fast enough if your external memory is only 8 bits
04:53:08 <zzo38> madbr: It would be OK, as long as, the number of clock cycles is based on a fixed DRAM size/speeds
04:55:39 <madbr> if your part is a cpu, it's going to mix up accesses to data with accesses to instructions
04:55:51 <madbr> so you're going to have the page-change-penalty every cycle
04:56:04 <madbr> well, every time you access data actually
04:56:10 <Bike> http://web.archive.org/web/19990128210124/http://people.netscape.com/brendan/ this is real right? tell me it is
04:56:34 <^v> function SwapBack() { document.knob.src = Image1.src; return true; }
04:56:58 <zzo38> madbr: You could have a separate GPU as well, as CPU, so it is possible to write the program in the way to act in parallel; you can also store the data in the cache which you would use mostly often, to increase the speed; and, depending on the way the program is written to use/unuse cache, use self-modifying codes, too.
04:57:01 <^v> page still loading
04:57:14 <zzo38> (Possibly even the program in cache is allowed to modify itself)
04:58:16 <zzo38> Self-modifying codes should be allowed, as it is very useful.
04:58:31 <madbr> I'm not convinced it's worth the complexity
04:58:58 <zzo38> If you store the value of a variable in an immediate operand, then you can avoid a page penalty.
04:59:01 <Jafet> Bike: not enough jquery
04:59:13 <zzo38> (It also avoid a memory access, too.)
04:59:24 <madbr> except it's still a memory access
04:59:50 <madbr> and later on when you're pipelining your architecture, you're in deep trouble
05:00:42 <zzo38> Some instruction sets don't have pipeline stalls, so it avoids that problem; you then need to program them yourself.
05:01:23 <zzo38> You can also, tell it to copy it to the cache and then tell it to read/write cache and execute instruction in a cache, is another way speeding it up a bit.
05:01:24 <madbr> it's really hard to avoid pipeline stalls
05:01:36 <madbr> if you have cache you have pipeline stalls
05:01:55 <madbr> if you have branch prediction you have pipeline flushes
05:01:56 <zzo38> That is why, it has to be explicit-only cache.
05:02:26 <madbr> if you have something like load reg, [reg + 5]
05:02:33 <madbr> you have pipeline stalls
05:02:36 <zzo38> If you use it wrong, you are subject to the consequences by yourself.
05:02:57 <madbr> because if the reg in [reg + 5] changes the cycle before, you have to catch that
05:04:01 <zzo38> madbr: The program would be written to avoid that if you want it to use the register that changes in the cycle before.
05:04:40 <madbr> then your program has extra nops every time some other useful instruction can't be swapped in
05:05:14 <madbr> the extra nops take up extra code cache which makes the thing slower
05:05:15 <zzo38> Yes, it does, but if you don't have another useful instruction to put in, then be careful maybe you wrote your program badly and there might be a way to fix it.
05:05:25 -!- oklopol has joined.
05:05:32 <madbr> depends on the kind of algo
05:05:49 <madbr> if it's number crunching stuff then usually there's something you can stuff in yes
05:06:07 <madbr> if it's like, zip decompression or something nasty like that... god have mercy on you
05:06:14 <zzo38> Anyways, my suggestion was that, the instruction cache would be VLIW, so different than the instruction set used for executing external memory anyways
05:06:45 <zzo38> (It would execute microcode ROM if the instruction cache is not being executed.)
05:07:30 <madbr> I guess vliw would be ok if you had a way to switch to some less efficient instruction set
05:07:46 <madbr> for like non-number-crunching code
05:08:08 <madbr> where you're going to do lots of memory accesses anyways so there's no point to having 6 ALUs
05:08:37 <madbr> and then for that one hand-optimized crunching loop, use the VLIW mode
05:08:49 <^v> Bike, the page finnaly loaded and xD
05:09:33 <zzo38> If the program isn't in cache, it would use a less efficieint instruction set. Otherwise, if it is in the cache, you would need to implement your own instruction set that the program in microcode RAM runs from the rest of the cache.
05:10:20 <madbr> essentially this is what the ARM does with the THUMB vs ARM
05:11:09 <madbr> thumb is 16 bits which limits the number of ram cycles you lose to loading in the stuff
05:12:40 <madbr> though you could probably just have a VLIW that has a choice between 1 big VLIW instruction word, or an instruction word that encodes multiple one-cycle instructions
05:14:09 <zzo38> Sure, that is another possibility
05:15:46 <madbr> it's hard to find a good balance in this kinda thing :D
05:17:08 <madbr> optimal instruction is somewhere between 16 and 32 bits AFAIK
05:17:42 <madbr> less than 16 and it's too small, not enough bits for the register selection
05:18:08 <madbr> plus you need too much granularity in your instruction word shifter
05:19:56 <madbr> more than 32 and you're probably wasting too much instruction cache space, unless it's VLIW and you're packing more than one instruction per word...
05:20:05 <madbr> AFAIK this was a major problem on itanium
05:20:57 <madbr> also if your cpu is dual issue that is kinda equivalent-ish to making your instructions 64bits
05:22:39 <zzo38> What does "dual issue" mean?
05:22:47 <madbr> two instructions per cycle
05:23:23 <madbr> see: intel pentium, ARM A8 (used on lots of older iphones), one MIPS generation (can't remember which)
05:23:35 <madbr> I think there was also one of the 68k that was designed like that
05:23:54 <madbr> afaik it's one of the cpu design "sweet spots"
05:24:26 <madbr> less than 2 and you're running 1 instruction per cycle... and essentially twice as slow
05:24:45 -!- chaiomanot has quit (Quit: Leaving).
05:25:05 <madbr> more than 2 and chances are you're going to need crazy stuff like out of order execution to make it any faster than 2 instructions per cycle
05:25:19 <madbr> (though I guess the IBM POWER6 did it)
05:25:20 -!- tromp has quit (Remote host closed the connection).
05:25:55 -!- tromp has joined.
05:25:59 <madbr> (and it really depends on the type of program, I'm sure you can do a lot more in-order if your programs are number crunching or floating point)
05:28:07 <madbr> I guess it all comes down to "what kind of game is going to run on it" :D
05:30:09 -!- tromp has quit (Ping timeout: 252 seconds).
05:31:03 <madbr> the general problem with a VLIW is to make it faster than a well designed RISC
05:31:56 <madbr> ie "pay for" your large instructions by figuring out stuff for your CPU to do in the leftover slots
05:33:16 <madbr> if this fails, the RISC is faster than you because it needs less code cache
05:35:37 <madbr> generally the stuff that reduces your gains are stuff like
05:35:52 <madbr> - ram/cache read ports
05:36:07 <madbr> - register file read/write ports
05:37:39 <madbr> - absolute latencies in instruction processing, which can also be described as "lack of number crunching to do while working on the critical-latency-path"
05:41:37 <madbr> that being said, gfx and sound rendering are more or less the ideal case for finding stuff that won't fall into these limits and will actually benefit from VLIW or similar stuff like SIMD
05:42:15 <^v> anyone still have barely.asm?
05:42:21 <^v> link b bork
05:46:25 -!- zzo38 has quit (Ping timeout: 255 seconds).
05:49:56 <Sgeo> > fix (sequence [(!! 1), 2 + 2])
05:49:56 <idris-ircslave> When elaborating an application of constructor __infer:
05:49:58 <lambdabot> No instance for (GHC.Show.Show a0)
05:49:58 <lambdabot> arising from a use of `M688017572578786861922522.show_M6880175725787868619...
05:49:58 <lambdabot> The type variable `a0' is ambiguous
05:49:58 <lambdabot> Possible fix: add a type signature that fixes these type variable(s)
05:49:58 <lambdabot> Note: there are several potential instances:
05:50:26 <Sgeo> @run fix (sequence [(!! 1), 2 + 2]) :: [Int]
05:50:27 <lambdabot> No instance for (GHC.Num.Num ([GHC.Types.Int] -> GHC.Types.Int))
05:50:27 <lambdabot> (GHC.Num.Num ([GHC.Types.Int] -> GHC.Types.Int))
05:50:56 -!- Patashu[Zzz] has joined.
05:50:56 -!- Patashu has quit (Disconnected by services).
05:51:06 <Jafet> @run fix (sequence [(!! 1), (2 +)])
05:51:07 <lambdabot> Occurs check: cannot construct the infinite type: a0 = [a0]
05:51:09 <Sgeo> Trying to recreate something similar to the loeb example
05:51:28 <Sgeo> With just reader monad + fix
05:54:35 <Jafet> :t sequence [(!! 1), const (2 + 2)]
05:54:44 <Jafet> @run fix $ sequence [(!! 1), const (2 + 2)]
05:54:56 <Jafet> @run fix $ sequence [ (!!5), const 3, liftM2 (+) (!!0) (!!1), (*2) . (!!2), length, const 17 ]
05:55:35 <Jafet> @let loeb :: [[a] -> a] -> [a]; loeb = fix . sequence
05:56:12 <Sgeo> That's not the standard defintion of loeb, is it?
05:56:34 <Jafet> The type looked more general than that, but sequence is constraining it
05:57:09 <Jafet> :t let loeb x = ($ loeb x) <$> x in loeb
05:57:46 <Jafet> :t fix . sequenceA
05:57:47 <lambdabot> `T.sequenceA' (imported from Data.Traversable),
05:57:52 <Jafet> :t fix . T.sequenceA
05:57:53 <lambdabot> Traversable t => t (t a -> a) -> t a
05:58:49 <Jafet> @pl loeb x = ($ loeb x) <$> x -- trivial fix
06:00:27 <Jafet> @let loeb = fix (fmap.flip id =<<)
06:00:29 <lambdabot> No instance for (Functor f0) arising from a use of `fmap'
06:00:29 <lambdabot> The type variable `f0' is ambiguous
06:00:29 <lambdabot> Possible fix: add a type signature that fixes these type variable(s)
06:00:29 <lambdabot> Note: there are several potential instances:
06:01:18 <Jafet> @let loeb :: Functor f => f (f b -> b) -> f b; loeb = fix (fmap.flip id =<<)
06:04:15 -!- madbr has quit (Quit: Rouringu de hajikunda!).
06:15:22 -!- ^v has quit (Quit: http://i.imgur.com/DrFFzea.png).
06:25:58 -!- ter2 has quit (Ping timeout: 240 seconds).
06:28:58 <mroman> > loeb Just (\Just x -> x)
06:28:58 <idris-ircslave> When elaborating an application of constructor __infer:
06:28:59 <lambdabot> Constructor `Data.Maybe.Just' should have 1 argument, but has been given none
06:29:18 <mroman> > loeb Just (\(Just x) -> x)
06:29:19 <idris-ircslave> When elaborating an application of constructor __infer:
06:29:20 <lambdabot> Couldn't match type `Data.Maybe.Maybe (Data.Maybe.Maybe t0 -> t0)'
06:29:20 <lambdabot> with `((Data.Maybe.Maybe t0 -> t0) -> b0) -> b0'
06:29:20 <lambdabot> Expected type: (Data.Maybe.Maybe t0 -> t0)
06:29:20 <lambdabot> -> ((Data.Maybe.Maybe t0 -> t0) -> b0) -> b0
06:29:20 <lambdabot> Actual type: (Data.Maybe.Maybe t0 -> t0)
06:34:11 <Jafet> @run loeb $ Just fromJust
06:34:44 <mroman> > let fun :: (Functor f, Functor g) => f -> g -> (f b -> b) -> f b -> g b; fun f g x = f ( g x) in fun Just Just (\(Just x) -> x) 9
06:34:44 <idris-ircslave> let fun :: (Functor f, Functor g) => f -> g -> (f b -> b) -> f b -> g b; fun >
06:34:45 <lambdabot> Expecting one more argument to `f'
06:34:52 <mroman> ^- what's wrong with that?
06:36:03 <mroman> > let bar :: Functor f => f -> a -> f a; bar f x = f x in (bar Just) 9
06:36:03 <idris-ircslave> let bar :: Functor f => f -> a -> f a; bar f x = f x in (bar Just) 9<EOF>
06:36:04 <lambdabot> Expecting one more argument to `f'
06:36:35 <Jafet> @run let fun :: (Functor f, Functor g) => (a -> f a) -> (a -> g a) -> (f a -> a) -> f a -> g a; fun f g x = f (g x) in fun Just (:[]) (\(Just x) -> x) (Just 9)
06:36:36 <lambdabot> from the context (GHC.Base.Functor f, GHC.Base.Functor g)
06:36:36 <lambdabot> fun :: (GHC.Base.Functor f, GHC.Base.Functor g) =>
06:36:36 <lambdabot> (a -> f a) -> (a -> g a) -> (f a -> a) -> f a -> g a
06:37:00 <mroman> > let bar :: Functor f => (a -> f a) -> a -> f a; bar f x = f x in (bar Just) 9
06:37:01 <idris-ircslave> let bar :: Functor f => (a -> f a) -> a -> f a; bar f x = f x in (bar Just) 9<>
06:37:11 <mroman> ah. I see the problem.
06:37:54 -!- ter2 has joined.
06:39:37 <mroman> @run return 9 :: Maybe Int
06:43:16 <mroman> @run id (Just 9) == (id Just) 9
06:48:31 -!- ter2 has quit (Ping timeout: 255 seconds).
07:04:35 -!- MoALTz has quit (Quit: bbl).
07:54:49 -!- trolly has joined.
08:02:36 -!- trolly has quit (Remote host closed the connection).
08:14:29 -!- sgelios has joined.
08:17:35 -!- Slereah_ has joined.
08:25:08 -!- sgelios has quit (Ping timeout: 240 seconds).
08:37:10 <fizzie> Huh, is Brainfuck/Ook commonly used in goecaching circles? This geocaching tool I stumbled upon while looking for something else -- http://gcc.eisbehr.de/features.html -- lists conversions between text, Brainfuck and Ook among its features.
08:38:06 -!- oerjan has joined.
08:38:07 <fizzie> (Also an absolutely ludicrous list of non-eso things.)
08:39:41 <Taneb> Yogscast is getting pretty huge
08:56:16 <oerjan> @run length . nub . take 128 . flip iterate 1 $ \x -> (x*47) `mod` 256
08:57:51 <oerjan> @run nub [length . nub . take 256 . flip iterate 1 $ \x -> (x*n) `mod` 256) | n <- [0..255]]
08:57:52 <lambdabot> <hint>:1:70: parse error on input `)'
08:58:02 <oerjan> @run nub [length . nub . take 256 . flip iterate 1 $ \x -> (x*n) `mod` 256 | n <- [0..255]]
08:58:42 <oerjan> none 128, so not cyclic
09:01:03 <oerjan> hm why is there no 7 i there
09:02:28 <oerjan> @run nubBy ((==) `on` snd) [(n, length . nub . take 256 . flip iterate 1 $ \x -> (x*n) `mod` 256) | n <- [0..255]]
09:02:29 <lambdabot> [(0,2),(1,1),(2,9),(3,64),(4,5),(7,32),(8,4),(15,16),(16,3),(31,8)]
09:03:40 <oerjan> @run nubBy ((==) `on` snd) [(n, length . nub . take 256 . flip iterate 1 $ \x -> (x*n) `mod` 256) | n <- [1, 3..255]]
09:03:41 <lambdabot> [(1,1),(3,64),(7,32),(15,16),(31,8),(63,4),(127,2)]
09:05:43 -!- zzo38 has joined.
09:06:43 <oerjan> @run last . sort . nub . take 256 . flip iterate 1 $ \x -> (x*3) `mod` 256)
09:06:45 <lambdabot> <hint>:1:70: parse error on input `)'
09:06:49 <oerjan> @run last . sort . nub . take 256 . flip iterate 1 $ \x -> (x*3) `mod` 256
09:07:22 <oerjan> ok so 3 and 255 are summand generators
09:08:39 <oerjan> @run sort . nub . take 256 . flip iterate 1 $ \x -> (x*3) `mod` 256
09:08:39 <lambdabot> [1,3,9,11,17,19,25,27,33,35,41,43,49,51,57,59,65,67,73,75,81,83,89,91,97,99,...
09:10:26 <fizzie> I keep wanting you to write \x -> (x*n) `mod` 256 as flip mod 256 . (n*) instead, because it has less pokey bits.
09:12:02 <oerjan> i pretty clearly decided against making that pointfree at one point.
09:14:04 <oerjan> @run nubBy ((==) `on` snd) [(n, length . nub . take 256 $ iterate (n*) 1 ) | n <- [0..255 :: Word8]] -- another option
09:14:05 <lambdabot> [(0,2),(1,1),(2,9),(3,64),(4,5),(7,32),(8,4),(15,16),(16,3),(31,8)]
09:30:07 <int-e> sort . nub -> head . group . sort
09:32:10 -!- ski has quit (Quit: Lost terminal).
09:32:23 <oerjan> and it wasn't in the inner loop
09:43:20 -!- yorick has joined.
09:43:49 <int-e> oerjan: I do that habitually; I usually get it right the first time, too, when actually coding.
09:44:11 * int-e should have an nubOrd helper instead.
09:48:30 <int-e> @run id * 3 `mod` 256 $ 123 -- I forgot whether this is still in lambdabot.
09:48:31 <lambdabot> No instance for (GHC.Show.Show a0)
09:48:31 <lambdabot> arising from a use of `M826470610663680039923602.show_M8264706106636800399...
09:48:31 <lambdabot> The type variable `a0' is ambiguous
09:48:31 <lambdabot> Possible fix: add a type signature that fixes these type variable(s)
09:48:31 <lambdabot> Note: there are several potential instances:
09:48:55 <Jafet> @run 0 0 :: Integer
09:48:56 <lambdabot> No instance for (GHC.Num.Num a0) arising from the literal `0'
09:48:56 <lambdabot> The type variable `a0' is ambiguous
09:48:56 <lambdabot> Possible fix: add a type signature that fixes these type variable(s)
09:48:56 <lambdabot> Note: there are several potential instances:
09:48:56 <lambdabot> instance GHC.Num.Num GHC.Types.Double
09:49:09 <Jafet> @run (0 :: Integer -> Integer) 0
09:49:10 <lambdabot> (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer))
09:49:15 <int-e> (when Cale ran it, there used to be a Num a => Num (r -> a) instance, acting pointwise
09:49:55 <Jafet> @instances-importing Num
09:49:57 <oerjan> i remember that, also when it was removed
09:50:19 <int-e> which is really irritating if you make a mistake in numeric code somewhere, but id * const k `mod` 256 would be kind of cool.
09:50:23 <oerjan> @help instances-importing
09:50:23 <lambdabot> instances-importing [<module> [<module> [<module...]]] <typeclass>. Fetch the instances of a typeclass, importing specified modules first.
09:50:41 <oerjan> Jafet: i think that requires the module list to do anything different
09:51:25 <int-e> (ironically it's longer than \x -> x * k `mod` 256)
09:51:50 <oerjan> yeah function instances confuse matters, which is why i was surprised they added the monadic ones by default to ghci lately
09:56:27 -!- MindlessDrone has joined.
09:58:24 <Jafet> @run (ap, ap.ap, ap.ap.ap, ap.ap.ap.ap)
09:58:25 <lambdabot> No instance for (Data.Typeable.Internal.Typeable1 m0)
09:58:25 <lambdabot> arising from a use of `M431492159472810415423670.show_M4314921594728104154...
09:58:25 <lambdabot> The type variable `m0' is ambiguous
09:58:25 <lambdabot> Possible fix: add a type signature that fixes these type variable(s)
09:58:25 <lambdabot> Note: there are several potential instances:
09:58:30 <Jafet> :t (ap, ap.ap, ap.ap.ap, ap.ap.ap.ap)
09:58:31 <lambdabot> Monad m => (m (a -> b) -> m a -> m b, (a1 -> a2 -> b1) -> ((a1 -> a2) -> a1) -> (a1 -> a2) -> b1, (a3 -> a4 -> b2) -> (((a3 -> a4) -> a3) -> a3 -> a4) -> ((a3 -> a4) -> a3) -> b2, (a5 -> a6 -> b3) -> ((((a5 -> a6) -> a5) -> a5 -> a6) -> (a5 -> a6) -> a5) -> (((a5 -> a6) -> a5) -> a5 -> a6) -> b3)
10:01:22 <oerjan> :t ap`fmap`ap`fmap`ap`fmap`ap
10:01:23 <lambdabot> (a -> a1 -> b) -> ((((a -> a1) -> a) -> a -> a1) -> (a -> a1) -> a) -> (((a -> a1) -> a) -> a -> a1) -> b
10:05:05 <Jafet> @run length.show.typeOf $ ap.ap.ap.ap.ap.ap.ap.ap.ap $ (undefined :: ()->()->())
10:05:10 <Jafet> @run length.show.typeOf $ ap.ap.ap.ap.ap.ap.ap.ap.ap.ap $ (undefined :: ()->()->())
10:05:30 <Jafet> @run 1688/1044 - (1+sqrt 5)/2
10:08:28 <oerjan> does that mean you can get the type of the next one with a fibonacci substitution on the previous?
10:09:03 <lambdabot> Monad m => (a -> m (a1 -> b)) -> a -> m a1 -> m b
10:09:24 <FireFly> Good way of deriving the golden ration IMO
10:10:13 <oerjan> hm the b only occurs once above
10:10:24 -!- olsner has joined.
10:10:44 <lambdabot> (a -> a2 -> a1 -> b) -> a -> (a2 -> a1) -> a2 -> b
10:12:20 <oerjan> indeed that's a fibonacci substitution
10:14:51 <oerjan> a2 becomes a2 -> a1, a1 becomes a2
10:18:00 <lambdabot> (a1 -> a -> b) -> (a1 -> a) -> a1 -> b
10:18:52 <lambdabot> Monad m => (a -> m (a1 -> b)) -> a -> m a1 -> m b
10:19:31 <oerjan> olsner: i added the ($) to force the function instance
10:20:01 <Jafet> @run (\(a,b,c,d) -> printf "%s -> %s -> %s -> %s" a b c d) <$> unfoldr (\e@(a,b,c,d) -> Just (e, (a, printf "(%s -> %s)" b c, b, d))) ("(a -> b -> c)", "(a -> b)", "a", "c") :: [String]
10:20:03 <lambdabot> ["(a -> b -> c) -> (a -> b) -> a -> c","(a -> b -> c) -> ((a -> b) -> a) -> ...
10:21:04 <oerjan> that's the base case, sort of
10:21:37 <oerjan> which is of course a refinement of ($)'s type
10:22:23 <Jafet> @run (12+) . sum <$> unfoldr (\e@[a,b,c,d] -> Just (e, [a, 6+b+c, b, d])) $ length <$> ["(a -> b -> c)", "(a -> b)", "a", "c"]
10:22:25 <lambdabot> No instance for (GHC.Num.Num [GHC.Types.Int])
10:22:25 <lambdabot> add an instance declaration for (GHC.Num.Num [GHC.Types.Int])
10:22:50 <Jafet> @run unfoldr (\e@[a,b,c,d] -> Just (12 + sum e, [a, 6+b+c, b, d])) $ length <$> ["(a -> b -> c)", "(a -> b)", "a", "c"]
10:22:51 <lambdabot> [35,49,70,105,161,252,399,637,1022,1645,2653,4284,6923,11193,18102,29281,473...
10:24:06 <oerjan> @run typeOf (undefined:()->()->())
10:24:07 <lambdabot> Pattern syntax in expression context: undefined : () -> () -> ()
10:24:13 <oerjan> @run typeOf (undefined::()->()->())
10:24:26 <oerjan> @run typeOf ap.(undefined::()->()->())
10:24:27 <lambdabot> Couldn't match expected type `(() -> ()) -> c0'
10:24:27 <lambdabot> with actual type `Data.Typeable.Internal.TypeRep'
10:24:35 <oerjan> @run typeOf $ ap.(undefined::()->()->())
10:24:36 <lambdabot> Couldn't match type `()' with `a0 -> b0'
10:24:37 <lambdabot> Expected type: () -> () -> a0 -> b0
10:24:56 <oerjan> @run typeOf $ ap$(undefined::()->()->())
10:25:03 <Jafet> Function instances.
10:26:51 <oerjan> ap f x y = f y (x y), which shows you get a fibonacci on the term level too
10:27:57 <oerjan> @run (ap.ap.ap) (f::Expr->Expr->Expr) a b
10:27:59 <lambdabot> Couldn't match expected type `((Debug.SimpleReflect.Expr.Expr
10:27:59 <lambdabot> -> Debug.SimpleReflect.Expr.Expr -> Debug.Simp...
10:27:59 <lambdabot> with actual type `Debug.SimpleReflect.Expr.Expr'Couldn't match t...
10:28:07 <oerjan> @run (ap.ap.ap) (f::Expr->Expr->Expr) g h
10:28:08 <lambdabot> No instance for (Data.Typeable.Internal.Typeable
10:28:08 <lambdabot> arising from a use of `Debug.SimpleReflect.Vars.g'
10:28:19 <oerjan> @run (ap.ap.ap) (f::Expr->Expr->Expr) g h :: Expr
10:28:20 <lambdabot> No instance for (Data.Typeable.Internal.Typeable
10:28:21 <lambdabot> arising from a use of `Debug.SimpleReflect.Vars.g'
10:28:29 <lambdabot> (FromExpr t, FromExpr t1) => (t, t1)
10:28:56 <lambdabot> (a -> a1 -> b) -> (((a -> a1) -> a) -> a -> a1) -> ((a -> a1) -> a) -> b
10:29:41 <oerjan> @run (ap.ap.ap) (f::Expr->Expr->Expr)
10:29:43 <lambdabot> No instance for (Data.Typeable.Internal.Typeable
10:29:47 <lambdabot> arising from a use of `M723199156154611174123930.show_M7231991561546111741...
10:29:53 <oerjan> :t (ap.ap.ap) (f::Expr->Expr->Expr)
10:29:54 <lambdabot> (((Expr -> Expr) -> Expr) -> Expr -> Expr) -> ((Expr -> Expr) -> Expr) -> Expr
10:30:29 <oerjan> @run g (h :: Expr) :: Expr
10:31:09 <oerjan> @run (ap.ap) (f::Expr->Expr->Expr) g h :: Expr
10:31:12 <lambdabot> No instance for (Data.Typeable.Internal.Typeable
10:31:12 <lambdabot> arising from a use of `Debug.SimpleReflect.Vars.g'
10:31:18 <oerjan> @run ap (f::Expr->Expr->Expr) g h :: Expr
10:31:54 <oerjan> :t (ap.ap) (f::Expr->Expr->Expr) g h :: Expr
10:31:54 <lambdabot> No instance for (Typeable Expr) arising from a use of `g'
10:31:55 <lambdabot> Possible fix: add an instance declaration for (Typeable Expr)
10:31:55 <lambdabot> In the second argument of `ap . ap', namely `g'
10:32:12 <oerjan> something is going horribly wrong in the typechecking
10:32:26 <lambdabot> (Typeable a, Typeable b, FromExpr c) => (a -> b) -> c
10:33:08 <lambdabot> Could not deduce (Typeable b0) arising from a use of `f'
10:33:08 <lambdabot> bound by the inferred type of it :: FromExpr c => c at Top level
10:35:00 <oerjan> you cannot actually show FromExpr values that aren't fully applied
10:35:11 <oerjan> which some of the subexpressions will be
10:35:59 <oerjan> so the Expr trick doesn't work with higher-order functions
10:42:25 <int-e> hmm. a challenge? :)
10:44:17 * oerjan somehow pressed return instead of tab
10:45:24 <int-e> *Main> f.id :: Expr -> Expr ---> \x -> f x
10:46:05 <int-e> unfortunately, f :: Expr -> Expr -> Expr becomes \x -> \x -> f x x ;-)
10:46:06 <Jafet> :t (ap.ap.ap) ?f ?g ?h
10:46:06 <lambdabot> (?f::a -> a1 -> b, ?g::((a -> a1) -> a) -> a -> a1, ?h::(a -> a1) -> a) => b
10:46:28 <oerjan> int-e: it's (Expr -> Expr) -> Expr which becomes the problem
10:46:51 <int-e> (but perhaps showsPrec can be abused to make instance Show a => Show (Expr -> a) where show f = "\\x -> " ++ show (f x) use different variables)
10:47:00 <int-e> oerjan: sure, there are limits.
10:47:47 <int-e> I'm not going to pursue this seriously
10:47:48 <oerjan> int-e: also, my examples don't actually give lambdas.
10:49:31 <Jafet> show f = show (['x':show n|n<-[0..]], f); instance Show a => Show ([String], Expr -> a) where show (v:vs, f) = "\\" ++ v ++ " -> " ++ show (vs, f $ var v)
10:51:10 <int-e> Possibly one would end up with horrible things like instance (Witness a, Show b) => Show (a -> b) where show f = let w = witness in "\\" ++ show w ++ " -> " ++ show (f witness), plus some hackery to get identifiers.
10:54:07 <oerjan> instance Witness (a -> b) => Show (a -> b) where show = witness 0
10:55:11 -!- conehead has quit (Quit: Computer has gone to sleep).
10:56:03 <oerjan> mroman: shall i ban you for not noticing that everyone else is using @run twh
10:58:35 <myname> i am thinking about making "indecision" a disadvantage for my rogue, but i'm not really sure if i want to
10:58:57 <oerjan> `addquote <myname> i am thinking about making "indecision" a disadvantage for my rogue, but i'm not really sure if i want to
10:58:59 <HackEgo> 1182) <myname> i am thinking about making "indecision" a disadvantage for my rogue, but i'm not really sure if i want to
10:59:06 <oerjan> i'm pretty sure i was baited.
11:00:11 <myname> that situation actually stands
11:00:39 <int-e> Right ... "I used to be indecisive but now I'm not so sure."
11:00:48 <int-e> (I wonder who came up with this.)
11:01:32 <myname> does anybody has good ideas for quirks which donkt hurt that much?
11:02:00 <int-e> It *is* a good weakness. "There is a cop. Should I run or hide? In the meantime I can just stand here and look suspicious."
11:02:07 <oerjan> i go with the typo and say "were-donkey"
11:05:24 -!- yorick has quit (Remote host closed the connection).
11:05:44 <myname> int-e: well, it may be *too* good
11:06:17 <int-e> only if you want to survive
11:06:23 <int-e> but how can you be sure about that?
11:07:14 <myname> as a player i'd like my character to be alive most of the time
11:08:10 <int-e> but such a character could be lots of fun ... as long as it lasts.
11:08:30 <int-e> But I do understand your concerns.
11:16:49 -!- Patashu[Zzz] has quit (Quit: Soundcloud (Famitracker Chiptunes): http://www.soundcloud.com/patashu MSN: Patashu@hotmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
11:16:58 -!- Patashu has joined.
11:21:42 <int-e> *Main Control.Monad> (ap.ap.ap) (f::Expr->Expr->Expr)
11:21:43 <int-e> \abb -> \aa -> f aa abb
11:23:02 <int-e> oerjan: http://sprunge.us/iMUg?haskell (not perfect, but now it stops being fun)
11:25:44 <int-e> (actually I have no clue what I did there, semantically)
11:27:36 <int-e> best I can tell the witnesses are now Skolem functions with all their arguments implicit. Hah.
11:27:54 <int-e> Clearly that's very useful.
11:28:14 <int-e> (Especially because their names clash, too.)
11:30:16 -!- olsner has quit (Quit: Leaving).
11:37:31 -!- fcrawl has joined.
11:38:13 -!- boily has joined.
11:39:04 <boily> good international boardgaming day morning!
11:48:22 <Taneb> I need to move my computer
11:48:29 <Taneb> Having it here is giving me a sore back
11:54:42 -!- Sorella has joined.
11:56:49 <Jafet> 3SUM purportedly in o(n^2): http://arxiv.org/abs/1404.0799
12:11:32 <int-e> Jafet: interesting.
12:13:25 -!- Phantom_Hoover has joined.
12:48:38 -!- Patashu has quit (Ping timeout: 240 seconds).
12:56:43 -!- ter2 has joined.
13:02:13 -!- ter2 has quit (Read error: Connection reset by peer).
13:02:28 -!- ter2 has joined.
13:05:11 <boily> that video was introductionarily interesting, lightly brushing against the Uncountability of the Reals.
13:06:07 <Phantom_Hoover> sam hughes wrote a better explanation: http://qntm.org/trollpi
13:06:45 <boily> IT'S NOT WROOOOONG!
13:06:48 <Phantom_Hoover> but all it comes down to is that when you take the limit of a sequence of curves that limit doesn't have to share any properties with the curves in the sequence
13:08:54 <Taneb> Phantom_Hoover, Vi Hart is pop maths. It's for viewerships, not correctness
13:09:25 <Phantom_Hoover> Right but it's not incorrect in a 'lies-to-children' sense, it's incorrect in the sense that it just leads viewers down the garden path.
13:10:44 <oerjan> and to the barn fell of doom
13:12:20 <Taneb> What really annoys me about Vi Hart is her video about Flexagons came out a day after I decided to make some
13:14:18 * oerjan now imagines gingerbread flexagons. and probably should eat.
13:14:24 <Taneb> Now I want to make a flexagon
13:15:15 <Taneb> Probably not out of gingerbread
13:17:04 <int-e> reminds me of https://en.wikipedia.org/wiki/Rubik%27s_Magic hmm
13:18:01 <boily> oerjan: can one make flexible gingerbread?
13:20:24 <quintopia> Taneb: what annoys me about vihart is that my friends got a private concert from her on joco cruise crazy 1 and i couldn't go :(
13:20:28 <oerjan> quintopia: oh the barn fell?
13:21:51 <oerjan> boily: i dunno do i look like a baker
13:22:59 <boily> oerjan: you are oerjan. maybe you are a baker. maybe not. hth.
13:41:12 <quintopia> nooooooooooo not the morse code .-.
13:42:54 <boily> the Morse Code is the Future!
13:43:07 <oerjan> .--.-..--..-.--.-..-.--..--.-..-
13:44:35 <oerjan> it uses separating pauses
13:44:50 <oerjan> because, it's like designed to be decoded by humans.
13:45:13 <quintopia> humans could decipher a pauseless stream with practice!
13:48:10 <boily> without humans in the way, communication would be much easier.
13:48:25 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
13:55:36 -!- copumpkin has quit (Quit: My MacBook Pro has gone to sleep. ZZZzzz…).
14:01:32 -!- Phantom_Hoover has joined.
14:04:49 -!- boily has quit (Quit: BOARDGAMING CHICKEN!).
14:11:28 -!- shikhin has joined.
14:15:17 -!- shikhin has changed nick to shikhi.
14:19:02 <Sgeo> Is it normal for a Haskell question to go unanswered on SO this long? http://stackoverflow.com/questions/22851565/getting-input-into-netwire-programs
14:20:12 -!- shikhi has changed nick to shikhin.
14:26:00 <oerjan> well it's not about a very widely used library afaik
14:28:10 -!- Lola has joined.
14:29:12 -!- applybot has quit (Quit: sorry!).
14:30:39 <HackEgo> Lola: ¡Bienvenido al centro internacional para el diseño y despliegue de lenguajes de programación esotéricos! Por desgracia, la mayoría de nosotros no hablamos español. Para obtener más información, echa un vistazo a nuestro wiki: http://esolangs.org/. (Para el otro tipo de esoterismo, prueba #esoteric en irc.dal.net.)
14:32:38 -!- ter2 has quit (Ping timeout: 240 seconds).
14:33:39 -!- ter2 has joined.
14:36:28 -!- ter2 has changed nick to tertu.
14:36:39 -!- tertu has changed nick to ter2.
14:36:55 -!- Lola has left.
14:41:25 <elliott> oerjan: don't bother welcoming ~canaima
14:41:38 <elliott> all the spanish people of the past N months are just one person.
14:41:48 <elliott> in fact we should just set a ban or something. it's silly.
14:42:25 <ion> Ban all the users
14:49:17 -!- conehead has joined.
14:49:52 -!- oerjan has quit (Quit: Omelette du fromage).
15:03:32 -!- applybot has joined.
15:04:39 -!- yorick has joined.
15:11:44 <Jafet> idris-ircslave: let x = 1 :: x in x
15:11:45 <idris-ircslave> (input):1:14:When elaborating argument val to constructor Delay:
15:17:24 -!- tromp has joined.
15:25:57 -!- int-e has changed nick to notregistered.
15:26:10 -!- notregistered has changed nick to int-e.
15:28:00 -!- tertu3 has joined.
15:28:13 -!- ter2 has quit (Read error: Connection reset by peer).
15:31:37 -!- ^v has joined.
15:31:48 <HackEgo> /hackenv/bin/pastelogs: line 2: cd: /var/irclogs/_esoteric: No such file or directory \ grep: ????-??-??.txt: No such file or directory \ http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.22298
15:32:33 <int-e> No such file or directory
15:33:13 <fcrawl> HackEgo just doesn't keep have logs anymore?
15:33:15 <int-e> afaik, hackego moved and the logs are now stored elsewhere
15:33:39 <int-e> While previously they were on the same machine. But I don't know for sure.
15:43:48 -!- shikhin has quit (Quit: Leaving).
16:12:20 -!- fcrawl has quit (Read error: Connection reset by peer).
16:16:00 <fizzie> That is my impression, too.
16:17:01 <fizzie> kmc: Just so you know, I have made the opcode generator into an opcode quiz, as per your suggestion. (Just need to collect data for a couple more architectures before making it public.)
16:18:40 -!- copumpkin has joined.
16:23:41 <Jafet> Call it the Label Ersatz Generator; name the quiz "ARM or LEG?" Add some Thumb to throw people off.
16:25:59 <Jafet> (People who pass are True Opcode Experts.)
16:26:04 -!- nooodl has joined.
16:27:55 -!- Phantom_Hoover has quit (Ping timeout: 268 seconds).
16:34:13 <fizzie> "incorrect; opcode HW_LD/PAWQVL is real" man, Alpha is hard.
16:35:43 <fizzie> It's not in the web yet. I only have x86 and Alpha in it.
16:36:34 <fizzie> Also it's missing "share your score in Facebook/Google+/Twitter" buttons, which were something I was thinking of "ironically" adding.
16:36:38 <fizzie> (I'm trying to figure out where the ARM opcodes are in this GNU binutils GDB checkout.)
16:39:23 <fizzie> They seem to be somewhat complicatedly in it, due to having some structure programmatically constructed.
16:46:05 -!- Phantom_Hoover has joined.
17:05:24 <zzo38> Program a quiz using Internet Quiz Engine. It work better, and is faster, too.
17:07:09 <zzo38> Yet, it includes a few extra commands for feature such as arithmetics and a few others.
17:07:37 <kmc> fizzie: did I ever show you http://ugcs.net/~keegan/complexity.html
17:11:25 <fizzie> I don't think I saw that.
17:11:44 <fizzie> And the Internet Quiz Engine will probably not be able to generate fake opcodes from n-gram models, will it?
17:13:08 <zzo38> fizzie: That feature is not included yet, although you can pregenerate the data. Currently, there is not the program to allow manipulation of Internet Quiz Engine files using SQL, sorry.
17:14:21 <zzo38> (But, it is currently possible to manipulate them using AWK, so you can use that.)
17:18:31 <fizzie> Well, I've already written this thing.
17:19:59 <zzo38> Currently IQE has no features for any kind of string manipulation at all, actually; only arithmetics and conditions are supported (although, there is timer support, multiple selection support, percentages, and some other things like that). There are no kinds of backward flow control at all, so loops are impossible.
17:23:09 -!- ^v has quit (Ping timeout: 252 seconds).
17:35:43 <fizzie> kmc: Here, you can have a preliminary-ish look at http://zem.fi/2014-04-05-opquiz -- though I'm going to have to go to do some sauna things real soon.
17:37:49 <fizzie> (Wonder if I should really add those score-share buttons.)
17:45:59 -!- bekirov has joined.
18:02:12 <zzo38> It is not working OK.
18:09:12 -!- variable has changed nick to trout.
18:09:35 <int-e> hmm, github. why don't forks have their own issue trackers, and why can't I merge an upstream pull request to my own fork using their frontend?
18:11:19 <zzo38> I have looked at (but not used) the Fossil system, which is said to be simpler than Git. Fossil is a SQL-based system, implemented as a single C program. I do not know if it can solve those problem or not.
18:14:53 -!- ^v has joined.
18:15:53 <int-e> No, because I have no issues with git itself.
18:17:39 -!- conehead has quit (Quit: Computer has gone to sleep).
18:18:39 <zzo38> You could move it to a system other than Github, even if it is still git-based system, though.
18:22:47 -!- S1 has joined.
18:27:38 -!- olsner has joined.
18:34:42 -!- MindlessDrone has quit (Quit: MindlessDrone).
18:43:21 -!- bekirov has quit (Remote host closed the connection).
19:23:32 <fizzie> kmc: Re the complexity class game, I would've wanted to have similar short descriptions of the (real) instructions, but those would've been less simple to extract. (And I guess also the entire list would be much larger.)
19:26:29 -!- nooodl_ has joined.
19:27:36 -!- nooodl has quit (Ping timeout: 252 seconds).
19:30:38 -!- ^v has quit (Quit: http://i.imgur.com/DrFFzea.png).
19:30:55 -!- ^v has joined.
19:34:12 -!- tertu3 has quit (Ping timeout: 252 seconds).
19:54:04 -!- lambdabot has quit (Quit: requested).
19:56:26 -!- fungot has quit (Quit: requested).
19:57:26 -!- fungot has joined.
19:58:22 -!- lambdabot has joined.
19:58:57 <int-e> The request was supposed to go to my test instance of the bot :-/ Oh well. It took its time (as usual) but it made it back.
20:05:26 <HackEgo> danddreclist 50: shachaf nooodl boily \ http://zzo38computer.org/dnd/recording/level20.tex
20:10:43 <zzo38> How can I tell gdb which module to debug by default? I have two modules loaded, and the one I want to debug isn't the main program.
20:18:43 -!- evalj has joined.
20:19:21 -!- olsner has quit (Quit: Leaving).
20:20:31 -!- nooodl_ has changed nick to nooodl.
20:50:42 <fizzie> http://cybermap.kaspersky.com/ that looks ridiculously like in a movie
21:01:11 * Sgeo goes to listen to all the music here: http://jessicadickinsongoodman.com/2008/01/18/pachebels-rant-dissected/
21:02:14 -!- oerjan has joined.
21:06:42 <Sgeo> And some of those videos don't exist :(
21:09:35 -!- nisstyre has quit (Quit: WeeChat 0.4.3).
21:16:23 -!- evalj has quit (Remote host closed the connection).
21:31:33 -!- augur has quit (Remote host closed the connection).
21:37:01 -!- Patashu has joined.
21:56:05 -!- Koen_ has joined.
21:59:35 -!- Patashu[Zzz] has joined.
21:59:35 -!- Patashu has quit (Disconnected by services).
22:10:41 -!- ejls has joined.
22:20:12 <^v> i made bottles of beer in fishstacks
22:21:15 <^v> its 142K chars
22:21:40 <^v> who wants it?
22:23:17 <^v> https://dl.dropboxusercontent.com/u/55181333/bottles.fishstacks
22:26:57 <Sgeo> Why are haddocks not built for this? https://hackage.haskell.org/package/python-pickle-0.2.0
22:28:01 <^v> D: me no likey python
22:29:21 -!- ^v has changed nick to PixelTerst.
22:31:13 <Taneb> I am still not quite sure what Object-Oriented programming actually is
22:31:52 <PixelTerst> i dunno, if memory addresses are objects, arent all programs object oriented
22:35:03 -!- PixelTerst has changed nick to ^v.
22:39:37 <Taneb> On the other hand, I have biscuits
22:40:22 <S1> k I'm outa here
22:40:24 -!- S1 has left.
22:40:43 -!- Phantom__Hoover has joined.
22:42:10 <oerjan> On the first hand, do you have cheese?
22:42:45 <Taneb> I am one of those weird people who isolates biscuit and cracker consumption
22:44:03 <^v> i am one of those weird people who makes programs in languages without an official interpreter
22:44:07 -!- Phantom_Hoover has quit (Ping timeout: 252 seconds).
22:44:18 <^v> i made my own fishstacks inturpreter
22:44:28 <^v> but im not giving it to you, because lazyness
22:44:51 <oerjan> did you know that if you don't put things on the wiki, they don't exist hth
22:44:57 <Taneb> ^v, have you seen Eodermdrome?
22:45:18 <^v> oerjan, ohey you are the person who edited fishstacks after me
22:45:23 <^v> please dont slap me
22:45:26 <^v> my first edit
22:46:01 <^v> Taneb, i remember it now ;-;
22:46:34 <oerjan> i'm one of those weird people who makes programs in Eodermdrome.
22:47:09 <oerjan> still waiting for someone to implement it so i can test the program.
22:47:24 <oerjan> (too lazy to code up actual graph algorithms)
22:47:43 <oerjan> BUT I PUT THE PROGRAM ON THE WIKI HTH
22:53:25 -!- conehead has joined.
22:55:50 -!- Zom-B has quit.
23:09:00 -!- tertu3 has joined.
23:42:07 <^v> the barely page is full of shit
23:42:25 <^v> h adds 71 not 47
23:45:29 -!- oerjan has quit (Quit: Nite).
23:49:31 <^v> proof: http://puu.sh/7XtPL.png
23:49:41 <^v> ]xjjjjjhhhhxjhhhhhhhhjjjhh~
23:49:44 <^v> is what i entered
23:50:45 <^v> its because some dumbass misread the assembly source
23:50:57 <^v> fucking.. dumbass
23:52:53 <^v> i am just mad
23:54:53 <elliott> that's no reason to take it out on the intelligence of someone you don't even know who made a simple mistake
23:55:04 <elliott> after all, it was not that long ago you misread how Deadfish works...
23:57:06 -!- yorick has quit (Remote host closed the connection).