cfbolz changed the topic of #pypy to: PyPy, the flexible snake (IRC logs: https://botbot.me/freenode/pypy/ ) | use cffi for calling C | "the modern world where network packets and compiler optimizations are effectively hostile"
<LarstiQ>
jkbbwr: it's not that bad, it becomes clearer with more context
rokujyouhitoma has joined #pypy
rokujyouhitoma has quit [Ping timeout: 248 seconds]
<simpson>
jkbbwr: "Guilds are composed of at least one Thread which in turn has at least one Fiber. Threads from different Guilds can run in parallel while Threads in the same Guild can't. Objects from one Guild cannot read or write to objects from another Guild." Compare and contrast with vats (http://monte.readthedocs.io/en/latest/vats.html). I am interested in bringing vats to Python, given a desire to have them.
Arfrever has joined #pypy
redj has quit [Ping timeout: 264 seconds]
AndroUser2 has quit [Read error: Connection reset by peer]
tbodt has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
adamholmberg has quit [Remote host closed the connection]
blachance has joined #pypy
raynold has quit [Quit: Connection closed for inactivity]
<kenaan>
cfbolz regalloc-playground 7ffc9b6f6e75 /rpython/jit/backend/llsupport/: a kludgy and lengthy explicit way to test the register allocator with a fake set or registers
<kenaan>
cfbolz regalloc-playground d8e2a043e8eb /rpython/: - implement __contains__ support in rpython - wrap a class around the Lifetime dict
<kenaan>
cfbolz regalloc-playground f6baf7f14279 /rpython/jit/backend/llsupport/: some fundamental data structures for supporting putting boxes into fixed registers
<kenaan>
cfbolz regalloc-playground 85eb224c8d6c /rpython/jit/backend/llsupport/: support not specifying a variable (eg for caller-saved regs)
<kenaan>
cfbolz regalloc-playground ffb5755ee817 /rpython/jit/backend/llsupport/: a special case for repeated uses of the same fixed register (with different vars). a test for longest_...
<kenaan>
cfbolz regalloc-playground 84209398e70f /rpython/jit/backend/: enough mocking for a simple call test (but with wrong results!)
<jkbbwr>
simpson: Im getting to a point where I think Python is screwed from the base design for any of the toys I want (Plus I aint as smart as you to put them in anyway)
<jkbbwr>
Monte has lots of the toys I like the idea of
<simpson>
jkbbwr: I mean, that's literally the feeling that caused me to work on Monte in the first place. But I still write some Python occasionally, and if I can show people what vats look like in Python, maybe they won't be so weirded out by implicit vats in Monte.
<jkbbwr>
simpson: Biggest flaw with python is the lack of truly frozen data structures
<simpson>
jkbbwr: It's certainly a weakness that I can't take an arbitrary object and ask some trusted runtime object whether it's immutable.
<jkbbwr>
simpson: wait did you just `send` to that vat in the example
<jkbbwr>
isn't that the same as sending a callable with the scoped namespace
<simpson>
jkbbwr: #monte?
<jkbbwr>
Yis
adamholmberg has joined #pypy
rokujyouhitoma has joined #pypy
adamholmberg has quit [Ping timeout: 248 seconds]
rokujyouhitoma has quit [Ping timeout: 248 seconds]
oberstet has quit [Ping timeout: 240 seconds]
<mjacob>
LarstiQ: interesting paper, what was the context?
<the_drow>
mjacob, Something related to threading and the GIL
<the_drow>
Ruby is going to introduce guilds which allow some threads to run in parallel. jkbbwr asked if it's a useful concept for Python as well
<simpson>
And I brought up vats, from E and Monte, because they are very much like the proposed guild structures in Ruby.
<mjacob>
how are guilds related to linear types?
<the_drow>
I have no idea
<mjacob>
maybe something like "if we need a new language anyway, it should be purely functional, statically typed and have linear types" :)
<mjacob>
with which i wouldn't necessarily disagree
<the_drow>
That paper is hardcore.
<the_drow>
I get why they use Haskell to describe the type system but it makes it nearly impossible for engineers to read such papers since almost no-one uses Haskell in real life.
<the_drow>
and on top of that, it includes lambda calculus :)
<the_drow>
Good luck implementing linear types in another language without a PhD in CS and a specialty in Type Theory
<exarkun>
I am writing a Haskell program right now fwiw
<the_drow>
Are you a researcher?
<exarkun>
no
<the_drow>
Impressive :)
<exarkun>
I plan to put it into production later this week
<exarkun>
For most people it is an _actually_ new language so it requires some serious investment of effort
<exarkun>
Maybe I'm just lucky that I've had the opportunities to put in that effort.
<the_drow>
Yes you are. I avoid rust for the same reason
<the_drow>
It gives me a headache just to figure out what all those lifetimes are and especially how to use them :P
<the_drow>
The moment you make a language too complex it will have smaller audience
<exarkun>
But are you implying that "normal" programming doesn't give you a headache?
<exarkun>
Sounds like you may be the lucky one.
<the_drow>
exarkun, occasionally but not in the same sense
<exarkun>
Someone once said all real learning is painful
rokujyouhitoma has joined #pypy
<exarkun>
(Haskell sure does have a lot of unnecessary syntax, though.)
<the_drow>
Thinking about Higher Kindred Types has the same mental feeling as thinking about time paradoxes. It can sometimes be very confusing
oberstet has joined #pypy
<the_drow>
simpson, Monte looks nice. Is it your project?
<simpson>
the_drow: Half mine, or something like that. And yes, it's very much a response to a decade of putting up with Python.
<the_drow>
Interesting.
rokujyouhitoma has quit [Ping timeout: 240 seconds]
<the_drow>
why have you guys chosen to not provide classes?
<mjacob>
the_drow: well, it's a research paper, so it's not expected to be read the average haskell programmer (although they would propably understand half of the chapters)
<simpson>
the_drow: #monte for longer discussions. In short, classes are extra boilerplate that adds functionality to the language which would make it harder to use.
asmeurer__ has joined #pypy
raynold has joined #pypy
asmeurer__ has quit [Quit: asmeurer__]
asmeurer__ has joined #pypy
<kenaan>
mattip default 0087987731d8 /pypy/objspace/std/typeobject.py: cextension types should have the short names and long module for pickling
<mattip>
down to 24 pandas errors, 9663 passed , 1984 skipped
<LarstiQ>
the_drow: it may be my circles, but quite a number of people do know Haskell
<LarstiQ>
the_drow: as to the paper, it's specifically about bringing linear types to Haskell in a "backwards compatible" way
<LarstiQ>
mjacob: the context now was "< jkbbwr> fijal: Idk im stumbling around looking for something to do" and " < jkbbwr> idk im just stumbling around blurting words hoping not to be noticed as stupid"
asmeurer__ has quit [Quit: asmeurer__]
<LarstiQ>
mjacob: not that I think linear types necessarily make sense to introduce to Python, but then guilds isn't clear either
<LarstiQ>
I do think they're cool
<cfbolz>
mattip: nice!
rokujyouhitoma has joined #pypy
Arfrever has quit [Quit: 御出で]
rokujyouhitoma has quit [Ping timeout: 240 seconds]
<mattip>
once I hit an asymtote, I would like to release a PyPy2/3
<mattip>
maybe the asymtote will be 0, maybe not
<LarstiQ>
how do you determine you're hitting one?
<mattip>
time to fix a test > 1 week
<mattip>
?
<mattip>
in any case we should consider whether we change the abi pypy_41 version,
<LarstiQ>
right
<mattip>
and whether the pip python tag should stay pp58 or move to pp59
<mattip>
wasn't there something about cffi changes wrt bool?
<mattip>
arigato: ping ^^^
bgola has quit [Quit: leaving]
AndroUser2 has joined #pypy
asmeurer has joined #pypy
rokujyouhitoma has joined #pypy
AndroUser2 has quit [Read error: Connection reset by peer]
rokujyouhitoma has quit [Ping timeout: 248 seconds]
tbodt has joined #pypy
inhahe_ has quit [Read error: Connection reset by peer]
inhahe_ has joined #pypy
nimaje1 has joined #pypy
nimaje1 is now known as nimaje
nimaje has quit [Killed (adams.freenode.net (Nickname regained by services))]
<kenaan>
cfbolz regalloc-playground bb3d99077725 /rpython/jit/backend/llsupport/: chose the fixed register if it is available
<kenaan>
cfbolz regalloc-playground ce386eba1dfa /rpython/jit/backend/llsupport/: a variable that survives a call gets put into a callee-saved register
rokujyouhitoma has joined #pypy
rokujyouhitoma has quit [Ping timeout: 240 seconds]
Yardanico has quit [Remote host closed the connection]
marky1991_2 has joined #pypy
marky1991 has quit [Ping timeout: 255 seconds]
lritter has joined #pypy
marky1991_2 has quit [Ping timeout: 248 seconds]
oberstet has quit [Ping timeout: 248 seconds]
inhahe_ has quit [Read error: Connection reset by peer]
inhahe_ has joined #pypy
kipras`away is now known as kipras
Yardanico has joined #pypy
<mattip>
bummer. cython has two version of the code that does int64( '0') -> 0 on PyPy it uses PyNumber_Int() which is like int() and succeeds,
<mattip>
but on CPython it looks for tp_as_number->tp_int which is NULL so it raises
<mattip>
now I need to figure out the cython workflow
<mattip>
to submit a fix
rokujyouhitoma has joined #pypy
rokujyouhitoma has quit [Ping timeout: 248 seconds]
<kenaan>
cfbolz regalloc-playground e8eede93629e /rpython/jit/backend/llsupport/: another heuristic: if there's a fixed register around and the current to-be-allocated one fits before ...
<kenaan>
cfbolz regalloc-playground f6f7d81e72e9 /rpython/jit/backend/llsupport/test/test_regalloc.py: harder test for later
<mattip>
it gets worse - with cython 0.26rc2 pandas now fails, since we do not implement PyType_IS_GC