skysight-inc/HackerNews huggingface dataset:
A bit of thermal paste between the chip and the coin would also help with heat transfer
Of course it's not that simple. There are other ways to gain leverage over Google and the Chrome development process than money. But money is the easiest one for enterprises, especially if they boast their multi-million-dollar programs, so there at least seems to be a cashflow of considerable size depending on Chrome, of which a tiny part may possibly be diverted. And for a lot of enterprises that are not exactly at Google-scale, paying for it and hence being able to request support (and maybe even make Google pay for some of the monetary damages, depending on how the contracts are written) is the only feasible option to motivate Google.

However, Chromium being open-source, there is always the possibility of taking matters into your own hand here as an alternative to the above. That doesn't come free of charge as well, of course, the money just ends up somewhere else than Google.
The answer to that question is obviously 0%

Now, what would be the answer to the same question with the answer options:

A) 20%

B) 40%

C) 60%

D) 20%

E) 0%
That is how I used to work; then I got into finance and there are two things different with the work I did before that (web/desktop/app (or too long ago; there was no 'testing' in the 80s) the software I write now has to be certified/audited to some extent and I cannot change/repair production software on the fly. That could costs a lot of money for certain bugs. So now I tend to write tests for everything and that helps a lot.
Lithium supply can be grown without meaningful limit, if someone is willing to invest the capital for it. The problem is that the supply follows the capital investment with a ~5 year lag, and 5 years ago a little too much was invested, so now there is a glut.

As the actual extraction costs are relatively small compared to the initial capital outlay, and everyone needs to pay their investors, no-one can really cut production and everyone needs to sell at whatever price they can until someone goes bankrupt and capacity is reduced again. This is how relatively small mismatches in capacity can lead to major price fluctuations.
Eh, I think graffiti is or can be used to send a message or bring to light an issue. So in that way it is trying to manipulate you.

That being said I don’t disagree with the rest of your post.
I mostly agree, with the caveat that in my experience, if the configuration generation stage is entirely imperative it is harder to reason about it. That might not be a problem for low-complexity setups, but can get quite important (and bad) in some more involved cases.
I agree. Languages like Elm and Go seem much more sane and we'd have to include other very good examples of this like Julia and AWK. They are designed to serve a specific purpose and (try to) make the right trade-offs to achieve that.

Because that is what every language has to do. There is always something about a language that is crappy/boring/verbose/difficult/complected. And even with highly extensible languages (Lisp) you are at least forced to be disciplined, which also 'sucks' in a way.

Having the right trade-offs/constraints around a purpose/domain opens up many opportunities for optimization of performance, readability, accessibility and so on.
"play audio in background on mobile" is quite a big feature.
We are building a company that helps people take control of their time
Yeah, at that one I started trying to decide if the whole thing was meta trolling:

”XSLT is my favourite language of all time and it made all sorts of lights go on in my head. This is what sparked my analysis of programming languages, I wanted to program generally in an XSLT-like style, whatever that really means, and more. Of course, all data should really be in XML at all times, but that got killed with the whole XMLSchema nonsense...”
Here's why GHOST supports shorter block times for the same security.

In Bitcoin, the chosen block is the one with the most hashpower in the linear chain behind it. Abandoned forks contribute nothing to that.

With GHOST, the chosen block is the one with the most hashpower descended from it, in all forks. This way all the forks contribute to a block's security.

With a linear chain, propagation time is an issue. If blocks are too short it's more likely that miners will find more than one candidate block, causing the work on abandoned blocks to be wasted. With GHOST, no work is wasted.

The original GHOST paper, which proposed the algorithm as a modification to Bitcoin, has some math to calculate, for a given propagation time, the block time that would produce equivalent security to a linear chain. It was significantly shorter.
> Agile is about trusting people, not process

Not according to the highly paid consultants with strange acronyms following their names...
Do you consider coverage an effective metric? I've got some code that has a test suite which is effectively a bunch of low level driver checks, plus a bunch of common example snippets and checks for eg empty inputs etc.

Coverage gives an idea of how many lines of code have been run, but obviously no guarantees of correctness for those specific lines (eg you can't detect a double negative).

It's worked well for me so far, since the important parts are (a) the hardware communication works and (b) users can process and output data in a way that is correct. No need to obsessively check the intermediate steps if the output is good.
I'd be kind of curious about the reverse filter. I wonder how some of my photos would look like if I "underwaterified" them.
Lots of people like the content on YouTube but don't like all the Googley parts.

I frequently watch YouTube over Tor, and they've started making me do lots of reCAPTCHAs and occasionally even rejecting me after I've completed the reCAPTCHAs.

HookTube is an improvement over the real YouTube interface in the sense that it never makes me do CAPTCHAs, except some proportion of videos don't work on HookTube, it just gives a black box saying "Watch this video on YouTube".

From a sample of 1 video that I couldn't watch on HookTube, it worked straight away on Invidious. So it's useful in that sense if nothing else.
Visual Studio is amazing at juggling things that are wonderful while you have a mental map of your code and nightmarish once you don’t.
I don't see how splitting code in multiple modules makes it easier to communicate to others. It forces you to constantly switch places, which, knowing the limitations of the brain with regards to short term memory, would make it harder to keep a mental model. With mixins you don't even know where a particular function might come from, must be a nightmare following a trail when you don't know the code.
> Committing the red test and the fix to the test in two commits makes the bug and its fix easy to review.

I don't think this is compelling argument. Normally the test and the fix are looked at together and are already sufficiently separated in the code.

It makes more sense to me to use a single commit so the fix can be described in a single commit message, keeping the history clean.
I've just ordered my first Windows laptop ever, literally. Dell XPS 13 (6 core model). I've been using Macbook Pros solely since the original Aluminium model when Apple moved to Intel processors. Apple's apparent hubris and inability to go back on their design decisions (Touch Bar...) has just pushed me over the edge.

I've been using my mid 2015 Macbook Pro and hopefully waiting for them to release a new MBP ideally without the touch or move the trackpad down/make it smaller, and have the Touchbar PLUS physical function keys (which I use for programming).

So yeah... "Pro" users at least in my case (and some friends) are moving away from Apple.
Great sentiment, poor design thinking.

With any technology used in the support of freedom, especially in oppressed countries, the technologist has to ask 'How can the bad guy turn this around?'.

USB has been a common vector for viruses. North Korea is rumoured to have a passing familiarity with creating cyberweapons. So they could intercept the USB sticks, infect them, and then let them get redistributed. Then all these people will use the sticks, the virii will call home with personally identifying information, and NK will either jail or closely watch the people you are trying to help. And that assumes that this effort isn't wholly an op by NK.
I'm not sure I'd trust lowest bidder flag of convenience ships operating beyond national law to operate a reactor safely without ever dumping radioactive material in the only ocean we have.
iMessage is the implied feature that Apple never has to mention but everyone knows about.

They have no incentive to bring it up more, the green bubbles are burned into the psyche of every Apple user.
I wouldn't consider v0.30 "production ready", especially for a programming language. Breaking changes should be expected until they reach 1.0.
Also on Turris with knot-resolver and adblock... is there a reason to outsource blocking really? Why trust nextdns? Isn’t going to be a subscription based service once out of beta?
I would've hated it if my parents could monitor my internet access when I was 15 in the early 2000s. I've been in some weird places by pure chance and curiosity, though the Geocities era of the Internet was much different that today's.
I guess the story here is that payment providers, including Apple, are required to open-up to third-parties under FRAND conditions according to late-night legislation. Didn't see this one coming.
I am now worried that this day will looked back on later in history as the start of the alien wars.
Everyone in the comment thread seems to be focused on whether each proposition can be true. This is looking for your keys under the lamppost despite the fact that you dropped them in the dark. It's easy to determine whether a proposition can be true.

But the question doesn't ask about that. It just asks "which of these is the correct answer to this question?" There are no stated criteria for being the correct answer, and there is no reason to assume that the correct answer must be true or even capable of being true.

Consider this other question:

Which of the following is the correct answer to this question?
(A) This one.
(B) This one.
DD-WRT hasnt had a stable release in 11 years.

Tomato hasn't had a stable release in 9 years.

OPEN-WRT is a fork of DD-WRT. Lede was a fork of OPEN-WRT, but has remerged with OPEN-WRT. OPEN-WRT is the best firmware for home routers/access points in my opinion.
Keeping it separate allows ensuring the test works easily: just revert the fix keeping only the patch for the test and make sure the test fails.

My workflow tend to be to keep them separate, and write a big description in the merge commit rather than the individual commits (those have a small description of the local change).

There's tradeoffs to both approach though, and as you mention, it's easier to keep track of the provenance of a fix in the git blame when it's unified in a single commit message.
This is cool as an option but personally I prefer filtering at home using Diversion and Skynet on AsusWRT router firmware.

This dns may be a good option for the non-technical but personally I never want a DNS to do filtering for me.
I put "Crimea" in a venmo transfer to my own wife and they will no longer allow me to transfer funds to her.
Crystal is most certainly not production ready but nonetheless I find it interesting and useful and use it for https://ratwires.space (nsfw)
My two cents: write long procedures, write short functions.

It is not very useful to break up long sequences of imperative commands (procedures) because chances are the procedure chunks you end up with are completely ad-hoc and non-reusable anyway. Also, as John Carmack puts it, "you should be made constantly aware of the full horror of what you are doing".

For pure functions, it's often a bit of a smell if they're very long; usually you can decompose them into smaller functions which are actually reusable, and you end up with small units that can be tested in isolation and are very easy to understand.

Generally speaking (not a hard rule), it's a win to have more of your program written as pure functions. But it cannot always be done in a sane way, in that case, write procedures and write them long.
Before you excitedly jump to coding a new algorithm to produce eigenvectors from eigenvalues, it's worth noting that:

. This only applies to hermitian matrices and is therefore of limited scope.

. The identity only produces the magnitudes of the coefficients of the eigenvectors. The signs of the coefficient sare still unknown.

. Even if knowing only the magnitude of the coefficients is somehow useful, this is still very expensive to compute - just like Cramer rule which is of great theoretical interest, but has very little practical use when actually computing a matrix inverse or a determinant.

None of the above diminishes the importance of the result, btw.
If 6 was true, then 5 would also be true, making 6 incorrect.

It has to be 5
Someone who wants an extra large font for whatever reason, perhaps due to sight problems.

The point is that this is an option.
I think he will be popular in the future as cybernetic theory provides much a much more reliable design viewpoint than "artificial intelligence"
> "In the background, the first video of the user’s recommendations is playing"

Well that sounds horrendous.
5 is the only answer that could be correct.

But is it an answer to the question? If the question were something completely different, "How green is interstellar space?", then we would still find 5 as the answer. But "None of the above" is a non-answer. And "What is the answer to this question?" is not well defined.
I suspect he was joking.
Alternatively using z3 [0]:

(declare-const a1 Bool)
(declare-const a2 Bool)
(declare-const a3 Bool)
(declare-const a4 Bool)
(declare-const a5 Bool)
(declare-const a6 Bool)

(assert (= a1 (and a2 (and a3 (and a4 (and a5 a6))))))
(assert (= a2 (not (or a3 (or a4 (or a5 a6))))))
(assert (= a3 (and a1 a2)))
(assert (= a4 (or a1 (or a2 a3))))
(assert (= a5 (not (or a1 (or a2 (or a3 a4))))))
(assert (= a6 (not (or a1 (or a2 (or a3 (or a4 a5)))))))
(assert (or a1 (or a2 (or a3 (or a4 (or a5 a6))))))

(check-sat)
(get-model)
(exit)

The model is satisfiable where only a5 is true, anyone can run it themselves and play with it [1].

Additionally forcing a5 to be false by adding the following to the list of assertions:

(assert (not a5))

And the model becomes unsatisfiable.

Edit: Finally, to make sure there's not some possible solution where a5 is true as well as another assertion you could alternatively add this assertion:

(assert (and a5 (or a1 (or a2 (or a3 (or a4 (or a6)))))))

And the model also becomes unsatisfiable. So 5 only seems to be the correct answer.

[0] https://github.com/Z3Prover/z3

[1] https://rise4fun.com/Z3/1DMW
They are also available free online -- "PostScript Language Tutorial & Cookbook", also known as the PostScript Blue Book, is at https://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF. There is also the Red Book (useful to fully understand the language, to the point of writing a PostScript interpreter), and Green Book (more of a reference book than a cookbook).
Try to watch Gary Bernhardt's "Boundaries" screencast (2012), if you haven't yet.

There are also some collection of links in github such as https://gist.github.com/kbilsted/abdc017858cad68c3e7926b0364....

The pattern articulated by Gary also best resonated my thoughts and experience in building software.
I think most residents are ok with them, but it’s because they don’t have a clear choice, haven’t stopped to think about it, and/or “that’s just how things have always been”.
LinkedIn's skill tests are hilariously poor. They ask unanswerable questions, and mistype the answers. The more familiar you are with the subject matter, the more uncertain you become.
He also posthumously patented a "non-von Neumann" architecture that has never been built, to my knowledge. I'm surprised that all the attention on quantum computing hasn't revived the idea.

https://patents.google.com/patent/US2815488A/en
> ...fanatical anti government propaganda.

Jim Crow, Watergate, Catholic priest abuse scandals, regulatory failure in 2008, too big to fail, gerrymandering, police involved shootings, Hurricane Katrina flooding, Keystone Pipeline leaks, ...

And, yes, it happens in local markets too: taxi medallion systems, overzealous zoning, local corruption, running Amazon out of Queens, and so on.

We could call skepticism fanatical, but that dismisses some pretty substantive history and current events regarding government corruption and incompetence.
mostly tests while doing implementation, but not 100%.

however, I've started working on a project with others, and am becoming a bit more adamant on "this needs tests". Codebase had none after a year, and the other dev(s) are far more focused on code appearance than functionality. Fluent interfaces, "cool" language features, "conventional commit" message structure, etc are all prized. Sample data and tests? None so far (up until I started last week).

I've had push back on my initial contributions, and I keep saying "fine - I don't care how we actually do the code - change whatever I've done - just make sure the tests still run". All I've had is criticism of the code appearance, because it's not in keeping with the 'same style' as before. But... the 'style' before was not testable, so... there's this infinite loop thing going on.
>* A nuclear reactor is pretty much the only thing where a local fuckup can have globally disastrous consequences

Hydro-electric wants you to hold its beer.

Over the timeline that civilian nuclear has existed dams going pop has killed a lot more people and caused more destruction than nuclear. The fact that the consequences are "global" is mostly a reflection of how good we are at measuring radiation. While (for example) Chernobyl going pop was detectable over much of Europe the actual amount of radiation was of basically no consequence (i.e. less than more local sources of air pollution) except in the immediate vicinity.
Also relevant is that there are additional management features targeted at Enterprise needs like group policy.

https://www.mozilla.org/en-US/firefox/enterprise/
tests can be used to clarify your intentions and what you are attempting to build. It's best place when you are actually starting from a clean slate.

Just write enough code to make the test pass, no more no less. Refactor and repeat.

In recent years I've never written any new piece of code without test first and can not be any happier. Beside the confidence a test gives you, it really a great way to pin down your thoughts and write what makes them meterialize.
old doonas are cheaper, just sew some elastic to them, unless where talking golf ball size hail.
I just lie about the version: an ESR can lag current by 8 major versions, ~12 months (with full security patching of course)
I can see where relying on a black box could get really hairy though. What if it’s a light storm that produces virtually no damage but the device produces a payout? What if the exact opposite happened? Who is programming and vetting the code?
> Just keeping in mind that you have to write a test for your code, changes how you write it.

Which is often enough to ensure the code is testable.

Generally, I'll write some tests sort of alongside, or soon after (like, a couple hours or a day) to not lose the initial thought process. Going back to code days/weeks later and trying to 'test' it when it wasn't conceived of as testable is tough.
it is licensed under AGPL. For white-label embedding it requires a commercial license: https://www.metabase.com/enterprise/pricing.html
Pricing for variant with row-level security is not cheap as you might expect, so if you plan to embed reports in your web app it might be better to consider another alternatives.
OpenWrt is not a DD-WRT fork.
Scion: Scalability, control, and isolation on next-generation networks
It doesn't make sense to bring the material back to Earth. But getting mass to Earth orbit from Earth is very expensive and if you want a big space habitat the material from an asteroid might be very useful, even if just as radiation shielding.
I use Cypress with this plugin: https://github.com/palmerhq/cypress-image-snapshot

In my setup, it creates the PNG snapshots and compares them to the snapshots stored in Git at each test run. In result, I get the number of different pixels and the test fails if the nunmber is higher than 0. It also produces a visual PNG diff file, that has 3 panes: expected, actual, diff heatmap. The setup took just few hours.

However there are some screen resolution limitations in Cypress right now. I could not get it to work in resolution higher than 1200x1024. More about that problem: https://github.com/cypress-io/cypress/issues/2102
Until November 17 2019, I will reconstruct and color your old photos for any fee
Actually I’d suggest we all take some time to learn the law. Actual legal practices and whatever. I’m increasingly of the impression that lawyers are the real first class citizens of a constitutional government.
yeah, that's the problem. If they don't get the value of what a test gives them, and then the focus shifts to aesthetics and conventions, etc...

Personally when I review code, I look for the test, I need to find a way to tell me why that code exists and a proof that it works.
I get around this by squashing the PR commits. Reviewers see the individual commits, and good CI means they can see the test-commit failed and the fix-commit passed, but post-merge it's a single passing commit.
Is the early adaptor included?
> What is the best alternative router firmware these days

I don't know that there is one.

My experience these days when I install a new wifi router is wading through pages and pages of forum posts to try and identify the firmware (or particular build thereof) that will work best on the particular hardware I am configuring that day.

Usually, after a few hours of digging, I sort of "converge" on a particular firmware and a particular release.

Then it's on to experimenting if the thing actually works. If it doesn't, rinse and repeat.

This is very frustrating, and for a number of reasons:

- From a security perspective, you end up installing a random unvetted piece of binary software on what is basically the gate holding the fort secure.

- You operate on hearsay (forum posts)

- There is no guarantee the process will converge.
Depends on the metal. For certain platinum-group metals (iridium, osmium), a single asteroid might contain several years' or decades' production. For more common metals like iron, copper, or even gold, it wouldn't make a dent in the market.
Normally no. I do not do TDD either. If however I am writing some complex algorithm where I know that I'll make few bugs here and there I would write test.

Being too proper, doing everything by the book does not always translate to better code or good ROI

Also being an older fart and programming for so many years I am usually pretty good at not making too many bugs anyways.
99% of the code I write is test first. It makes my life easier - I always know what to do next and it reduces the amount I need to keep in my head.

TDD done the way many developers do is a PITA though. When I write a test it will start off life with zero mocking. I'll hit the db and live APIs. From here I'm iterating on making it work. I only introduce mocking/factories because it's harder work not to. I'll gradually add assertions as I get an idea about what behaviour I want to pin down.

Done this way using tests is just making life easier, you can start off testing huge chunks of code if that's what you're sketching out, then add more focused tests if that's a faster way to iterate on a particular piece. For me the process is all about faster feedback and getting the computer to automate as much of my workflow as possible.

edit: Kent Beck had a fantastic video series about working this way, I can only find the first 10 mins now unfortunately but it gives you a taste, https://www.youtube.com/watch?v=VVSSga1Olt8.