skysight-inc/HackerNews huggingface dataset:
Funny. I was actually hoping that with python2 officially dying, after more than ten years there's finally a chance to re-join at least these two specific camps.
Now that managers will have to have good reasons to keep maintaining the language on their own or make the switch, I was hoping to see a more focused community with less "import * from six" overhead.
Part of the problem with visual programming in the "flow" style is the very fact that "branching" and "merging" has two internally-consistent, equally worthwhile but totally incompatible interpretations. Namely, parallel flow of data (known from "dataflow" diagrams; with parallel juxtaposition representing a product, the empty product standing for a unit flow, and a natural branching operation standing for "copy" or "clone") vs. divergent choice (known from "flowchart" diagrams; with parallel juxtaposition representing an alternative, the empty case standing for a zero flow, and a natural merging operation standing for a processing step that can be reached in multiple ways).

This ambiguity clearly does not exist with a pipeline-like, single-source/single-sink "flow", but it does arise as soon as one has multiple juxtaposed 'flows' in a single diagram or section of a diagram. I'm not aware of visual programming methodologies that try to handle both semantics with equal clarity, and without introducing significant confusion between them.
Are they really divided? Maybe if people only used one language. I would suspect that almost any Rust, Go, Swift, Dart, and Nim developer today is proficient in one, probably two other languages, at the least. I doubt that even 10% of "Rust programmers" are employed to write Rust full time.

What I might agree with is that interoperability is something that should be considered more going forward. I'm unsure about some of them, but Rust focuses a lot on interoperability via FFI, Go's FFI story is bad, as far as I know, Nim's is decent, and I don't knwo about Dart or Swift.

The top languages are all virtually identical. There's so little difference between, say, Java and Python, despite there being so much difference. So maybe there are 50 "serious" languages, but they all fall into a few buckets. There's less meaningful diversity than it seems, I think.
Nope. Just a Bay Area native who got into the local industry.
It’s worth highlighting that in the iOS ecosystem, Apple makes money on the hardware, apps, and in-app-purchases, with few exceptions.

On Android, Google makes money on the apps, and some in-app-purchases, but the OEM makes money on the device.

I think that, in addition to underlying architectural flaws, helps explain why OEMs are so disinterested in supporting phones for more than 1-2 years. LG only makes money when you upgrade, whereas Google and Apple make money every time you buy an app. It’s in LG’s interest to sell you a $300 phone every two years, whereas it may be in Apple’s interest to sell a $400 phone every 5 years and make up the difference on software and services, and hope enough people are enticed by the new shiny to upgrade more often.
PHP is still used by 78.2% of the internet according to some sources [1]. The death of any language or version is always greatly exaggerated. Maybe new projects aren’t being spun up with it, but many old projects never die and need ongoing maintenance. Until very recently the most recent project I was working on used python2.

1. https://w3techs.com/technologies/details/pl-php
It’s been on my mind lately and I’d be surprised if anyone else recognized these:

Information Leak

SoCal (ProBoards)

Too Smart Guys/PSP Hacking 101
digg.com. still exists, but it's not the same.
Really insightful comment.

It's true. C compilers are so optimized, the day of re-write in assembly have long passed for most of us.
I got an interesting broker email on March 23rd:

"Make sure you have a beneficiary on file"

perfect timing.
So just wait another 10 years and we'll get there for 3.5.
It's not a secret! Many media outlets and government officials have been very explicit about it: shutdowns are the only option for us, it's irresponsible to demand a date when they'll end, and it's very offensive to ask whether they're worth the cost.

I do share your confusion about why the media would say such things, but they are.
circa 1999 I was a big fan of Jakob Nielsen's books and website about web usability. The website he had back then had all sorts of advice around usability which I attribute, in part, to my success early in my career. I often wonder what he thinks of the web today with all of the design systems and frontend frameworks versus the simplicity of the 90s.
I don't agree with the article, but it throws an interesting question. What is poverty. Our poverty is dread. You don't have a job, because nobody wants to hire you, because you are useless. You cannot do the one thing everybody must absolutely do, so that they can do more things, the real things that bring joy.

And the world will tell you every minute every hour of the day, in a constant stream of products and lifestyle broadcast in every available medium. "This is where the fun is. You need _that_ to be happy. Come join the freedom and excitement."
Having multiple report formats is also obvious, but generally so from reading the spec, which addresses the subject. (-:
This is the Google/Alphabet that is infamous for no human customer support at all. If you ever mention coronavirus or related terms, expect the automatic ban with no way to argue for it.

I'm beginning to think that the Harry Potter was actually a dystopian novel. You must refer it like You-Know-The-Pathogen or The Pathogen That Must Not Be Named.
For a language it sure does open itself up to schoolboy humour like many other languages.

How are you? In esperanto is: Kiel vi fartas?

Which for the uninitiated trying to understand what was said and from an english speaking background, would probably yield a response of : Pardon me.

Not sure how other languages bases see this and it does seem to be more palatable towards french/spanish in how it sounds and may for those native speakers be easier to pick up I suspect.

Though I've never met a person who can speak esperanto, I've met many people who can speak Klingon. Which makes me wonder is there more people in the world that speak some Klingon than esperanto!
As long as when you're writing code, you're solving only immediate problems in a lightweight way, this is the way to go.

Most people, of course, overengineer. I remember being on a project where a guy wrote 5000 lines of code to put two columns in a specific browser.
That seems like a bit of a tangent for a page explaining that the talent works on Python 3 and not 2 now.
iOS Mail App Vulnerability
Because minority members of a congressional committee can't stop the majority members from getting things through. The Senate is R majority, thus so are the Senate committees, thus the Dems on that committee couldn't have stopped it.
So maybe rather than centrally planned economies, we should have centrally observed economies.
If your commits are clean and properly ordered, you won't need this.

And if they aren't, then you cannot rely on the diff because semantics may have changed in-between...
I saw somebody mention recently how we're closer to the Y2038 problem than we are to the Y2K problem, and that made me feel old.
https://m.youtube.com/watch?v=vK3WhJGg7PM
Careful. You can break the internet with a comment like that.
Geocities! And the olle Slashdot. Stuff that matters, news for nerds, or some such.
By the way: https://www.uchicagomedicine.org/forefront/coronavirus-disea...
In case someone else is also confused by this, it seems that instanceof checks whether the objects prototype matches, and these prototypes are not shared across different contexts, which iframes are [0]. (Though I would still like to know why it works like this.)

[0] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...
Not a lawyer but "need this money" seems reasonable to interpret as "you could not pay your employees if you didn't get this money". Which suggests VC-backed startups probably shouldn't have taken it and should return it.
ithell.com

As a relatively new IT admin, for a brief time it was a great forum for swapping war stories with others in my position.

The site is actually still up, but appears strangely frozen in time at around April of 2001.
Conlang Critic's episode on Esperanto is worth watching, if only for his criticism of Esperanto's phonology: https://www.youtube.com/watch?v=Sao9mCLy3Xo
Their meerkat mini NUC fully loaded. The fan hardly ever comes on.
Lots of gas stations violate this "legal prohibition". I suspect an enterprising lawyer could create inconveniences for the credit card firms, such that they'd have to purchase more horrible laws to keep the racket going.
Some optimisation can only be performed after the fact (in as much as profile of a real run against real data informs the branch prediction and choices in speculative execution and order)

Some execution fails: hardware has pathological instruction sequences which force sub optimal choices to be made.

Alternative algorithms cannot always be identified from an instruction sequence. What if a higher order function identifed better seeds and led to faster detection in a large field of candidate solutions?
Apple gave it one bump: https://www.theverge.com/circuitbreaker/2017/3/21/14998660/a...

Apple also lowered the price to $349 at some point in order to continue enticing new purchases, partially compensating for the lack of spec bumps.

But, I don't think a lack of spec bumps indicates they aren't serious about a given market. The iPhone SE appears to be a way to reuse the manufacturing and tooling that was developed for a given multigenerational style for a few more years, further amortizing the cost and providing a value-oriented phone for customers that want this.

If you watch some videos[0], you'll see that the original 2016 iPhone SE is still surprisingly usable in 2020, and it is rumored to get iOS 14 as its last major update.

If they were "not serious" about that market, the original iPhone SE would've been unusuable a year ago, with no clear upgrade path for its users, leading to user pain and confusion. This is not the case at all. Users got along just fine, and the new iPhone SE has launched with plenty of time to spare before things become either painful or unsupported.

[0] example of one video that shows how the new iPhone SE is measurably faster, but the old one is still perfectly usable: https://www.youtube.com/watch?v=KgwtGmyTDiY
I do not really understand your concern. What you say "duplication" is not harmful in any way, but a path towards progress.

A new programming language is like a new material. You can build chairs and tables in wood. But when a new metal is introduced, is it worth to "duplicate" the work and build chairs in the new material? Maybe, who knows. You may end up with a chair that has surprising new properties, impossible to have in wood. Or maybe it is worse in any measurable way, but some people may still prefer it for some reason. Would you complain to the discoverer of a new material that they should not build chairs in that material, because chairs are already solved (by using wood), and they are just losing time by reinventing the wheel?

Technology advances by the continued reinvention of the wheel. Rewriting old algorithms in new languages is a beautiful part of that.
https://www.worldatlas.com/articles/english-speaking-countri...
I am also curious about this. As I understand it, an immune individual could have any mathematical subset of antibodies from the base set, which is the collection of all proteins that can bind to something on the surface of a COVID-19 virion. Furthermore, I would think these base sets can change slightly for different mutations of the virus.

Perhaps humans tend to have enough random antibody generation that they are likely to start mass producing most of the protein shapes that are able to bind to the virus? And as another commenter pointed out, there are not that many options to bind to.
> This was the best way to do it.

Was it really though? Speaking as somebody who considered learning Python several times over the course of a decade I was seriously put off by the protracted uncertainty around 2 vs 3.

There was a long period - years long - where everything that "mattered" seemed to be supported by and available for Python 2 and there was a ton of FUD, along with genuine issues, about incompatibilities with Python 3. When I asked which version I should learn I felt like I couldn't get a straight answer.

I never had a strong need to learn Python: I just thought it might be a fun and useful thing to do, because people seemed to like the language. But I wasn't interested in investing time in something that might wind up unsupported in a few years, and because I didn't have any serious need for it, it wasn't worth digging through the morass of misinformation to get to the truth.

As an outsider it was extremely unclear to me which version of Python would be actively supported for the long term. 20:20 hindsight says 3 was the future but - and maybe this is just bad mar-comms - back then it seemed like there was a reasonable chance it was either going to be a dead end or exist perpetually in this weird no-mans-land of "not quite ready for prime time".

Had I learned it there's a good chance I probably would have used it for something more serious by now. But I didn't, and so I have to disagree: it was done extremely poorly.
Hardly any OEMs makes money on Android devices.

https://www.counterpointresearch.com/apple-continues-lead-gl...
I think you're making a very similar point to the comment you're replying to --- that "dead" really means stability; no more worrying about changes that make things stop working.

Personally, as a developer who has been working on software for a few decades, I've gotten increasingly irritated with the growing churn of platforms today and the astonishing waste of time for everyone who has to deal with it. It's hard to hit a moving target or build on a shaky foundation, but that's what the state of software seems to be today. Instead of platforms approaching stability and spending time on the actual problems at hand, countless developer hours are wasting solving problems created by others "pulling the rug out from under them".

I guess the younger generation of developers just hasn't felt enough of that pain yet, or they're overeager to try new things without thinking of the consequences. I've always taken the conservative approach and as a result some of the software I've written has needed little if any new attention in decades. Some utilities I wrote 25 years ago (not in Python, obviously), I still use regularly. "It's not the tool, it's how you use it."
I'm really interested in using this, I just can't seem to easily find the 33 currencies that are supported. Any chance you could clarify which ones?
and thus spoke C++.
Python3.8 is breaking things left and right because people are using the walrus operator and then realizing that users don't actually have python3.8 installed.

https://github.com/search?q=remove+%22walrus+operator%22&typ...
Also, how should we weight the validity of the data, given the political leadership issues surrounding this situation.
Slashdot was fun... But then somehow it stopped to be. Not sure even what happened.

Posting as user 1XXX :)
I'm a developer, but I'm also on-call 24/7 for a Node.js application. The number of people here saying "this is why you don't use dependencies" or "this is why you vendor your deps" is frustrating to see. No one _but no one_ who has managed complex enough systems will jump on the bandwagon of enterprise-ready, monolithic and supported over something like Node.js. I'd trade in my JavaScript for J2EE about as fast as I'd quit tech and move up into the mountains.

There are trade-offs, absolutely. Waiting on a vendor to fix a problem _for months_, while sending them hefty checks, is far inferior to waiting 3 hours on a Saturday for a fix, where the actual issue only effects new installations of a CLI tool used by developers, and can trivial be sidestepped. If anything, it's a chance to teach my developers about dep management!

I'm positive my stack includes `is-promise` about 10 times. And I have no problem with that. If you upgrade deps (or don't) in any language, and don't have robust testing in place, the sysadmin in me hates you - I've seen it in everything from Go to PHP. There is no silver bullet except pragmatism!
Isn't this what "utility libraries" like lodash and jQuery (each for their respective domains) are for?
Do you monetize the query stream to inform fourex investment decisions? What if they are adversarial to my intent? You profit from asymmetric knowledge.

If you detected you could leverage an advantage by lying about the rates, what constraints are there and how do we know?

Banks are highly regulated. What's your regulatory oversight.

Profitable information is hedged by conditions. Therefore beset by utility limits.
Show HN: Brew Diary – An Apple Watch application to track your brews
> If enough people say it’s dead and believe it in their heart, it makes it true.

except for COBOL, which has the Schrodingers' property of having been (called) dead for 40+ years, but also somehow powering the world and its' infrastructure.
Ytmnd.com
you could use interactive rebase for this
No. Not unless. You misunderstand what all cause mortality means. The state can count COVID19 deaths as all bungee-jumping related the number still shows up in the total death rate. If you know what is the usual statistic you can show if there is an effect.

This is what “dead is dead” mean. One can argue what should count as a COVID19 case, and how exactly we are counting. There is a lot less argument over who is dead and who is not.
My company technically could have paid our employees if we didn't take the money, but we'd have to cancel 90% of our R&D projects, slash operations, etc etc. So that still doesn't really mean anything, unless the intent was "if you literally could not make payroll after liquidating equipment / canceling all operational expenses," which I hope was not the case.
If not, try Moon, from 2009
When a programmer says "I want visual programming" I think it's often one of those situations where 1) the asker has correctly identified a pain point, but 2) the thing they are asking for isn't necessarily the right way to do it.

Instead of a box-and-lines diagram, I think the stuff that people really want is:

- Structured editing. Valid change operations are obvious (maybe listed in a menu). No invalid states.

- Cross-cutting connections are explicitly displayed (with lines or arrows or etc) instead of being implicit.

- UI does a better job of highlighting just the relevant information and hiding everything else.

- Overall more simplicity. As in, I think some people imagine that their thousand-lines-of-code project could be fully represented as a few boxes and lines with labels. There's some unrealistic expectations tied up in this area. But simplicity is still a good goal.

Those are all good goals and there's different approaches to solve them. A lot of those asks can be solved by keeping the text document interface and adding enough cleverness on top of that (like EVE / LightTable). And there's other visual systems other than boxes-and-lines. People just need to think outside the box. (ha ha, sorry)
I don’t really see how this is more of a direct advertisement than other Show HN posts and the service is free.
My first computer was a decommissioned CAD machine from my dad's work. A 12.5MHz 286. It also had two 5.25" drives in that configuration, but never thought why. Eventually installed a 1.44MB drive in place of the single density drive.
Because no one could ever be justified in moving to Python 3 for AsyncIO, f-strings, ordered dictionaries, assignment expressions, pathlib, new features in shutil/tempfile/subprocess/etc, along with massive improvements to memory consumption, runtime performance, and overall stablility?
There's a neat tool called crater (https://github.com/rust-lang/crater) for Rust. It can run an experiment across every Rust package (or every popular one), so you can e.g see if some theoretically breaking compiler change actually hits anyone. Something like that could be interesting for node packages as well.
It's also a thick interpreter and runtime system that will slowly rot away without maintenance.

I've never understood where this mentality comes from. I have programs 30+ years old, and still use them because they work perfectly fine.
I would much rather have the each question ask me to rate all my options on one aspect. I had to keep scrolling up and down to see what I said for other things to see where my answer fit in with what I said about that aspect for other options.

Btw, it tells me I should be using F#
When the 15 comes out, I’m buying.
DIY Oximeter
You might be right that that statistical estimate from a month ago was the source of the 20% number. I also can’t find any good follow-up sources.

I probably saw that factoid hyped up in multiple media stories which misconstrued the original paper.

If anyone knows of more reliable recent sources about this, it would be great to clear it up.
Old school quake 1/2/3 news portals! Those were fun. Classic example today would be https://www.quakeworld.nu/
The double blind part is very difficult, but at least they can have a randomized control group [1]. It doesn't sound very difficult.

Also, in most cases the control group get the "standard" treatment, because "do nothing" (taking literally the GP) is too bad. And you want to be sure that the new treatment is better than the "standard" treatment.

[1] A real randomized control group, not an unrelated bunch of guys in another city of France.
Level up CloudFormation with VS Code
Python 2 has been zombified!
I frequently make this point so I may sound like a broken record, but I believe this is more or less a fallacy.

Again, the point isn’t that better assembly couldn’t be written. It’s that it most likely wouldn't be significantly better than the compiler because all of the suggestions are things compilers would be doing anyways. There are some cases where this isn’t true, especially when dealing with vectorization, but those are mostly just exceptions (and intrinsics often offer easier ways to do such optimizations...)

But here’s the point that I feel is often ignored when it comes to programming language debates in general: just because you are experienced with and aware of advanced usages of the environment you’re programming in, does not mean the complexity and especially cognitive overhead of said complexity has disappeared. Looking at the C version, it doesn’t really look especially optimized, which is not really something that you would see in assembler, at least not in my opinion. Complexity adds up over time; abstractions are the antidote to that problem.

On top of that, assembly language is obviously not portable, which IMO is even more reason to use a high level language and drop to asm only when needed; you can easily swap implementations and have a fallback for architectures that aren’t specifically optimized.
Two questions:

1. How good is this test? Maybe people have no symptoms because the test is wrong?

2. Is there some reason prisoners would deny having symptoms even if they did?
The Other Kind of MMO
SEC. 2301. EMPLOYEE RETENTION CREDIT FOR EMPLOYERS SUBJECT TO CLOSURE DUE TO COVID–19.

see "(2) eligible employers" section"

https://www.congress.gov/bill/116th-congress/house-bill/748/...

good luck
In my country there are politicians declaring the 1.5 meter society 'the new normal'.
I'm not comparing functionality of Node and Python. They are different beasts. I was pointing out problems inherent with Python packaging, which you didn't even address in your fanboy rant.
> I can't comprehend how anybody could find this acceptable.

Because Linux is primarily funded by server companies, and servers are optimized almost exclusively for throughput?
Incredibly well done. Takes me back to my childhood. Seamless multiplayer experience as well, great job.