skysight-inc/HackerNews huggingface dataset:
How many do you think is the appropriate number? Surely not zero, since this can only be approached in the limit of infinite expenditures. So what principle would you use to tell?
That's not what I said, they were two times that the community fractured.

There is fracturing with asyncio. Look at popular libraries. The "requests" library comes to mind, but there are others. It's hard to use different 3rd party components between the two paradigms which causes fragmentation in the libraries. You end up with aiohttp-requests and stuff.

PS: it does make a huge difference. If someone posts "how do I make a web server?" on a forum you'll get two different frameworks and approaches as answers. The community basically goes in two directions and much of the work becomes incompatible. The multithreaded sync vs event loop async just don't play well with each other. There still aren't many 3rd party libraries that really focus on asyncio because much of the community is still in the "threaded" design.
This is underappreciated! I suppose you are less likely to care about errors if you aren't getting values from a function, but not always. I wonder if there is a proposal to force this case to be handled, like Haskell's -Wunused-do-bind?
MySQL has transactions. MyISAM doesn’t, but the apples to apples comparison would be InnoDB, right?
The thing that worries when I hear things like this is the future of Patreon.

Many of my subscriptions are people who would be demonetized on YouTube or who refuse to show ads on YouTube.

As I see them taking more investor money, I start wondering about payout. Will they become publicly traded? What will happen when the board starts demanding that they stop supporting ‘those’ creators?

You have a lot more power as a company when you’re not publicly traded and I fear for the future of it.
Fascinating. Is this based on an earlier still-frame method or is it entirely unique to video?
Parent comment mentioned durability, in fact. Not sure where did you read availability?
1) The money quote from your link is:

"The [WHO] Working Group classified cell phone use as “possibly carcinogenic to humans, ..."

2) You're gonna love this ... phone mfgs. test the in-use radiation pattern at 3" to 4" from your ear. In other words, exactly how people don't use a phone.

So we're a long way from proving phones are safe.

You would even be excused if you thought there was a conspiracy to cover up the risk, because nobody is trying very hard to test them as commonly used - against the ear or in your pocket next to your skin for 16 hours a day.
Floating-point precision can work depending on the financial application. If you are back-testing on exchange data, your simulation code only buys or sells at the bid or ask prices, so even if the signal has floating point imprecision, it doesn't really affect the result. On valuation work, getting the inputs into a DCF/reverse DCF right is much more important than exact precision. I realize this is vastly different than writing an accounting application, but for most hedge funds, it probably won't make a difference to use floats vs. decimals.
Traditionally the pulp is left on the beans during fermentation to impart flavor, and is basically used up in the process. It's mostly American style chocolate that removes the pulp before fermentation and throws it away, in order to... reduce flavor, I guess?
> But it results in still less cumbersome code, since you only need scoping for the error handling portions.)

There isn't a meaningful difference in cumbersomeness between having two try-catch blocks and two if-err blocks. There is a meaningful difference in cumbersomeness between what Go has today and "try foo(try bar())". Which is why it's so unfortunate that the community killed the try proposal.

> But forgetting that, because passing errors down in Go is explicit, it is actually customary to use error wrapping to add context as an error is propagated,

People say this, but in practice any code search reveals that "if err != nil { return err }" is everywhere. I believe that many Go projects aspire to annotate all errors, but much fewer actually do.

Ironically, the nice thing about exceptions, as well as Rust error chaining crates, is that they do this automatically, so in practice programs written in languages with those features tend to have better error diagnostics than Go programs do. Computers are better at doing things consistently than humans are.

> It is a simpler language than Java. You get most of the benefits of checked exceptions without all of the calories from exceptions.

Go is a more complex language than Java is overall, because of all the special cases the language adds to magic types like maps and errors that are just part of the library in Java.
Probably more obscurity than actual security, in my experience. I once knocked off about 10k users off of a dev mainframe LPAR simply by running a SQL query (crashed DB2 and the underlying OS). With someone with more experience than I had, probably could have been exploitable. It was an accident, but it happened.

Mainframes weren't nearly as rock solid as their reputation in the 3 years of dealing with them that I had.

Mainframes were great at processes that need high IO.

I've not dealt with them in close to 20 years, so dont know how current x64 linux or Windows stacks line up.

Mainframes are hugely expensive. 20 years ago, entry level for the hardware was around $500k, IIRC. Dont think that even provided storage or software licenses. But, yeah, youve got one largely extremely reliable piece of big iron that can handle nearly all of your needs.
Exploring the Raspberry Pi 4 USB-C Issue IN-Depth
HTTPS: //Www.reddit.com/R/BritishOpen_Liv/
https://www.reddit.com/r/BritishOpen_Liv/comments/ce5fka/officialsstreams_british_open_golf_2019_live/
https://www.reddit.com/r/BritishOpen_Liv/comments/ce5fmf/1925_et_live_british_open_championship_2019_live/
https://c.mi.com/thread-2300186-1-1.html
https://www.reddit.com/r/BritishOpen_Liv/

https://www.reddit.com/r/BritishOpen_Liv/comments/ce5fmp/how_to_watch_the_open_tv_schedule_livestream_times/
https://www.reddit.com/r/BritishOpen_Liv/comments/ce5fn8/livestreamofficialgolfthe_open_championship_2019/

https://www.reddit.com/r/BritishOpen_Liv/comments/ce5foe/matchthreadthe_open_championship_golf_2019/
https://www.reddit.com/r/BritishOpen_Liv/comments/ce5fow/golfthreadthe_open_championship_golf_2019/
The article states that 5G signal doesn't penetrate the body far enough to be able to touch the most important organs. mmWave 5G in the 28 GHz band is significantly attenuated by a window, let alone skin.

10 mw/cm2 for critical tissue doesn't happen. The power levels by the time the signal reaches important body tissue are much, much lower than that.
Why not both?

Besides, the lions share of FB's current revenue still comes from US Ad spending. Amazon's dominance of e-commerce threatens this because people who want to buy something increasingly just go to Amazon.com. Amazon's ads offer the opportunity to influence consumers at the end of the conversion funnel.

But this means that Amazon will get a bigger slice of both the ad spend and the purchase data which FB doesn't yet have. Their ad business already makes almost $3B a quarter - that's almost 1/5th of FB's revenue. This is money that likely would otherwise have gone to FB/Google, but isn't anymore.

This is big threat to FB's core business in what is their most lucrative market right now. Would they leverage this data to try to keep their ad business competitive? I certainly think so. Just imagine how much stuff an AI that knows your purchases and your social life can get you to buy.
Verizon too.

Despicable.
The Wikipedia section should probably be changed to be more critical as discussed on the talk page. EHF therapy has mostly seen study in Eastern Europe where it has been shown to be effective in a range of small studies for treating skin diseases, TB, and cancer(!) however these results have not been replicated elsewhere and the evidence for non-thermal effects from this radiation seems very flimsy.

In a way it reminds me of acupuncture where there are plenty of studies having proved that it works, but as studies are better designed and carried out the effects disappear (for example, https://www.ncbi.nlm.nih.gov/pubmed/9084865 and https://ieeexplore.ieee.org/abstract/document/4122198).

edit: itcrowd said it better and first.
This three-part article is written by an electrical engineer who approaches the subject without any preconceptions or previous bias one way or another (make sure to read all 3 parts):

https://www.edn.com/electronics-blogs/5g-waves/4461754/Does-...

https://www.edn.com/electronics-blogs/5g-waves/4461840/Does-...

https://www.edn.com/electronics-blogs/5g-waves/4462072/Does-...
This is so easy. Point your finger at the person, look them in the eye, and say assertively, “Don’t interrupt me”, and keep talking without skipping a beat.
> at what point did this change

Out of Africa has been disproven but it was the status quo for so long that many are having a hard time letting go.

Current fact based on actual evidence is multiregional coemergence, previously hypothesis now reasonably theory. Many of us have Denosivan, Neanderthal, etc ancestors, DNA fact, all prior to the hypothetical single point emergence event, therefore even if the hypothetical single point emergence event of some group is correct it's not the full story.
Best of both worlds—

I know many people that use a mouse and Magic Trackpad and fluidly switch between them depending on the task. I did exactly that for about a year—before eventually ditching the mouse altogether.
Here's how I review resumes. I'll scan the document for evidence of some kind of selectivity in terms of education and/or past employers. I ignore action phrases, GitHub accounts etc. If I see one that interests me I'll setup a phone call. It's a common misconception that we look for reasons to hire someone when in fact the opposite is true: we are looking for reasons to say 'no'.
Customer confidence in butterfly keyboards is shot. They’re now toxic and it’s a marketing disaster the longer Apple prolongs this design. The best Apple can do is hold their hands up, admit they messed up, and hope for forgiveness.

Keyboards shouldn’t have design flaws. There’s no wiggle room here and no excuses for Apple’s incompetence. It is simply poor design and equally poor testing processes.
The linked source doesn't contain the word "5G" but it talks about radiation from 30 kilohertz to 300 gigahertz (30 kHz - 300 GHz). This encompasses 5G by a very large margin. The article makes the following conclusion about this frequency range:

> The only consistently recognized biological effect of radiofrequency radiation in humans is heating. The ability of microwave ovens to heat food is one example of this effect of radiofrequency radiation. Radiofrequency exposure from cell phone use does cause heating to the area of the body where a cell phone or other device is held (e.g., the ear and head). However, it is not sufficient to measurably increase body temperature. There are no other clearly established effects on the human body from radiofrequency radiation.

(last paragraph of https://www.cancer.gov/about-cancer/causes-prevention/risk/r...)
> Unfortunately, the community that has sprung up around Go is more or less opposed to new language features on principle.

I think this comes straight from the original go team. Rob Pike had a talk[1] that is partly about why go doesn't keep adding features and why it doesn't have certain features that other languages have. I think people who like go have bought into the idea that the go team has made good trade-offs to make go code easier to read and maintain at the expense of expressibility.

[1]: https://www.youtube.com/watch?v=rFejpH_tAHM
Found it: https://github.com/golang/go/issues/20803
If you are using KDE connect but not KDE you are doing it wrong.
The product is a license for which Apple is an agent, not a party. From the Terms of Service:

"Apple acts as an agent for App Providers in providing the App Store and is not a party to the sales contract or user agreement between you and the App Provider. Any App that you acquire is governed by the Licensed Application End User License Agreement (“Standard EULA”) set forth below, unless Apple or the App Provider provides an overriding custom license agreement (“Custom EULA”). The App Provider of any Third Party App is solely responsible for its content, warranties, and claims that you may have related to the Third Party App." [0]

You would need to refer to the EULA for AirMail to determine if you have a claim against them, which Apple would help enforce. But it doesn't seem like you would get very far:

"Developer grants you a limited, non-exclusive, non-transferable, revocable license to use the App for your personal, non-commercial purposes." [1] (Emphasis mine).

[0]https://www.apple.com/legal/internet-services/itunes/us/term...
[1]https://airmailapp.com/eulaios.html
I wish gofmt would let you set a desired line length and break it for you.. prettier has me spoiled in that regard
Stuart and Sons 102-Key Piano Review
>1) In a real rust codebase you'd probably simply forward std::io::Error instead of converting it into a string like I have here, or give it a better error struct/enum type.

In all the real code bases I've worked on, there are multiple disparate types of errors that nevertheless have the same context.

Example: A function that takes in a path and parses a config file at that path fails if it can't open the file or if the file is malformed. The file can be malformed because indentation is wrong, because there's a string where there should be an integer, or because a required field is missing. All of these are different error types.

So a single `std::io::Error` is not possible, and erasing them into a `Box<dyn Error>` or wrapping them in a custom (context-containing) type nevertheless requires writing a `.map_err` per each Result value.
Ask HN: Should Software Be Proven?
To quote Richard Hamming:

> There is a group of people in software who believe we "should prove programs correct," much as we prove theorems in mathematics are correct. The two fallacies they commit are:

> 1. We do not actually "prove" theorems!

> 2. Many important programming problems cannot be defined sharply enough so a proof can be given; rather, the program which emerges defines the problem!

I find that any errors prevented by compilers are small and sometimes partial proofs. They definitely help. Types and generics are tremendously powerful.

That being said, I find that the current landscape includes a lot of tools that seem useless (or haven't learned to use). Here I'm thinking of things like TLA+ and dependent types (both of which I haven't explored much beyond reading).

Are specifications proofs? Are tests proofs? I don't think so, but both go pretty far in giving me confidence about my software.

I find that I'm sufficiently happy with the combination of static types, generics and testing (specification based, property based, "example" based).

What about you?
Postgres was first written in Lisp and had to be re-written in C because of slow performance [1]. YugaByte DB reuses the same C-based Postgres query layer but runs it on a Google Spanner-inspired distributed document store written in C++. The goal of this new “rewrite” is to add horizontal write scaling, native failover/repair and geo-distribution. As long as users love the language they interact with, the underlying software will continue to see such re-writes in order to meet the needs of the current times.

[1] https://thenewstack.io/the-slow-climb-of-postgres-and-the-va...
>Firstly, 5G has never been tested with regard to its possible health effects.

Well, duh. It's not even deployed except in a few handful of countries. Should we have waited half a decade or so before using 5ghz wifi?

>Lai’s findings were replicated by a 2007 analysis in Environmental Health Perspectives, which concluded that industry-funded studies were two and a half times less likely than independent studies to find health effects."

non charitable explanation: the industry is paying off scientists[1] so they can say their technology is safe!

charitable explanation: industry funded studies have more $$$, thus can perform better controls than poorly funded studies. also, studies on both sides can be subject to publication bias.

[1] not well enough it seems, because I'd expect a rate lower than 28% if I was paying a bribe
WSJ is on the front page a lot too.
> Exceptions feel super good, even as you're taking too many shortcuts and glossing over things.

I'm not sure I follow this talk about "short cuts.". Exceptions provide stronger guarantees by default than multiple-value-bind and manual if statements. Your code fails closed as opposed to open.

> Proper handling of the unhappy paths is often going to feel like a slog, because it often is complicated, and it's often a slog.

I'm used to languages where this generally isn't the case, but sure. Why twist the knife in the wound though?

> Glossing over error handling in golang can feel bad exactly when it should.

When you capture but fail to check an errval and an untraceable default value starts rattling around inside your code causing unexpected behavior? It's like an NPE but worse because it won't immediately trap. It's more like a double free.
And they also "fast tracked" the decline "ahead of schedule".
That's what I used to do, but I was naive and tried out the Google Voice app after it updated. If you're not grandfathered in, I don't think you can go back to Hangouts for voice/sms anymore.
The PGP Problem
r.e. Michael Collins, his memoir 'Carrying the Fire' is a terrific read.
Does anyone an opensource equivalent of this? I do not like closed source apps anymore.
That looks fantastic! I believe that Adobe Premiere and After Effects already offer that feature called content-aware fill for video and it seems to work very well [1].

Of course those are not open-source but it's really inspiring to see such uses of AI. Another very interesting one when it comes to video has been [2]

[1] https://www.youtube.com/watch?v=25ltIoHtiO4
[2] https://github.com/avinashpaliwal/Super-SloMo
Yeah, it wasn't an issue of doing CTRL-F, it was about making sense of that flow when the control jumps you multiple screens of code.

The problem isn't finding the destination, its what alternately happened been source and destination.

Also, if your reading on paper, CTRL-F isn't available. You're scanning those pages by hand. When you're sitting there, highlighter and pen in hand to make annotations and point out important shit, its a problem. End up with circles around the periods and arrows point to it with comments like "this is how we got to x from y."

Edit: also if you end up at the same place regardless of the source or from multiple sources. You can't keep the code for a level to find everywhere a jump emds up there.
He has no principle. Just politics wrapped in environmentalism. Don’t dig too deep - there isn’t much to find.
There's go vet. But it's inconsistent with the Go warnings-are-errors philosophy. Ignoring the return value of os.Mkdir() is far more likely to be a bug than an unused import is.
It's a valid question. The environment required to form these rocks is not found on Earth.[0] The chemistry and mineral composition of Moon rocks is different from Earth rocks. Some of the rocks are older than almost all rocks on Earth (Earth's crust is more active than the Moon's because of plate tectonics). One of the more famous rocks collected is the Genesis Rock.[1] Recently a few channels on YouTube did videos about where the Moon rocks are currently stored [2][3][4] (It's a lot of work and money to keep backyard rocks from getting contaminated if it really is a hoax.)

[0] http://meteorites.wustl.edu/lunar/howdoweknow.htm

[1] https://en.wikipedia.org/wiki/Genesis_Rock

[2] Where does NASA keep the Moon Rocks? - Smarter Every Day 220 https://www.youtube.com/watch?v=QxZ_iPldGtI

[3] Apollo’s Most Important Discovery (Inside NASA’s Moon Rock Vault!) https://www.youtube.com/watch?v=Qr28zMXQ3bU

[4] The Genesis Rock - Objectivity #208 https://www.youtube.com/watch?v=yvhLBzsDwSQ
Because they prefetch without any reference to said attribute? Or at least there used to be a setting on the mobile version that was on by default that enabled that.
Transactional Outbox Pattern
> Littering your code with try-catch is what makes exceptions infeasible for error handling.

I honestly don't see the big difference between littering your code with if/else blocks versus littering them with try/catch blocks. Can you elaborate?
Having only read the subtitles for each section, it is interesting to me to see how this could easily be understood by either political party to vilify their opponents and find things that they do that fall under each. Some categories seem to apply more to the current-day left, others the current-day right. Maybe it means they're both screwed up and we're on the path to disaster. Maybe it means neither is really all that fascist and we're kind of okay for now.
To be fair, these other tools do this as well.
But it doesn't simplify, it just moves the complexity around. That's not necessarily bad, you get better safety guarantees as a result but you also spend more time fighting the compiler and locked in design space trying to get a model that works (and even MORE time is spent if you want it to be readable and something that other people can grok quickly).

I don't see this as an either/or situation. There's a continuum between do whatever the hell you want C and rigorously defined Idris code. Picking a spot on that line involves many trade-offs and everybody has to choose what's right for their situation. That means Go approach is sometimes superior to the Scala approach for a certain class of problems in certain domains.

Edit: don't downvote me, tell me how I'm wrong.
Correct, the study wasn't about prevention
> any code search reveals that "if err != nil { return err }" is everywhere

Code searches in languages with exceptions tend to wrap the tryblocks around massive portions of code instead of the individual function calls to the point that you have a top level doing:

try:
...program here...
except:
print('¯\_(ツ)_/¯')
I have seen a code base in the high six digits of LOC that is written with three space tabs. Ack.
Did you know where every page fault would happen, and manually check every memory access and fix the situation?

You didn't have to because there is an precise, robust non-checked exception handling system which takes care of that: the hardware catches the situation, dispatches a handler in the operating system which fixes it and re-starts your program at the original machine instruction to try the memory access again.
Justice John Paul Stevens Has Died
Reputation matters

So you're dismissing Thiel's claims based on reputation. I'd argue that, based on his reputation, on what he has done in this industry and his trajectory, they have even more weight.

This is a 2 way street.
Or perhaps it means that this essay is fluff.
I guess then I have to ask, why would try() make that worse?

Because I can't stand Golang error handling. It's repetitive, it's error prone, and other language features interact with it so that when you make a mistake it can be as hard as a double free to track down where the erroneous default value was introduced.

On the other hand, using Rust, Ocaml, F# or Haskell I understand how my code composed and I can be confident I can just use an error handling strategy. The only complexities appear, as with everyone else, when we have asynchronous code.

So I don't mean to disagree with your feelings, but they're sure not mine and they're part of why I don't use Golang. I was excited about try() because it at least addressed the most tedious part.