I don't think that's a fair representation. Like for any community, you tend to hear the most about a vocal minority, and drama there was, indeed. That's not unique to Scala, that doesn't mean that a majority was engaged in it or was affected by it.

The point about fragmentation holds, though: Scala is a multi-paradigm language, so you tend to have communities assembling around core set of libraries and abstractions that fit their specific needs. It's not a bad thing from an engineering perspective (you get to pick the most adequate tool for the job), but it will be intimidating at first, and understandably ridiculous when coming from a different ecosystem that you've a choice of a dozen or so JSON deserializing libraries. https://index.scala-lang.org/ Is a great help, though.

I mean, the elephant in the room is the blatant licence violations orchestrated by LLM vendors. If your codebase is GPLed and serves to feed a LLM, it should extend to all the code produced by that LLM.

For decades, the FOSS community has been at each others throats about those licenses, and now that we contemplate the largest IP theft/reappropriation of all time, it's like, not big a deal. I can't tell that I'm a prolific OSS contributor, but enough to understand the sentiment: "I put code in the open to help humanity, not to make oligarchs better off with a newfound mandate to pollute".

Telegram never was private, group chats never were encrypted (and that's not an opinion: the feature simply is missing). If anything, they are just removing their false and deceiving claims. That they remained there for so long is something I can't wrap my head around.

If you are curious, you should give XMPP a shot, it's equivalent to Signal in terms of encryption, but anyone can host their own. Signal is ideologically opposed to anyone but themselves being in control of your account, and because of that I don't want to trust them.

A more accurate title could be "Privacy is Priceless, but Centralization is Expensive": with the era of cheap money coming to an end, grows a lot of uncertainty regarding the future of some large internet services. Signal is no exception and this emphasises the importance of federated alternatives (XMPP, fediverse, …) for the good health of the future internet.

😂

A truly better signal is one that's not using a centralized service.

People don't choose, people use whatever most people around them use. Whatsapp and telegram are both centralized, and shouldn't be trusted because, by the nature of it, they can (and eventually will) turn user-hostile.

Messengers come and go, if we really want to make some progress in this area, we should embrace federated and p2p protocols as the logical evolution. Anything else is just wasting time and user privacy.

Or, you know, just use key auth only and fail2ban. Putting sshd behind another port only buys you a little time.

That's absolutely true in the physical sense, but in the "commercial"/practical sense, most respectable companies' QA process would shave off a large part of that first bathtub slope through testing and good quality practices. Not everything off of the assembly line is meant to make it into a boxed up product.

IMO Scala is one of the best programming languages out there. I know it might sound like zealotry because Scala is already way past its hype curve, and the "Through of disillusionment" already caught a fair bunch in ways that more recent and hyped languages haven't yet, but it's not only still very relevant today, but more and more so (IMO).

So, what's to like about Scala? Like most of things, those are two-edged swords:

1- multi paradigm

To my knowledge Scala is the only language that unifies object oriented programming and functional programming so seamlessly. You can pick the right tool for the job, opting for imperative-style where it's fit and choosing elegant composable/curried when appropriate, without having to bend your mind as much as you would with Haskell/clojure/OCaml/F#/… where things are more one-sided. The downside is that different programmers will have different takes and preferences as to what's the most adequate style might be, and a same codebase might look very different from one place to the other.

2- type system

Scala has one of the most advanced type system. Nothing Rust or Kotlin might match any time soon, or ever. Scala's implementation of GADTs, combined with its powerful pattern matching enables concise and idiomatic abstractions. Many of which are zero-cost thanks to things like opaque types, inlining, tail recursion, … There is a whole area of the Scala community striving to make invalid states irrepresentable (your code won't compile if your instance of a pizza is missing a topping), which makes such libraries self-documenting and easy to use. The downside is that nothing prevents you from climbing the abstraction ladder and encoding everything in the type system when all you need is a simple trait/generic, and that's a human/complexity management problem tooling and the language can hardly mitigate.

3- scalable

The author of Scala (who was a long-time Java compiler architect) wanted Scala to scale from shells one liners to complex multi-cluster distributed systems, and delivered on that. You can start small with a scala-cli proof of concept, transition to a mid-scale "python with types" kind of project, and grow up to very large and complex projects. Beyond the JVM, you can target the browser with scala-js and share models and validation logic between the front and back ends. You can target native binaries for instant startup/low footprint executables that are cheap to spin-up as microservices.

4- has a foothold in academics

A whole team at the EPFL is pushing boundaries of programming languages and using Scala and its compiler as a ground for experimentations. Scala 3 has a proven sound type system thanks to its foundations on the DOT calculus. Effects and Capabilities are being researched as part of the project Caprese to offer a solution to "what color is your function" (mixing sync and async), of memory management/lifecycles (more generic than rustc's), of pure/side-effectful code, etc. The downside is that this gives an impression that Scala's development lacks focus, but arguably those happen in distinct development branches and by different people.

Anyway, feel free to continue the discussion on: !scala@programming.dev

!scala@programming.dev

Before this devolves into a flame war, here's for you the introductory paragraph

Disclaimer: I’m aware that Richard Stallman had some questionable or inadequate behaviours. I’m not defending those nor the man himself. I’m not defending blindly following that particular human (nor any particular human). I’m defending a philosophy, not the philosopher. I claim that his historical vision and his original ideas are still adequate today. Maybe more than ever.

That said, I only see valid points here. For a long time, I too had a preference for MIT-style of licenses, thinking that they would "at least give a chance for a major business to embrace and extend, for the benefit of the open-source world", win-win, right?

Fast-forward, it's now pretty clear how the corporate world used the open-source movement to consolidate its monopoly, common good shouldn't get privatized, and large corporations don't have your best interest at heart.