skysight-inc/HackerNews huggingface dataset:
Buy Google Reviews: Google
Absolutely. In many experience if clang can deduce a function will definitely trigger UB such as definitely dereferencing a null pointer, it generally optimizes the entire function after the reference into a single ud2 instruction. (Which raises the #UD exception in the CPU).

This is something really hardwired into the C and C++ language. Even if the underlying operating system perfectly supports dereferencing null pointers, compilers will always treat them as undefined behavior. (In Linux root can mmap a page of memory at address 0, and certain linker options can cause the linker to place the text section starting at address 0 as well.)
Yeah I'm not sure. I think ants are an extreme case, but I do think groups of humans have similar sorts of "mechanisms".

The book Sapiens repeats this over and over and I tend to agree. Religion, government, corporations, etc. are ways in which we cooperate with thousands or millions of others. We don't have to have the exact same genome, and it's not perfect cooperation, but there's something there.
You gotta watch it though, srsly. Totally accessible and reasonable.
By then Rust will also seem a cobbled-together relic, and you will be chasing the new hotness. In the meantime, we are writing the code that makes the world work. In C++.

By then, many will also be writing it in Rust, and you will be sneering at them, too. It has always bern easy to sneer at people busy making things work.
There have been static analyzers that will detect this for years. They report "check for null after use" or some such.
I use both Python and R. tidyverse/ggplot2 alone are enough reason to use R, and are substantially faster for tasks that utilize those packages than the equivalent in Python (in my opinion).

Although I haven't had as much reason to use base R. For more ML-related tasks I do go back to Python.
‘Anyone relying on Lidar is doomed,’ Elon Musk says
What's the more interesting question is not whether there will be corner cases where self-driving fails, but when the average performance is so much better than humans that AI saves 10s if not 100s of lives every day, but that's still a reality where AI driving software could be actively out there involved in the deaths of a single digit number of different people a day or week.

Do you deploy that build or not?
Python's standard lib has had something like this for years, but it's been criminally under-promoted (probably because of the terrible name): https://docs.python.org/3/library/cgitb.html

However, yours provides much nicer output. Thank you!
There's an incredibly thorough tutorial with an IDE and examples of all of the things you mentioned plus TONS more. It was super easy to find... https://svelte.dev/tutorial/writable-stores
> If you set your pages and repositories to be viewed publicly, you grant each User of GitHub a nonexclusive, worldwide license to use, display, and perform Your Content through the GitHub Service and to reproduce Your Content solely on GitHub as permitted through GitHub's functionality (for example, through forking)

So I can "perform" and "reproduce" content through forking, solely on Github. But I couldn't clone it, nor make modifications to my fork, if I read that correctly.

It makes little sense and could be avoided altogether by disabling forking for un-licensed repositories. Or by simply giving all new projects a default (with an opt-out option for no license or alternate licenses).
ADTs in Java, that's pretty cool. The nice thing it's not really adding anything new in the language, only restricted forms of classes.
smart-private-npm is nearly API-compatible, I've been using it for years.
Maybe some people with bad handwriting might find such service useful, or other reasons (what dugluak mentions is also a possibility; another possibility may be if you do not want to get all of the envelopes and stuff yourself). Sometimes people used to hire scribes to write stuff, so if that is what you want, then this service could do such thing, although it seem less being needing these days. Still, if anyone wants this service, now you have it; just because I don't like it doesn't mean that it is no good for anyone else either.

However, I think I do not need this; if I want a handwritten letter (for various reasons, including I am composing it while not at the computer, to include hand-written diagrams, or because I have the postal address to send it to, etc), I will do it by myself (I will still generally type the address on the envelope with a typewriter, though). If I wanted a copy of text from a computer I would probably use the printer (except that it seems to sometimes doesn't work on my computer, but sometimes it does work).
A lot of MOOCs teach matrix algebra that way, which I admit I'm not fond of.
Why Does Exercise Guard Against Cancer? Inflammation May Play a Role
Complex values (a unitary matrix) make sense if the stochastic matrix is representing a probability amplitude.
Oh wow, I never knew about that. Thanks.
Looks very good! Will give it a spin soon.
“change the portion of code you care about, follow the compiler's complaints and by the end you're likely to have a codebase in a good state.”

That has always been my refactoring algorithm with C++, C# of TypeScript now. I know a lot of smart people using dynamic languages but I always prefer to lean on the compiler to tell me what needs to be changed.
This feature is in the new update plan. I'll publish this feature in the next updates. :)
Anxious Times in Pakistan’s Pagan Valley
Sure, the way I'm imagining it is some sort of collision avoidance system, where the person drives but the computer can also put on the brake? It seems like that could be safer (although it could still cause an accident by braking in certain situations like in an intersection). If the self-driving system does other things to reduce accidents like leaving greater margins of safety for other drivers (by stopping less suddenly, pulling out into intersections differently, etc), it seems like that would be harder to integrate with a human driving, instead of having the self driving system take over.

A lot of the utility of self driving cars is not just increased safety. It's allowing disabled people to be more independent, reducing the need for car ownership with (less expensive) self-driving taxis, reducing the need for parking lots and allowing that land to be used differently, etc. Do you think self driving cars should be prohibited as long as they are less safe than the standard set by human+collision avoidance cars?

I don't think that makes sense unless cars with human drivers and no collision avoidance are also prohibited. Even then I'm not sure. As a society we know that driving is not totally safe but allow people to drive anyway because it's a useful tool. I don't see why the safety standard should be even higher for self-driving cars, which are even more useful, especially for people who can't drive.

One last thing is that anything that slows the adoption of self-driving cars will probably lead to a much greater number of old, less-safe, cars in use for a longer period of time, since it's very unlikely politically that the existing car stock will be just kicked off the road, regardless of what regulations are set for new ones.
Chinese Startup Luckin’ Coffee Files for Its U.S. IPO
The issue with bindings is that you either commit to maintaining them yourself, or you rely on someone else. In this case, the Rust Qt bindings I found [0] were generated for Qt 5.8, which was released nearly 3 years ago. The tests on Github report "failing".

Then, you have the cognitive overhead of translating the documentation, and other sample code. In my experience with bindings, this ends up requiring knowledge of the language you're binding to. It seems easier to just write it in the native language instead and deal with those quirks rather than bindings quirks.

Do the Rust bindings show the Qt docs in the autocomplete? If there's not input validation on the binding side, then you'll end up in C++ again figuring out how to sort things out.

Regarding CUDA, I think we're all hoping for a cross GPU alternative. There's OpenCL, Sycl, ROCm, Kokkos but their API is also written in (you guessed it) C++. Need to render to OpenGL? You'll be writing in C. Unless one of the companies decides to replace driver interfaces with Rust, any application using them will be dependent on N bindings working.

You're ultimately not escaping C/C++ for any systems development. You either deal with the complexity of interfacing between language A and C/C++ or just deal with the quirks of C/C++ themselves. Pick your poison.

0. https://github.com/rust-qt/ritual
Internally, no. When dealing with incident response, you would not just say "http2 broke it", but as a quick way to describe the issue, it's fair to say "http2 broke our application" as it prevented access to the service.
> But yes, publicly exposed jenkins and repos lead to the compromise …

You mean the past-tense verb led, not its metallic homonym lead. :)
Bowley Lock Analysis and Update [YouTube]
I turn it off and every so often Apple decides that no, I want their dumb news notifications again. Then it goes off again. I have never received an Apple News notification that was not dumb, stupid, and useless. It's sort of like airport CNN except in your pocket that randomly turns itself on after you have opted out of it.
Large React apps get slow very easily once the component density gets high in a complex web app. Part of the reason for that is actually the overhead of a virtual DOM.
I thought Tumblr's 'adult content' ban was due to the Apple appstore refusing to host the app? If not why would Tumblr ever make that decision? There were so many other ways to approach it - shadow banning for example.
Or wide terminals.
Cloning someone's documentation is not "cloning our product"

Using the Wayback machine, I looked at both company's docs and the navigation isn't the same - https://twitter.com/CaseySoftware/status/1120521768723255297 - so even the copy/paste job looks like a single page.

Yes, it's absolutely poor form and may be a copyright violation but the screencaps cover OAuth 2.0, therefore everything - yes, including the parameter names - MUST be the same, according to the spec.

Without more evidence, this is a nothing burger.
This seems useful. Are there other good recent tools for analyzing network traffic? For example something more high-level than Wireshark? A common use is to zero in on the flow you're interested in, and see which party is saying what. And maybe zoom back out and pick another flow. The flow choosing part could use better UI, maybe in the form of a more high level view.
* this idiot claimed "Ansible was used to keep the attacker in the system" which in all reality Ansible did what it was supposed to by altering the correct authorized_keys file and the attacker leveraged an old default in the sshd config. This is a sshd config issue, not Ansible.

The sales-pitch for Salt (against Ansible) is ridiculous and misguided.

I just checked out the Salt SSH module and even if they used salt they would still have this issue. Then answer here is to not use the default /etc/ssh/sshd_config value of #AuthorizedKeysFile .ssh/authorized_keys .ssh/authorized_keys2. Uncomment and remove authorized_keys2.
The problem is that this is the default behavior of Apple News and is poor design. It doesn't even align with Apple's own Human Interface Guidelines[0], which states "If you send multiple notifications for the same thing, you fill up Notification Center, and users may turn off notifications from your app."

[0]: https://developer.apple.com/design/human-interface-guideline...
I would be filling a bug report over at http://bugreporter.apple.com

Definitely not normal for the OS to be ignoring notification settings.
Codercom/Sshcode: Run vs. Code on Any Server over SSH
The whole point of C++ is that it enables writing more powerful libraries, capturing semantics in libraries that can then just be used. C++ is still quite a lot more powerful for this purpose than Rust. Rust will get better at it, over time, but it has a long way to go and C++ is not siiting still.

Rust is still a niche language, and if its rates of adoption and improvement do not keep up, it will remain a niche language, and fade away like Ada.

I cannot imagine a serious programmer switching from C++ to Go. If you can, you have a much livelier imaginary life than I do.
But it isn't notifications for the same thing. They are different articles.
There were multiple attempts at such bindings. The most promising is this one:

https://github.com/KDE/rust-qt-binding-generator

> You're ultimately not escaping C/C++ for any systems development.

We eventually should. C/C++ should retire even for drivers and kernels. But for now there is still a lot of baggage to deal with indeed.
The point is that raw genius is insufficient for replicating Ramanujan-like accomplishments in the 21st century. It's almost irrelevant how brilliant someone is these days - if they haven't had the opportunity to learn a vast amount of theory, they can't really make significant progress towards theoretical problem.

The field simply has far less low hanging fruit than it did a century, or even a half-century ago. It's not reasonable to expect that a lone genius with little to no academic background in mathematics could resolve a famous open problem through sheer creativity. For literally generations the field's most intelligent researchers have spent their careers chipping away at this problem.
thanks, just updated the license in the readme: https://github.com/sneha-belkhale/AI4Animation-js#license
getElementById() is perfectly allowable under Rust's rules, though it may not look like what you expect (and to be fair Rust doesn't make it easy to write today).

The most straightforward way to get it working would be to return a `&Element` (or `Rc<Element>` if you like), and make all of `Element`'s fields `Cell`s. No panics, no runtime checks, and you can do everything JS can do. The cost is "infecting" the type definitions with `Cell<T>` and the usage with `.get`/`.set`, and the loss of what is normally rich pointer aliasing information for the optimizer (but which other languages don't have to begin with).

The reason Rust `&mut` feels so restrictive is that it allows you to change the "shape" of the object, thus invalidating (if they existed) any other references into it- replace an enum value with a new variant, reallocate a `Vec`, overwrite a `Box`, etc. But in other memory-safe languages you can't do any of those things. Instead any "shape changing" is done by allocating a new GC'd value and overwriting a pointer- enums are boxed (or don't allow interior pointers), arrays only contain primitives or pointers, etc.

So I like to think of `&Cell<T>` as a kind of third reference mode, that matches what people expect from other languages. It's not fun to use today, but there are a couple of language additions that could make it much, much nicer:

* First, field projection- given a type `struct S { x: T }` and a value `r: &Cell<S>`, let `r.x: Cell<T>`. This is safe as you can't invalidate `&r.x` by overwriting `r`- but by extension you can't project a reference through a `Cell` into an enum or `Vec` (just like other languages as described above).

* Second, some syntactic sugar for reading and writing. Replace `cell.get()` and `cell.set(x)` with `cell` and `cell = x`. Given that `Cell` has zero overhead (other than the loss of optimizations described above) this shouldn't be an issue.
I highly recommend virtual card numbers through capital one's chrome extension called Eno: https://chrome.google.com/webstore/detail/eno®-from-capital-...

They really nailed the UX of generating and managing virtual CC numbers per use case.
Two things: It's npm Inc and yarn isn't a competitor to npm Inc. It's at best an alternative to the npm cli client.
If they get their market rents, and they get upzones, I feel like they’ll build.
There's an argument to be made that this [0] (generated via [1]) is not something to be celebrated. But that's just me, not necessarily what the parent poster had in mind.

[0]: https://i.imgur.com/LhEahvi.png

[1]: https://www.evidon.com/solutions/trackermap/
Banning "violent speech" is the same as banning political opinions altogether. Politics is essentially deciding in which ways the state should apply violence against its citizens. Saying "the state should be violent against people who do X" is violent speech.

Also, asking the govt. to ban "violent speech" is violent speech itself.

Are people too dumb to understand this or would they actually love to live in a totalitarian dictatorship?
Actually those filthy commies let you choose all the news sources, so you can pull yourself up by your bootstraps and construct your own fortress of whatever you want. I wouldn't suggest it, but the bootstraps are there.
If npm is down, so is yarn. Yarn's registry url is just a CNAME to npm Inc's registry.
There's no such thing as a yarn registry. The uri is just a CNAME to npm Inc.
How is the prng over engineered? I agree its a little clunky for casual use but it makes all the right decisions, imo, for serious use of prngs (e.g. reproducible experiments for Monte Carlo methods in simulation and statistics)
Lots of languages have been around a long time without attracting billions of lines of code. To get that, the language must be unusually useful.
You are very much wrong, on several fronts.

First, you obviously have some measuring stick for what the "right" language design goals should be. But what you don't seem to recognize is that other people can validly have other design goals. It's not "your way or they're wrong".

In fact, given the decades of experience the designers of go have (and wide variety of languages that they have experience with), it's almost certain that you know far less than they do. And yet they still made different choices than you would. Instead of wondering how they could be so stupid, that should make you wonder what they knew that you don't.

(I've seen some rants from people saying stuff like "they couldn't have made that design decision if they knew anything about Modula 2!" And they miss the talk by Rob Pike where he said (paraphrased) "don't think we're so smart for coming up with that object file format - we stole it from Modula 2". They knew it at a very deep level - almost certainly better than their critic did.)

Then there's this:

> Go simply punts complexity to technical debt of any project and assumes you will throw out your code after a year of using it.

Go was designed for multi-million line code bases that live for decades. Really. Read Rob Pike's notes on Go's design.

So, yeah, there's a lot about this rant that is factually off in the weeds...
I agree with him. in many practical applications with well design class hierarchies it just really isn't much of an issue. Hasn't been for me either.
Own Your Analytics Data: Replacing Google Analytics with Amazon QuickSight
Commies undermining the only remaining site of innovation (capitalism) in the West: it's their purpose after all
Kt.dart: kotlin-like collections for dart
I leave it to that someone else to have to resolve the cognitive dissonance. One concrete benefit might be not doing in my 50ies due to stress-related health issues.

And I would happily live in a poorer society with better ethics any day (given some minimum threshold of live quality).
Authors are persons and clearly have freedom of speech, no one here is arguing with that.
The evolution of a multi-platform app (Voice in a Can – Alexa everywhere)
It absolutely blows my mind that Menstrual cups aren't more widespread globally. I basically wouldn't even know about them if my partner didn't use them. They seem like a better option than tampons and pads 90%+ of the time.
How about a browser / service that makes you pseudonymous instead?

This would probably be hard to do with canvas-based browser fingerprinting, but might work with the various other fields. Basically create a large pool of 'profiles' based on common browser settings, then assign one at random to clients.

Basically, make it look like thousands of users on the same machine.
Good luck implementing something like std::is_standard_layout without "magic language hacks". No, not all libraries are made equal and std is part of the language now, there is no way back
Of course. This is the least controversial opinion out there and it borders on fact. Anyone who claims otherwise is an idiot or an exploiter. There's simply no substitute for sleep in any discipline or in life in general. It simply doesn't exist as far as we know. People who short themselves on sleep are self harming, often out of stupidity. I've been there as have many because it's part of our stupid work culture, but once one wises up, there's no going back. Sleep quality and stress levels matter more than anything. Period.
The point is that I've noticed a broad "religious" trend where those promoting Rust don't lend any credit to the places where C/C++ has valid strengths, even if due to it's legacy. It doesn't do a great service to either community to constantly pit the two against each other, and to misrepresent the other in a way that's not honest. C++ doesn't exist and continue to evolve just because it's been around forever, there are a number of things leading to it's continued use that should be brought into the discussions.

C++ isn't going anywhere. In 20 years you may not be writing in it, but you'll still be calling into it somewhere in the software stack (especially if things continue moving the WebAssembly direction).

Even if you're using Python's SciPy today, you're calling into LAPACK written into Fortran.
It's the author of the package, the readme says:
Copyright (c) 2019 Ram Rachum, released under the MIT license.
There's no guarantee that std::move moves elements out of x. (and thus no guarantee that it's equivalent to a Rust mem::replace with a new Vec) The only requirement the C++ standard imposes is that the vector is left in a "valid but unspecified state".
If C++ is the new Fortran, Rust might very well be the new Ada. Many of the same relative merits were claimed for Ada as for Rust, and it had the backing of the biggest and best-funded organization in the world, but it faded from view because it did not keep up.

Rust could easily go the same way.
Tesla video shows a Model S erupting in ball of fire in car park in China
Why is it difficult to believe? I've also written plenty of C++ code without memory bugs. It's not that hard if you play by a few simple rules.
As far as India is concerned, Amazon is definitely giving a strong competition to Flipkart(the Indian counterpart).
For most people I know, Amazon is the first go-to store for any online purchase.

It's interesting to see, how Amazon will fare in near future, due to recent change to e-commerce law by Indian govt.

https://www.cnbc.com/2019/02/05/amazon-how-india-ecommerce-l...
Interesting, but it doesn't mention hell.com and the many related sites. Lots of seizure-inducing flash. I see that https://medialounge.org/ is still there, but I don't have flashplayer installed.

> <meta http-equiv="content-type" name="medialounge - metamash mediation" content="There is a concept which corrupts and upsets all others. I refer not to Evil, whose limited realm is that of ethics; I refer to the infinite. The possibilities of the art of combination are not infinite, but they tend to be frightful. It is a constant interplay of ideas, a collection of story synopses that work better than novels ever could. Ideas are thrown away as quickly as they arrive. An incomplete, but not false, image of the universe, I am a mistake, a ghost" >
The article you posted claims that, since animal non-existence is "preferable" to animal suffering, the ethical choice is to euthanize / sterilize as many animals as possible. But you claim after you post the article that the actual better outcome is that animals are brought into existence by humans should be given better lives before they are killed by humans.
I have to point out that putting luxury brands in the same space as amazon is not an apples to apples comparison.