skysight-inc/HackerNews huggingface dataset:
I think part of the issue is how a lot of people who may not hold intricate views have a hard time separating well formed, nuanced views from their emotional world view stances. I feel like there's an inherent desire in tech, where knowledge is seen as strength, to always speak up even to show understanding via having an opinion. I know I fall prey to it myself too.

So people in the median often either stay out of discussions they don't have a stake in, or they espouse the most easily digestible view. Unfortunately those happen to usually be more reactionary and simplified views, since nuanced views require greater subject onboarding. Either way, it results in a large skew towards reactionary comments on social media sites.

This original submission being a great example, where many comments are about thought policing, without substance.
Nice idea. One recommendation: include real snapshots in the GitHub's Readme file, or a link to a live demo, there seems to be only a mockup. If you do that, people don't need to set up everything to have a better idea of how it works.
WHY!? "Wise" is unsearchable, it's a common word, this is an idiotic move.
Yes, I've already checked them: they are pricing per seat or per reservation.
The average IQ in the U.S.A and the E.U is roughly the same[1][2]. The tax rate is also very similar [3]. Salaries can also vary a lot. If a tech worker in SF can have a salary that dwarf most of its EU colleague, a minimum-wage worker is often going to have a better salary and benefit in the E.U (although it vary a lot per-country basis and the same can be said with states in the U.S.A).

[1] https://www.worlddata.info/iq-by-country.php

[2] https://worldpopulationreview.com/country-rankings/average-i...

[3] https://stats.oecd.org/Index.aspx?DataSetCode=CTS_ETR
The github readme seems to mention it's "structurally typed", but I'm still not confident if the types are checked statically or dynamically? Could you please clarify this on he website & readme?
Practiced Humility in Retrospectives
Tech companies and billionaires are leaving California
Will the new people spend their money at my restaurant?
The original buyer is covered by the warranty so doesn't care about the plastic parts that will, likely, not wear out in the first couple of years anyhow.

The next sucker down the line though is in for some severe finacial pain.
The interesting thing to me is, that I don't feel vi and modern programs do things that much differently. In vi, Esc puts me in command mode, in any modern GUI Editor (at least on windows) Alt puts me in command mode (Jumps to the menu).

Yet, I seldom use the wrong mode accidentally on modern applications, yet constantly on vi. One part, as you said, is probably down to visibility, but a highlighted menu item could just as easily be overlooked. Maybe vi's main problem is the command mode as default? I always pondered if I would make as many mistakes (or would have found it quite so confusing as a new user) if edit mode was the default.
The US has a good social security system, better than Canada’s in terms of providing retirement pension (where I’m from).

It also has very high quality (Berkeley, UMich, etc) public universities where you won’t pay $40k per year in tuition.

And for healthcare, a good tech job will provide good coverage.

So it’s kind of a “eat your cake and have it too situation” for some.
If only we could tax carbon...
It seems like iframes may be a better solution. They provide quite strong isolation of inside to outside communication. I worked in the ad tech industry 5 years ago and everything was iframes.
From the existing explanations, I’ve deduced that coroutines are a form of continuation based coopetative multitasking. Is it possible to “restart” the sequence, and how would this be done?
AFAICS this isn’t talked about enough! If lockdowns were taken seriously from the start, it would had prevented going wild and risking new strains. But here we are
NBA Top Shot Continues Meteoric Rise with over $50M in Sales in a Week
This assumes an ideal upstream: This is not always the case.

If someone publishes a CVE for a Go or Rust library it's not always the case the project is well maintained or the dev cares to update the dependency. Even if they did, there are no guarantees the upstream decides to publish a minor release just to update dependencies. Because that is what vendoring dependencies get you.

Instead of applying one patch to a shared library I'd need to hunt down all upstreams utilizing the library and manually patch between 10-140 packages independently and submit them upstream.
Making sure that there are multiple people with the knowledge and access to produce new releases of E that incorporate security fixes in a timely way is definitely good. But I'm not convinced that distro maintainers are a good answer to that problem; the distro landscape is very fragmented, and distro maintainers are often not very closely involved with the packages they're notionally maintaining or aware of best practices / pitfalls that apply to that ecosystem. I suspect that something along the lines of the rust platform efforts might have a better chance of pushing out releases of all reverse-dependencies of some package that had a security flaw in a timely way, with minimal risk of breakages.
It's project work with different clients. Each project lasts for 3 to 9 months and you are involved in many stages, from defining requirements and expectations at the beginning, to developing and possibly deploying a solution, to presenting the work done to stakeholders at the client's. After a project is done you either negotiate an extension of the project or leave maintenance to the client and leave to start a new thing.

So there is much more focus on soft skills, such as leaving a good impression, properly selling your work so that the client is happy, securing future collaborations with them, and so on. And, on the flip side, hard technical skills are not that important: as long as you can produce something that works in a reasonable time and sell it well you will be fine.
+1 to this. I'd say nearly half of the channel code I've encountered in "real code" has had severe flaws when things don't align perfectly. They don't have data races, in that the race detector will give it a thumbs-up, but they do have semantic races leading to deadlocks, misbehavior, dropped data, etc. They generally work fine when they're not under heavy load / contention, so they aren't noticed until they collapse.

Mutex code though? 90% correct, easily. It's often dramatically simpler to make correct, especially when more than one construct is needed, or nearly anywhere with error handling. (`defer` is quite nice for locks)
Sad this didn't get any attention. A fantastic project. I intend to use Vite for all of my future work.

demo of Create-Reate-App vs vite equivalent:
https://twitter.com/amasad/status/1355379680275128321
Just learn Rust.
I've long been curious how non native UI libraries may assist with accessibility frameworks.

Does anyone have any good resources?
Engineering dependability and fault tolerance in a distributed system
Andrei Alexandrescu has a scheme to encode these in the D typesystem on his website. It didn't get merged into the standard library in the end but you can happily do it in your own code
are you trying to imply he should continue responding to you after leaving the job?
There was a great quote of his too: “I can calculate the motions of the heavenly bodies, but not the madness of the people.”
Unfortunately you did raise some fair points but I'm on HackerNews looking for constructive conversations without sly jabs and insults.

> This is true in most of the world, but the US particularly has an especially racially-charged environment, primarily because due to denial for centuries by people exactly like you to have the conversations about how race plays into society and culture and architecture.

I never denied a racial issue and now you're comparing me to people from centuries ago that committed atrocities on other races.

Flame wars are expressly disallowed on HackerNews and I will be ending this conversation now. I warned you of this rule and asked for a mature conversation. It's unfortunate it couldn't be possible.
Finally, I'm taking your advice: price per SMS notification and let's see how it goes :D
> “In the UK infections are decreasing because we are in a harsh lockdown. The vaccine show little to no effect _yet_”

UK data does suggest that the vaccination campaign is having an effect: hospital admission rates have been dropping more sharply than infection rates.

No doubt the lockdown has reduced infection rates, but there are also seasonal factors. As the weather warms up, people spend more time outdoors, windows are opened for better ventilation, etc. Covid rates will naturally drop in spring for the same reasons that cold and flu do.
There seems to be an inherent assumption built into all of these kinds of studies that all humans are identical interchangeable units. You don't see a lot of "this intervention is wildly successful in 20% of subjects and useless in the rest" type results advertised.
What Is True Resilience? (Hint: It’s Not About Managing Risk)
Insect-level intelligence in robots would already be extremely dangerous IMO.

Especially if they were equipped with reasonable models of our "fast thinking" pathways, which aren't that smart to begin with and are already easily gamed by bots on the Web.
But no one said Go was easy. It's just simple and easy to reason about. There's a huge benefit to something doing exactly what it says. No hidden behaviours, no overly complex syntax, nothing like that.

I came from C# where I have gotten increasingly frustrated with the amount of additions to the language. Like we now have classes, structs and records. We now have async/await but we also have channels. This is what having a huge toolbox causes. Some people are going to write code using channels, me others will use async. Some people will use features that others don't care about.

I think there's huge benefit in a simple language. In Go I know that there's only 2 ways to do concurrency. You either use go routines and mutexes or you use go routines and channels.

Generics will bring a lot of helper functions that weren't possible before which will remove a lot of repetitive code.

But otherwise I am super happy with writing Go code. All my pet peeves of something like modern Java or C# are gone.
I'll try saying it a little more verbosely, perhaps.

There is no evidence from this trial to refute the null hypothesis, which is to say there is no evidence from this trial that IF provides any protection from CVD.
Great episode. What was wrong with that Sheriff?

Fantastic response from the company those guys work for though.
Fix Fast for finding and fixing regressions
I don't understand this area well at all, but I know the existing classification of finite simple groups is very long and detailed.

Wikipedia says

> The proof consists of tens of thousands of pages in several hundred journal articles

and that the second-generation simplified version might possibly run to only 5,000 pages.

5,000 pages of math is easier to understand and/or believe in than tens of thousands of pages, but it's still a pretty daunting amount even for specialists.
AI is still far away from being able to solve these tasks, like detecting the separator and understanding its consequences.
The flimsiness of one's understanding tends to manifest as false "lemmas", which can't really be proved because one forgot certain conditions that are typically implicit with human understanding but must be made explicit formally. However if a proof can be completed then it's solid by definition. I would contend when a proof becomes hard to understand instead of documenting tactics one should break up the proof into more lemmas or create more subgoals; preferrably all tactics are "auto". It's nice that the tool you referred to is general and can be used to document any prospect of proof but being based on a markup language it is mostly static. When Gonthier mechanized Feit-Thompson Odd Order Theorem, he had very large graphs showing the relationship of the lemmas. Unfortunately those were also static as I remember and only really comprehensible to the experts. It would be nice to have interactive versions that can aid an average reader on comprehending and exploring the overall relationships. Such a tool is also sorely missing for understanding large code bases. The two are really two sides of the same coin through Curry-Howard. The good thing is a tool that lets users efficiently navigate structures can be done without extra effort of the proof writer (of course documenting intention is always important).
"There's no bit string reversal in DEFALTE"

The DEFLATE RFC describes it as such.

"Huffman codes in bit-reversed order (i.e., with the first bit of the code in the relative LSB position)."
If you're using pandas, try duck db
Learning code shapes and conventions as a skill is definitely an important approach for the pragmatic programmer. Ultimately though, isn't this a necessary consequence of just not having a high enough level of abstraction in our programming languages?

Here's my very opinionated view: in scenarios where maintainability and readability are the most important long-term characteristics of a program then the best programming language would be one which separated out the specification of a program's intent from its implementation.

Separating concerns is a design pattern that we've learnt is really important (remember the early days of PHP?). We currently encapsulate logic around reasons for that code to change because we recognize the value of that pattern. Extending that same design pattern to what we know about the long-term maintainability of code means that we should be abstracting intent from implementation to allow both to change independently. Compilers and virtual machines already do some optimizations to this effect at the moment but we could go way further in our programming languages themselves. I think this means that declarative programming is the logical evolution of software design (really hope someone has an intelligent counter argument here because I can't see any myself).

Go makes a great implementation language in this sense (Rust too) but it's bound to loose ground in the application space as soon as we find the right high-level declarative language to describe application software.
Then again, not going to trust the WSJ for scientific news (opinion?). Their record isn't exactly stellar.
Ask HN: How do you feel about business given you’d have done better in crypto?
All the money you and others invested, all the time and effort..... you’d have done so much better if you’d put it in crypto/bitcoin.

How do you feel about that? How does it make you feel about business going forward?
This is so impressive! How did you find out about that hack?
You can write a list data structure with performant 'delete' properties if you're willing to maintain a sort or a hash table. There would be people here bitching about memory usage if the stdlib did that natively. Here's a solution: don't use list.delete. You're using the wrong data structure if that's your solution to whatever collection you're maintaining.
Sorry, yes, the £80k protection is under the Financial Services Compensation Scheme (FSCS)
https://www.fscs.org.uk/

Transferwise are not in it and say they protect your money in other ways...
https://transferwise.com/help/articles/2949821/is-it-safe-to...
You should use a tool that supports a lockfile, not pip directly. I recommend Poetry.
> What, the linked study proves the opposite. A massive amount of death in Manaus in 2021, despite 'herd immunity' measured in October 2020.

That is not a study. It is an editorial. It "proves" nothing, and instead advances a few alternative theories that might explain the discrepancy. However, it is not a complex situation. The following quote from the editorial is consistent with my personal belief after reading the original paper [1] that made the herd immunity claim:

"The 76% estimate of past infection might have been biased upwards due to adjustments to the observed 52·5% (95% CI 47·6–57·5) seroprevalence in June, 2020, to account for antibody waning."

This is true, but it understates the extent of the authors "adjustments". If you look at the original paper (Figure 2; linked below), they adjusted the raw data upward by a factor of about 3x. It is an...aggressive...modification to the raw data.

The parsimonious explanation for what is being observed in Manaus is that the Science paper claiming herd immunity was wrong. The authors of this Lancet editorial go to great lengths to advance alternative explanations involving "variants", but these are all unfounded, convoluted alternatives. The simplest explanation is that the original paper was wrong.

[1] https://science.sciencemag.org/content/371/6526/288
Data annotation service: What are AI company wants and needs?
The customer wants and needs
1 High-quality training data at scale
“We are eager to find reliable and cost-effective data labeling teams. The accuracy and quality of the processed data determine the outcome of our machine learning training test and final performance,” says Mr. Wang, an engineer in an AI company.
The strength of an AI system depends on the algorithm model and the quality and quantity of training data. It is showed that many AI companies use similar algorithm models, therefore, the quality and quantity of training data play a key role. In fact, getting high-quality labeled data is the toughest part of building a machine learning model. If the data quality is unqualified, the algorithm model cannot be well developed, AI company needs to label the data again.
2 Flexibility
In machine learning, in each round of testing, engineers would discover new possibilities to perfect the model performance, therefore, the workflow changes constantly. There are uncertainty and variability in data labeling. The clients need workers who can respond quickly and make changes in workflow, based on the model testing and validation phase.

ByteBridge provides a full range of data solutions for AI companies. We are a human-powered data labeling tooling platform. We provide scalable, high-quality training data for ML/AI industry with flexible workflow. On the dashboard, we support end-to-end data labeling solution including visualizing the labeling rules, and all the processes are managed in real-time. As individuals can decide when to start and end the task, the by yourself service makes it possible to engage and to take control of the labeling loop. Meanwhile, the transparent pricing lets you save resources for more important part.

More info: https://tinyurl.com/hlyth6gh
The official website:http://bytebridge.io
my issue with Promise-style exception boundaries is the lack of type checking or explicitness, especially since `catch(Exception)` is discouraged in C#, specifically (since e.g. you probably want to panic on null refs but handle a socket exception.)

in my ideal, exceptions could only be thrown/caught at the async/await boundary because only there should you have real side effects, and there should be structure, but at that point I'm reinventing Haskell's monads.
> Most experienced programmers will realize this is a linear search and that it may be slow on large arrays.

Experienced programmer can think that values in a list with such operation are indexed by a hash and delete by value is O(1) unless there is a big warning in documentation. Novice programmer probably haven’t seen such combination of an array and a hash table and will assume O(N) as taught in a college.
Is there any country where there isn’t a strong disconnect between what they say and what they do?

I mean, that’s kind of a human thing.
I don't know, but as someone who grew up in the alps surely know that the european nations with more social and solidaric laws are certainly happier than e.g. former balkan states where rugged individualism and corrupt feudalism disguises itself as democracy at times while distracting the commoners with nationalism.
I don't need uniqueid as my dictator.
For anyone in the UK looking for alternatives for simple transfers and no interest in another banking service I've had good experiences with Azimo.

Wasn't sure where to plug the recommendation
> Even the CME contract becomes sketchy when you’re talking about a meltdown at this scale

CME has Tether?
There is definitely a certain writing style among Java developers that is overly abstract, but there are plenty of examples of properly written code bases as well.

Also, Java’s “verbosity” is pretty much only a constant factor, and not even necessarily in terms of LOC, but width. What research also show is the benefits of static typing. Also, I am fairly sure there is some survivorship bias working in the background, where an ugly java version of a complex domain survived because the language’s great observability sort of kicking it into a working spaghetti code state, while other projects died a premature death.
For me, writing notes work to overcome that. If I write notes, I can keep focus longer. Plus, I would scribble all those questions on side and come to them later if they were not answered by something in lecture after.
And American imperialism is what, just and benign?
Your analysis of history there is a bit lacking. Coroutines didn't go out of fashion because of OOP, it went out of fashion because of structured programming and higher level languages.

Coroutines are doable if you're programming directly in assembly, but if you want to do it in C-like structured languages, it turns out that it's really tricky: the whole concept of those languages are about having a single stack and hierarchical lexical structure. You can do coroutines in languages like this, but unless you want to do nasty things with longjmp and manually manipulating the stack pointer, they simply aren't built for it. You can build structured languages with first-class support for constructs with coroutines, but it took a couple of decades of programming language development for that to happen. Even today, most of the languages that support coroutines (C++20 included), only has support for the stackless kind. Basically the only languages with full stackful coroutine support in wide use are Lua and (sort-of) Go.
The Internet Archive provides an Emulator of the Canon Cat at https://archive.org/details/canoncat
There are more services regulated by the FCA than which fall under the protection of the FSCS.

AIUI it would have to sign up to stricter regulation, and be treated as an actual bank account, or maybe as an investment (forex) account.
This has been happening for a long, long time. Back in the day, we had an voice-mail system with a certain amount of storage. When you paid to increase the storage a technician came on-site and removed a bolt that allowed the hard drive head to move farther into the disk. Camera manufacturers are a recent example. There are firmware "hacks" that allow you to access more advanced features from a less expensive body.

Are these things bad? Maybe, but if you were the manufacturer would you rather source 2 (or 15) different components or just use 1 and modify it to fit the need and price point?
> Manaus shows that pursuing herd immunity through natural infection is not a guarantee.

Not a guarantee of what? Are we suggesting that we have a virus here that, unlike every previous virus, we can only reach herd immunity for with a vaccine?
did anyone tried putting xanadu on a blockchain

with ICO and all
>there is no Bitcoin tracking security on public markets

$GBTC Grayscale Bitcoin Trust