Can you suggest any good intro to Scala philosophy and programs design?

In Java and C++ designing program's objects hierarchy is pretty obvious. B开发者_JS百科ut beginning Scala I found myself difficult to decide what classes to define to better employ Scala's syntactic sugar facilities (an even idealess about how should I design for better performance). Any good readings on this question?

I have read 4 books on Scala, but I have not found what you are asking for. I guess you have read "Programming in Scala" by Odersky (Artima) already. If not, this is a link to the on-line version:

http://www.docstoc.com/docs/8692868/Programming-In-Scala

This book gives many examples how to construct object-oriented models in Scala, but all examples are very small in number of classes. I do not know of any book that will teach you how to structure large scale systems using Scala.

• Imperative object-orientation has been around since Smalltalk, so we know a lot about this paradigm.
• Functional object-orientation on the other hand, is a rather new concept, so in a few years I expect books describing large scale FOO systems to appear. Anyway, I think that the PiS book gives you a pretty good picture how you can put together the basic building blocks of a system, like Factory pattern, how to replace the Strategy pattern with function literals and so on.

One thing that Viktor Klang once told me (and something I really agree upon) is that one difference between C++/Java and Scala OO is that you define a lot more (smaller) classes when you use Scala. Why? Because you can! The syntactic sugar for the case class result in a very small penalty for defining a class, both in typing and in readability of the code. And as you know, many small classes usually means better OO (fewer bugs) but worse performance.

One other thing I have noticed is that I use the factory pattern a lot more when dealing with immutable objects, since all "changes" of an instance results in creating a new instance. Thank God for the copy() method on the case class. This method makes the factory methods a lot shorter.

I do not know if this helped you at all, but I think this subject is very interesting myself, and I too await more literature on this subject. Cheers!

This is still an evolving matter. For instance, the just released Scala 2.8.0 brought support of type constructor inference, which enabled a pattern of type classes in Scala. The Scala library itself has just began using this pattern. Just yesterday I heard of a new Lift module in which they are going to try to avoid inheritance in favor of type classes.

Scala 2.8.0 also introduced lower priority implicits, plus default and named parameters, both of which can be used, separately or together, to produce very different designs than what was possible before.

And if we go back in time, we note that other important features are not that old either:

• Extractor methods on case classes object companions where introduced February 2008 (before that, the only way to do extraction on case classes was through pattern matching).
• Lazy values and Structural types where introduced July 2007.
• Abstract types support for type constructors was introduced in May 2007.
• Extractors for non-case classes was introduced in January 2007.
• It seems that implicit parameters were only introduced in March 2006, when they replaced the way views were implemented.

All that means we are all learning how to design Scala software. Be sure to rely on tested designs of functional and object oriented paradigms, to see how new features in Scala are used in other languages, like Haskell and type classes or Python and default (optional) and named parameters.

Some people dislike this aspect of Scala, others love it. But other languages share it. C# is adding features as fast as Scala. Java is slower, but it goes through changes too. It added generics in 2004, and the next version should bring some changes to better support concurrent and parallel programming.

I don't think that there are much tutorials for this. I'd suggest to stay with the way you do it now, but to look through "idiomatic" Scala code as well and to pay special attention in the following cases:

• use case classes or case objects instead of enums or "value objects"
• use objects for singletons
• if you need behavior "depending on the context" or dependency-injection-like functionality, use implicits
• when designing a type hierarchy or if you can factor things out of a concrete class, use traits when possible
• Fine grained inheritance hierarchies are OK. Keep in mind that you have pattern matching
• Know the "pimp my library" pattern

And ask as many questions as you feel you need to understand a certain point. The Scala community is very friendly and helpful. I'd suggest the Scala mailing list, Scala IRC or scala-forum.org

I've just accidentally googled to a file called "ScalaStyleGuide.pdf". Going to read...