skysight-inc/HackerNews huggingface dataset:
The right french door is hard to close compared to our last side by side fridge. For now it helps me remember to close it when I’m in a different room and can’t hear the alarm.
Cool. You get to see the image and even save it, before the pay wall appears.
And an image is truly worth a 1000 words.
For obvious reasons we can’t allow the executive to persecute the legislature with something as difficult to prove as insider trading. It could be used by a tyrant to push through legislation in theory.
> But China imprisoning populations solely for having a different religion and culture

Do you have any evidence for this claim that isn't compromised by a State Department-sized CoI? I'm genuinely curious.
His average is above the average user https://data.stackexchange.com/stackoverflow/query/1467873
I don't know anything about what Nubank is up to or how things work there overall, but integration tests are absolutely worth doing. The argument against this to me reads like "coordination and testing of big systems is hard, so let's not do it."

> Waiting. Engineers had to wait more and more to get feedback from this long-running suite;

"Our tests are inefficient, not sufficiently parallelized, the setup / tear down of the test environment isn't optimized, and it isn't possible to run only the relevant subset of tests during feature development or bug triage for short feedback loops"

> Lack of confidence. Flaky tests meant that we had to re-run the suite frequently to see if something was really wrong or just a false negative;

"Our tests aren't well written (we have sleep-polling)", "we don't build-in testability into our system (we can't introspect or wait on the thing we care about in the test, so we have massive work arounds)", or possibly worst "our system is flaky and our tests reflect that".

> Expensive to maintain. Manual changes in our staging environment corrupted test data fixtures and maintaining the environment “clean” was a challenge;

"We haven't spent enough time developing our own tools for testing, so we have tests that are extremely fragile (think copy and paste of massive JSON blobs with comparisons just to check a handful of values)"

> Failures don’t point to obvious issues. Test failures were very hard to debug, specially due to our reliance on asynchronous communication that make it hard to connect the cause of failure (a message not published to a queue) with its effect (changes not made in another system);

"Our system is over-engineered and our service boundaries match our internal structure rather than clean separation in the functions of our APIs. We don't have good visibility because doing any one thing involves massive levels of coordination. We lack proper tracing and aggregation."

> Slower value delivery. Queueing of commits in the End-to-End suite resulted in less frequent deployments;

"Quality is hard and takes time. Let's not do it so we can move fast and break things."

> Not efficient. Few bugs caught in this stage. One experiment suggested that, for every 1000 runs, we had 42 failures, only 1 bug;

See above about flakiness and fragility. Also, integration tests catching bugs tend to point to really bad obvious bugs. I'd be happy about the one that was caught.

> Not effective. Bugs were still being found in production.

"We still found bugs. This means testing must be ineffective altogether?"
GP didn’t say “if you thought there was insufficient evidence before, you have some reflecting to do!”
Our product is an end-to-end testing tool, so it's always interesting to see what issues companies hit with E2E tests and how they solve them. What's interesting about Nubank's experience is that after deleting their E2E suite, they realized that replacing them with integration tests wasn't providing enough value. There's a lot value in E2E tests, but so many orgs end up taking the wrong approach and ending up with a slow, flaky test suite.

We wrote a guide [1] for building automated test suites based on our experience working with and talking to software orgs. Teams who get value out of E2E tests generally do the following things right:

1. They keep tests as small as possible. This makes maintenance easier and forces a separation-of-concerns in the tests.

2. They factor the tests so they can run in parallel. This, plus shorter tests, is the best way to mitigate the slowness issue brought up in the article.

3. They have a good strategy for test data management. It looks like Nubank had test data represented as fixtures, but then somehow manual testing in that same environment was clobbering test data and causing false failures. A better strategy for managing test data could have solved for this. Or maybe even just running the automated tests in an isolated environment.

[1: https://reflect.run/regression-testing-guide/]
I have seen efficient e2e suites, often built by and having a BDFL who had the same experiences as you. They have enforced best practices like "no sleeps", "no time-based tests", "every test must be concurrent and isolated", "refactor liberally", "bootstrap/share expensively allocated resources", etc.

I don't know how to say it humbly, but the biggest problem I've witnessed in slow e2e suites is that they are considered second-class pieces of software and only get the attention of QA engineers or developers who are not applying the same level of effort as their runtime code.
Animal origin theory/wet market/etc. have zero "meaningfully qualified evidence", are you as skeptical about those theories?
What do you reckon the monthly fee would be? Targeted ads by search is quite lucrative...
Is “cromulent” a woody or a tinny word?
Yes, it is hard to proselytize your views when you talk down to everybody while doing it. Useful lesson for you to learn in life.
It would be nice if they showed code on the front page. Lots of marketing words, no idea how it works, what the language looks like, etc...
> In our analysis, we figured out that the most frequent category of bugs caught by End-to-End tests was schema violations.

Schema violations are pretty much just type errors.

Fortunately these can be prevented automatically and with 100% confidence without writing even a single test.
If tether went belly up what would happen is everyone would sell their tether for BTC and other cryptos (whatever they can get into) and you would have the largest squeeze of all time. We actually witnessed this during the tether freak out saga a couple years ago where BTC on the bitfinex exchange was priced like 10 or 15% higher than the rest of the market. I wouldnt mind just getting it over with. Then we could get that over with an just have USD trading. But what most likely will happen is they will just be forced to comply with certain rules.
E2E can't catch all bugs either. This team decided the number of bugs their test suite caught was not enough to be worth keeping it. With a robust canary deployment, they will quickly find and rollback breakages whether or not the e2e suite would have caught it.
It's still somewhat common in coastal areas. Though I realize "common" leaves a lot of room for interpretation.
I've flagged it. Article is ok. But the title on HN is a
cheap clickbait.

Someone, in USA, asking for a grant in the past doesn't point to anything about origins of SARS-CoV-2.
Because if you eat beef, you have cow skin also. And cow bones. And cow entrails. And you have two choices of what to do with it: make leather with the skin or throw it into a landfill.

I'm 100% OK with leather for shoes, chairs, wallets, car interiors, etc. Because throwing it away is wasting it.

And I like beef. I raise steers to eat them. I'm not going to stop. I will NEVER become vegetarian, let along vegan.
Generics Are Coming to Go
Tether claims to be backed 1:1, but claims to have reserves in investments, which are, yes, claimed to be mainly A2.

We have zero evidence of any of these being true other than the word of Tether executives, who have lied about their backing before, as determined in court.

(Also, this is only the latest claim in a series of gradual backtrackings on earlier, fraudulent claims about their reserves.)
If your tolerance to deal with regressions and bugs in production is high and you have millions of users, then you can think of the user as the end to end tester.
Maybe you ship some change and put it behind a feature flag and make it available to only 2% to 5% of the users.

If you get 1000 users to go through a particular flow and you have a way to collect failure signals from production accurately and in real time, then you can just dial down that flag to 0% if you see a lot of production errors.

I'm still not convinced that you can't drop e2e testing completely but maybe if your business allows it you can confidently rely of unit testing or testing contracts without having to run the app through all the user flows for every change.
> The support for messaging tests was immature in the JVM implementation: most of the critical interactions between our microservices occurs through Kafka messages (we favor mutations in asynchronous flows while HTTP calls are mostly reserved for read-only operations).

Trying to wrap my head around what is meant by that. I mean I get the second half, but the first half not so much.
Even with this one bit of evidence (assuming it actually indicates what we think it might) we aren't there yet. We might be eventually but not today.
Hah, weird to make this nationalist. I studied at a top-tier French university without much hand-holding (and indeed tutored my French and English counterparts with their computer science lessons), but I guess I'm still not qualified to inquire of the OCaml community.

Thank you, however, for illustrating my point. :)
Right, they talk about fighting for a queue. Firstly, a good test-suite can be run (a configurable subset) on the developer's workstation. Secondly it needs to run on commits in a reasonable amount of time. This is just as true of E2E as of unit tests.

They also mention flaky tests. If there is a spectrum between unit tests that can run on a single function and e2e tests that need a complete system, the closer to e2e you get the more likely you are to have flaky tests.

Flaky tests are an indication of non-determinism either in your test or your system. If you have non-determinism in your system, then you can't confidently test it regardless of the flavor of tests you use. Non-determinism in your tests should be minimized; if you can take a random-seed as an explicit parameter, do so, so that you can reproduce the flaky failures. Test failures (flaky or not) are always indicative of a bug either in the test or in the system, and should be investigated as such. Flaky tests should be removed from the production testing system just like code that fails tests should be removed from production deployments.
Microsoft ships new Chromium Edge browser on Xbox, with WebGL2 support
This cable industry site regularly publishes an Almanac of all current active cables with maps and details for each one:
https://issuu.com/subtelforum/docs/subtel_forum_almanac_issu...
The comments got moved because I used some software I wrote to merge threads. (Just in case it's not clear, I'm a moderator here.)

When two threads are covering substantially the same story, we often merge them to prevent split discussions and to prevent duplicate posts on the front page. Is it a fair practice? That's for you to decide. I think it is! Actually the community tends to get annoyed if we don't do it.
Yes they were, in particular with the Wuhan Institute of Virology, and Peter Daszak himself was in Wuhan in October 2019.

EcoHealth just got defunded by the US Congress with bipartisan support: https://twitter.com/GReschenthaler/status/144122144752803020...
I mean, even in the case that occurs, what is the endgame? Fine China? Sanction China? Demand accountability from China? Not happening, not when they make everyone's chips among other things.

Can someone enlighten me about the value of this theory? It just seems like another vector of anti-establishment distrust discourse with a more intelligent veneer; easy to profit off of (clicks, book sales, etc) and doesn't require a conclusion.
Some coaxial lines were laid until the 1980s. Seems likely that at least one small island somewhere has a copper submarine cable supplying their data/phone needs still. But it's decidedly obsolete, yes.
I work a lot on compilers and VMs and have written tens of thousands of tests at different scales over the years. Different kinds of tests serve different purposes.

Unit tests help you pinpoint errors in the code. They can exhaustively test (only) small components to make sure they are fully compliant. They are a refactoring and development aid to the extent that they are focused (don't involve too many components), quick (run in seconds or less), not too tightly coupled to the code under test (i.e. can change code under test without changing tests), and explanatory (failure output is easy to understand and points exactly at the faulting component). Making good unit tests is an art form. Some people love their mocking frameworks. Personally, I hate them. Mocks are confusing and they try to check behavior rather than input/output. They make refactoring hard because they test behavior rather than results, and they are usually confusing.

Integration tests are about putting one or more systems together to test their interactions. More than just a single unit, we can put services together and test their interface. They can be more exhaustive about testing a component's interface because the combinatorics haven't exploded yet. Because there is a lot more code under test, failures are less explanatory and thus there is more work to investigate these failures. Investments here that help are to make failure modes as helpful as possible. That, too, is an art form.

End-to-end tests are inherently going to be slow. We put the whole system together and run some canned interactions on it. It might be flaky (because large scale, because networks, because OOM, timeouts, etc). End to end tests are generally a bitch to debug, because essentially anything could be at fault...well, anything except the things that are clearly passing their unit tests and integration tests. Which is why you need to have good unit and integration tests, so that you don't need many end-to-end tests.

It sounds from the article like they reduced or eliminated their end-to-end tests and went for more integration tests. That does seem to have paid off. Sometimes tests are slow and bad, and other kinds of tests are better.

I would say though, working now on a system with many, many, distributed moving parts, you do want to at least have some end-to-end tests that make sure everything comes up properly. Nothing like committing a change that passes all the small scale tests and then a component fails to come up because some stupid command-line flag is set wrong. You gotta have tests for anything you could absent-mindedly break.

And all of that testing needs to be a one button push away. You can't have tests that developers don't run, or don't know exist. Personally I like having shell scripts that are checked in and all at least one that does the whole enchilada, even if it is just a wrapper around the build system's or CI's test targets.
Like I said, you don't know what you don't know.
> if you don't test end-to-end you aren't going to catch bugs that only appear end-to-end

Points 2, 4 and 7 from the assessment expose why sometimes this is not achieved even in E2E tests.
The only bug-less software is software that was never written.

Please point me to a consumer OS that doesn't have security vulnerabilities.
> Section: Class 57 - Operator Intervention
> # (class borrowed from DB2)

> Section: Class 72 - Snapshot Failure
> # (class borrowed from Oracle)

Nothing from SAP / ABAP ? :^)
Couldn't agree more! Erwin's SO answers are incredible source of knowledge on Postgresql usage, especially things like plpgsql. I benefited from his answers a lot, thanks to Erwin.
Moving the arrow on the center disk of the two physical disks would rotate the insides of the circle and realign the person parts.

Took me a second too.
Yep. The first one was iPhone 4 vs Canon 7D video[1] that convinced me to replace my DSLR with an iPhone.

Only later I realized that it was pure manipulation.

[1] - https://youtu.be/H7bStLePvKo

There are others like that:
https://www.youtube.com/watch?v=ceblrDsG-aw
https://www.cnet.com/news/1080p-shootout-iphone-4s-vs-canon-...
Both media sources rely on speculation from one individual, so why not just link that shared source?
The one thing I'm "jealous" of with iphones as an android user in terms of camera features are live photos, and how seamlessly integrated they are. Whenever friends take live photos, it just seems to capture the moment way better, even if it's just a second or two of video in addition to a fully post-processed photo. Really wish there was a standard file format for these and Google / all Android manufacturers would adopt it. It really adds a lot.
To be fair, it might incentivize them to prioritize overall stock growth over the more pressing issues of the populace. Mixed bag on that one I think
In the ninth book of the Republic, Socrates casually describes the mass of human beings as things without even the dignity of animals, characteristically they are " bent over their tables, they feed like cattle with stooping heads and eyes fixed upon the ground; so they grow fat and breed, and in their greedy struggle they kick and butt one another to death (...) because they can never satisfy with unreal nourishment that part of themselves which is itself unreal and incapable of lasting satisfaction."

Contrary to the article, there is no doubt: Socrates would have no use for social media. His view is closer to Freud's, who remarked in a letter to Lou Andreas-Salomé : "In the depths of my heart I can’t help being convinced that my dear fellow men, with a few exceptions, are worthless." & Elsewhere "In my experience most of them are trash, no matter whether they publicly subscribe to this or that ethical doctrine or none at all ... If we are to talk of ethics, I subscribe to a high ideal from which most of the human beings I have come across depart most lamentably." - this is much the tone of Plato.

Walt Whitman I can imagine on Twitter.
Right, and if we punish people for speaking their minds we just drive them underground where this kind of thinking festers and becomes even more extreme. People need to accept that the internet isn't safe and neither can nor should be made safe.
Metal.
Test suites will tend to fail the more your system has to work with "outside" data. I recently had a client where their own data was entirely dependent on data drawn from 23 different 3rd party APIs, which meant the bulk of their code was devoted to parsing APIs they had no control over. Those external APIs sometimes changed, and sometimes contained bugs (that is, violations of published contracts).

To talk about this, I use a broad definition of "outside data". If you're a small startup, "outside data" typically refers to data that belongs to another company. But if you're working in a Fortune 500 company, "outside data" can also refer to data coming from an API run by some other division, which is nominally part of "your" company but is affectively independent.

One rule I now offer to my clients: the more your system relies on outside data, the more it is helpful to have run time checks, rather than a test suite. Assuming you run your code on multiple machines or nodes or dynos or instances, you can chose to run the tests on just a percentage of your system, enough to detect problems, but without paying the performance price on 100% of your system.

When a problem in your system is because of a change in an external API, your test suite won't catch it, since your test suite works with dummy data. But run time checks will catch the problem and make debugging easy -- you'll see almost instantly which API call created the problem.

Code written on the JVM has the beautiful property that you can add pre and post assertions on every function, and you can pass a flag to the compiler asking that the assertions either be left in the code or stripped out. This makes it easier to build 2 copies of the code, one with the asserts and one without, and that makes it easier to, again, deploy the code in such a way that only a limited percentage of your code needs to run those run time checks.
Protecting the sea lanes of communication is actually a core US Navy mission (and probably high priorities for several other world Navies as well). Particularly the major choke points: Strait of Gibraltar, Strait of Malacca, Strait of Hormuz, the Panama Canal, Suez Canal, Bab el Mandeb, Turkish Straits, and the Cape of Good Hope.
Who watches the watchmen?

https://en.wikipedia.org/wiki/Quis_custodiet_ipsos_custodes%...
That's not communism. It's selfishness, and either a lack of self-awareness or being a jerk, but it's not communism.

Communism would be advocating that the government take his assets - all of them.
Even if that analysis were accurate, that isn't mining "in private" before "publicly launching" as you claimed.
What do you do when, say, the TSA, or the police, or some equivalent thereof steals it, as was discussed in another thread?

I take it you also don't use any online service, because 99% of them don't take cash? Don't own a cellphone, because that broadcasts your location data 24/7? Don't own any device that actively scans for wi-fi networks?

Your government already has fingers in all of those data sources.
E2E tests are still extremely limited and let bugs through, unless they also fuzz somehow. But that will make them even more flaky and difficult to debug, costing more time. It's a tradeoff.

Example: You run some number of operations and then batch them. If you run the exact same operations each time you test, you may not catch conflicts between them. Instead, you'd have to run a random number of, and type of, operations. But then test failures would become extraordinarily difficult to reproduce. You'd have to hope that your tests log exactly what the inputs were, and have a semi-efficient way to recreate those inputs locally.
The Art of the Thiel
Spotify’s Discover Weekly: How machine learning finds your new music
The iPhone certainly didn’t help, but just as important is the fact that progress has slowed. Remember the digital camera of 2000 vs 2010, and then 2010 vs 2020. I can take excellent photos with a 10 year old digital camera, and dreadful ones with a 20 year old.
'E2E' is often impossible as in most ecosystems as things are constantly changing and you will dependencies out of your control you cannot simulate. The key is faking the right dependencies with accurate-enough versions to keep test fidelity and speed, keeping the test svelte and fast enough so it can run before you merge code to eliminate the size of change being tested and thus more easily understand the outputs to determine if they represent a false positive or negative and where any problems may be. This also all requires building the infrastructure to spin up a simulated world quickly enough to simulate how the proposed change effects the simulation and then analyze the results which is also pretty hard and can get expensive.

Luckily spending time optimizing often helps test speed and can control cost so there can be a good case to make for it but orgs have to be willing to pour engineering hours into that and engineers need to want to do it vs building new things which is typically more enticing.
Words are just memes that stick around for a while.
> than pearl-clutching about the universal practice of "forced labor".

So it's because everyone does it that it's "ok", then?

Or because you think it's better than "rotting in a cell"?

Whatever man. The issue is that the labour is _forced_. Give prisoners a choice to work or not and pay them, at market value, for their work.

If you're against choice and pay for prisoners you really shouldn't be embarrassed to just go ahead and call it what it is: slavery.