It's not clear this is any different from just bombing random locations, but we're certainly already at the bad place. By the numbers Israel certainly seems incredibly bad at precision bombing, possibly the worst state ever to do it, for a state that is allegedly trying to.
You mean the best. Hamas have an explicit policy of using human shields. It's damn impressive to get so low number of casualties in such an environment.
It's more accurate to say that Hamas are members of the population that is being ethnically cleansed.
Saying Hamas uses human shields is like saying that the IDF uses human shields because they embed themselves into the civilian populations of Israel and of Washington, DC.
Look, I detest Hamas but it’s really hard to look at entire cities’ worth of dead Palestinian civilians and a forced population movement of millions of people and say that “investigated by the IDF” is doing much. This is a long, brutal war and neither side is covering themselves in glory.
I’ve supported Israel’s right to secure itself for decades but this campaign has made me question the moral aspects more than anything else because they’ve been more willing to take the kind of collateral damage Hamas does, not be better, and that seems self-destructive for both the international consequences and the near-certainty that many young Palestinians, who until 2023 did not like Hamas much, have fresh grievances to fuel a desire for revenge.
The only grievance they ever needed was their anger that Islam does not cover the entire Earth. Or their grievance that Hindus or Jews exist.
But yea, I agree that Israel can't win this one. The west are squeamish about civilians and Hamas forces civilians to die. And Israel is placed inside what is a genocidal anti-semitic part of the world. It's just a bad place to place the state. Kinda like trying to start a Jewish state inside 1933 Germany. Even with a strong army, it's a very bad idea.
"The use of civilians as human shields is not novel.8 Evidence of the
practice dates back to the American Civil War9 and the Second World War.10
The practice has also been documented in the Korean Conflict and the Vietnam
War. 11 United Nations (U.N.) peacekeeping forces similarly faced attacks from
weapon systems placed within civilian areas or hostile forces that used civilians
as human shields, for example, in Beirut in the early 1980s and Somalia in the
early 1990s.12 The human shields tactic was also employed by Saddam
Hussein’s Iraq in many of its conflicts.13"
Did people say the same thing about radar technology 80 years ago, though? a new tech that filters through data to infer a possible combatant location... seems like the same abstraction, to be honest.
80 years ago we were intentionally firebombing European civilian populations. I don't think it's a comparable situation. Israel has no justification for engaging in total war tactics (or rather, the justification is contemptible and holds no water).
The system names of “the Gospel” and “Lavender” I find very offensive as a Christian and they are very intentional. Orthodox Jews can be violently anti-Christian and will even spit on them to replicate the treatment of Jesus at his crucifixion, the naming is not coincidental, it’s to mock Christianity. The alliance between Zionists and Evangelicals is a very bizarre phenomenon.
The downvoting here (as well as comment scoring) is probably my least liked thing about the site. It exacerbates the already prominent issue of hivemind and seems to actively lower the quality of discussion. People seem to mostly vote based on emotional reaction. On paper, a downvote just doubles the value of a vote. Meanwhile the graying of comments that never deserved to be downvoted to begin with is infuriating and seems to mostly stifle interesting conversation.
Personally, I advocate for abolishing the downvote and the scoring and switching to randomized comment order.
I'd argue ranking comments per se isn't the issue, it's whether the culture is preserved that encourages useful application of the voting system. Whether any community can preserve their desired culture is arguably the most important factor and it's what the grandparent post is essentially referring to.
On HN the main goal of upranking is if one comment is more interesting/informative than another (or as a group test to see how robust its argument is if the voter has no experience to judge directly). Downranking ime isn't meant to be the method used shift the order of comments but rather to discourage a post that doesn't fit the HN culture/guidelines. OTOH most popular gamified discussion systems don't discourage use of reactionary downvoting, which can creep into other posting cultures.
The problem the grandparent post raises is if signals that voting users would ordinarily use to shape the continued posting culture (eg: downranking comments that don't fit in tone/substance) aren't used like they were intended to be and if the guidelines discourage meta discussion then there isn't any other avenue to inform users what the desired culture should be in practice.
Certainly one can post non-meta comments showing what type of comments one would like (and thankfully for most strictly tech topics here it's still reasonable) but if the culture shifts enough among the silent voting users then the concern is this erodes the quality of discussion as the signals for what is wanted/not wanted get skewed.
That's hardly isolated to this site. COVID did a number on us.
Fwiw, people have been saying this since the site started. Don't worry. There will always be a safe space for rich assholes to divorce themselves from reality and romanticize their exploitation.
Right, first thing I did after opening the article is CTRL-F'ing for conflict, and got zero result. How are they not talking about the only real problem about the local-first approach? The rest is just boiler plate code.
All this recent hype about sync engines and local first applications completely disregards conflict resolution. It's the reason why syncing isn't mainstream already and it isn't solved and arguably cannot be.
Imagine if git just on its own picked what to keep and what to throw away when there's a conflict. You fundamentally need the user to make the choice.
Zero (zerosync.dev) uses transactional conflict resolution, which is what our prior product Replicache and Reflect both used. It is very similar to what multiplayer games have done for decades.
It works really well and we and our customers have found it to be quite general.
It allows you to run an arbitrary transaction on the sever side to decide what to do in case of conflicts. It is the software equivalent of git asking the user what to do. Zero asks your code what to do.
But it asks it in the form of the question "please run the function named x with these inputs on the current backend db state". Which is a much more ergonomic way to ask it than "please do a 3-way merge between these three states".
Conflict resolution is not the reason why there has not been a general-purpose sync engine. None of our customers have ~ever complained about conflict resolution.
The reason there has not been a general-purpose sync engine is actually on the read side:
- Previous sync engines really want you to sync all data. This is impractical for most apps.
- Previous sync engines do not have practical approaches to permissions.
These problems are being solved in next generation of sync engines.
I think with good presence (being able to see what other users are doing) and an app that isn't used offline, conflicts are essentially not a problem. As long as whatever is resolving the conflicts resolves them in a way that doesn't break the app, e.g. making sure there aren't cycles in some multiplayer app with a tree datastructure. Sounds like Zero has the right idea here, I'll build something on it imminently to try it out.
"It is the software equivalent of git asking the user what to do. Zero asks your code what to do."
You are asking the dev what to do. You are _not_ asking the user what to do. This is akin of the git devs baking in a choice into git on what to keep in a merge conflict.
It's hard to trust you guys when you misrepresent like this. I thought long and hard on whether to respond confrontationally like this, but decided you really need to hear the push back on this.
> You are asking the dev what to do. You are _not_ asking the user what to do.
I get that your actual issue is you don't think that what we do is "the software equivalent of git asking the user what to do". But like, I also said what we do concretely in the same paragraph. It's not like I was trying to hide something. This is a metaphor for how to understand our approach to conflict resolution that works for most developers. Like all metaphors it is not perfect.
FWIW, there is nothing stopping a developer from having this function just save off a forked copy and ask the user what to do. Some developers do this.
Also FWIW, Zero does not allow offline writes specifically because we want to educate people how to properly handle conflicts before we do. I see down-thread this is the majority of your concern.
I assumed you were doing offline support yeah. I've heard a lot about local first development lately, so I guessed this what what you guys are tackling too.
Without offline support AND you're doing real time updating of data, then conflict resolution is not a real world practical concern. Users will be looking at the same data at the same time anyways, so they generally see what data won out in case of a conflict, as they are looking at real time data as they are editing.
IF you had offline support, and for other sync engines that do: There is a real and meaningful difference between a backend dev and an end user of the application choosing what to do in case of a conflict. A backend dev cannot make a general case algorithm that knows that two end users want to keep or throw away in a conflict, because this is completely situational - users could be doing whatever. And if you push the conflict resolution to the end users, then you are asking a lot of those users. They need to be technically inclined and motivated people in order to take the time to understand and resolve the conflict. Like with git users.
> Without offline support AND you're doing real time updating of data, then conflict resolution is not a real world practical concern.
I disagree with this. There are many real-world cases where keywise lww does the wrong thing. The article I linked up-thread covers many of them. Even a simple counter does the wrong thing.
This is where robust conflict resolution really matters in these systems, not the long-time offline case people often ask about.
You need robust conflict resolution to make correct software and maintain invariants in the face of write/write systems.
> A backend dev cannot make a general case algorithm that knows that two end users want to keep or throw away in a conflict, because this is completely situational - users could be doing whatever. And if you push the conflict resolution to the end users, then you are asking a lot of those users. They need to be technically inclined and motivated people in order to take the time to understand and resolve the conflict. Like with git users.
I agree completely. In my opinion the ideal offline-first write/write UI has never been built, but the team at Ink & Switch are closest:
I think the perfect UX in many cases is that syncs goes ahead and tries to land the offline writes, but the user has a history UI where they can see what happened. Like how many collaborative apps do today.
But importantly in this UI the app would represent branches and merges. But unlike Git's fine grained branch/merge points, in this UI it would literally represent points where people went offline and made changes.
Users could then go back and recover the version of their data from when they were offline, or compare (probably manually in two tabs) the two different versions of the data and recover.
This does still ask users to compare and resolve conflicts in the worst case, but it is not a blocking operation or one that is final. The more common case is the user will go ahead with the merge and sometimes find some corruption. They can always go back and see what went wrong after the fact and fix. This seems like the right tradeoff to me of making the common case (no conflict) easy and automatic but making the uncommon but scary case at least not dangerous.
There also needs to be clear first-class UX telling users that they're going offline and what will happen when they come online.
I'm looking forward to someday working on this, but it's not what our users ask about most often so we're just disabling offline writes for now.
No. When we started the project we used prolly trees initially, but we don't need the content addressing feature for Zero and all the hashing was quite expensive. So now we just use a plain immutable b-tree:
> All this recent hype about sync engines and local first applications completely disregards conflict resolution
The main concern of sync engines is precisely the conflict resolution! Everything else is simple in comparison.
The good news is that under some circumstances it is possible to solve conflicts without user intervention. The simplest example is a counter that can only be incremented.
More advanced data structures automatically solving conflicts exists, for example solving conflicts for strings exists, and those are good enough for a text editor.
I agree that there will be conflicts that are resolved in a way that yields non-sensical text, for example if there are 2 edits of the sentence "One cat":
One cat => Two cats
One cat => One dog
The resulting merge may be something like "Two cats dog".
Something else (the user, an LLM...) will then have to fix it.
But that's totally OK, because in practice this will happen extremely rarely, only when the user would have been offline for a long time. That user will be happy to have been able to work offline, largely compensating the fact that they have to proof read the text again.
This doesn't "solve" conflict resolution, it just picks one of the possible answers and then doesn't care whether it was the correct one or not.
It can be acceptable for some usecases, but not for others where you're still concerned about stuff that happens "extremely rately" and is not under your direct control.
> Something else (the user, an LLM...) will then have to fix it.
This assumes that user/llm knows the conflict was automatically solved and might need to be fixed, so the conflict is still there! You just made the manual part delayed and non-mandatory, but if you want correctness it will still have to be there.
> in practice this will happen extremely rarely, only when the user would have been offline for a long time.
I don't think it would happen "extremely rarely". Drops in connectivity happen a lot, especially on cellular connection and this can absolutely happen a lot for some applications. Especially when talking about "offline first" apps.
> All this recent hype about sync engines and local first applications completely disregards conflict resolution.
Not really true though. I've used a couple of local sync engines, one internally built and another one which is both commercial and now open source called PowerSync[1]. Conflict resolution is definitely on the agenda, and a developer is definitely going to be mindful of conflicts when designing the application.
My unfortunate point is that the dev cannot know what the user is doing, and so cannot in principle know what choice to make on behalf of the user in case of a conflict. This is not a code problem. It cannot be solved with code.
I've found that in almost all cases - the latest update "wins" strategy is fine. You could have two sessions working with conventional API calls and still have a conflict. As a dev you need to restrict what the user can do.
Very good point. The local-sync ecosystem is still in a young phase, and conflict resolution hasn't been tackled or solved yet. Most systems have a |last write wins" approach.
Ah, no. Not really. People sometimes think about conflict resolution as a problem that needs to be solved. But it’s not solvable, not really. It’s part of the domain, it’s not going anywhere, it’s irreducible complexity.
You _will_ have conflicts (because your app is distributed and there are concurrent writes). They will happen on semantic level, so only you (app developer) _will_ be able to solve them. Database (or any other magical tool) can’t do it for you.
Another misconception is that conflict resolution needs to be “solved” perfectly before any progress can be made. That is not true as well. You might have unhandled conflicts in your system and still have a working, useful, successful product. Conflicts might be rare, insignificant, or people (your users) will just correct for/work around them.
I am not saying “drop data on the floor”, of course, if you can help it. But try not to overthink it, either.
> But it’s not solvable, not really. It’s part of the domain, it’s not going anywhere, it’s irreducible complexity. You _will_ have conflicts (because your app is distributed and there are concurrent writes). [...] Another misconception is that conflict resolution needs to be “solved” perfectly before any progress can be made. That is not true as well. You might have unhandled conflicts in your system and still have a working, useful, successful product. Conflicts might be rare, insignificant, or people (your users) will just correct for/work around them.
I can't speak for whatever application-level problems you were trying to solve, but many problem-cases can be massaged into being conflict-free by adding constraints (or rather: discovering constraints inherent in the business-domain you can use). For example (and the best example, too) is to use an append-only logical model: then the synchronization problem reduces down to merge-sort. Another kind of constraint might be to simply disallow "edit" access to local data when working-offline (without a prior lock or lease being taken) but still allowing "create".
> Database (or any other magical tool) can’t do it for you.
Yes-and-no.
While I'm no fan of CORBA and COM+ (...or SOAP, or WS-OhGodMakeItStop), but being "enterprise-y" it meant they brought distributed-transactions to any application, and that includes RDBMS-mediated distributed transactions (let's agree, an RDBMS is in a far greater position to be a better canonical transaction-server than an application-server running in-front of it). For distributed systems needing transient distributed locks to prevent conflicts in the first place (so only used by interactive users in the same LAN, really) this worked just-as-well as a local-only solution - and make it fault-tolerant too.
...so it is unfortunate that with the (absolutely justified) back-to-basics approach with REST[1] that we lose built-in support for distributed transactions (even some of the more useful and legitimate parts of WebDAV (and so, piggy-backing on our web-servers' built-in support for WebDAV verbs) seem to be going-away) - this all raises the barrier-to-entry for doing distributed-transactions _right_, which means the next set of college-hires won't have been exposed to it, which means it won't be a standard expected feature in the next major internal application they'll write for your org, which means you'll either have a race-condition impacting a multi-billion-dollar business thing that no-one knows how to fix or more likely, just a crappy UX where you have to tell your users not to reload the page too quickly "just in case". Yes, I see advisories like that in the Zendesk pages of the next line-of-business SaaS you'll be voluntold to integrate into your org.
(I think today, the "best" way to handle distributed-locking between interactive-users in a web-app would necessitate using a ServiceWorker using WebRTC, SSE, or a highly-reliable WebSocket - which itself is a load of work right there - and don't forget to do all your JS feature-checks because eventually someone will try to use your app on an old Safari edition because they want to keep on using their vintage Mac) - or anyone using Incognito mode, _gah_.
GP was talking about modelling your problem. A hashmap is seldom a good model for a given problem. Typically they're "just" an implementation detail.
For example, in some cases it can be useful to consider triangles in a 3D model as cyclic graphs of vertices. The edges of the triangle correspond to the edges in the graph.
However I can't think of any case where it's useful to think of a triangle as a hashmap.
I feel the same way about letting a corporation control who can visit your site and when (CA TLS only). I personally tunnel to a VPS for browsing because my ISP, Comcast, will do MITM injections of javascript into HTTP pages. This notably used to break the Steam browser.
So the best solution is HTTP+HTTPS on the server and using HTTPS till it inevitably breaks (for legal, technical, social, or other reason), then the HTTP is there to keep things accessible. I'm not anti-HTTPS. I'm anti-HTTPS-only. And you should be too if you care about human persons over corporate use cases.
It's not cheaper. However, Coca-Cola does consume an enormous quantity of water and it is popular and it does drive the cost of water up. I'd prolly be pissed too if I were mexican.
It's not clear this is any different from just bombing random locations, but we're certainly already at the bad place. By the numbers Israel certainly seems incredibly bad at precision bombing, possibly the worst state ever to do it, for a state that is allegedly trying to.