[scala-language] The cake’s problem, dotty design and the approach to modularity.

Good morning everyone. 

I’m very interested in the topic of modularity in Scala. It’s not a secret 
that today The Cake Pattern is the most popular way to achieve modularity 
in the project and, to some extent, a nice way to manage dependencies. On 
the other hand this way of structuring the application becomes more and 
more an anti-pattern, but unfortunately there’s not much explanation why. I 
feel that it’s pretty hard to answer why it’s becomes an anti-pattern 
without some big, active project (like Scala compiler), but in general i 
can think of things like - complicated design, not that nice way to manage 
dependencies, problems with binary compatibility, slower compilation due to 
inheritance overuse and complex cyclic dependencies, any other issues that 
i didn’t think of? 

I remember that not so long ago Prof. Odersky mentioned he was also 
disappointed in the pattern and went a bit different way with a Dotty 
design. But, unfortunately, i couldn’t find details on this decision, what 
were the problems and how they were solved with a new design (would be good 
to read a paper like Scalable Component Abstractions). Anyway the project 
is open-source, so it’s not hard to take a look and see that there are some 
differences in the design, some components are packed within 
modules/objects and it uses less cake-style coupling (beside the Context 
structure). Could someone please unveil the secrets of the dotty 
architectural design?

And, i guess, that last question that bothers me, what to use instead of 
the Cake? In the talk “Scala - the simple parts” i liked the idea on the 
Scala’s Modular Roots where we can see the mapping between Scala and SML 
languages. Can’t reason much on this, i’ve just started looking at what we 
can achieve with this SML-style modularity (maybe someone could explain 
this as well =)? ), but it looks like a better approach to the modular 
design, especially in combination with typeclasses. Of course we should 
“use the right tool for problem”, but it feels like the Cake Pattern, is 
not good as the essential approach to the application architecture and 
modularity. 

-- 
You received this message because you are subscribed to the Google Groups "scala-language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
For more options, visit https://groups.google.com/d/optout.