1. Scala
Functional programming for the imperative mind

2. Scala
Functional programming for the imperative mind
‘of the nature of or
expressing a
command;
commanding.’
- imperative. (n.d.).
Dictionary.com

3. Scala
‘imperative
Functional programmingisfor the imperative mind
programming a
programming paradigm
that describes
computation in terms of
statements that change
a program state.’
- Imperative programming
Wikipedia.com

4. Outline
• Introduction
• Functional programming
• Scala features
• Java to Scala in three steps
• Scala community
• Wrap up

5. Roots
• Created by Martin Odersky
• Supported by EPFL Switzerland

6. What is Scala?
A programming language ...
• Runs on JVM (and .Net)
• Statically typed
• Object Oriented
• Functional
• From scripting to enterprise apps

7. Scalable language
• Scalable language constructs:
• Composition ‘in the small’
• Composition ‘in the large’
• Java interoperability
• Performance on par with Java

8. Scalable language
• Scalable language constructs:
• Composition ‘in the small’
• Composition ‘in the large’
• Java interoperability
• Performance on par with Java
Fuses functional and object oriented paradigms

9. What is
Functional
Programming

10. Functional programming
• Focus on functions, not state fx=x+1
• Functions are values vs.
• Recursion, not loops x=x+1
• Immutability (‘referential transparency’)
• Schools of thought:
pure and impure (‘pragmatic’)

11. Functional programming
• Focus on functions, not state fx=x+1
• Functions are values vs.
• Recursion, not loops x=x+1
• Immutability (‘referential transparency’)
• Schools of thought:
pure and impure (‘pragmatic’)

12. Functional programming
• Focus on functions, not state
• Functions are values f g x = g(x)
• Recursion, not loops
• Immutability (‘referential transparency’)
• Schools of thought:
pure and impure (‘pragmatic’)

13. Functional programming
• Focus on functions, not state f0=0
fx=
• Functions are values
f (x - 1)
vs.
• Recursion, not loops for(i=x; i>0
; i--) {
• Immutability (‘referential transparency’)x--; }
• Schools of thought:
pure and impure (‘pragmatic’)

14. Functional programming
• Focus on functions, not state
• Functions are values
• Recursion, not loops
• Immutability (‘referential transparency’)
• Schools of thought:
pure and impure (‘pragmatic’)

15. Functional programming
Why should I care about FP?
• Concurrency: FP ‘killer app’
• Higher order functions: expressiveness boost
• Type-system: when present, often superior
• It is coming to a language near you
(C#, Java 8?)

16. FP in Scala
• First-class functions: functions are objects
with pleasing syntax
• Immutability
• Algebraic data-types and pattern matching
• Parametric polymorphism (e.g. generics)

17. What are
Scala’s
Features

18. Scala is like Java...
(Generic) classes: class Foo[T], or:
class Foo[+T]
public class Foo<T>
Methods:
def m(s : String) : Unit = ..
public void m(String s) {..}
Bean properties: private Foo foo; Real properties:
getFoo() {..}, setFoo(..) {..} var foo: Foo
Fully interoperable with existing Java
Mature, large amount of proven libraries
code
Class/Interface distinction, single Abstract classes, traits (restricted
inheritance. multiple inheritance)

19. Pure object orientation
No primitive types:

20. Pure object orientation
No primitive types:

21. Pure object orientation
Every operation is a method call:
1+3 1.+(3)

22. Pure object orientation
Every operation is a method call:
1+3 1.+(3)
Console.println(“hi”) Console println “hi”

23. Pure object orientation
Every operation is a method call:
1+3 1.+(3)
Console.println(“hi”) Console println “hi”
Since operators are methods,
operator overloading is trivial.

24. Pure object orientation
Every operation is a method call:
1+3 1.+(3)
Console.println(“hi”) Console println “hi”

25. Pure object orientation
Every operation is a method call:
1+3 1.+(3)
Console.println(“hi”) Console println “hi”

26. Pure object orientation
No static members, but singleton objects:

27. Type inference
• Types may be omitted in declarations
• Does not mean there is no type!
• Inference is local only
• Var/val: mutable vs. immutable

28. Type inference

29. Everything is an expression

30. Everything is an expression

31. Everything is an expression

32. Everything is an expression

33. Functional objects
• Functions are first-class values
• Function literals:

34. Functional objects
• Functions are first-class values
• Function literals:
(x: Int) => x * 2

35. Functional objects
• Functions are first-class values
• Function literals:
(x: Int) => x * 2
val double = (x: Int) => x * 2

36. Functional objects
• Functions are first-class values
• Function literals:
(x: Int) => x * 2
val double = (x: Int) => x * 2
double(2) == 4
What is the type of double?

37. Functional types
val double = (x: Int) => x * 2
has type
(Int) => Int

38. Functional types
val double = (x: Int) => x * 2
has type
(Int) => Int Function1[Int,Int]

39. Passing functions
Since functions are values, we can
pass them around:

40. Passing functions
But we can do this with anonymous classes...

41. Passing functions
But we can do this with anonymous classes...

42. Passing functions
But we can do this with anonymous classes...

43. Passing functions
But we can do this with anonymous classes...
Well, sort of... but:
• You need explicit interfaces (no function types)
• Verbose
• Doesn’t scale (syntactically and semantically)
• No true closures:

44. Passing functions
But we can do this with anonymous classes...
Well, sort of... but:
• You need explicit interfaces (no function types)
• Verbose
• Doesn’t scale (syntactically and semantically)
• No true closures:

45. Traits
• Compare trait with abstract class
• No interfaces, but: completely abstract traits
• Can mixin multiple traits, statically and
dynamically

46. Traits as rich interfaces
Java interfaces have two consumers with
conflicting interests:
1) Implementors
2) Users

47. Traits as rich interfaces
Java interfaces have two consumers with
conflicting interests:
1) Implementors
2) Users

48. Traits as stackable
modifications
• Situation: IntQueue interface (abstract trait),
IntQueueImpl implementation
• We want to add logging and filtering to any
IntQueue implementation

49. Traits as stackable
modifications
• Situation: IntQueue interface (abstract trait),
IntQueueImpl implementation
• We want to add logging and filtering to any
IntQueue implementation

50. Traits as stackable
modifications
• Situation: IntQueue interface (abstract trait),
IntQueueImpl implementation
• We want to add logging and filtering to any
IntQueue implementation

51. Pattern matching

52. Pattern matching

53. Pattern matching
Yes, it prints 9

54. Pattern matching
• No more instanceof/typecasts
• No more visitor pattern

55. Pattern matching
• No more instanceof/typecasts
• No more visitor pattern
No more NullPointerException:

56. Pattern matching & XML
• Scala has XML literals, can be matched
• Other literals can be matched as well

57. Language feature or
Library
Support

58. Actors
• Message-based concurrency
• Actors exchange immutable messages
• Extract them by pattern matching

59. Actors
• Message-based concurrency
• Actors exchange immutable messages
• Extract them by pattern matching
Looks like language feature, but is a library

60. Other library features
• Enums
• Map ‘syntax’
• Events
• Using ‘keyword’ (e.g. Java 7 ‘automatic
resource management.’)
• Virtually all other Project Coin proposals

61. Other library features
• Enums
• Map ‘syntax’
• Events
• Using ‘keyword’ (e.g. Java 7 ‘automatic
resource management.’)
• Virtually all other Project Coin proposals

62. Other library features
• Enums
• Map ‘syntax’
• Events
• Using ‘keyword’ (e.g. Java 7 ‘automatic
resource management.’)
• Virtually all other Project Coin proposals

63. Other library features
• Enums
• Map ‘syntax’
• Events
• Using ‘keyword’ (e.g. Java 7 ‘automatic
resource management.’)
• Virtually all other Project Coin proposals
Lesson: choose language core wisely,
all else will follow...

64. Lift webframework
In own words:
✓Seaside's highly granular sessions and security
✓Rails fast flash-to-bang
✓Django's quot;more than just CRUD is includedquot;
✓Wicket's designer-friendly templating style
• Heavy use of actors for async features
• Integrated O/R mapping (surprisingly little
boilerplate code)

65. From Java to Scala
In
Three steps

66. Requirements
• Person entity with age
property
• Method to separate
minors and adults
• Input: List[Person]
• Output: list of minors,
list of adults
• One pass over input

67. Requirements
• Person entity with age
property
• Method to separate
minors and adults
• Input: List[Person]
• Output: list of minors,
list of adults
• One pass over input

68. What happens in the
Scala
Community

69. Scala progression
• Current version: 2.7.4
• Version 2.8 beta coming up:
• Package objects
• Named and default parameters
• Many library improvements

70. Tool support
• Major IDEs (Eclipse,
IntelliJ, NetBeans)
supported
• Maven support
• Scaladoc
• SBaz package manager

71. Wrapping up with
Concluding
Remarks

72. Scala hitting mainstream?
Reports of first switchers
Twitter, SAP, LinkedIn, Sony Pictures

73. Scala hitting mainstream?
Reports of first switchers
Twitter, SAP, LinkedIn, Sony Pictures
April 2009: top-30 of TIOBE index

74. Scala hitting mainstream?
Reports of first switchers
Twitter, SAP, LinkedIn, Sony Pictures
April 2009: top-30 of TIOBE index
Lots of books appearing

75. Scala hitting mainstream?
“If I were to pick a language today
other than Java, it would be Scala”
James Gosling,
‘Father of Java’

76. Scala hitting mainstream?
“If Java programmers want to use
features that aren't present in the
language, I think they're probably best
off using another language that targets
the JVM, such a Scala and Groovy.”
Joshua Bloch
Author of ‘Effective Java’

77. Pro’s and cons
• Complexity
• Java interoperability
• Java -> Scala
• Hides accidental
complexity harder than
Scala -> Java
• Expressiveness
• Type-system may
• Uniform, extensible be intimidating
language

78. Conclusion
• Scala feels like ‘cleaned up Java on stereoids’
• Small core (takes some time to see it as such)
provides broad options
• Type inference brings ‘dynamic language’ feel
• Adoptation growing because of:
• Java interoperability
• Growing discontent with Java

79. Conclusion
• Scala feels like ‘cleaned up Java on stereoids’
• Small core (takes some time to see it as such)
provides broad options
• Type inference brings ‘dynamic language’ feel
• Adoptation growing because of:
• Java interoperability
• Growing discontent with Java
Scala provides deep features, but at the
same time helps getting things done.

80. More
information
http://www.scala-lang.org
http://liftweb.net
Article Java Magazine 1/2009

81. Questions?