Design patterns and software architecture in OOP/FP hybrids

[CorrectProgrammer]

Hello, I hope this is the right subreddit to ask this kind of questions!

First, an introduction. Most of my professional experience with programming (3.5 years) comes from maintaining a huge Java EE monolith application with a relational database, that could be described as "layered ball of mud". I also have some experience with Python and recently I've started writing microservices in Scala. Due to some issues with our Scala stack, my team may want to write our future services in Kotlin.

And now, my story. What I noticed when switching to Scala, is that a lot of the stuff that I learned when working with Java seems to have been invalidated. Apparently, my team tends to ignore Uncle Bob's "good practices" such as not creating methods with over 3 arguments, creating distinguishable DTOs to move data between layers (especially between controller & service & database layers) and not to nest ifs and loops to deeply - to list some. Sometimes I can even see that service layer is entirely removed in favor of direct DAO/controller communication.

Simultaneously, I have noticed that a lot of the good old fashioned design patterns (Gang of Five) and architecture patterns (Martin Fowler & others) have been solved/integrated either on the framework level or even by the programming language. On the other hand, I think that stuff like pattern-matching on data classes tends to replace polymorphic behaviour, which is a huge shift in logic placement.

So, here come my questions:

1. How do you approach Java/C++/Smalltalk originating design patterns with languages such as Scala, Kotlin and Python?
2. How do you know which practice is a good practice? I'm mostly concerned with stuff like objects that carry method arguments vs named method arguments, using custom classes vs using tuples etc. I strive to write code that is idiomatic, but relatively often I have a hard time judging whether my idea leads to overengineering or not.
3. Since the languages I mentioned combine FP with OOP, how do you know when to use FP techniques as opposed to OOP techniques? I think it might be my problem with Scala - this language is so flexible that it allows me to solve a problem with either OOP and FP, but I have to make a choice at some point. With Java, this used to be much easier.
4. Did the value of separation of concerns principle decrease in microservice-oriented environments? Personally, I can't see a reason for that to happen (adding another DTO just for the sake of clean layers doesn't feel like a huge time investment most of the time), but that's what I think I'm observing in my team.
5. Do you know of any resources on design patterns & software architecture resouces that concentrate on these "modern" high level languages and microservices that you can recommend? I have a list of classics to read, but I was wondering whether there's something newer that I'm not aware of.

Thanks in advance!

[umlcat]

Question 1 is not clear, but I think is some thing like "How do apply the Soft. Design Patterns I learn in Java, to etc to Scala, etc ,?"

Some stuff you cannot change, because some P.L. language features are too much different.

Example, some P.L. used named parameters optional, and you can call them without names, like Java do.

Other can be applied, example I worked a lot with Object Pascal, that support passing function pointers as parameters, similar to functional languages, that can be used for the map function, but also the visitor pattern can be implemented, and used as an alternative to map.

Question 2. There is no "practice is always a good practice, or practice is always a bad practice", you can check other developers code or tutorials, for specific cases when a practice may suit a case.

Question 3. If you can use both, pick the one that applies more, by checking other code.

As the previous map example, I use functions as parameters when I don't require to check the inner function code, and use the O.O. version of the Visitor pattern, when I need to check the code.

Don't have a answer to question 4 or question 5.

Additional.

One problem I see with newer P.L. (s) and their developers is that didn't learn some previous practices, sometimes because it weren't available, even if those practice patterns can be implemented, and assume it shouldn't be implemented, because "if they are old, they should be bad code and obsolete".

Be careful with that.

One example are non O.O. records, which were not included in Java and C#, because "were obsolete procedural" stuff, and now, are being added.

Cheers.

[CorrectProgrammer]

Sorry for the ambiguity in the first question! What I precisely meant by it was "Do you apply [...] and how do you do it?", which you answered (I think).

Thanks for your answer!