akka-core

> The better question is why use Java for anything these days. Java (the language) is pretty much "C for the JVM." By that, I mean frameworks/libraries intended for maximum potential use in languages running on the JVM (such as Kotlin, Scala, and of course Java) all support Java (the language) interoperability. Many written in alternate languages targeting the JVM, such as Akka[0], typically have some degree of Java (the language) support as well. While I prefer to program in one of the alternate programming languages targeting the JVM, I understand why many OSS projects are implemented in Java (the language) for the reasons outlined above. 0 - https://github.com/akka/akka

Recently Akka [0], a 12K star project. [0]: https://github.com/akka/akka/pull/31561

In the open source world, Akka, the most popular actor system library in the JVM ecosystem, that’s heavily used in tonnes of open source projects, recently went from “free and open source” to “paid/proprietary and source available.” https://github.com/akka/akka/pull/31561 Same strategy - the pricing is insanely high (for a library), and the project is effectively dead now, but it’ll take some larger enterprises awhile to move away from. I find it especially sleazy due to the nature of transitive dependencies in open source. For example, somebody creates a popular open source lib out of their own sense of good will, let’s call it “Foo lib.” It depends on Akka, all is fine for years, then all of the sudden Typelevel (Akka maintainers) say “physche, Akka is proprietary now, Foo lib users now owe us $$$.” Gross.

> So Amazon can take free code, sell it as a slickly-packaged service, and not need to share anything. Right, because they didn't change it. So what would there be to share anyway? 'Go to https://github.com/akka/akka'? > but it does mean that at least every user has access to the code to make their "Akka Service" as good as Amazon's. That code is meaningless. In this scenario we already established that Amazon is selling an unmodified copy of Akka as a Service (which, by the way, we will revisit this point later). And we already established, in your own words, that it's not about the code: > Their secret sauce is "we have a Borg Cube's worth of datacenters, so we can run the same code as you at a lower price". So what would the SSPL require, they publish their deployment scripts to their cloud datacentres? Like I said, that's meaningless.

Here is Akka's dependency specification: https://github.com/akka/akka/blob/main/project/Dependencies.... How many of these would have to opt for this source available approach before Akka would no longer be sustainable?

Do you mean actors? I kinda hate how they’re always referred to as processes. https://github.com/actix/actix https://github.com/akka/akka

Just off the top of my head, there are .NET copies of: - Akka https://github.com/akka/akka - Lucene https://github.com/apache/lucene-solr - Aeron https://github.com/real-logic/aeron - Retrofit https://github.com/square/retrofit Not to mention projects like Apache Spark, Cassandra, Elasticsearch, Druid - Java projects. Many projects (Foundation DB, Scylla DB, I could find more) will have in-house support for Java and not .NET. The .NET equivalents to these libraries tend to be playing catch up. Xamarin Android will always be playing catch-up to Android's Java/Kotlin APIs for Android. Big machine learning projects like PyTorch and TensorFlow tend to give first-class support of some fashion to a Java API (mostly due to Android). Is there a .NET equivalent to Deeplearning4j? Hadoop? Hive? Kakfa? In Java there is a proliferation of web project

I found the Akka source code to be very clean and readable: https://github.com/akka/akka

What is the closest (conceptual) analogue for this model: - https://github.com/jodal/pykka (Python) - https://github.com/quantmind/pulsar (Python) - https://github.com/akka/akka (Java) - https://github.com/eclipse-vertx/vert.x (Java) - etc.

https://xkcd.com/386/ Disclaimer: I am an akka and akka-http community contributor. I don't know how this works for other projects. But I don't think the process is as painful as you describe in the akka world. My experiences are quite to the contrary. The community here is warm and welcoming. But, please look at this from the other side. Would you use the software in your mission critical application if the project was accepting quickly contributions from random strangers on the internets? Please, find an issue marked as community in https://github.com/akka/akka/issues or https://github.com/akka/akka-http/issues and give it a go. How to solve the "credentialize yourself" problem? Be known to the commiters by first working on a docs issue.

Exactly. Though I'd add that its not just the financial space that is doing this for performance. Lots of people that are trying to scale high throughput systems use unsafe for similar reasons: Akka for instance uses it: https://github.com/akka/akka/blob/0de9f0ff40fc5e43540df58718...

That's their plan for Akka 3.0. I believe this is the current status: https://github.com/akka/akka/pull/16665

Good point. Though implicits I feel are so much simpler than many people fear. From a Ruby perspective: Just think of them as operating similarly to Refinements, except not completely insane because there is no global scope at compilation. You only have to worry about your own package, imports and inheritance. Tracking down an implicit generally takes all of 10 seconds, and never more than a few minutes. Even moderately brain-bendy ones like akka.patterns.ask (where does the implicit "?" come from? "ask" is actually an implicit conversion to a class that defines it: https://github.com/akka/akka/blob/master/akka-actor/src/main...).