I skimmed through the blog post, and it seems to me that they are not claiming they invented something new, just that they are adding this to Swift language.

(Distributed) actor model is nothing new, but I definitely wouldn't classify it as something that's common in other languages. To my knowledge Erlang/OTP is the only mainstream language where this is part of the standard library.

There are implementations for other languages, such as Akka for Java/Scala and Orleans for dotnet, but most languages (sadly) don't have a battle-tested implementation of this.

> most languages (sadly) don't have a battle-tested implementation of this.

I’d argue that this is because it’s a failed idea that conflates OO encapsulation, concurrency constraints, identity, serialization, and networking into a behemoth that does none of those things well.

> Orleans for dotnet

Also Akka for .NET and my echo-process library

[1] https://github.com/louthy/echo-process

They are adding features they 'took' to put it kindly from other existing, mature implementations without giving any credit or acknowledgement.

Not only that, they expect people to test their beta grade software because they keep releasing it half baked ever since the release of Swift itself.

It's embarrassing and it also angers me because these companies have wall gardened their ecosystems to proprietary languages and tools that all do the same thing poorly, differently and in ways that prevent sane cross platform development, on purpose, this being yet another apple-only 'thing'.

Here's Swift's roadmap: copy C# and other languages for the next 5 years while making sure you can't write cross platform code by adding arbitrary garbage like SwiftUI or this 'distributed actor' implementation that will surely differ and not be compatible with existing features of other languages and their tooling.

Gosu's roadmap... copy .NET and Groovy

Kotlin's roadmap... Copy Gosu and Groovy

Java's roadmap... Make Gosu, Groovy and Kotlin redundant by supporting the idioms of Gosu and Kotlin eventually and force those languages to 'nativize' their underlying implementations.

Manifold's roadmap... Ditch Gosu on the JVM and make a java library, copy all the stuff Java doesn't' have a plan for like .Net's (and by extension Gosu's) class extensions and java 8 to 9 workarounds

We could go on and on. Nothing new under the sun. Great minds think alike and at the end of the day the value of delivering a product is what matters in the end.

Ah yes, that's exactly what the slave owners said before the civil war - look at the product we are delivering, and everyone else's doing it too!

Their argument was so compelling that we decided to keep having slaves.

That might be the worst analogies I've ever heard. Humans extracting value asymmetrically out of captive humans has nothing to do with new syntactical features and/or sugar of other languages that language developers are inspired implement to implement in their own language because they solve modern workflow. And those developers are well compensated for for their contributions being by monetary, notoriety or self satisfactory means.

This blog post is an announcement for a wide audience. In the proposal[1], which gives detail on motivations and implementation, there is an "Acknowledgements & Prior Art" section that mentions Akka, Orleans, Erlang, and Elixir.

[1]: https://github.com/ktoso/swift-evolution/blob/distributed-re...

Ah yes, they acknowledge it in a sentence down on page 37 in a document only people paid by apple read top to bottom.

Thank you. That really changes things.

> without giving any credit or acknowledgement

You could be forgiven for not being familiar with the Actor model. But if you’re familiar with it, saying that isn’t recognition is bonkers. Everyone who knows what Actors are knows they’re referencing Erlang/OTP.

The model even predates that. It’s like one of the OG concurrency ideas IIRC.

The Actor Paradigm is much more widespread with offerings from Microsoft, Lightbend, etc.