skysight-inc/HackerNews huggingface dataset:
“People’s behavior and negligence caused all this,” Michael Ginsberg, an attorney for RPI, told the Times Union. “Unfortunately, they wiped out 25 years of research.”

I agree. It was people's negligence: the researcher's. They weren't serious about protecting their stuff. They keept important samples in a broken freezer, without lab UPS equipment. They did not rush to get someone to repair the freezer immediately. Did not transfer to another freezer...did not have a backup freezer.

Blaming the janitor is the proffesional researcher equivalent of "the dog ate my homework".
I keep thinking that when my grandma's laptop gets too slow from all the Windows updates, I'll install some linux on it and teach her that so she doesn't have to keep learning how the new Windows works every time (because, indeed, the masses aren't switching). Won't have a problem with malware either. Cinnamon is 100% stable for me and very similar to Windows, that's going to be as much effort to learn as Windows 11 would be.

Now, if only I could convince my dad, he might allow me trying to put it on my mom's computer as well... he insists on buying Microsoft Office for everyone under his roof so that I don't have an excuse to install LibreOffice

Sometimes it seems like old-ish white men is why we can't have nice things (I'm gonna be one of those :/)
You seem to be laboring under the false impression that people can replicate a system perfectly just by having used it once upon a time.
This is a great request! We've been considering building out a managed auth flow and bank syncing, would love to chat for 15 minutes and learn from your use case. Does any of these times work for you this week https://calendly.com/letsfuse/fuse-demo-15, appreciate it!

In regards to coverage in the UK, we currently support Truelayer and we are building out a Tink and SaltEdge integration. They'll be available early next month.
I build game about Software Development Culture
If only this were true. ORMs have come up with some very subtle foot guns over the years.
Lightrail – AI-Powered IDE for React/Tailwind Apps
A vim plugin would be a nice enhancement to the OP.
France conducts maiden test of hypersonic glider
https://microservices.io/patterns/index.html has some patterns as well that aren't necessarily specific to a microservice architecture.
> you will eventually end up writing and maintaining one yourself

Only if you insist on formulating your logic based on "objects" instead of "rows"; see https://news.ycombinator.com/item?id=36498583
I was just exploring some Tablet PC on AE, and one of the sellers had posted a photo of how the tablet would be shipped - it would be without the box, directly wrapped with small-bubbles plastic wrap, then wrapped / placed inside a big-bubble plastic box-like wrap and then placed inside an envelope (obviously with a lot of tape)! Looks like they prefer and trust plastic over cardboard.
I had to use stockfish
Mini-split systems to the rescue.

Or, an attic system with high velocity air, but that’s big $$$
What would be good evidence of a high-quality user base with the relevant skills? A transparent, well-calibrated track record?
Indeed, my introduction to databases was extracting stuff using Perl's DBI and getting good at pushing the work out to the DB. When I was introduced to ORMs it was instantly clear that they were a game changer for MVC development.

I've transitioned a few legacy (large) Rails applications through Arel and often did not understand why we were putting the work in, other than to make it easier on new/future developers who did not understand SQL. In pretty much all of them we ended up having to keep some non-Arel queries -- you know, the ones where `STRAIGHT_JOIN` cuts 5 minutes off a query!
Came to post this comment and you beat me to it. I think it deserves an overdub with some very intense industrial techno or the Terminator theme.
SnarkOS: A decentralized operating system for zero-knowledge applications
totally. metal studs are widely used in commercial construction as well. you'll also see metal studs in finished basements instead of wood furring strips. they're used where they're a good fit, and if the region and conditions there support it.
We don’t have Sharia in Turkey and for countries that implement it, there’s leftover corruption and puppet govts from colonial era whose best interest is not exactly fully implementing Sharia. Those who do it (e.g. Afghanistan) are immediately sanctioned to poverty. There is 2+ billion muslims in the world and not everyone is religious. If we had Sharia here (we’re working towards it) those muslims would be subject to and benefit from the prohibition. We’re returning to the pre-colonial days of Islam though, see an analysis: https://muslimskeptic.com/2023/04/12/finally-admit-youth-rel...
I actually agree, lol
The NG has been produced since 1997 and there are essentially no pre-NG aircraft in Western service. The NEO is equivalent to the MAX.
> "élitist libertarians"

Why the e acute? "élitist" (used twice in TFA) is not a word in french. The word "élitiste", with an 'e' at the end, exists though. The english word is "elitist" if you ask me.
? B737 has been flying for nearly sixty years at this point.
sometimes ignorance is bliss - I'd prefer not to know the crashes by model and fly without thinking about the statistics
Nobody is responsible for a murder except the person who did the killing. And it must be so, otherwise we will go down the thoughtcrime path.
Oncall: Developer-friendly incident response with brilliant Slack integration
Probably, given how rare any fatality in commercial aviation is.
> fairly ordinary

I don't know if I'm just nostalgic for American homes, but that home looks striking to me. But I know what you mean.
The Poozeum – “#1 for fossilized #2”
Statements of the form "nobody is doing X" are almost universally incorrect. There are 8 billion people on this planet, you can almost certainly find an entire organization dedicated to whatever X you please.
Also see here:

people looking for still standing Sears houses

https://www.atlasobscura.com/articles/do-you-live-in-a-mailo...

Sears house sites https://www.searshouseseeker.com/2015/11/blogs-about-sears-h...

House database(s) http://www.sears-homes.com/2015/02/wheres-list.html?m=1

http://www.searsarchives.com/homes/enthusiasts.jsp
Also what if a twig gets in the wheel? Seems like it wouldn’t be able to fly then.
One of the three 777 accidents is being shot down by a Russian SAM.
Following this advice too closely and your application logic starts leaking into your data layer.

One simple example is when you need to make atomic changes to two different types of entities. In the data layer, this is usually trivial — just run two queries within a transaction — but you need to expose a function that boils down to `updateBothAandB`. Rinse and repeat enough times and your data layer is a soup of business logic.
And sometimes they fail mysteriously. They call it "rocket science" for a reason.

If you want a 95% probability of 90 days, you also get something like a (pulling numbers out of thin air) 75% probability of a year.
Maybe you don’t remember when Google started inserting its own maps at the top of location searches in place of the top-result: MapQuest. Probably a good 15 years ago.
I really struggle with this attitude that companies that make their code available, but don't do it "open enough", are therefore "BadCompanies".

Companies are not obligated to make their source code available (excl: copy-left, where they are).

Those that do, often choose to do so in a way that balances aiding a community, and growing their business.

That's a good thing IMO. Being commercially savvy, and ensuring the company that authors software today, will be here tomorrow, is good for the software, and therefore, for it's community.

I don't understand where the sense of entitlement comes from that it's OK to shame/berate/insult a company who publishes their source code, because of the restrictions they elected to impose.

Companies like Lago are small startups, who need to pay the staff to author the software. They also created a company to generate profits. Electing to do so under an Open Core model is a good thing - as we get Open Source software as a side-effect.

They have no obligation to do so under a permissive license. That they do so under any license should be celebrated, IMO.

> many new YC open core companies are doing this now.

Great! Long may this continue. Companies that are open-core are beneficial for everyone. Splitting hairs over the license they elect seems ungrateful IMO.
Absolutely, there are times where programmers try to do way too much in LINQ and don't realize that the query being generated to back up their chain of LINQ operations is a monstrosity of thousands of lines of SQL that will grind the server to a hault. Or the abstraction leaks badly due to the programmer using something EF doesn't know how to translate to SQL, so it ends up loading a much larger dataset and trying to complete the rest of the filtering in memory.

As developers get more acclimated to the .NET ecosystem they usually pick up a good spidey sense for what query "shapes" are appropriate to express in LINQ and which are asking for trouble.

However, for every one of those awful LINQ queries in a codebase, I think there are 40 to 50 run-of-the-mill queries that make it worthwhile. The biggest win that it delivers over a simpler, "stringier" ORM is the ability to return structured data. I have no problem writing SQL, but processing the results back out of flat rows into objects gets extremely annoying.

Say I want to load some Foos with their Bars. If I use straight SQL with a row mapper, I define a type to represent each FooBar row, load a List<FooBarRow> into memory from my simple left join, then I'll have to do a GroupBy in memory on that List to get the actual structure that I want: a list of Foos where each one has its own list of Bars. Notice that I also have to handle the empty-list case specially.

var fooBarRows = await connection.QueryAsync<FooBarRow>("select f.FooId, f.Name as FooName, b.BarId, b.Name as BarName from Foos f left join Bars b on b.FooId = f.FooId where whatever");
// re-shape result set manually from flat query results
var foos = fooBarRows
.GroupBy(fbr => fbr.FooId)
.Select(g => new Foo
{
FooId = g.Key,
FooName = g.First().Name,
Bars = g.First().BarId == null ? new List<Bar>() : g.Select(b => new Bar { BarId = b.BarId.Value, BarName = b.BarName }).ToList()
});

In EF it's just:

var foos = await db.Foos.Where(whatever).Include(f => f.Bars).ToListAsync();

Saving that clutter -- both the code and the otherwise useless intermediate FooBarRow type -- really adds up because the apps I write have a zillion queries very much like this.
So I'll take the occasional shitty query that has to be tracked down and optimized in exchange.
> Apple are experts are experts at creating these patterns that fall just at the edge of being classified as anti-consumer, to the point where you frequently find heated discussions about whether they are.

I argue that they are blatantly anti-consumer, but have created a brand identity association that causes people to pretend (and argue) they are not. Try using an ipad without handing over your credit card details. Even google is better in this area.
> Pulling metrics from your service is easy and simple. Pulling metrics from thousands and thousands of services, spread out over many clouds/regions/environments, puts a HUGE strain on the single pulling server. Especially if it then evaluates its list of rules for each pull, etc.

Oh god if you're trying to do that with a single pulling server you're doing something terribly wrong.

> But for pushing, if you don't get a message from service X in the last hour, is it down, or is it just not being used. So things like heartbeats intervals need to be configured, etc.

The inverse is true on this situation, if a server is attempting to accept traffic from thousands of services it's got the potential to get DOS'd pretty damn quick, and you can't even control that flow easily. At least from a pulling server you can dictate that on one host, or scale that out and aggregate in another layer. (Thanos/Cortex).

I'll always prefer pulling versus pushing because you gain more control and prevent yourself from blasting a server into space with a thousand calls it can't refuse.
Not currently.
Better visualization/viewability of what's happening again seems like the best thing. If we could have a uml diagram of the orm's model, then see the retrieval access patterns flowing across that model, the risks/badsides of ORMs would be much reduced. Making clear what's happening is as usual a win.
Yup, we use Alpine on all of our hypervisors, the init system has never been a problem :P
Yeah, our Swytch experience hasn't been completely seamless either, but it comes in at still like $1000 or more cheaper than an actual electric Brompton and with a higher speed limit so I still think it's better overall. I also found that getting rid of the cadence sensor and relying solely on the throttle made fore a more relaxing and confident experience. With the finicky pedal sensor you are always wondering if it will pick up your motion, which is a constant source of mild anxiety whereas the throttle is totally solid every time.
SQL is much more powerful than most people think, and taking an afternoon to learn everything you can do with it is a great investment.

After you do that, you will probably not WANT an ORM anymore, finding that it makes your code less readable than plain sql, not simpler.

Actually, you'll even realize that you may not need anything BUT sql to write your application, using something like (shameless plug) SQLPage [1]

[1] https://sql.ophir.dev
And that's how religions got spreaded over.
Also, I think as bread was taken as "sacred", at least in Christianism, I think that could be related to the fungus (or mold) in some cereal/bread such as ergotism releasing hallucinations and "visions" of virgins/daemons and so on.
My prior/current experiences with most ORMs are that developers feel like they need to know less about how a relational database functions than they should because they can focus on the abstraction. This leads to schema designs that aren't ideal or not understanding where it is efficient to perform an action (should this be filtered in the database or application, when does a query need to be optimized, where is caching happening, indexes?).

Great for initial productivity, but without monitoring, can run into some serious issues down the line. I've seen lambda expressions hitting ORM interfaces where it wasn't immediately obvious how much data was being grabbed, cached, and pulled back. Then when the database was moved just a few milliseconds further away (network hops) from the application server, it caused significant issues because of the number of round trips happening magnified that small latency increase.

This is ORM specific, but not all of them are great at handling transaction blocks. In such cases dropping into a database stored procedure may be ideal, but then again you are no longer using the ORM and having to take your object and do mapping into a different structure (the stored procedure).

My personal preference is for just enough quality of life tools around the database access. In Java land, jdbi for quality of life plus flywaydb for migration (written in raw SQL) is my current preference. jdbi fixes many basic mapping/binding issues JDBC doesn't handle and flywaydb provides a good foundation for keeping environments in a consistent state.
I would imagine for myriad financial, personal and most of all technological reasons (of which you would not know, as by your own admissions, “you have no idea” what it was).
I'm a little bit tired of the Bitter Lesson copypasta.

It doesn't seem to me like point 1 to 3 have been proven to be true about ConvNets. Sure, scaling convnets further help, I don't think anyone would argue that training a big model on more data would not at least see some improvement.

I also think there are irrefutable lower bounds of computation that it would be important to consider when building these meta-methods. If your problem requires N steps of computation for a problem of N size, but your method can only always perform at most K steps of computation, no amount of data or compute you throw at it will result in the right solution.
I'd point out that most of the foundational components of Docker's technology stack are FOSS (e.g. [0] [1]). Mutagen also has (and had, prior to acquisition) closed-source components and components licensed under non-OSI licenses (e.g. SSPL), so evaluate my response in that context (and also please note that these are my responses, and not representative of Docker's opinions/positions). Also, as mentioned in the acquisition FAQ [2], we don't have any plans to change the open-source licensing structure, and we're still open to contributions.

It's a delicate balance to strike, and almost more delicate to discuss. At the end of the day, an open source business is still a business, and you have to make money to eat, shelter, and continue writing code. I can certainly appreciate that there are different approaches to balancing that with open-source (e.g. consulting rather than close-sourcing), but so long as you're setting natural (non-contrived) boundaries between open-source and proprietary, then I don't think you're doing anything wrong. In fact, several companies were embedding and making money from Mutagen before I was, but that never really bothered me — that was the freedom I was affording them as users.

I have nothing but the utmost respect for user freedom and I've always strived to offer that with Mutagen (e.g. allowing people to disable components that might not fit the OSI definition of FOSS). I also have nothing but the utmost respect for the authors of open-source software; Mutagen stands on the shoulders of many different dependencies and I've always strived to ensure that we're acknowledging those in a manner that is compliant with their licensing requirements (or going above and beyond that).

In the end, it's a tough but fair question. I don't think my views have changed and I don't think there's any real incompatibility. It's a balance I'll necessarily continue to assess on a daily basis, both at Docker and in any other FOSS I write.

[0] https://github.com/docker

[1] https://github.com/moby

[2] https://www.docker.com/blog/mutagen-acquisition/#mutagen-faq
You said:

> The evaluated incidents include terrorist bombings

From the site:

> Excluded would be events where the only fatalities were to crew members, hijackers, saboteurs

The numbers in the "Events" column are not the same numbers as are on the linked Events page, if that makes sense.
Not a great take, I must say.

"They assume, falsely, that the only reasons why some would seek to understand how disinformation flows is to suppress information. Again, though, that’s not the intent of such research."

Over the years I've written a few essays about the problem of fraudulent research into misinformation, specifically social science papers that claim to track bots on Twitter and understand the misinformation they're spreading. There's an enormous literature that studies this topic with over 10,000 papers in it. I got interested in meta-research into these studies because I used to do anti-bot work for Google, but the problem was, every time I read one of these papers it turned out to be some sort of intellectual fraud.

I wrote about one of the more famous papers on my blog in 2017, which was later picked up and cited in a paper by Gallwitz & Kreil which studied the problem of meta-misinformation more rigorously. I summarized it here:

https://blog.plan99.net/fake-science-part-ii-bots-that-are-n...

Their paper can be summed up as "social science has engaged in a vast conspiracy-like effort to argue that the existence of a grand conspiracy to control social media [e.g. by Russians] justifies imposing controls on social media". Which isn't so far off the thing that the TechDirt article attacks, is it? So when Masnick says "that’s not the intent of such research" I wonder which papers he's been reading, because it sure seemed like the intent of a lot of the papers that are out there.

Why are academics publishing so many invalid papers? Speculatively, there seem to be a few reasons:

1. Such papers are easy to publish. If you throw around enough equations apparently you can bluff your way past peer reviewers and journal editors without having real results to report.

2. They want to believe. It feels smart to write about the false beliefs of the little people.

3. The authors are ideologically predisposed towards information control. These papers invariably argue for imposing strict speech controls justified by their "findings".

4. There's a lot of foundations and NGOs dishing out grant money for such findings. Journalists also lap it up, because it gives them ammo to argue that people should only get information from legacy media.
This is just brilliant, thank you!
What exactly is an American name?
The only one I gave experience with is SqlAlchemy (1.x). You certainly can do a query builder update and get current subsequent data out of ORM objects, but it’s really easy to mess up, at least in my experience.
ORMs are like any category of tool. Some are good. Some are bad. Either way, you need to master it (in additional to SQL) to get the most of out it.

These days, my approach is to start with some repository interface/abstraction that exposes well defined access patterns/operations and models. Then I hand code the implementation with just normal SQL that I hand code. You can get really far with this. Eventually, if it starts feeling unwieldy, I'll look at reimplementing it with an ORM. This rarely happens. In fact, its only really happened twice that I can think of.

That said, if I joined a team that was set on using a particular ORM and they had experience with it, I wouldn't think twice. The only thing that is a deal breaker for me is using any ORM feature like Hibernate's auto flush insanity (something that figures out which objects you've dirtied and automatically generates updates and inserts when you close the session). It will be very difficult to ever untangle that if you need to. Far better to explicitly have to persist things than rely on some auto-magic like that.
Cool, now try it with a knowledge field that isn't code that can be tested for the proper output.
> Giving them use of a platform makes Facebook complicit.

I don't understand this perspective. Johannes Gutenberg, inventor of the printing press, shouldn't be responsible for what folks print. Neither should Sir Tim Berners-Lee, inventor of the world wide web, be responsible for what people use the web for. Humans needs to accept personal reasonability and not blame their tools.
Tailscale gets pretty good performance using Wireguard in userspace, with some very clever use of the tun/tap device like supporting TCP segmentation offload. Does (or could) tinc use the same tricks?