Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

From First Principles: Why Scala?

lihaoyi.com

Post reply on HN
Print view View original

271–280 of 342 posts

Re: From First Principles: Why Scala?

#271

Post by lmm »

yw3410 wrote: post #82
pdpi wrote: post #77

Earlier quoted context omitted.

> Scala has tons of language features and lets people do crazy things in the code. In many ways, it's even worse than that. Scala has exactly two features (implicits and punctuation-free method calls) that allow you to build massively complicated libraries that pretend to be language features, and which work worse than equivalent features in languages that support them explicitly. A good example of this is typeclasse…

Scala 3 has type-classes as a core feature.

No it doesn't, it has syntax to make them look more like a language feature but they're actually still just implicits.

Re: From First Principles: Why Scala?

#272

Post by quilombodigital »

When you go to an auto repair shop, the mechanic uses four different screwdrivers or just one super ultra incredible 8-in-1 screwdriver for everything?

Why not? is the mechanic stupid? the 8-in-1 screwdriver is marvelous, has the DOUBLE of features!

At the end of the day, he has only the tools he need for his job, and thats it.

Re: From First Principles: Why Scala?

#273

Post by lmm »

msluyter wrote: post #75
MrPowers wrote: post #36

I am a Scala programmer & think it's a great language. Here are some arguments for why not Scala: * Li's libs (os-lib, upickle, utest) have clean public interfaces, but most Scala ecosystem libs are hard to use, see the JSON alternatives for examples: https://www.lihaoyi.com/post/uJsonfastflexibleandintuitiveJS... * The Mill build tool looks a lot better than SBT, but seems like everyone is still using SBT * Scala mi…

After a number of years with Python, I started a position working in Scala about 6 months ago. I really wanted to learn something new, and become acquainted with functional programming concepts. I agree with most of the above. A couple of additional thoughts: * sbt -- I still have a lot of coming up to speed to do here, but the manual is like 500 pages and it's somewhat overwhelming. There are tons of little oddities…

> sbt -- I still have a lot of coming up to speed to do here, but the manual is like 500 pages and it's somewhat overwhelming.

SBT is not worth it. Ignore it and use Mmaven.

> The functional side is fascinating -- I'm still studying the cats library. I can almost describe a Monad! It's a pretty big mountain, though, and there are times where I have doubts whether the benefits will be worth it. Would love to hear some re-assurance! ;)

You shouldn't use these things unless and until you need them. Cats is basically a library of techniques for letting you accomplish things that seem like they might need language features by instead writing plain old functions that return plain old values. If you use the fancy technique for the sake of using the fancy technique, you're putting the cart before the horse. You should use them where you'd otherwise have to use some weird language feature (exceptions, magic async, mutable variables...).

> * The ecosystem for microservices seems pretty closely tied to akka & lagom. These are quite complex in their own right and we've been having trouble with the latter in particular. Curious to learn about alternatives. ZIO?

Mostly you don't need anything too complex. I'd recommend using akka-http to start with, but don't use any akka proper - stick to the routing DSL level and use futures rather than actors. When you're more comfortable with the functional abstractions you can switch to http4s.

Re: From First Principles: Why Scala?

#274

Post by lmm »

fmakunbound wrote: post #128
rubyn00bie wrote: post #110

I loved Scala until a minor version updated somewhere around 2.9-2.11 destroyed all my hope. Eight years later I still refused to use it to build anything. Yet, with that said, IMHO, it can be fucking great _second_ language. If you haven't used a statically typed language before, i.e. you're from Ruby, JS, Python, et. al then it's one bangin' ass brain rodeo. I'd highly recommend spending a couple months trying to l…

> only to find this bad boi: https://www.scala-lang.org/api/current/scala/Function22.html Dang. I just checked in the Common Lisp I use and it's a bit higher. What's the reason for having to have at least 22 concrete function signatures like that? CL-USER> call-arguments-limit 4611686018427387903 (62 bits, #x3FFFFFFFFFFFFFFF)

The JVM had no support for functions as values (it was designed around the idea of only having objects with methods). So if you want to very closely mirror Java at runtime (e.g. you want Java reflection libraries to work with your language) but you want to use functions as values, you have to bridge that gap with classes whose instances will represent functions.

Re: From First Principles: Why Scala?

#275

Post by ibraheemdev »

dionian wrote: post #255
elmalto wrote: post #242

I have used python and scala for work and I find myself wishing to be able to use scala a lot when I use python (especially when using pandas or trying to multi process/thread). Not so much the other way around even though I also love python and think it’s amazing. Main reason: The type system is great and there are so many things that I can express/enforce using it that are missing for me in python even using typing…

My favorite thing about the language is its flexibility, if i want to have pure imperative java style code i can do it. I dont think everyone should blame it just because there are so many haskell fans. I think ZIO is a good sign

Funny, ZIO was also on the front page today: https://news.ycombinator.com/item?id=26101463

Re: From First Principles: Why Scala?

#276

Post by mbo »

valenterry wrote: post #245
Cthulhu_ wrote: post #46

Earlier quoted context omitted.

I feel like Scala started a trend in language design, where every language adds features from other languages. Not because there's a need, but because some people are used to language X. Example: adding OOP in PHP and Javascript. In both examples, especially the first attempts, were half-baked. Why bolt on half a language feature? Both languages would be much better served with dependency management and / or modules,…

> Counter-example would be Go, that resists change Now it gets generics, so we are one step closer to Scala. :)

Even with square-bracket syntax!

Re: From First Principles: Why Scala?

#277

Post by jmfldn »

elmalto wrote: post #242

I have used python and scala for work and I find myself wishing to be able to use scala a lot when I use python (especially when using pandas or trying to multi process/thread). Not so much the other way around even though I also love python and think it’s amazing. Main reason: The type system is great and there are so many things that I can express/enforce using it that are missing for me in python even using typing…

Your point about the FP crew being seeming obnoxious sometimes is true. The style itself can be great, I use IO daily and the monadic style is the glue that holds our apps together. The difference with my team, or approaches that work generally, is that we don't go on and on about these abstractions. I barely mention the 'M' word and just talk about chaining things together. Once that is appreciated then IO isn't that hard to get a basic idea of either. We talk a bit about lazy evaluation but I try not to freak everyone out by mentioning purity, higher kinder types and functors every second breath. It's enough to gain a working intuition for these things without bringing theory to the foreground. That can come later if / when ppl are interested.

I guess we also choose our style and abstractions carefully and only use things when we can justify it as a team. If someone raised a PR full of novel concepts that we hadn't grokked as a team, it might well get rejected. For example we started using monad transformers a while ago only after the concept and benefits in our code was explained and bought into by the team. This doesn't just apply to Scala but is especially important when using it. Reach consensus with your team about the style and evolve it together.

I get the feeling that other language cultures, maybe Rust being one, are good at just using FP, without talking endlessly about it.

Re: From First Principles: Why Scala?

#278

Post by ibraheemdev »

sireat wrote: post #213
rubyn00bie wrote: post #110

I loved Scala until a minor version updated somewhere around 2.9-2.11 destroyed all my hope. Eight years later I still refused to use it to build anything. Yet, with that said, IMHO, it can be fucking great _second_ language. If you haven't used a statically typed language before, i.e. you're from Ruby, JS, Python, et. al then it's one bangin' ass brain rodeo. I'd highly recommend spending a couple months trying to l…

I actually like Scala. I teach it to complete beginners to programming and generally it goes great - there is a huge demand for junior Scala developers in my neck of woods. However when I found that 22 argument monster a while ago it was a bit of a wtf moment to me. Why 22? Why not 21 or 23 ? Is it one of those no one is going to need more than 22 arguments?

22 is just arbitrary.

> Is it one of those no one is going to need more than 22 arguments?

You can work around this limit with nested tuples, or just defining Function23 yourself. Although if your function accepts 23 arguments, you should probably refactor that anyways.

It is also worth noting that Scala 3 drops this limitation by implementing function arguments with arrays: https://github.com/lampepfl/dotty/pull/1758

Re: From First Principles: Why Scala?

#279

Post by lmm »

mwcampbell wrote: post #20

I dabbled with Scala several years ago, but I've been using Kotlin for a JVM-based project and am happy with it. My main reason for choosing Kotlin is smoother interop with the JVM world. For example: - Scala adds an Option type, whereas Kotlin adds nullability checking for existing object types. - Scala has its own convention for getters and setters, whereas Kotlin automatically turns JVM getters and setters into pr…

> - Scala adds an Option type, whereas Kotlin adds nullability checking for existing object types.

Kotlin's approach amounts to doubling down on null IMO - it actually makes it harder to interoperate with newer JVM code that favours options over nulls (e.g. streams) from Kotlin than from Scala. And since "platform types" are silently treated as non-null, you still get null exceptions at runtime.

> - Scala defines its own set of collection classes, whereas Kotlin has zero-overhead wrappers over the JVM collection types.

Which means Kotlin has no actually immutable collections; a supposedly immutable collection can be silently mutated by another thread in parallel, which can be pretty surprising.

There are definitely things that Kotlin does well, but IME "smoother interop" is mostly a myth.

Re: From First Principles: Why Scala?

#280

Post by lmm »

bsg75 wrote: post #21
adenozine wrote: post #3

If I've said it once I've said it a thousand times: the day Scala kills sbt officially will be the day thousands of devs consider a return to it. Until then, I couldn't dare.

For new Scala devs, how much of a challenge is it to avoid sbt? Especially for those coming from languages like Python and Go, where the former has no build system (ignoring setup.py), or an almost universal one (go build, sometimes make). All of the projects I have touched are documented using sbt, and transitioning the build process for existing code projects while a new language learner is a double cognitive load.

If you're already used to the JVM, it's easy: just use whatever you were using before (e.g. Maven) and everything works the way you expect it to.

If you're not, the documentation is missing as you say. Maven does just work, but the documentation assumes you're using Java.

Post reply on HN