skysight-inc/HackerNews huggingface dataset:
My work uses Microsoft Edge and it’s just not very good. Not as many sites work on Edge as Chrome.

I hope this changes when Edge goes to Chromiun but from a UX perspective, too much stuff doesn’t work on Edge.
I do, TDD gives me such a sense of confidence that now that I'm used to, it's hard not to use.

> Can you describe the practical benefit?

Confidence that the code I'm writing does what it's supposed to. With the added benefit that I can easily add more tests if I'm not confident about some behaviors of the feature or easily add a test when a bug shows up.

> Do you happen to rewrite the tests completely while doing the implementation?

Not completely, depends on how you write your tests, I'm not testing each function individually, I'm testing behaviour, so unless there's a big architectural change or we need to change something drastic, the tests have minimal changes

> When does this approach work for you and when did it fail you?

It works better on layered architectures, when you can easily just test the business logic independently of the framework/glue code. It has failed me for exploratory work, that's the one scenario where I just prefer to write code and manually test it, since I don't know what I want it to do...yet
SlateStarCodex "The Atomic Bomb Considered As Hungarian High School Science Fair Project" https://slatestarcodex.com/2017/05/26/the-atomic-bomb-consid...
The comments was specifically about the use case of getting a large refactor merged.

If you are simply adding code or making simple changes, then unit tests can have advantages. It is when you are making a large refactor that you need end-to-end testing to verify that nothing was broken.
Upvoted for collapsing spurious layers. I've started doing this, too. Why am I writing code to allow an alternative database engine, when I'm never going to move this thing off Postgres?
The Future of Banking Is You're Broke
Or great genes
Yes! It’s a pretty big controversy so far as computing goes and a very interesting read. ENIAC (ISBN 978-0802713483) is a good account that includes it.

I have to wonder what else gets washed away in all the myth-making about these guys.
If the text hasn't been changed, what they say it means isn't relevant - they can still end up going for a different interpretation later and be entirely in the right.
It Turns Out There's Not a Lot of Science Linking Testosterone to Violence
That's what I am wondering.
So, they're advising to recreate a custom version of the old OpenGL statemachine?
And I've just discovered fusesoc and this is 50x better...
That's because we're lucky to live in a world where the cold war stayed cold, and LeMay and von Neumann were coming from half a century of the worst slaughter the world had ever seen.
I've been writing software professional for 20 years and for much of that time I was very skeptical of testing. Even after I started writing tests it was several more years before I saw the value of writing tests first. I've moved to doing this more and more, especially when doing maintenance or bug fixes on the back-end. I still struggle with writing valuable tests on the front-end, apart from unit tests of easily extracted logic functions, or very basic render tests that ensure a component doesn't blow up when mounted with valid data.

If you write your test after making the code changes, its easier to have a bug in your test that makes it pass for the wrong reasons. By writing the test first, and progressively, you can be sure that each thing it asserts fails properly if the new code you write doesn't do what is expected.

Sometimes I do write the code first, and then I just stash it and run the new tests to be sure the test fails correctly. Writing the test first is simply a quicker way to accomplish this.

Like others have said when there is a lot of new code - new architectural concerns etc, its not really worth it to write tests until you've sketched things out well-enough to know you aren't so likely to have major API changes. Still, there is another benefit to writing the tests - or at least defining the specs early on - which is that you are not as likely to forget testing a particular invariant. If you've at least got a test file open and can write a description of what the test will be, that can save you from missing an invariant.

Think of tests as insurance that someone working on the code later (including yourself, in the future) doesn't break an invariant because they do not know what they all are. Your tests both state that the invariant is intentional and necessary, and ensure it is not broken.
The built-in ability to pattern match on data nested deeply within the application state (or the XML document) is radically powerful. Haskell, for example, has nothing like this.

Eve is a really interesting language where you define global pattern matches, using datalog-style unification rather than XPath, and these "templates" can result in state changes. So for example you can trivially define global invariants over the entire state, kind of like defining a database integrity constraint but for your program's state.

As an aside, I'm recently feeling disillusioned with Haskell—after loving it since 2004—as any kind of ultimate or next-level general purpose language, precisely because of the lack of this dimension. Dealing with relational data in Haskell is quite tedious. Even writing multipass compilers in Haskell is not very pleasant.
i always find it quite strange that for some reason, norbert weiner, is generally excluded from such paeans...
That s great, but any good bachelor students should be able to give you a similar answer.
It written right ther:

> Terminations and Suspensions by YouTube for Cause

> YouTube may suspend or terminate your access, your Google account, or your Google account’s access to all or part of the Service

The question is why we still don't believe it even when it's written in black and white?
Maybe you should study game theory
No. I have always felt that TDD gives a false feeling of safety and satisfaction, and that it is mostly a waste of time that could be better spend optimizing and refactoring.

Testing simple code is simple and therefore pretty much useless. Testing complicated code is complicated and therefore more likely to fail by making to few or to many assumptions in the test, or completely screwing up the test code itself.
Where can I find eCommerce Development Service provider?
There is no reason to think we are no longer producing people with colossal intellect. They are probably now collaborators on a large project, since that is what math and science have become.

Plus we haven’t had enough time to make myths about the recent times. Of course the 20th century was incredible for physics, but we don’t know yet what will make the recent years special. We may, for example, in 80 years wonder about how it was that the early 21st century produced so many ambitious, large-scale experiments.
Tests need to cover small units one at a time. I've been bitten too many times by tests that were too complex and attempted to test too many things at once. They invariably ended up doing nothing of value. Test setup becomes overly complex and prone to oversights. Writing another test for a variation of a problem that takes a slightly different code path becomes a chore. It also gets hard to spot that odd untested corner case hidden deep inside some complex logic.

The proper way to think about this is to have unit tests that cover the nooks and crannies of the business logic and integration tests that make sure that interfaces are correct.
I played Half Life 2 for the first time in 2010. True that consuming media late changes opportunities to be part of social groups about it.
If I'm changing a software that's in production: yes.
If I'm just messing around with a prototype I'm the only user of and don't yet know if it's going to be useful or go in production: no.
I do like to write tests that actually write tests though, see such patterns in django-dbdiff, django-responsediff, or cli2 (autotest function).
> I used to have a copy of "SQL for Dummies" at hand whenever I, with dread in my heart, needed to write some SQL, especially if there was any funky stuff like joins and such going on.

SQL isn't so much a programming language as a query language. It never claims to be an efficient way to write a factorial function.

And why do people freak out when they see a JOIN? It's one of the simplest concepts in databases: intersecting two sets. Everything in column A that matches everything in column B. You don't even have to concern yourself with the most optimal way to do it, just say it!
To play Devil's advocate, applicant B might just be better than A at not getting caught.
> Hungary had a great education system at the time.

I seriously doubt you could back this. You are generalizing from a single school. Might as well argue that socialist Hungary had a great education system because of Fazekas. Neither are true. I happen to have a maths teacher degree from a Hungarian university and we studied Hungarian education history and I learned much more about education systems later on my own (and this is not to say this university maths teacher course was a good one, quite the opposite). If you want to know what great education at the time looked like, read up on Summerhill -- it was founded in 1921 but humanistic education has been around for centuries.
I’m not sure thatvthe same principal doesn’t apply. For example, by the time I take advanced calculus in college, if I already know a huge chunk of the material and have strong mathematical maturity, I can spend more of my time on “the hard parts” without it stressing me as much as if they were harder for me.
"Inlining" A, B, C is OK when they go down in abstraction about the same depth. If not, you have a mix of simple and low level code. Using A, B, and C masks this.
I wonder if ActivityPub or some sort of federation is on the roadmap
Specifically this example I don't know, but there are pretty big differences between look and feel on websites when sending a Chrome UA vs a Firefox UA. The most obvious example is Google.
Yeah, the law is on your (customer's) side in the EU also. Unfortunately people don't know that, so banks can afford to bully their customers into renouncing their claims. Technically if you are the type of person who knows how to deal with these types of problematic businesses that push you around, you will eventually prevail, but it will cost you a lot of time and effort. In my case, the financial loss was not high enough in order to waste even more than three trips to the bank.

My partner's parents were hit hard though, about €5k. They argued back and forth with the bank for about 6 months to no avail. "Sorry, we can't do anything" type of answers. The bank also tried to trick them into signing "fraud forms" that in the fine print absolved the bank of any responsibility. It was only after I actually filed a claim with relevant financial authorities, and then hit the bank with that that they suddenly got their money back.

The interesting thing is that this mentality is so prevalent that even the non-fraud department bank employees genuinely didn't know that the bank is supposed to actually help them. Many of them told us their own stories about how they were defrauded (I have no reason to suspect they were lying because they were family friends, and I heard the stories before our incident).
The 75% supertax was in would-be president Hollande programme, but has _never_ been applied!
The front camera usually doesn't filter IR.
IBM: Mac users outperform Windows users
The paper says that they used current dehazing algorithms as a base, and added more parameters to them.
We have the same challenge, except that in our case the issue is hardware.

Hardware comes at a very fixed iteration speed, usually around 3 months for something of moderate complexity. That's how long it's going to take to do schematic capture, layout, pcb manufacture, board population and bringup. Even if you can speed up this iteration process, there is still a sizeable financial cost of going around the loop.

This means that at a project level you need to do a certain amount of requirements capture before you start work on electronics. You can then run your software in a fairly agile manner 'inside' the project, hoping that the inevitable changes in requirements can be dealt with in software. Obviously you design your system in such a way as to increase that likelihood.
maximum resolution in Invidious is 720p even 1080p is supported when goes to youtube. Are there some technical limitations?
Biofuels are a much simpler carbon-free option for ships. Cargo ships are built and scrapped, made to last only a few decades. Powering them with nuclear would be insanely cumbersome and expensive.
Their eyes must be much better than mine. I think I would probably have eyestrain and be even more tired at the end of the day if I had to squint at 8pt font all day.
I agree, and I think there is an arrogance by those with the view that 'coverage testing is useless' which blinds them to the real purpose of code coverage testing: to tell you what you haven't tested yet.

Coverage isn't supposed to tell you anything about the quality of the tests beyond what code simply has never been tested yet.

And yet, people seem to think "code coverage testing" means something else entirely. The only purpose for paying attention to coverage metrics, as a manager, is to understand how much more work there is to be done on the tests - or, to determine code paths which never get executed and are therefore dead weight on the project.
> It does not. It makes it exponentially more difficult.

You should realise you are falling victim of your own assertions here. You're cargo-culting the idea that abstracting functions makes debugging exponentially more difficult, without having provided any substance to qualify.
Ask HN: Let's Discuss Hacker News' Logo Icon
I sometimes zoom into Hackernews in my browser, and something caught my eye. The small Y logo in the top left of the screen is not a vector graphic. I am referring to the graphic located here:

https://news.ycombinator.com/y18.gif

Instead when I zoom in, I get a blurry image since it's actually a raster (GIF) image. Can whoever is in charge of HN's site design convert this to an SVG image? If we're worried about compatibility, SVG works in all modern browsers and is an underused and unappreciated file format. A small tweak will go a long way.
What's a recycling center? What if your country doesn't have them?
I've always wondered. Do you think someone studying Medicine or Mech. Eng. at Harvard wouldn't get a higher quality education than what many public colleges provide ?
Sadly, not anymore. The government is doing everything to dumb down education and research in academia. It's really pathetic. We are doomed for generations thanks to this.

Just a recent example: a Prezi.com founder decided to create an alternative private school to show and lead by example. They didn't get the accreditation this year. If you stick out, they shut you down.
Their reasoning was based on the idea that a war with the Soviets was inevitable and that the US should attack before it lost the strategic advantage - given that there was no war are you actually arguing that they were correct?
Native CI is definitely going to cause a user base shift, drone-ci does the job but in my opinion the decision to not let users directly edit env vars makes it pretty annoying to maintain simple configurations - where you don't deport environment variables to some external secret manager which you'de put a key for in your CI, when such complexity is not needed for a project.
China’s Internet Is Flowering
Direct link:

chrome://flags/#enable-ntp-remote-suggestions
"Von Neumann would carry on a conversation with my 3-year-old son, and the two of them would talk as equals, and I sometimes wondered if he used the same principle when he talked to the rest of us." - Edward Teller

See [0] for a demonstration.

I watched a documentary from the 80ies a long time ago. A mathematician (can't remember his name) who worked with von Neumann in Los Alamanos was interviewed. He described von Neumann's last weeks in the hospital - the cancer had already metastasized into his brain. The mathematician said something along this lines (I am citing from memory): "von Neumann was constantly visited by colleagues, who wanted to discuss their latest work with him. He tried to keep up, struggling, like in old times. But he couldn't. Try to imagine having one of the greatest minds maybe in the history of mankind. And then try to imagine losing this gift. I was terrible. I have never seen a man experience greater suffering."

Marina von Neumann (his daughter) later wrote this about his final weeks:

"After only a few minutes, my father made what seemed to be a very peculiar and frightening request from a man who was widely regarded as one of the greatest - if not the greatest - mathematician of the 20th century. He wanted me to give him two numbers, like 7 and 6 or 10 and 3, and ask him to tell me their sum. For as long as I can remember, I had always known that my father's major source of self-regard, what he felt to be the very essence of his being, was his incredible mental capacity. In this late stage of his illness, he must have been aware that this capacity was deteriorating rapidly, and the panic that caused was worse than any physical pain. In demanding that I test him on these elementary sums, he was seeking reassurance that at least a small fragment of this intellectual powers remained." [1]

[0] https://www.youtube.com/watch?v=vLbllFHBQM4

[1] https://www.amazon.com/Martians-Daughter-Memoir-Marina-Whitm...
Shopshastra is one of the Mumbai based startup , you can get from their https://www.shopshastra.com/
> If you write your test after making the code changes, its easier to have a bug in your test that makes it pass for the wrong reasons.

I see this a lot. I don't write tests first, but I always make sure my changes are properly covered by my assertions. For instance, when fixing a bug, I comment/undo my fix and make sure my test fails.

One could say I'm doing twice the work (fix, write test, comment out fix), but I find it easier than just writing the test first.
That, and I also switched my search engine to DDG. I also use Lawnchair as my home launcher, and you can also change the search engine there too.
This is neat. Although in recent years I have trimmed down my extensions to just uBlock Origin and HTTPS everywhere. I went through a huge phase of installing novelty addons like this but got concerned about the privacy of the addons and what kind of code they were running. Sure - I could vet the addon by inspecting the code, but that's now outside my scope. I don't have the time or energy to do it anymore.
You want to look up adverse selection and moral hazard in an economics text about insurance.

Basically if you have some mixed population where some are lower risk and some higher, and they're separable, the low risk people will decide the insurance is not worth the premium. That leaves the higher risk population on the books, which will cause problems for the insurer of they had assumed they'd get a nice sample of the population.

So maybe some car dealers are aware of possible hail storms in their region but for some reason their particular shop is protected. Maybe by hills that drop the hail on the other side or something that which gross aggregates might miss.

Moral hazard plays in as well. If you're protected maybe you place more cars outdoors than you would otherwise, raising the costs to the insurer.
As an admin why would you not also run the beta version of the browser in a limited setting? That would have helped you find out about this issue sooner, since the experiment was enabled there for a while.
Only the 5th is true, Metamath:
$( <MM> <PROOF_ASST> THEOREM=noneabove LOC_AFTER=?

h50::noneabove.1 |- ( ph <-> ( ( ps /\ ch /\ th ) /\ ( ta /\ et ) ) )

h51::noneabove.2 |- ( ps <-> ( -. ch /\ ( -. th /\ -. ta ) /\ -. et ) )

h52::noneabove.3 |- ( ch <-> ( ph /\ ps ) )

h53::noneabove.4 |- ( th <-> ( ph \/ ps \/ ch ) )

h54::noneabove.5 |- ( ta <-> ( ( -. ph /\ -. ps /\ -. ch ) /\ -. th ) )

h55::noneabove.6 |- ( et <->
( ( -. ph /\ -. ps /\ -. ch ) /\ ( -. th /\ -. ta ) )
)

56:50:simprbi |- ( ph -> ( ta /\ et ) )
57:56:simprd |- ( ph -> et )
58:51:simp3bi |- ( ps -> -. et )
59:57,58:anim12i |- ( ( ph /\ ps ) -> ( et /\ -. et ) )
60::pm3.24 |- -. ( et /\ -. et )
61:60,59:mto |- -. ( ph /\ ps )
62:61,52:mtbir |- -. ch
63:50:simplbi |- ( ph -> ( ps /\ ch /\ th ) )
64:63:simp2d |- ( ph -> ch )
65:62,64:mto |- -. ph
66::3ioran |- ( -. ( ph \/ ps \/ ch ) <-> ( -. ph /\ -. ps /\ -. ch ) )
67:53:notbii |- ( -. th <-> -. ( ph \/ ps \/ ch ) )
68:67,66:bitri |- ( -. th <-> ( -. ph /\ -. ps /\ -. ch ) )
69:68:anbi1i |- ( ( -. th /\ -. th ) <->
( ( -. ph /\ -. ps /\ -. ch ) /\ -. th ) )
70::pm4.24 |- ( -. th <-> ( -. th /\ -. th ) )
71:69,70,54:3bitr4i
|- ( -. th <-> ta )
72::nbbn |- ( ( -. th <-> ta ) <-> -. ( th <-> ta ) )
73:71,72:mpbi |- -. ( th <-> ta )
74::df-xor |- ( ( th \/_ ta ) <-> -. ( th <-> ta ) )
75:73,74:mpbir |- ( th \/_ ta )
76::xoror |- ( ( th \/_ ta ) -> ( th \/ ta ) )
77:75,76:ax-mp |- ( th \/ ta )
78:55:simprbi |- ( et -> ( -. th /\ -. ta ) )
79::pm4.56 |- ( ( -. th /\ -. ta ) <-> -. ( th \/ ta ) )
80:78,79:sylib |- ( et -> -. ( th \/ ta ) )
81:77,80:mt2 |- -. et
82:51:simp2bi |- ( ps -> ( -. th /\ -. ta ) )
83::pm4.56 |- ( ( -. th /\ -. ta ) <-> -. ( th \/ ta ) )
84:82,83:sylib |- ( ps -> -. ( th \/ ta ) )
85:77,84:mt2 |- -. ps
86:65,85,62:3pm3.2ni
|- -. ( ph \/ ps \/ ch )
87:86,53:mtbir |- -. th
88:87,75:mtpxor |- ta
89:65,85,62:3pm3.2i
|- ( -. ph /\ -. ps /\ -. ch )
90:89,87:pm3.2i |- ( ( -. ph /\ -. ps /\ -. ch ) /\ -. th )

qed:90,88,81:3pm3.2i
|- ( ( ( -. ph /\ -. ps /\ -. ch ) /\ -. th ) /\
ta /\
-. et )

$= ( w3a simprbi mto
wn wa mtbir wb sylib mt2 3pm3.2i pm3.24 simprd simp2d
simp3bi anim12i simplbi wo notbii 3ioran bitri anbi1i
wxo w3o pm4.24 3bitr4i nbbn mpbi df-xor mpbir xoror ax-mp simp2bi
pm4.56 3pm3.2ni pm3.2i mtpxor )

ANZBNZCNZKZDNZOZEFNZVLVMVIVJVKACC
ABOZVPFVOOFUBAFBVOAEFABCDKZEFOZGLUCBVKVMENOZVOHUFUGMIPZABCDAVQVRG
UHUDMZBDEUIZDEUNZWBWCDEQNZVMEQWDVMVMOVNVMEVMVLVMVMABCUOZNVLDWEJUJ
ABCUKULUMVMUPUAUQDEURUSDEUTVAZDEVBVCZBVSWBNZBVKVSVOHVDDEVEZRSZVTT
DWEABCWAWJVTVFJPZVGDEWKWFVHFWBWGFVSWHFVLVSUELWIRST $.
$)
How many times has it turned into this:

DoA(DoAllContext ctx);
This was filed in 2017-05-31, so wouldn't have been published until 2018-12-01 (18 months later). Samsung likely wouldn't have know about it until then.
> c++ has a awful compile time

I have a thoery that C++ compiler writers obsession with pointless micro optimizations is because C++'s compilation model scales horribly. Thus they desperately want their compiler to be faster. But they are fucked because the more optimizations just slows down the compile times even more.
That Tailspin language looks even worse than Perl. After the author didn't understand his own Perl code after a while, this seems like a lesson not learned. Creating a good language really is hard, let alone a "perfect" one.
Indeed. The relevant part of k \h can be put on one side of a postcard.
When the valuation is based on investment by investors already in the deal... It does not imply that they think there’s a plausible path for the business to be worth the money.

As events have shown with WeWork, it implies that they are maintaining the façade for a little while longer while hoping o get to the point where they can unload the business onto the public markets.

Asking SoftBank what they think their investments are worth is like asking me what I think my house is worth. You Have to go by what arms-length investors are willing to pay.

I really think we need a new rule where nobody quotes a valuation if the last round involved existing investors and/or founders pumping up the valuation with additional investment.
True, although it would be possible for some. Only regarding this property, pancake stack would be nearly perfect (ok, it probably is)