cfbolz changed the topic of #pypy to: PyPy, the flexible snake (IRC logs: https://botbot.me/freenode/pypy/ ) | use cffi for calling C | the secret reason for us trying to get PyPy users: to test the JIT well enough that we're somewhat confident about it
aguilbau has joined #pypy
aguilbau has quit [Remote host closed the connection]
AbortRetryFail22 has joined #pypy
AbortRetryFail22 has quit [Remote host closed the connection]
lritter has quit [Ping timeout: 268 seconds]
sentriz10 has joined #pypy
sentriz10 has quit [Remote host closed the connection]
Luker3 has joined #pypy
Luker3 has quit [Remote host closed the connection]
adamholmberg has joined #pypy
dexterlabs_ has joined #pypy
dexterlabs_ has quit [Remote host closed the connection]
jcea has quit [Quit: jcea]
adamholmberg has quit [Remote host closed the connection]
adamholmberg has joined #pypy
Amt27 has joined #pypy
adamholmberg has quit [Ping timeout: 240 seconds]
Amt27 has quit [Remote host closed the connection]
DIRT has joined #pypy
nimaje has quit [Ping timeout: 252 seconds]
nimaje has joined #pypy
speeder39 has quit [Quit: Connection closed for inactivity]
dustinspringman has joined #pypy
dustinspringman has quit [Remote host closed the connection]
nimaje has quit [Ping timeout: 260 seconds]
nimaje has joined #pypy
fazid728 has joined #pypy
fazid728 has quit [Remote host closed the connection]
adamholmberg has joined #pypy
adamholmberg has quit [Remote host closed the connection]
adamholmberg has joined #pypy
adamholmberg has quit [Ping timeout: 268 seconds]
hsanjuan3 has joined #pypy
hsanjuan3 has quit [Remote host closed the connection]
Trent15 has joined #pypy
Trent15 has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
forgottenone has joined #pypy
Myk267 has joined #pypy
Myk267 has quit [Remote host closed the connection]
glyph has quit [Quit: End of line.]
glyph has joined #pypy
glyph has quit [Ping timeout: 268 seconds]
glyph has joined #pypy
malfunc_ has joined #pypy
malfunc_ has quit [Ping timeout: 244 seconds]
oberstet has joined #pypy
tayfun26 has joined #pypy
Khayman has joined #pypy
TheAdversary has quit [Disconnected by services]
Hasimir has quit [Ping timeout: 272 seconds]
Khayman is now known as Hasimir
TheAdversary has joined #pypy
TheAdversary has quit [Disconnected by services]
TheAdversary has joined #pypy
Khayman has joined #pypy
Hasimir has quit [Ping timeout: 252 seconds]
Khayman is now known as Hasimir
<fijal>
simpson: may I complain your argument is not very coherent?
DarkUranium has left #pypy ["Leaving"]
another_clue8 has joined #pypy
kevans9117 has joined #pypy
another_clue8 has quit [Remote host closed the connection]
kevans9117 has quit [Remote host closed the connection]
tayfun26 has quit [Remote host closed the connection]
tayfun26 has joined #pypy
keywordNew has joined #pypy
keywordNew has quit [Remote host closed the connection]
rlmaers6 has joined #pypy
rlmaers6 has quit [Remote host closed the connection]
antocuni has joined #pypy
CookieMr has joined #pypy
CookieMr has quit [Remote host closed the connection]
tayfun26 has quit [Remote host closed the connection]
tayfun26 has joined #pypy
tayfun26 has quit [Quit: tayfun26]
tayfun26 has joined #pypy
<energizer>
fijal: you dont think == should be reflexive, symmetric, transitive?
<fijal>
energizer: I didn't say a word about contents
redj_ has joined #pypy
redj has quit [Ping timeout: 252 seconds]
liori_ has joined #pypy
liori_ has quit [Remote host closed the connection]
antocuni has quit [Ping timeout: 252 seconds]
mickael9fK has joined #pypy
bear`wR has joined #pypy
bear`wR has quit [Remote host closed the connection]
mickael9fK has quit [Remote host closed the connection]
arigato has joined #pypy
arigo has joined #pypy
arigato has quit [Ping timeout: 268 seconds]
arigo has quit [Remote host closed the connection]
SpamapSxk has joined #pypy
arigo__ has joined #pypy
SpamapSxk has quit [Remote host closed the connection]
KuukunenHz has joined #pypy
KuukunenHz has quit [Remote host closed the connection]
s_edrikKh has joined #pypy
ExorcisEbd has joined #pypy
s_edrikKh has quit [Remote host closed the connection]
easyeVq has quit [Remote host closed the connection]
jcea has joined #pypy
lritter has joined #pypy
<fijal>
smvv: sorry, I'm afraid vmprof is not really being maintained properly
<fijal>
we run out of steam on that one
<smvv>
ah I see. What do you use to see the jit generated code?
<fijal>
PYPYLOG mostly
nzhuk98_ has joined #pypy
nzhuk98_ has quit [Remote host closed the connection]
marky1991 has joined #pypy
StaryVB has joined #pypy
StaryVB has quit [Remote host closed the connection]
adamholmberg has joined #pypy
trippeh_lP has joined #pypy
trippeh_lP has quit [Remote host closed the connection]
mmethot_ has joined #pypy
mmethot_ has quit [Remote host closed the connection]
antocuni has joined #pypy
TheAdversary has quit [Ping timeout: 252 seconds]
Hasimir has quit [Ping timeout: 252 seconds]
fryguybo1 has quit [Quit: leaving]
fryguybob has joined #pypy
Hasimir has joined #pypy
TheAdversary has joined #pypy
TheAdversary has quit [Disconnected by services]
snits_sz has joined #pypy
snits_sz has quit [Remote host closed the connection]
TheAdversary has joined #pypy
tayfun26 has quit [Quit: tayfun26]
oberstet has quit [Quit: Leaving]
<simpson>
fijal: Sure, that's a common opinion. Is there a particular spot where you find my reasoning breaks?
<fijal>
simpson: I don't mean that
<fijal>
I think the presentation is awful
<simpson>
fijal: Oh. Sure.
<fijal>
I'm not in a space where I can coherently judge the contents
<fijal>
well, fix it :-)
<simpson>
I don't know how to fix it; I can't see how it's broken.
<fijal>
do you want help?
<simpson>
Not really. The entire point of that post was to show some CPython folks how life could be better, not to get anything changed.
<ronan>
smvv: you can use a local instance of the server. I think the issue is only on the vmprof.com server
<simpson>
But I'm not really interested in the emotional side of things. I just want CPython's implementers to consider that, maybe, Python could have been better if more thought was put in a decade ago.
Rhy0lite has joined #pypy
<simpson>
I dunno. I'm still waking up.
<fijal>
heh ok :-)
<fijal>
heh
<fijal>
I guess you never wanted monte to be a popular language, so it does not
<simpson>
Popularity requires appeasing a large portion of society's expectations, and I dunno if you've seen our language-designing peers, but their expectations are a little...old-fashioned.
<simpson>
But honestly this isn't a pro-Monte document, just an anti-Python document.
smvv has quit [Quit: Connection closed for inactivity]
rrvaVJ has joined #pypy
nunatak has joined #pypy
rrvaVJ has quit [Ping timeout: 252 seconds]
nunatak has quit [Client Quit]
Zaab1t has joined #pypy
<kenaan>
rlamy py3.5 f4bc915225bc /pypy/module/cpyext/: Resync boolobject.h with CPython, rename _Py_ZeroStruct to _Py_FalseStruct
HannahWolfewC has joined #pypy
HannahWolfewC has quit [Remote host closed the connection]
marky1991 has quit [Remote host closed the connection]
marky1991 has joined #pypy
marky1991 has quit [Remote host closed the connection]
marky1991 has joined #pypy
maze has joined #pypy
maze has quit [Remote host closed the connection]
jsatk has joined #pypy
jsatk has quit [Remote host closed the connection]
esp32_progld has joined #pypy
esp32_progld has quit [Read error: Connection reset by peer]
marky1991_2 has joined #pypy
marky1991 has quit [Ping timeout: 268 seconds]
<kenaan>
rlamy py3.5 911406cbc134 /pypy/module/cpyext/api.py: PyNone_Type and PyNotImplemented_Type are private in py3
IGHORAf has joined #pypy
IGHORAf has quit [Remote host closed the connection]
jadesoturi has joined #pypy
jadesoturi is now known as Guest41755
Guest41755 has quit [Remote host closed the connection]
chasbapI has joined #pypy
chasbapI has quit [Remote host closed the connection]
DIRT has quit [Ping timeout: 245 seconds]
antocuni has quit [Ping timeout: 252 seconds]
mattip has joined #pypy
kanaka has joined #pypy
kanaka has quit [Changing host]
kanaka has joined #pypy
DIRT has joined #pypy
Rhy0lite has quit [Quit: Leaving]
TheAdversary has quit [Disconnected by services]
Khayman has joined #pypy
Hasimir has quit [Ping timeout: 245 seconds]
TheAdversary has joined #pypy
Khayman is now known as Hasimir
Zaab1t has quit [Quit: bye bye friends]
Zaab1t has joined #pypy
antocuni has joined #pypy
redj_ has left #pypy [#pypy]
redj has joined #pypy
TheAdversary has quit [Ping timeout: 268 seconds]
Hasimir has quit [Ping timeout: 260 seconds]
<kenaan>
rlamy py3.5 e6fcda16c6ae /pypy/module/cpyext/: kill some PyFile_* functions thyat were removed in py3
Hasimir has joined #pypy
TheAdversary has joined #pypy
TheAdversary has quit [Ping timeout: 246 seconds]
psyqtN has joined #pypy
Hasimir has quit [Ping timeout: 252 seconds]
Hasimir has joined #pypy
psyqtN has quit [Remote host closed the connection]
Zaab1t has quit [Quit: bye bye friends]
TheAdversary has joined #pypy
Khayman has joined #pypy
TheAdversary has quit [Disconnected by services]
TheAdversary has joined #pypy
Hasimir has quit [Ping timeout: 252 seconds]
Khayman is now known as Hasimir
forgottenone has quit [Quit: Konversation terminated!]
jedai has joined #pypy
jedai has quit [Remote host closed the connection]
<energizer>
simpson: if youd be interested i could ask you a bunch of simple questions from the perspective of a reader who hasnt thought about it much. obviously you have a certain audience in mind though, so i not be what you're interested in targeting :)
<energizer>
i might*
<simpson>
energizer: Sure, go for it.
burncycle has joined #pypy
SsquidlyOh has joined #pypy
<energizer>
simpson: lingering names - "Learning which scopes are lexically contained is not hard." you're saying this is an annoying inconsistency as a beginner but it's not so bad? or it would be better if it were consistent?
marky1991_2 has quit [Ping timeout: 246 seconds]
<simpson>
energizer: I explicitly am not interested in "bad", "better", etc. value judgements. I meant what I said: It isn't difficult to memorize Python's scoping rules.
<simpson>
Certainly there are languages with much simpler scoping rules, but also languages that are worse (ES and Java come to mind amongst today's popular languages)
<energizer>
simpson: what is the purpose of that section in this document
<energizer>
in service of the document's goal
<simpson>
energizer: To have feelings, I think? It's a feelings-document, isn't it?
<simpson>
Oh, no, I guess it's an evidence-document. Then yeah, most of the words are a waste.
burncycle has quit [Remote host closed the connection]
<energizer>
simpson: ill just lay out some questions. i'm curious about the answers but no obligation to respond to any/all
<energizer>
of course
SsquidlyOh has quit [Remote host closed the connection]
<energizer>
does types.MappingProxyType help with the frozendict thing?
<energizer>
should __eq__ not be user definable?
<simpson>
Not really; e.g. it'd be great if `**kwargs` were immutable, and certainly Python's semantics could survive such a change.
<simpson>
Yes, equality should be completely out of users' hands. What can be done instead is to define object traversal, which can then be used to build equality, ordering, etc.j
<energizer>
like youd define __fields__ = ('name', 'age')?
<energizer>
aka attr.fields
<simpson>
Roughly, yes. Like the `attrs` library does.
<energizer>
all the code examples would benefit from a structure, perhaps: Setup (+explanation); Expected (+why); Result (+why); Commentary;
<simpson>
That wouldn't be enough. Ultimately, there's zero substitute for reading the papers I linked, and several of my complaints are better-fixed by abandoning Python syntax.
<energizer>
yeah it's just a convenience for the reader, so i dont have to mentally step
<simpson>
And there's a bunch of extra stuff to make the traversal correct and to machine-verify the correctness.
<energizer>
concurrency-one toolkit vs many. of course this is due to historical development of the language. there are also lots of web frameworks. seems like a consequence of fragmentation is evolution which leads to improvements in new libraries over old libraries. im glad most things arent built in for this reason
<simpson>
Sure. Two decades ago, we didn't know the path.
<energizer>
do you want a language to have one web/async/data analysis/whatever framework? or some kind of system with shared interoperable apis?
<energizer>
or perhaps multiple, until you figure out the solution, then just one
<simpson>
Async features have to be built-in to some degree; e.g. languages like Monte and Haskell try to put immutable structures first to reduce concurrency bugs. (Maybe not the only reason, but *a* reason.)
<simpson>
Also, I think that frameworks are not great as a concept. I'm not sure whether a language should allow frameworks.
<energizer>
you're talking about django and scrapy as frameworks, not twisted, right?
<energizer>
i.e. where you use the framework's entry points rather than your won
<energizer>
own
<simpson>
Yeah, I think, although most of the other kinds of magic are also pretty unappealing to me, like Twisted's global modules or Django's metaclasses and ORM models.
<simpson>
Or numpy's weird type hierarchy.
<mdash>
frameworks and the ease of building frameworks are a major driver of language/runtime popularity though, lua being an extreme example of this
<simpson>
Sure. People will put up with *very* poor kernel languages in order to get access to a certain library or runtime.
DrMcCoyES has joined #pypy
FIQJH has joined #pypy
DrMcCoyES has quit [Remote host closed the connection]
hoke_tYP has joined #pypy
FIQJH has quit [Ping timeout: 268 seconds]
* mdash
gestures at javascript and sh (and C for that matter)
hoke_tYP has quit [Ping timeout: 252 seconds]
<energizer>
the coroutine example is hard to follow, and i guess that's the point, but i wonder if modern concurrency tools allow their users to avoid that confusion by taking care of the complicated stuff
<simpson>
Oh, the coroutine example, not the status-holder exapmle. Yes, it's hard to follow, and yes, that is a large part of the point. I couldn't find a more effective way to highlight the `breakInvariants(); maybeYield(); restoreInvariants()` flow.
Hennirr has joined #pypy
Hennirr has quit [Ping timeout: 260 seconds]
adamholmberg has quit [Remote host closed the connection]
adamholmberg has joined #pypy
adamholmberg has quit [Remote host closed the connection]
adamholmberg has joined #pypy
lritter has quit [Ping timeout: 252 seconds]
antocuni has quit [Ping timeout: 252 seconds]
Br|aNDf has joined #pypy
Br|aNDf has quit [Remote host closed the connection]
adamholmberg has quit [Remote host closed the connection]
adamholmberg has joined #pypy
<njs>
simpson: fwiw I found the coroutines example totally unconvincing. it doesn't even use the fact that it's a coroutine; it's just "if you invoke an arbitrary callback while in the middle of manipulating internal state, bad things can happen", which, well, yes, I'm not aware of any language that prevents that.
adamholmberg has quit [Ping timeout: 268 seconds]
adamholmberg has joined #pypy
adamholmberg has quit [Ping timeout: 268 seconds]
<energizer>
that's an example where i'd like some more commentary to help me think about what a better alternative would be. is it just 'dont write code like this' or 'there should be an immutable locking primitive' or 'python shouldnt have allowed coroutines' or ...
<simpson>
Oh, right, the other example. Yeah, I guess it's a trash example.
Guest11686 has quit [Remote host closed the connection]
<simpson>
"Don't write reentrant code" and "don't write code which doesn't preserve its invariants" are absolutely things I could say. And it's just like with C and memory safety; sure, it's *possible* to do well just with good discipline, but maybe it's time for languages to help us out.
<energizer>
simpson: does monte help with this?
<simpson>
energizer: Yeah. There's two things: First, a rule insisting on *no stale stack frames*, banning coroutine-like possibilities. Once a scope is entered, execution *will* plow through the entire expression and then exit the scope.
<simpson>
Second, any time async is needed, a call like m`f.go(x)` can be turned into a send like m`f<-go(x)` which will be evaluated later.
<simpson>
So it's not possible to have coroutines, but it is possible to have coroutine-like async behaviors, but not in a way that allows for bamboozling callers.
<njs>
simpson: ...but what if I need the return value from f.go(x) in the calling scope?
seizoZm has joined #pypy
seizoZm has quit [Remote host closed the connection]
<simpson>
njs: Then too bad, mostly. To use an analogy, it'd be like wanting to use a mid-nursery intermediate result.
<simpson>
The analogy isn't exact; Monte vats (the things that hold objects and manage sent messages) aren't exactly nurseries. But it's close. A send returns a promise for the result.
<njs>
simpson: having read ~half the article, I think I see what you're getting at
Guest97300 has joined #pypy
<simpson>
In practice, most code is explicitly meant to be called, or is a combinator of sends, so this doesn't matter much because typically one isn't holding a promise. Even in quirky cases like m`def x := [1,x]` which uses a promise under the hood, the cycle is still completed immediately.
<njs>
fwiw, both asyncio and trio have defenses against the plan interference issues discussed at the beginning
<simpson>
njs: FWIW this is an *extremely* mind-bending way to think about computation, and we've had roughly as much evangelical success as, say, Hy or Lever, rather than Julia or Python 3. So no worries if it's not obvious.
<njs>
asyncio b/c it always routes future resolution through the event loop, as recommended in the paper (this was a major point of debate between Guido and Glyph)
<simpson>
How so? Mostly the defenses I've seen come from (1) combinators, which are very helpful for not getting simple things wrong, and (2) futures/deferreds are callback-driven, which naturally breaks up plans.
<njs>
and trio b/c it doesn't use callbacks; the idiomatic way to do that notification example would be to send a message to an explicit channel
<simpson>
Ah, yeah, the CSP style.
<njs>
they're still shared-memory concurrency, so race conditions are a thing