Lex Spoon has worked with Martin Odersky on the Scala language, and is also a co-author of Programming in Scala, the authoritative book on the language.

At the 2007 JAOO conference, Spoon gave a presentation on Scala, focusing mainly on the reasons the language should be of interest to a general developer audience. The video of Spoon's presentation was recently posted on InfoQ's Web site:

[Scala] is interesting for a general audience for two reasons. One, from a pure design view, it manages to integrate functions and objects fairly well: it gives you objects that are functional.

And ... it does this while maintaining compatibility with what mainstream practitioners are doing right now. This is an effort to bring advanced [programming] language constructs to where programmers are right now...

We really believe in domain-specific languages. We think you're either going to write them in another language, or you're going to write internal DSLs in the same language. We would like to support you writing them internally, when possible...

Scala also has a lot to say about component-style development, which everyone is talking about, but is somehow not working really well...

The rest of Spoon's presentation focuses on the functional and object-oriented aspects of Scala, and on key Scala programming constructs:

The way Scala tries to do this is with two hypotheses: The first one is that [if] you want to make progress, you should make that with a language that's scalable, [meaning] the constructs work with both small and big pieces of code.

So Scala uses the same constructs for everything from programs and structures down to tiny little integers. It totally resists the temptation to add a module keyword, for example.

The problem is that you end up implement similar language [things] at different levels of code size, but [those things are] not quite the same, and then programmers have to decide [if they] want to use the big code construct or the little code construct. Scala's answer is [to] use the same constructs for all scales.

The second hypothesis is that if you're going achieve this, then you'll have to steal ideas from both the functional and the object-oriented language [communities].

Functional languages are very good at parametric abstraction... The lowly function, is abstracted over values. You can think of the parameters of a function as parts of a computation that have been left out. The caller has to fill in those values...

Higher-order functions are nothing more than doing this very same thing for control. A function that takes functions as arguments allows you to abstract over control. Finally, parametric polymorphism of your type system does the same thing for types. Functional language do this parametric abstraction for a lots of different things.

Object-oriented languages, on the other hand, are very good at abstracting and extending. OO languages have inheritance, they have a strong notion of subtype. Also, OO languages let you reconfigure things at runtime. If your modules are hooked up one way, and you want to reconfigure them in some other way at runtime, that's no big deal in an OO language...

A key message of Spoon's presentation is that while Scala is a production-ready language, familiarity with key Scala concepts can make one a better programmer, regardless of whether one ends up using Scala in a project.

How has Scala influenced your thinking about programming in general?