pfps-shopping-cart VS scala-steward

Or you mean learning to use the Cats and Cats friendly ecosystem? In this case you could try to build something similar to Gabriel Volpe's shopping cart project he uses to illustrate his FP book: https://github.com/gvolpe/pfps-shopping-cart

Practical FP in Scala: A hands-on approach will definitely help you to feel how FP Scala applications are built in the real world. After that Functional event-driven architecture: Powered by Scala 3 can be your next read. Regarding free video materials, I could recommend Jakub Kozłowski and DevInsideYou. Also, there are two great courses from RTJVM: Cats, and Cats Effect.

I would follow up with Practical FP in Scala, which is really about application architecture in the Typelevel ecosystem, and is very hands-on, using a pretty wide variety of Typelevel libraries.

Then there's Gabriel Volpe's book Practical FP in Scala which covers exactly how to use http4s and the rest of the Typelevel/FP ecosystem to build a full-blown HTTP application.

https://github.com/gvolpe/pfps-shopping-cart https://github.com/devinsideyou/tagless-final https://github.com/devinsideyou/zio-todo

Looking for this book: https://leanpub.com/pfp-scala

If you have a look at https://leanpub.com/pfp-scala you'll see the table of contents and also this list in the description: "[...] Cats Effect, Fs2, Http4s, Skunk, Refined & others".

If you have a look at the build file of the app that is built inside of the book you'll see the stack.

Practical FP in Scala

https://github.com/scala-steward-org/scala-steward Might be the one you are looking for

This is one of the reasons why statically typed languages have a big advantage when it comes to maintenance.

Take Scala for example. There is now mature tooling for keeping your dependencies / libraries up-to-date automatically, using automatic migration-scripts (must be provided by the library author of course).

See here: https://github.com/scala-steward-org/scala-steward/blob/mast...

The difficult part here is of course to write the migrations. This works very well in Scala (and can work as well in certain other languages) because the type-system provides enough information to do automatic rewrites and it is easy to _not_ use unsound techniques such as reflection, code generation, macros etc.

The reason why we don't see such tooling in other languages yet is that they are either dynamically typed, which makes it almost impossible to write migration scripts that pretty much always work. Or they are statically typed, but the typesystem is so limited, that developers have to fall back on mentioned unsound features.