skysight-inc/HackerNews huggingface dataset:
It is probably best known as part of nazi ideology: https://en.wikipedia.org/wiki/Aryan

This is no the only use, of course, but that doesn't matter. Good luck being a Hindu and displaying a swastika.
California may extend health coverage to seniors here illegally
Americans see record drop in cancer death rate
This is making me think of elevators that deliberately leave out floor numbers (13 in north america, 4 in asia) because they are 'bad luck'. Numbers! As Mitch Hedberg would say, the people on the 14th floor know which floor they're really on.
The only cost of duplication is when you're making changes to it. Let's say that the cost of typing, checking and finding the code to change is "t". Duplication makes it "n*t". Abstraction, in case of no special case, makes it "1t".

So if "n" is somehow big, it'll be costly to make changes and abstraction makes sense.

However do not abstract similar code for different behavior early (as in OP's case), but abstract similar behavior early (ex: file system, db access)
Thanks! I will keep app as a reference for my future feature development. The app will lean towards understanding the algorithms rather than being used in other apps.
Or they didn't really want the change. Or (devil advocate) maybe they had a very good reason you did not know. Like, they asked repetitively for that before. It takes a special straw to break a camel's back.

This reminds me of the M&Ms color in rock concerts artist room: a canary in the mine for the venue having ignored more important requests.
The track record is that of them being morally bankrupt. Not a track record of having applied their moral bankruptcy to this particular scenario as of yet.
Bees are essential to the almond industry, and billions are dying in the process
you have to type "exit" after you're done.

you may have to do it a few times before it works.
>For me, it just sounds like a really good reason not to be buying cameras and microphones and slapping them up all over the place.

It's being sold as convenience and we can expect a lot more of it. The last decade has shown that the general populace will trade almost anything for the perception of convenience.
Very cool. Definitely curious to see this part:

> I plan to add textual information on each step, to show how algorithm is "thinking"
Maybe Monad in R
But, according to gdpr, they still have your data even if you're "suspended", so they should make it available to you.

I haven't had a suspended account yet but if google really doesn't let you copy your data under any circumstance, they will have even more fun with the data protection agencies.
> ...Big Five neuroticism...

It's gonna be really hard to deconvolve hormones from environment. Men and women are treated very differently in our culture; men's and women's behaviors are interpreted very differently; the former having a possible causal relationship with neuroticism, the latter having a possible causal relationship with diagnosis. You'd need a fairly large study involving a large number of trans people who aren't on hrt but pass as well as those who are.
> This seems a quite dangerous way of thinking. New attacks, methods to attack crypto are discovered regularly.

He does actually address this counterargument in his paper. In fact most of his paper is a rebuttal to this argument (the status quo wisdom, so to speak).
Can you run graphical applications inside a BSD jail?
Ask HN: What to Study After Computer Science?
I am finishing my undergraduate in CS this month and was asking myself, what to study after that. I don’t want to study just CS again (Master). I’d like to study a field which could benefit the most from a fresh perspective of a CS Student. Biology? Neuroscience? Philosophy?
Way Cooler Post Mortem (Rust Window Manager)
Hacker defaces some Iranian gov sites and puts victims names there as memorial
Nice visualization, but the algorithm doesn't seem quite right: given the following map (don't have a good way of sending a screenshot, sorry), it goes above and around rather than below:

XX
S XE
X
It’s Gatsby with (I think) a custom-made theme.
My understanding is that there will never be a consumer-facing browser called "Servo." Instead, pieces of Servo will get merged into Firefox as they become production-ready (this has already begun). Presumably, eventually everything will be merged in and Servo will stop existing as a separate project.
GNOME has "GNOME Web", previously known as Epiphany.

KDE has "Falkon".

Both are quite good.
24/7 support by phone or email.
Are you saying congress voting on legislation is akin to a corporation voting on members of Congress?
This is some lousy prose for writing about writing
Correct url: https://crates.io/crates/thrussh
Building a working RC drone out of Lego
> If someone spends a week or two writing a patch and you come in and rewrite it in an evening, that, in and of itself, is telling me...

Or, what it might be telling you is the second person wouldn't have been able to clean it up in an evening without the first person having already spent a week or two on it. The second person was building on the first. Just because it was (hypothetically) less lines of code doesn't mean it could have been written without starting with the more lines of code and refactoring; it often takes more time/steps to get to fewer lines of code.

But don't get me wrong, I'm in favor of colleagues discussing code, not just changing each other's code without discussing it.
Non-rolling releases might work with smaller software where your distro maintainers can backport security bugfixes easily, but as soon as your software gets too big and complicated the distro maintainers won't be able to backport fixes themselves and will have to just resort to packaging the latest version of certain packages (like Debian had to do with Chromium and Firefox).

Also, for the most part, the "Arch is unstable" thing hasn't been true for a long time. I find that it's far more stable than Debian or Ubuntu LTS on my machine because of newer kernels containing newer hardware drivers.
The Planty Cube Aims to Make Vertical Farming More Modular and Automated
Cafe X shuts some of its robot coffee shops
From looking at the commit history of Pale Moon, it is maintained by essentially three people. Their maintenance strategy is to freeze at an old version of Firefox, and randomly backport patches purely to try to keep somewhat up-to-date on JS or DOM features. Given the sheer size of the codebase, its inherent complexity (a JIT compiler is going to be very ripe for potential security vulnerabilities), and the utter lack of any sign of trying to mitigate these problems (e.g., fuzzing, or even merely attempting to identify security fixes in Firefox that may warrant backporting), if you are worried about any security issues in Firefox, moving to such a fork should only worry you more.
Zume Reportedly Lays Off 80% of Staff
> except now it has actually been true for years

Sure it is true. It isn't a tech journo writing a quick piece to get some clicks. I am quite cynical these days.

There hasn't been any competition in the Desktop CPU space for years until 2019.

Also clock rates haven't increased since the mid-2000s (there were 5ghz P4 chips). Clock rates being an indication of speed stopped being a thing back then when I could buy a "slower" clocked Athlon XP chip that was comparable to a P4 with a faster clock.

Also more stuff is getting offloaded from the CPU to custom chips (usually the GPU).

> We need developers who understand these new low level details as much now as we needed that kind of developer in the past.

I suspect that there will get better compiler and languages. I work with .NET stuff and the performance increase from a rewrite to .NET core is ridiculous.
Failjure: Exception-free error handling for Clojure (2016)
You can check the status for the firefox package in Fedora at https://admin.fedoraproject.org/updates/ which shows firefox-72.0.1-1.fc30 as "testing" (that is, you can install through "yum --enablerepo=updates-testing update firefox"). The reason for it not being promoted to stable yet is, according to that page, "disabling automatic push to stable due to negative karma" - that is, the update was marked as broken by a couple of people.
Its due to this:
https://github.com/ssaric/algoviz/blob/012c60acb2fa452ee5a3c...
Currently heuristics is hardcoded to be greedy. I am looking to change this in next few days
A friend of mine just says "Understood." I find this to be the best method that I have heard so far.
It looks like drip irrigation. It is more efficient, especially in arid climates.
The sign of a junior is someone who refers to hand wavy design principles rather than getting to the heart of the problem.

This is the real issue which the author completely glosses over:

https://news.ycombinator.com/item?id=22023568
Good clarification! Thanks! I didn't read that one, although, I generally like Rober Martin, I really don't like when language figures go too far.

If pushed one bit too far it becomes propaganda in a culture war instead of a healthy intellectual honest discussion. What we know as flamewars is an example of that.
Specifically for this issue, linters also have many false positives. Some Go libraries trying to encourage a fluent style will accept an error for some logic also return it, so you can `return x.HandleError(err)` - but if you don't want to return it, you obviously don't care it returns what you just passed it. (I personally consider fluent methods a bad idiom in Go, but I also don't get to write all the Go code in the world or even in my project.)

There are also a lot of functions that return errors because Go's type system demands that if the interface returns two values `T, error`, every implementation must also - it won't auto-create a nil value for the second result. That's reasonable if you are committed to errors just being normal values. But such a restriction would not be necessary if the interface could be declared with a sum type - promotion of a `T` to a `Either<T, ...>` or `Just T` or so on would be fine for all types, not just error handling . Lots of infallible Writer implementations like bytes.Buffer and hash.Hasher suffer from this, and linters can't be aware of all such cases.
Several times, several different accounts.

Fortunately Google is (or more accurately, was) simply a convenience for me.

I have not yet fully deactivated the several Gmail accounts I have still standing, though those are largely inactive, and most are strictly associated with specific nyms I'd created (one notably after a primary nym account was suspended).

The best way to avoid having your Google account be suspended is to not have one.

But moving to self-hosting, or increasingly, entirely offline, has been a goal and project of the past few years.

I touch a few Google services directly:

- Google Scholar: still amongst the best academic search engines I'm aware of.

- Google Ngram Viewer and Google Trends: quite useful for tracking concepts over time.

- Google Maps: There are times OpenStreetMap's search simply falls down even when specifying lat/lon coordinates directly, Because Reasons. Google Maps is my fallback, but I still rely on it far more than I'd care to.

- Gmail: Secondary for several accounts.

- YouTube: still the largest online video hosting service, though alternative interfaces (https://invidio.us/) and alternate hosts (both centralised and federated or self-hosted) are increasingly viable. YouTube's UI tweaks and aggressive pre-roll ads over the past several months have been aggressively user-unfriendly.

- Google Web Search. A very distant second to DuckDuckGo, but still necessary for 1) date-bounded search, 2) getting overall counts of results (occasionally useful), and 3) rare edge-cases where DDG doesn't turn up expected/desired results (GWS is ~50% successful here).

I don't know if it's because I rely so heavily on DDG that I'm influencing its results, but I find that both searches and content that I've posted tends to turn up high-ranked on it. I'm not as aware of this with Google.
I've set up the app in a way that I am sending "steps" from the worker. That way I can describe each step textually. I'll post updates here probably!
I tried to search on their site but it didn't work out (I block JS, couldn't figure out which set of whitelist selection would make search work w/o enabling tracking. Derp NPR, derp.)
Abbreviation for Homotopy Type: https://homotopytypetheory.org/book/
There are real problems with IL compatibility. There’s a reason F# doesn’t have ML functors.
It can be harder to understand; but, even worse, it can also be harder to change.

Which is a bit ironic, because if you asked one of us to explain why we "DRY", we'd probably say something about it making the code easier to change, because a change only needs to happen in one place.

The problem is that whenever you make abstractions, you necessarily limit your axes of flexibility, abstractions always have certain sorts of uses in mind, and built-in implicit limits. Abstractions make certain explicit things easier to change, while making all sorts of implicit things you haven't even thought of yet -- but which might come up later -- harder to change.

Still, obviously of course sometimes abstractions and DRY are the right thing to do. The trick is knowing which is which, which you get better at with experience at software in general as well as the specific domain -- and I'm not sure it can be systematized or formalized, I think it's still a craft.
It would be a lot more economical to just end-of-life the ISS.

The ISS is a vampire on science funding, and I can't think of a single important scientific paper from it, in contrast to hundreds from the Hubble and WMAP.
> So mass immigration can clearly change society for the worse outside of simply economic and population density reasons.

But it can also change for the better.

His point is that culture is not fixed and immutable. Whether it changes for better or worse depends on circumstances.
No, but I'm definitely paranoid about it. The difference is if any other service I rely on this heavily had a major issue, I could hop on the phone and get it fixed in a day.

Google doesn't do customer support, which is fine for maps or search where I can just hop and nothing matters, but I'm starting to think it's too big of a risk for my primary email/calendar/contacts.
Thank you for appreciating my kind, substantiative and thoughtful disagreement.
It took me a while to realize I was basically reading a really long advertisement that wasn't even intended for me. There should be little flags on stories that indicate it's basically a junket for someone's start-up.
The existence and popularity of homebrew, macports and fink (on mac) and ninite, chocolatey, cygwin, mingw and nuget (on windows) would suggest that the concept appeals to mac and windows users also.
If the change is so small, I don't see why they wouldn't be able to backport the fix? Don't upgrade firefox (and any dependencies), just fix the bug.

It would be a lot harder if the actual fix was more complicated and a much more complicated diff. Possible that master has diverged sufficiently from their version that backporting the fix would be unreasonable.
Some times, there's one feature that's so useful it justifies the lack of many others. Google Docs is a terrible word processor compared to Word or even Pages, but being able to edit a document at the same time as someone else (with full features and little friction—IIRC Pages doesn't support Track Changes while collaborating) is so useful that I end up using Google Docs anyway.
This seems to be exactly what the Unison language [1] tries to do.

I actually have been thinking about how the concept could be implemented for Rust.

[1] https://news.ycombinator.com/item?id=22009912
This seems more like a post-hoc justification than any real rationale for change. There's nothing stopping your new code from introducing new testing requirements that weren't needed for the original code and it sounds like for 1) it could be equally a case of you blaming another developer when its actually 3) that occurred.

This also assumes that everything is actually testable, sometimes you write unclean code because the underlying framework or module you're working with has an entirely separate issue that you have to work around. Which again, might not show up because your work around code sidesteps the underlying issues.

This all boils down to the fact that you should just talk to the developer and see what they had in mind rather than assuming that you're right and they're wrong by rewriting it yourself.
What other theoretical quantum design?

AES256 is considered quantum proof because grover's algorithm can in theory basically half they key size, and aes128 is secure on normal computers [we are still very very very very far away from a quantum computer that can use grover's algorithm to bruteforce aes128].

I'm not an expert on the subject but i believe a new quantum algorithm that could break aes256 would be a very major breakthrough in designing quantum algorithms.
When in doubt refer to authority over logic. Authority wins every time.
What sort of waste you tend to see more, if you do this regularly? Is it the case that people are aware of the cost and “don’t care”, or is it surprising/hidden cost?
I was struggling to find a concise summary of the debate between R7RS vs R6RS earlier this year. This article was the best I found to that end.
When it comes to the Human Organism and Medicine, in spite of all our advances, things are quite complex, interrelated and not fully understood. While there is a lot of "woo woo" in Traditional Eastern Medicine against which we must guard ourselves, there is still a lot of empirical evidence for it though we may not subscribe to the explanatory models behind them. This is why people/hospitals are trying to introduce the reasonably well understood parts of Yoga, TCM, Ayurveda, Meditation into a more holistic approach towards well being.

The point is not to fixate on some well known negatives but take a deeper look at what has worked over the ages and employ them for good effect regardless of the theoretical models claimed for them.
That guy's so used to services failing him that he doesn't use his real name unless necessary.
Always look where they don't want you to look. Something Newton knew and was careful to hide in his time.
>To me, this post didn’t age well. From what I recall, entrepreneurship is at something like a 50 year low in the US.

How does this conclusion follow from the factoid? The post is about not shunning(/shaming/boasting against) plain programmers (compared to founders), not about entrepreneurship in itself.

>From a different angle, Paul Graham to me always has evangelized over much else the virtue of freedom over schedule.

If developers actually followed his advice, he wouldn't have a rooster of companies to fund, since there would be no company larger than its 2-3 founders.
Just remove the "100 *" and it should be optimal.
As I mentioned downthread, surprisingly little stuff breaks by accident nowadays on Arch (on my desktop, zero breakage in the last year with a fairly complex stack; on one server machine I had one strange interaction between a language package manager and pacman that ended up being my fault). The "slow but dependable" solution ends up breaking as soon as software becomes too complex for maintainers to be able to backport security fixes onto old versions, so they just ship the latest version of those packages, negating the dependability aspect (like Debian's treatment of Firefox and Chromium).
I strongly disagree. In science, an every-increasing number of ideas are, for all intents and purposes, totally accepted and taken for granted, and any argument they might be wrong is simply dismissed out of hand. For instance, take the idea that the Earth is round, or that matter is composed of atoms.

Now it is true that scientists sometimes say something similar to your claim, but if you look at how they actually think in the practice of science, it is something quite different.

People get this wrong because, like many words, "prove" has more than one meaning, and they mistakenly apply one that is appropriate to mathematics or pure logical to an empirical area where a more pragmatic meaning actually applies.
but in college!
Distributions can make their own choices about versioning if upstreams "break" semver. Sometimes this results in weird version strings and you might not want to depend on these relabeled system packages for your own projects - that's the one case where "vendoring" a dependency version might be worthwhile. But it ought to be quite rare indeed.
Unified view of financial metrics of public companies
Which is neither here nor there as to the worth of their blogging at the period (or that which followed).
Me too. Especially as combined with fat binaries in the OS X rosetta years. It'd make it a lot easier to package something that would run on arm, arm64 and amd64 in a more accessible way for users.
Lyft just avoids operating in the city at all?
Sewage in Washington, DC gets treated to such a degree that the remaining “biosolids” are sold as a soil conditioner/fertilizer:

https://bloomsoil.com/about-bloom-soil-amendment/

They also generate 8MW of electricity from burning the methane produced during treatment, which is about a third of their electricity requirement.
Nye 2020 Australia Geelong
>the important thing is not to tie your self-worth to what others think or say.

That's half of what's important. The other half is to not tie your self-worth to your own estimation of your importance either.
Here's how it sounds if worded more frankly: "Paris sucks. The transport sucks, bathrooms suck, food sucks, everyone's rude, and there's lots of immigrants."
Researchers: Are we on the cusp of an ‘AI winter’?
Simple Calculator Using ClojureScript with Reagent
>I can only hope to one day write something so provocative that 12 years later people are still getting rankled by it.

That's not something to admire and doesn't take much of an effort either.

A bigoted racist remark, for example, will do just as well...
If it really can't ever be null, then it should just be an int, not an Optional<int>. The entire reason that it is an Optional<int> is that it CAN be null.

In this hypothetical language, not initializing an int is a compiler error, assigning null to an int is a compiler error, etc. If it's an int it literally cannot be null.

What ends up happening in practice is that the null is handled close to where it's created, and the rest of the code passes around an int you know isn't null, because people don't feel like passing around an Optional<int> and being forced to check it everywhere.

Sure, you can intentionally write code that does the wrong thing in any language, but the "return 0;" would be a very obvious error in even cursory code review.
It's perhaps coincidental, but I don't remember ever having a trouble on an update that I couldn't find a quick fix for in the Archlinux homepage.

In my opinion, the reason why Archlinux can be so dependable is that packaging is based on really simple ideas, like not starting or stopping services on installation like Ubuntu would, and that most if not all system files belong to a package. The package manager can do a whole OS installation just by installing the basic packages on a directory different from /. The package format is also really simple. Getting into the guts of Archlinux packaging is really approachable and that makes me feel at ease for whatever trouble I may find myself in.