Who is to say Google were actually responsible for delisting the app? Epic possibly could have done it as another leg of this campaign
572 karma · joined June 13, 2020
The reality is that the PyPy folk (all single-digit-number of them) have fought tooth and nail to keep the project going for well over a decade. I can't begin to imagine how much highly skilled labour has been poured in by such a small concentration, all for little more than praise and repute on a handful of IT forums.
Give them a break
(Serious comment, not some challenge to test how quickly Godwin's law can be invoked)
Hah, the front page of HN will generally drive upwards of 10k uniques to a page.
I'd sooner work the curb while living in a coal bunker
Ever since reading about Microsoft Singularity all that time ago, I reached the opposite conclusion: software is in such a sad state that it must rely on hardware to provide isolation. From this perspective, WasmBoxC and many projects like it are IMO a huge step in a desirable direction.
The main lesson from Singularity for me (aside from requirements for memory safety) was that cross-component safety can be achieved by formalizing the protocols those components use to communicate. Sing# had a dedicated type to capture the state machine for every cross-component transaction, with strongly typed inputs and outputs. This problem is not unique to software isolation -- it is the basis for a huge variety of security problems everywhere across the ecosystem, not least network services
Wouldn't it be a wonderful world if we knew our application was fully safe when exposed to a network for the same reason we know it is fully safe to run in the same address space as another untrusted application? That is that path Singularity took us along
Can't guess at specifics, but if it's a Windows network, I would be utterly unsurprised if all users had excess permissions to shared drives
Many Windows networks just have a giant X: everyone can write to, and it's been like that forever, and it's so deeply baked into everyone's workflow that it never gets fixed
A process is a "virtual machine" running on-host with many other such machines, virtualization is provided by the kernel
A host is a "virtual machine" running on metal with many other such machines, virtualization is provided by the CPU
Metal is a "virtual machine" running on microcode with up to 3 sets of sibling architectural state (did any vendor ever implement 8-way SMT?), virtualization is provided by the silicon
It's turtles all the way down
Even better if the isolate is itself running an emulator, in which case it's also turtles all the way up
> they are currently building a church to the tune of 100 million euros.
> 70% or more of that came from public funding, essentially tax payer money rerouted to build this monstrosity, something the country really can not afford.
In Tesla's case, $428m of public money contributed almost one third of all profits made by the company in a single /quarter/, at a time when the dollar's future as a reserve currency is being called into question due to panic spending to support a system on the brink of collapse.
The trick will likely qualify it for inclusion in the S&P 500, making it further eligible for more of that sweet public money over winter, as the current administration discusses that index's performance as an explicit target on an almost weekly basis.
People around the world have different value systems and tolerances. For me it's impossible to consider state-funded excesses of the church without drawing comparisons to the likes of Musk. As for their relative social benefit, that's another topic entirely..
I think this is an important point about CloudFlare that can't be made often enough. It's been some years since I first noticed, and it seems as true today as it was then: wedging themselves into core Internet services and data flows seems to be an intentional part of CloudFlare's strategy.
There is no case given the architecture of the Internet where one company need be exposed to so many traffic flows from millions of people. The search engines got there first and we eventually stopped complaining, but this does not make it any more justifiable to copy the model.
What reason would a company have for desiring this outcome? We know Google can detect and predict flu outbreaks. Imagine what is possible when you have every click on every target web site.
There is a fair chance their data is already approaching the comprehensiveness of Google, and I'd be surprised, if not disappointed to learn they were not already working on unannounced (now or eternally) internal intelligence products based on that data. There are simply too many pockets who would be willing to pay for it.
All I see are lots of "removed for partner depot" comments which are the kind of thing that shows up when code has been stripped down for public/semipublic sharing
This would have had me running screaming from the building
Consumer SSDs may indeed return an early indication that a flush is complete, but whether they are lying depends heavily on your notion of persistence:
- the SSD may return done once the data is buffered in RAM
- or once it has reached a temporary log
- or once it has reached a 'permanent' location on flash
- or once it has recorded the mapping of data<->location to some separate directory
- or once it has updated some separate root pointer pointing to the latest version of the log/mapping structures in some separate special storage
I don't believe any SSD waits until the last step above before returning done. Separately, the SSD:
- may have no electrical power outage protection whatsoever
- may have supercapacitors fitted
- the supercap may guarantee full durability of every acknowledged flush
- or only guarantee atomicity up to some prior acknowledged flush
- or only guarantee that the drive has /some/ data on it in /some/ state on the next reboot
SSDs are insanely complex
That was a decade ago, and tech has become a lot more normalized since. Today's Reddit gets visibility on MM possibly more often than any site other than Google. Its users span the political spectrum, treat it as a utility, and for the most part never chose to come to Reddit, never critiqued it, and wouldn't notice if anything about it changed much. It's easy to imagine many modern users never make it off the front page.
I don't think Reddit will die like Digg did. It's the megaphone of the Internet, and could probably commit much worse transgressions than some random DRM technobabble before the common user would take notice.
The example above is deterministic only on current versions of CPython and only if it is guaranteed to succeed and if it is the only line of code in the program now and in perpetuity.
- reference counting is an implementation detail, it is not part of the spec
- that's because real implementations exist where refcounting does not exist (ironpython, pypy, jython)
- even if it were part of the spec, the schedule for object destruction also is not part of the spec. Your file object was noticed as part of an unused graph at T+0, even mainline CPython can perpetually defer its destruction to T+infinity due to its handling of reference cycles
- the random system resource will eventually be garbage collected, but perhaps not if your code throws the wrong exception and/or one of those cute syntax sugar libraries takes a reference to its frame object you know nothing about. Or how about pretty much any debugging support library like Sentry? Best to have audited them all..
- the random system resource was garbage a few tens of opcodes ago, but you left it locked, and some future change caused your code to immediately attempt to reopen and relock it. surprise, deadlock in production
The comparison with 'dict.clear()' makes no sense whatsoever because explicit external resource control is precisely required because those external resources aren't automatically managed like normal in-memory objects. They have material external state beyond whether they are allocated or deallocated, and require explicit initialization and de-initialization in order to avoid leaving them in unspecified states. Python's memory allocator provides none of these behaviours as guarantees. It's not even guaranteed to always call __del__, this is most commonly observable during interpreter shutdown.
Perhaps a better way of looking at it is this: try/finally and with: exist for you to demand stronger guarantees from the runtime than it normally offers you. "Hey Mr. Python, I know you'll /probably/ clean up this object eventually, but I also know there are 100 edge cases where you won't bother. For this object, you are on the hook for every case, including the cases where I wrote buggy code"
Meanwhile, feel free to follow this advice, and good luck at 4am debugging your prod system that for some inexplicable reason recently began crashing due to running out of file descriptors..
Taxi straight from party to the office. I didn't realize until I was sitting at my desk how fucked I was
That aside, the official SSH implementation has never been any princess either. The PuTTY implementation is superior in many ways, not least in terms of modularity, although evidently just as prone to security problems as OpenSSH.
I'm all for new alternative implementations of important pieces of our stack, but please God no more security-critical C.