ELLIOTTCABLE changed the topic of #elliottcable to: a _better_ cult
yorick has quit [Read error: Connection reset by peer]
_ has joined #elliottcable
Sgeo_ has joined #elliottcable
_ is now known as Guest60674
Guest60674 has quit [Client Quit]
Guest60674 has joined #elliottcable
Guest60674 has quit [Client Quit]
__ has joined #elliottcable
TheMathNinja has quit [Ping timeout: 240 seconds]
__ is now known as TheMathNinja
Sgeo has quit [Ping timeout: 240 seconds]
TheMathNinja has quit [Ping timeout: 245 seconds]
TheMathNinja has joined #elliottcable
joelteon has joined #elliottcable
TheMathNinja has quit [Ping timeout: 240 seconds]
joelteon- has quit [Ping timeout: 245 seconds]
vil has joined #elliottcable
joelteon- has joined #elliottcable
joelteon- has quit [Client Quit]
TheMathNinja has joined #elliottcable
Willox has quit [Quit: Connection closed for inactivity]
prophile has quit [Quit: The Game]
TheMathNinja has quit [Quit: Leaving]
vil has quit [Ping timeout: 272 seconds]
eligrey has quit [Quit: Leaving]
joelteon has quit [Ping timeout: 272 seconds]
joelteon has joined #elliottcable
Willox has joined #elliottcable
yorick has joined #elliottcable
Sgeo_ has quit [Ping timeout: 244 seconds]
prophile has joined #elliottcable
Sgeo has joined #elliottcable
Sgeo has quit [Read error: Connection reset by peer]
alexgordon has joined #elliottcable
prophile has quit [Quit: The Game]
Rusky has quit [Ping timeout: 240 seconds]
<ELLIOTTCABLE> hello e'eryone
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<ELLIOTTCABLE> haven't talked in days c'mmon somebody say hi
prophile has joined #elliottcable
joelteon has quit [Quit: ZNC - http://znc.in]
joelteon has joined #elliottcable
<ELLIOTTCABLE> fine.
joelteon has quit [Client Quit]
joelteon has joined #elliottcable
<alexgordon> hi ELLIOTTCABLE
<ELLIOTTCABLE> hi
<purr> ELLIOTTCABLE: hi!
<alexgordon> gotta run
<ELLIOTTCABLE> oh >:
<ELLIOTTCABLE> dumb.
prophile has quit [Quit: The Game]
gozala has joined #elliottcable
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 1 new commit to Master: https://github.com/ELLIOTTCABLE/Paws.js/commit/fbf96d088fd34274986a2fad8b7878eabb31c59a
<purr\Paws> Paws.js/Master fbf96d0 ELLIOTTCABLE: (- client fix) Prepare groundwork for Client-compatible debugging output...
<purr\Paws> [Paws.js] ELLIOTTCABLE created windows-compatible-build (+1 new commit): https://github.com/ELLIOTTCABLE/Paws.js/commit/07b344537226
<purr\Paws> Paws.js/windows-compatible-build 07b3445 ELLIOTTCABLE: (- meta refactor inc) Begin using Cakefile again; refactor Cakefile...
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 1 new commit to windows-compatible-build: https://github.com/ELLIOTTCABLE/Paws.js/commit/8acec2192368a0ff55e28aefce9bc7775457446c
<purr\Paws> Paws.js/windows-compatible-build 8acec21 ELLIOTTCABLE: (- client fix) Prepare groundwork for Client-compatible debugging output...
<purr\Paws> [Paws.js] ELLIOTTCABLE force-pushed windows-compatible-build from 8acec21 to f18c667: https://github.com/ELLIOTTCABLE/Paws.js/commits/windows-compatible-build
<purr\Paws> Paws.js/windows-compatible-build f18c667 ELLIOTTCABLE: (- meta refactor inc) Begin using Cakefile again; refactor Cakefile...
<purr\GH> [System] ELLIOTTCABLE pushed 2 new commits to Master: https://github.com/ELLIOTTCABLE/System/compare/fe46af15871d...a9a3d92167c4
<purr\GH> System/Master a9a3d92 ELLIOTTCABLE: (- Win new) Setting the PowerShell prompt
<purr\GH> System/Master 5799273 ELLIOTTCABLE: (Win new) A registry hack to unlock the Win-L key
<joelteon> swift picked the absolute worst thing to be buggy about
<ELLIOTTCABLE> wassat
<joelteon> implicit numeric conversions
<joelteon> what a fucking nightmare
<joelteon> if a non-convertible literal is a subexpression in a complex expression, good fucking luck figuring out which one it is
<katlogic> implicit? as in coercion?
<joelteon> ye
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 1 new commit to windows-compatible-build: https://github.com/ELLIOTTCABLE/Paws.js/commit/0c443ddce9e0a3def5200f374f156b7352a58904
<purr\Paws> Paws.js/windows-compatible-build 0c443dd ELLIOTTCABLE: (- meta fix) Port the `clean` task
oldskirt_ has joined #elliottcable
oldskirt_ has quit [Changing host]
oldskirt_ has joined #elliottcable
oldskirt has quit [Ping timeout: 255 seconds]
<devyn> joelteon: yuck, I hate implicit conversion. should never be a thing.
<joelteon> i'm ok with it when the compiler messages are correct
<ELLIOTTCABLE> andy wingo is goddamn unreal
<joelteon> see the problem is
<joelteon> it's saying "i can't find an overload for << that takes these two arguments"
<joelteon> it doesn't mention what type the arguments are or what the return type should be
<joelteon> and the reason it can't find an overload is because one of the arguments is a type error
<ELLIOTTCABLE> so much to learn ugh
<ELLIOTTCABLE> so google's bugging me again
<joelteon> but good luck figuring that out
<ELLIOTTCABLE> and I'm thinking of giving in ...
<devyn> ._.
<ELLIOTTCABLE> I wonder how much I'd hate myself, working in Java or Python all day ...
<ELLIOTTCABLE> but. tick-mark for my resume.
<joelteon> i hate myself writing python all day
<ELLIOTTCABLE> and they have a Chicago office. wouldn't need to move again.
<joelteon> it's so not good
<joelteon> alexgordon loves python
<joelteon> i don't think there exists a person in the world whom i disagree with about more things
<joelteon> than alexgordon
<joelteon> he's cool though
* ELLIOTTCABLE laughs
<devyn> I've tried to use python a bit, and honestly it feels like Ruby done completely wrong in every way it could be done wrong
<ELLIOTTCABLE> you both write haskell.
<alexgordon> joelteon: I like writing python on my own
<alexgordon> joelteon: for the kinds of things I use python for
<joelteon> i know alexgordon, i just think it's funny how much our opinions differ
eligrey has joined #elliottcable
<alexgordon> but I don't believe it's suitable for a day job
<alexgordon> devyn: wtf?
<joelteon> if someone wanted my opinion on something, they could probably ask you what you think about it, then do the exact opposite
<alexgordon> devyn: then you haven't experienced the POWER of generators
<joelteon> alexgordon: how do you feel about pizza
<alexgordon> joelteon: honestly? don't like it
<joelteon> lol...like clockwork
<purr> lol
<joelteon> i like pizza
<alexgordon> can't stand stringy melted cheese
<ELLIOTTCABLE> devyn: what about generators? huh?
<alexgordon> I don't really like dairy stuff in general, I think I was born on the wrong continent
<ELLIOTTCABLE> idk python, 'splain
<ELLIOTTCABLE> joelteon: do you like dogs?
<joelteon> ruby has "generators"
<joelteon> yes
<alexgordon> it doesn't really
<ELLIOTTCABLE> alexgordon hates dogs.
<ELLIOTTCABLE> alexgordon, we can't be friends.
<alexgordon> ELLIOTTCABLE: nah dogs are OK
<joelteon> no, it definitely has "generators"
<alexgordon> ELLIOTTCABLE: I wouldn't want a pet dog though, too lazy
<ELLIOTTCABLE> I HATE
<ELLIOTTCABLE> everything.
<joelteon> in a couple months i'm going to be able to afford a russian domestic fox
<joelteon> i'm really excited
<devyn> alexgordon: Ruby's Enumerators are exactly like generators, and then there's also block syntax which generalizes this whole thing and makes it way simpler
<devyn> instead of needing list comprehensions
<ELLIOTTCABLE> I miss Ruby v.v
<ELLIOTTCABLE> i *hate* comprehensions.
<alexgordon> devyn: they're not really
<joelteon> so generators are like infinite lists, but you have to put some extra pipelining on it, right?
<ELLIOTTCABLE> only place I'm familiar with them is CoffeeScript, so maybe they're less terrible elsewhere; but just, fucking ew.
<alexgordon> joelteon: no, generators are a limited form of co-routines
<devyn> yes, which is exactly what you can do with lazy enumerators
<devyn> I know how it works
<devyn> lol
<joelteon> alexgordon how do you feel about foot ball
<alexgordon> joelteon: I love it! when it's not on
<joelteon> yeah that one's a little more common
<joelteon> learnt not to bring it up
<ELLIOTTCABLE> alexgordon, joelteon: penises?
<joelteon> i like mine
<ELLIOTTCABLE> I truly hate trying to do cross-platform development. This is hellish. /=
<joelteon> you mean other peoples'?
<ELLIOTTCABLE> of course. it was plural.
<joelteon> no
<alexgordon> devyn: how would you write say zip(*d.iteritems()) ?
<alexgordon> in ruby
<joelteon> whats that do
<ELLIOTTCABLE> ditto
<devyn> yeah, explain that first
<alexgordon> joelteon: takes a dictionary and returns a list of keys and a list of values
<alexgordon> in another list
<alexgordon> d = {"a": 1, "b": 2}
<alexgordon> >>> zip(*d.iteritems())
<purr> alexgordon: SyntaxError: Unexpected token *
<alexgordon> [('a', 'b'), (1, 2)]
<alexgordon> lol
<purr> lol
<joelteon> why zip
<alexgordon> joelteon: why not!
<ELLIOTTCABLE> don't get it.
<alexgordon> I don't know, I was trying to think of an example ruby couldn't do
<joelteon> how does zip(*a) differ from a
<alexgordon> joelteon: it does the transpose
<devyn> in any case, you could just do [h.keys, h.values]
<joelteon> oh
<devyn> in Ruby
<devyn> :p
<joelteon> d.to_a.transpose
<alexgordon> joelteon: haven't you used zip in haskell?
<alexgordon> devyn: not my point! :P
<joelteon> yeah, in haskell, zip associates two lists together as tuples
<alexgordon> joelteon: nope
<joelteon> which isn't consistent with what you said
<devyn> yeah like that doesn't make sense for zip()
<alexgordon> oh well nobody gets generators here or anywhere else :P
<devyn> usually zip is supposed to take two lists and zip them together
<alexgordon> the point is to do it with constant space complexity
<devyn> lol
<joelteon> alexgordon, when is python going to get the ability to use the up arrow to go to the previous line you typed in the repl
<ELLIOTTCABLE> so confused, alexgordon
<alexgordon> joelteon: it can do that already?
<joelteon> ok
<devyn> joelteon: yeah, that works for me o.o
<joelteon> as of python3 i guess
<ELLIOTTCABLE> lol readline much
<devyn> joelteon: even in my python2
<ELLIOTTCABLE> readline is terribz.
<ELLIOTTCABLE> joelteon: anyway, rlwrap it, bitch
<joelteon> i am confused as fuck
<joelteon> what the hell does zip do
<devyn> This function returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument sequences or iterables.
<joelteon> zip([(('a',1),),(('d',2),)]) == [('a', 'd'), (1, 2)]
<joelteon> no wait
<joelteon> that's wrong
<ELLIOTTCABLE> that's a lotta fuckin brackets
<ELLIOTTCABLE> jesus
<joelteon> yeah that's because i am wrong
<devyn> zip() in conjunction with the * operator can be used to unzip a list:
<ELLIOTTCABLE> new plan: write a language that has different meanings for each opening and closing member of any paired character
<devyn> how the hell does that make sense
<ELLIOTTCABLE> just to completely *fuck* with people who can't handle unbalanced brackets.
<joelteon> oh guys, by the way
<ELLIOTTCABLE> actually, I'll just ROT13 the entire set of operators.
<joelteon> alexgordon: anything that subclasses Enumerator supports #to_enum which turns it into a generator
<devyn> joelteon: you mean Enumerable
<joelteon> sure that
<devyn> there's a difference
<alexgordon> joelteon: it's still not lazy
<devyn> alexgordon: yes, Enumerator#lazy
<devyn> lol
<purr> lol
<alexgordon> devyn: not if you call it on an array lol
<joelteon> (1..10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000).to_enum.take(3)
<joelteon> [1,2,3]
<joelteon> wait, but now I'm confused
<joelteon> if you call it on an array, the contents of the array are in memory
<joelteon> how is space complexity relevant
<devyn> yeah, that wouldn't make a difference in Python either, alexgordon
<devyn> if you call it on an array, obviously you need the array first
<devyn> lol
<devyn> alexgordon: now, if you're talking about lazy map, that's what Enumerator::Lazy provides; you can map over an enumerator without actually mapping the entire thing first
<devyn> and other such functions
<devyn> filter etc.
<devyn> (well #select)
<joelteon> i have tried to 'filter' a ruby array so goddamn many times
<ELLIOTTCABLE> jesus christ devyn, is there any language you *don't* know in intimate detail
<devyn> alexgordon: (1..Float::INFINITY).lazy.filter_map{|i| i*i if i.even?}.first(5)
<joelteon> 'select' is such a stupid name
<alexgordon> devyn: yeah... now do iteritems
<joelteon> ...
<joelteon> {a: 1, b: 2}.to_enum
<devyn> alexgordon: I need you to explain that a bit more; it looks like the * actually makes it unzip instead of zipping
<alexgordon> devyn: yeah probably
<alexgordon> devyn: but not the point :P
<devyn> okay, so first of all, what does iteritems() provide
<devyn> generate
<ELLIOTTCABLE> CoverageError: Could not parse n\b\n\b\t\f\foo.coffee: [stdin]:1:1: error: unexpected //
<ELLIOTTCABLE> n\b\n\b\t\f\foo.coffee
<ELLIOTTCABLE> n\b\n\b\t\f\
<alexgordon> devyn: it enumerates over (key, value) tuples of the dictionary
<ELLIOTTCABLE> ...
<ELLIOTTCABLE> so, ruby's dictionary-each
<joelteon> yea that
<ELLIOTTCABLE> n\b\n\b\t\f\n\b\n\b\t\f\n\b\n\b\t\f\n\b\n\b\t\f\n\b\n\b\t\f\
<ELLIOTTCABLE> newplannewplan: bytecode interpreter for which folder names are the ops.
<ELLIOTTCABLE> hm, wonder what the limit to path depth is on OS X
<ELLIOTTCABLE> brainfuck-in-folder-names?
<joelteon> so out of my team at work, one guy is on a plane to belgium, and one lives in LA
<joelteon> i'm all alone
<ELLIOTTCABLE> /Users/ELLIOTTCABLE/>/>/+/+/+/+/+/+/[/>/+/+/+/+/+/+/+/+/</-/]/+/[/[/>/./[/>/]/+/</</[/-/>/-/</</</]/>/[/>/+/</</]/>/]/>/+/+/</+/+/]
<ELLIOTTCABLE> does anybody understand any of this?
<devyn> alexgordon: okay, so, iteritems() is definitely equivalent to just Hash#each then... the problem with translating your exact example to Ruby is that there doesn't appear to be any lazy unzip, but you could easily implement it... in any case, that seems like a pretty contrived example, so think of something a bit more useful :p
<alexgordon> devyn: I can't because code snippets small enough to post into IRC are never useful
<devyn> alexgordon: h.to_a.transpose would do what that does though, just using about double the space I think
<alexgordon> devyn: all I can say is, python's generators are very useful
<joelteon> so zip performs an unzip?
<alexgordon> joelteon: aren't they the same?
<joelteon> if they were, i wouldn't be asking
<alexgordon> they're the same
<joelteon> quickCheck (\ x -> zip x == unzip x)
<joelteon> wait no
<joelteon> that doesn't make sense
<joelteon> that won't even typecheck
<devyn> alexgordon: zip and unzip are definitely not the same lol
<purr> lol
<joelteon> unzip is, strangely enough, the inverse of zip
<devyn> alexgordon: Python for some reason treats zip(*...) as unzip(...) and I'm not really sure why
<devyn> alexgordon: gotta look up what * means
<alexgordon> devyn: transpose is an involution
<joelteon> zip [a,b] [c,d] is [(a,c),(b,d)]
<alexgordon> devyn: * means "as arguments"
<alexgordon> devyn: it's the same in ruby
<joelteon> unzip [(a,c),(b,d)] is ([a,c],[b,d])
<ELLIOTTCABLE> ugh no idea wat am doin' rong her
<joelteon> no, [a,b],[c,d]
<joelteon> my mistake
<joelteon> my examples aren't very helpful when i keep typing wrong
<alexgordon> joelteon: ok but python doesn't have currying
<devyn> alexgordon, joelteon: oh okay, so I see, basically it's taking that generator as an argument stream to zip()
<joelteon> my brian hurts
<devyn> so basically, d.iteritems() to [('a',1),('b',2)] to zip(('a', 1), ('b', 2))
<devyn> which obviously would result in [('a','b'), (1,2)]
<joelteon> that's so weird
<devyn> yeah, seems pretty weird to me too
<alexgordon> it is weird
<alexgordon> but I guess they wanted to support
<alexgordon> zip(a, b)
<devyn> well really it works because zip can take any n
<devyn> zip(a, b, c, d...)
<devyn> and then that combined with the *
<devyn> basically turns that into unzip
<devyn> *why* they chose to do it that way, I have no idea
<devyn> seems weird
<alexgordon> devyn: like I said, they wanted to have the two-list version as
<alexgordon> zip(a, b)
<alexgordon> not zip([a, b])
<alexgordon> so it was a concession to the norm
<devyn> no, *that* part makes sense, but why they don't have unzip() instead of doing zip(*...)
<devyn> but I guess it's the whole 'there should only be one way to do things'
<alexgordon> devyn: one and only one (preferably obvious) way to do it
<devyn> even when clarity suffers
<devyn> lol
<purr> lol
<devyn> yeah
<alexgordon> hey this is the language that got rid of reduce() and sort comparators
<alexgordon> ;P
<devyn> that whole philosophy is my biggest thing about Python
<devyn> against*
<devyn> Ruby has all kinds of redundancy that makes code look way nicer
<devyn> anyway, gtg, bbiab
<devyn> ELLIOTTCABLE: oh and yeah I tend to learn the languages I like in pretty ridiculous detail haha... I probably still know Ruby the best of any of the languages I know
<ELLIOTTCABLE> oh, really?
<joelteon> i like ruby
<ELLIOTTCABLE> I always thought of you as a Haskell-born.
<ELLIOTTCABLE> We should mutually masturbate about metasingletons sometime.
<joelteon> eigenclasses?
<ELLIOTTCABLE> orthogonal, actually.
<ELLIOTTCABLE> I remember a project where I meaningfully had to handle, uh, if I recall this correctly,
<ELLIOTTCABLE> a meta-metasingleton meta-eigenclass?
<ELLIOTTCABLE> or something?
<ELLIOTTCABLE> maybe an extra meta- in there.
<joelteon> there's no reason to do that
<ELLIOTTCABLE> there was a reason.
<ELLIOTTCABLE> trying to find the code now.
<ELLIOTTCABLE> was a part of my 'refinery' gem, which I never managed to complete to my satisfaction
<ELLIOTTCABLE> I think I rewrote that tiny little single-purpose library at *least* five times?
<ELLIOTTCABLE> hm. can't find any of it.
<ELLIOTTCABLE> none of my work appears to have ever made it into the one git repository I can find for that project.
<ELLIOTTCABLE> lol, elliott-as-a-developer in the mid 2000's.
<purr> lol
<ELLIOTTCABLE> ooo, here's some specifiations for it.
<joelteon> i'm trying to find the lowest valued sha256 hash
<katlogic> mining jewcoins huh
<joelteon> na
<joelteon> just experimenting on how to make a haskell program use the maximum number of available cores
<joelteon> "\140v\135\DC1W]\169" starts with seven 0s
<katlogic> how is hashcash different from infinite loop?
<joelteon> it has a higher return
<katlogic> monte-carloish tasks like this are not really fair though
<joelteon> y
<katlogic> some sort of more map-reducish take on that would perhaps pronounce the advantages
<katlogic> go solver :)
<katlogic> which could magically scale to whatever xbox-hueg botnet available
<katlogic> obviously to play go competitions online
<joelteon> it's embarrassingly parallel
<katlogic> joelteon: lowest beneath is just monte carlo indeed, but the upper you go also a lot of state syncing and heuristics
<joelteon> you don't have to do any state syncing
<joelteon> why would you have to
<katlogic> collecting just all mc sims resoults on one box is impractical
<joelteon> are we talking about finding the lowest value sha256 hashes
<katlogic> good go sims run on 5 board radeon box with 128gb ram
<joelteon> ok guess not
<katlogic> and plays like 3-4 amateur dan
<katlogic> joelteon: yes, hashcash is meant to be embarassingly parallel
<katlogic> my problem with that is simply that haskell provides no advantage over c
<joelteon> no i was trying to figure out the RTS flags i needed
<katlogic> in fact is rather cumbersome, because in c you can microoptimize
vil has joined #elliottcable
Sgeo_ has joined #elliottcable
gozala has quit [Quit: Connection closed for inactivity]
yorick has quit [Read error: Connection reset by peer]
TheMathNinja has joined #elliottcable