Sure, that seems plausible, but I still don't think that translates into the kind of user that would take the StackOverflow survey, which I suspect to mostly be users that are quite active on StackOverflow. More generally, I'm seeing StackOverflow metrics underperform on Julia compared to other languages (as opposed to things like Discourse usage for example).
Honestly, I'm pretty happy there were enough responses for them to actually call it out separately in the results. I'm not sure that was the case last year. Also, I think Julia's audience tends to not hang out on StackOverflow as much, since they're often scientists primarily and software developers second. Sure they use StackOverflow, but how many have an account and would answer a survey.
That ID was likely for feedbackassistant.apple.com. However, those reports are not public, so you can't see them unless you're the one that reported them though. Knowing the ID is still useful for things like emailing Apple people and complaining about their declining software quality ;).
What's the actual restriction? If it's literally just exec on apps outside the app directory, why not shim the dynamic linker and rewrite calls to exec to use that instead? Are there additional W^X protections that prevent mapping executables outside the app directory PROT_EXEC? (Note I have no idea how Android works so I may be missing something very basic).
I think this sets a bad example. In many fields the current standard is that code isn't published at all. If bad coding practices will cause you to get bullied into retracting your paper, that's just another argument for why people won't publish their code. Of course if somebody does find a big that invalidates the results of the paper given the stated assumptions, that's another matter, but that doesn't seem to be what's alleged here.
It's already being used :). That said, I've talked to the upstream kernel maintainers about the ability to attach a blog program to ptrace, which could possibly improve performance for the ping pong case if made sufficiently general. That's also the crux though, since sufficiently general probably means eBPF, which is still not considered safe for unprivileged use cases.
The 50% is average overhead and basically entirely due to context switch overhead and execution serialization. If the execution is entirely in userspace, rr's overhead is basically 0. I don't think PT will help here. That said, rr's performance on Intel chips is entirely acceptable for single threaded code. The big asks would be other architectures, or as roc mentioned, something like QuickRec for efficient multi-threaded recording.
I have done some experiments and it's reasonably possible to cut the average overhead to about 20% or so with known techniques. That said, I'm surprised you'd consider this high. I know of no system, including commercial ones that can even get close to these kind of low overhead numbers. Heck, I don't even know of one (other than rr) that actually works on applications of this complexity. If you have one, you should advertise it significantly more heavily ;).
Right, I concur with the reasoning that contributory infringement could be argued against the developers, but I think the interesting questions is whether that reasoning can be extended to the "material" under the takedown section - particularly as written. If so that seems like the kinds of thing that could get ugly very quickly. E.g. are instructions on how to google for infringing material suddenly infringing?
No, thank you for all your work on this :). Building something like rr is only possible with some really solid engineering and I think you managed to accomplish that. I think we're aligned on the vision here. I bring up rr every time I speak to hardware people, but of course the first question they ask is "how many people need this right now?". With this I'm hoping to be able to increase the answer to that by an order of magnitude or so ;).
Hi all, I'm pretty excited to get this out there for you. I had published this this morning, so I could be around through the day to answer any questions, but things were a bit delayed by the HN algorithm gods (- thanks dang for rescuing it ;) ). That said, I'll check in periodically for the next hour or two if there's any questions I can answer.
GitHub can decide a takedown notice is facially invalid. Of course if it's later found that they're wrong by a court of competent jurisdiction, they'd be in trouble, so they're likely to be extremely conservative in making this determination.
So the DMCA requires identification of "material that is claimed to be infringing or to be the subject of infringing activity". It seems pretty clear that the requested content is not by itself infringing. Is anybody aware of case law on how the "subject of infringing activity" is to be read?
Glad to see Dr. Patrick Hsu (https://bioeng.berkeley.edu/faculty/patrick-hsu) among the recipients. He is one of the smartest and most impressive people I know, so at least from my limited vantage point, this money is going to the right people :).
Yes, I considered it, but that's how unfinished draft blog posts end up on HN ;). We'll probably just stop using Pages and deploy to S3 instead - it's a fairly minimal change.
Hmm, looks like GitHub pages are a paid feature? One of our private repos hosts our (public) website. Even with the price cut, the Team plan is still almost $100/month more expensive than the grandfathered in legacy plan we currently have that includes GitHub pages.
While we have your here, any plans for more fine-grained IAM for GitHub Apps? It's already a lot better than legacy apps, but it's still pretty broad. Ideally every API call/resource could be specified individually in an IAM policy, so we can only request the minimum permissions possible in our GitHub Apps.
Releasing at JuliaCon was always the communicated goal, though admittedly with a bit of a hedge that we may not manage to get it done. As for the 1.0RC business, 0.7 and 1.0 are the same release except that 0.7 includes additional depreciation earnings that are not in 1.0. This decision was made to keep with our communicated policy of having at least one versions where deprecations would produce a warning. There were a number of 0.7 release candidates in the months leading up to the release. Since the changes in 1.0 were minimal over 0.7, it didn't need extensive validation and the one day was enough to make sure it worked. Would a bit more time have been better? Sure, but in retrospect it was totally fine. 1.0 was a fairly solid release and has gotten more solid with the LTS patch releases that many people still use. The big problem was packages in the ecosystem needing 2-3 months to catch up, but I'm not sure that could have been avoided. One of the learnings we have is that most people won't upgrade their software until the new version is released and upgrading is absolutely necessary.
Right, we're of course aware of that audience, which is why I posted that comment. The way the NEWS file gets written is just that each individual commit that makes a change that needs end user attention will add an entry in the relevant section. This is quite hand as people can just 'git blame' the file and automatically find a link to the relevant commit (or they can click through the linked issue). What's missing is a more high level narrative structure of changes in the release, but such a thing would have to be written once the release is done. Usually we do that in the form of a blog post announcing the release. However, invariably, these things end up on HN the second somebody thinks the release is done (or even just for early RCs).
To answer the usual complaint whenever the release announcement gets linked here, the NEWS file is intended to give current users of Julia an overview of all the things that changed that they may want to adjust to. It is however, not designed to give people who are only casually following the project an overview of all the work that's going on and why it's happening. We've been talking about writing a more casual document like that for the releases, since they do tend to get a fair bit of attention, but that's just one more thing on an already-extensive list of things that need to be done for each release.
It's not really documented, but human readable, may also not really mean what you think it means. For example, here's a snippet from the printed bytecode of the default system image:
It's human readable in the sense that all the operations have single character ascii opcodes and strings are embedded as is and there's no raw pointers, etc, so you won't get mojibake, but it's not human readable in the sense of say a pretty-printed IR.