Comment by alexashka | Hacker News Reader

Comment by alexashka | Hacker News Reader

Where is the side to side comparison of features and to-do between this and existing distributed actor implementations, such as erlang + otp or java and whatever thing it uses?

This approach of ignoring the rest of the world and explaining Swift concepts as if they exist in a vacuum is frustrating and counter-productive.

Even if this were a totally new feature, I'd expect links to research papers.

It is one thing to present end users with 'shiny new iphone' every year. It is another to treat developers like idiots and have every swift related announcement be this sales pitch of 'great new feature' when in reality they are all features other languages have had for decades (and are thus mature, while Swift is always half-baked and full of gotchas) and this is yet another re-implementation of what already exists with undocumented arbitrary differences that people then have to spend time to figure out (aka free beta test) when I'm sure the people who implement this stuff (hopefully) know full well what trade-offs they are making.

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.

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.

> 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.

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.

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.

> Orleans for dotnet

Also Akka for .NET and my echo-process library

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

> 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.

Reply on news.ycombinator.com